diff --git a/extension/manifest.firefox.json b/extension/manifest.firefox.json
index e2f7465..6b84e32 100644
--- a/extension/manifest.firefox.json
+++ b/extension/manifest.firefox.json
@@ -2,7 +2,7 @@
   "manifest_version": 3,
   "name": "Combo-X",
   "description": "Local-first browser agent — BYOK, vault, sessions, scrape/export, approvals.",
-  "version": "1.8.1",
+  "version": "1.8.2",
   "icons": {
     "16": "public/icon-16.png",
     "48": "public/icon-48.png",
diff --git a/extension/manifest.json b/extension/manifest.json
index 34df510..5e0868e 100644
--- a/extension/manifest.json
+++ b/extension/manifest.json
@@ -2,7 +2,7 @@
   "manifest_version": 3,
   "name": "Combo-X",
   "description": "Local-first browser agent — BYOK, vault, sessions, scrape/export, approvals.",
-  "version": "1.8.1",
+  "version": "1.8.2",
   "key": "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA1VhJsK7cNcf/9iGadvftWC4KBW8O5VrjJB4DCak24azuapM7NXoQVmMMXtNxM2qS4m+YytEsAqXEbWWffmwXCqAfxJ/acHgdxlbaF1eDX/HICqGVR1RIiyFhY4DmuEB0G68TjvfD6b6hs2O5KycxeWEcjOlgENJSP5j534Zv9swlKXrpPMJlbhxhhGhkjquNo/6WoEnAv7ebpmZDj+t1aTEXP6NV/uRrq9ja4tfkXGogKJbZcc7HS8oO3tHBE0WZOZWDcKmGcPXIBCOt1FzfVNuVcMjPuCK8SBw2RknLTMobJrefZNWfdE7215iFaw0hWgrNxyO4gTV8uFyy/SIJ0wIDAQAB",
   "icons": {
     "16": "public/icon-16.png",
diff --git a/extension/package.json b/extension/package.json
index a0aa8af..ff7e7ed 100644
--- a/extension/package.json
+++ b/extension/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@combo-x/extension",
-  "version": "1.8.1",
+  "version": "1.8.2",
   "private": true,
   "type": "module",
   "scripts": {
diff --git a/extension/src/sidepanel/App.tsx b/extension/src/sidepanel/App.tsx
index 2fbfe6b..57a5fef 100644
--- a/extension/src/sidepanel/App.tsx
+++ b/extension/src/sidepanel/App.tsx
@@ -341,6 +341,7 @@ const TOOLS_MIGRATE_FLAG = "combo_x_tools_migrate_v169";
 const TOOLS_MIGRATE_ADD = [
   "parse_data",
   "get_interactive",
+  "list_form_fields",
   "rag_search",
   "list_attachments",
   "save_view",
diff --git a/extension/src/sidepanel/toolGroups.ts b/extension/src/sidepanel/toolGroups.ts
index 07e18e0..c06223a 100644
--- a/extension/src/sidepanel/toolGroups.ts
+++ b/extension/src/sidepanel/toolGroups.ts
@@ -26,6 +26,7 @@ export const TOOL_GROUPS = {
     "get_page",
     "get_links",
     "get_interactive",
+    "list_form_fields",
     "press_key",
     "click_index",
     "type_index",
diff --git a/packages/core/src/agent/loop.ts b/packages/core/src/agent/loop.ts
index d6becc6..454fed3 100644
--- a/packages/core/src/agent/loop.ts
+++ b/packages/core/src/agent/loop.ts
@@ -100,7 +100,8 @@ import {
   type AgentBudgetMode,
 } from "./budget.js";
 import { PageTemplateCache } from "./pageTemplateCache.js";
-import { annotateRedirect, RepeatGuard } from "./repeatGuard.js";
+import { annotateRedirect, MUTATION_TOOLS, RepeatGuard } from "./repeatGuard.js";
+import { taskProgress } from "../tasks/store.js";
 import {
   leanHistory,
   truncateToolResultForLlm,
@@ -443,6 +444,9 @@ For interaction prefer get_interactive → click_index / type_index (Nanobrowser
 Each user turn may include ## Active browser tab (url/title/tabId/time) and ## Picked element(s) — treat those as ground truth for where the user is and what they pointed at; act on the picked element before exploring elsewhere.
 SEARCH, DON'T DUMP (this is how you stay fast on big apps):
 - Looking for ONE labelled thing? Go straight to it: get_interactive({filter:"Save"}) or find_text({text:"App content"}). find_text returns interactiveIndex on hits inside a control, so you can click_index immediately. Never list 100 controls to find one.
+- Unlabeled icon in a table row? get_interactive({within:{text:"FaqPage"}}) — item.i stays absolute for click_index.
+- Chat column / cookie wall flooding reads? excludeSelector:"aside,[data-testid='chat-panel']" on get_page / find_text / get_interactive.
+- "What can I fill in?" → list_form_fields (labels + type_index handles; passwords never leak values).
 - get_page defaults to mode:"main", which drops nav/header/footer. On consoles (Play Console, GSC, admin panels) the chrome is most of the page — mode:"full" is almost always the wrong call.
 - Reading a long document? get_page({filter:"keyword"}) greps it by line, and exclude:"…" strips boilerplate that repeats on every read. That beats paging through it.
 - Describe the control you want and let the filters do the work. get_interactive takes exclude (drop icon-ligature/nav noise), state:"enabled" (skip controls you cannot click yet — item.disabled marks them), requireLabel:true (skip unnamed icon buttons), and fields:["text"] (return only what you will read). get_links takes unique:true (nav is usually rendered two or three times) and origin:"internal". find_text takes clickableOnly:true so every hit is click-ready.
@@ -453,6 +457,7 @@ NOTHING IS EVER SILENTLY CUT — always read the envelope:
 - item.i from get_interactive is an absolute handle into the full scan — filtering and paging never invalidate it, so click_index({index:i}) always hits the control you saw.
 DON'T REPEAT YOURSELF:
 - Identical arguments return an identical result. If a call yields nothing useful, change the arguments or the tool — a third identical call is refused outright.
+- A streak of read-only observations with no click/type/navigate also trips a stuck guard — mutate, switch tool (list_form_fields / scrape_tables / within / excludeSelector), or report BLOCKED.
 - navigate reports redirected:true + requestedUrl when you did not land where you asked. That path is gated or renamed: reach the page through its on-page link instead of retrying the URL.
 - If two different approaches both fail, stop and tell the user what blocked you. That is a better answer than burning the step budget.
 For current facts / news use web_search (or OpenRouter built-in web search when enabled); use web_fetch or navigate for full pages. Prefer web_search over inventing URLs.
@@ -636,6 +641,8 @@ interface RunContext {
   boundTabId?: number;
   /** Detects identical call+result pairs and refuses the third one. */
   repeatGuard?: RepeatGuard;
+  /** Short description of the last mutating tool call (stop-checkpoint). */
+  lastMutation?: string;
 }
 
 export class AgentLoop {
@@ -931,14 +938,30 @@ export class AgentLoop {
         }
       }
       runCtx.ephemeralTabIds = [];
+
+      let finalText = outcome.finalText;
+      let doneMessage = outcome.doneMessage ?? outcome.finalText;
+      if (outcome.aborted) {
+        const checkpoint = await this.buildStopCheckpoint(runCtx);
+        if (checkpoint) {
+          finalText = checkpoint;
+          doneMessage = checkpoint;
+          messages.push({ role: "assistant", content: checkpoint });
+          emit({ type: "assistant_delta", message: checkpoint });
+        } else if (!finalText.trim()) {
+          finalText = "Stopped.";
+          doneMessage = "Stopped.";
+        }
+      }
+
       emit({
         type: "done",
-        message: outcome.doneMessage ?? outcome.finalText,
+        message: doneMessage,
         usage,
       });
       return {
         messages,
-        finalText: outcome.finalText,
+        finalText,
         steps,
         usage,
         aborted: outcome.aborted,
@@ -1404,6 +1427,26 @@ export class AgentLoop {
     }
   }
 
+  /**
+   * On abort/stop: one visible transcript line summarizing open tasks + last mutation.
+   * Returns null when there is nothing useful to say (no todo/doing tasks).
+   */
+  private async buildStopCheckpoint(runCtx: RunContext): Promise<string | null> {
+    if (!runCtx.tasks) return null;
+    try {
+      const rows = await runCtx.tasks.list(
+        runCtx.sessionId ? { sessionId: runCtx.sessionId } : {},
+      );
+      const open = rows.filter((t) => t.status === "todo" || t.status === "doing");
+      if (!open.length) return null;
+      const { done, total } = taskProgress(rows);
+      const last = runCtx.lastMutation?.trim() || "none";
+      return `Stopped. Tasks: ${done}/${total} done; last action: ${last}.`;
+    } catch {
+      return null;
+    }
+  }
+
   /**
    * Apply soft context limit: when lean history still exceeds `contextLimit`,
    * compress older turns into a single summary message and emit a
@@ -3083,6 +3126,17 @@ export class AgentLoop {
         }
       }
 
+      if (runCtx && MUTATION_TOOLS.has(name)) {
+        const ok =
+          !result ||
+          typeof result !== "object" ||
+          Array.isArray(result) ||
+          (result as { ok?: boolean }).ok !== false;
+        if (ok) {
+          runCtx.lastMutation = describeMutation(name, args);
+        }
+      }
+
       const repeat = runCtx?.repeatGuard?.record(name, args, result);
       if (repeat?.kind === "warn") {
         result = RepeatGuard.annotate(result, repeat.note);
@@ -4523,3 +4577,31 @@ export class AgentLoop {
     return mcpCall(conn, String(args.tool ?? ""), toolArgs, connectors.getSecret);
   }
 }
+
+/** Short human label for the last mutating tool (stop-checkpoint). */
+function describeMutation(name: string, args: Record<string, unknown>): string {
+  switch (name) {
+    case "click_index":
+      return `clicked index ${String(args.index ?? "?")}`;
+    case "type_index": {
+      const text = typeof args.text === "string" ? args.text.trim() : "";
+      const preview = text.length > 40 ? `${text.slice(0, 40)}…` : text;
+      return preview
+        ? `typed into index ${String(args.index ?? "?")}: ${preview}`
+        : `typed into index ${String(args.index ?? "?")}`;
+    }
+    case "click":
+      return `clicked ${String(args.selector ?? "element")}`;
+    case "type_text":
+      return `typed into ${String(args.selector ?? "field")}`;
+    case "press_key":
+      return `pressed ${String(args.key ?? "key")}`;
+    case "navigate":
+    case "open_tab":
+      return `navigated to ${String(args.url ?? "url")}`;
+    case "go_back":
+      return "went back";
+    default:
+      return name;
+  }
+}
diff --git a/packages/core/src/agent/loopGuards.test.ts b/packages/core/src/agent/loopGuards.test.ts
index 9a33124..860bbd0 100644
--- a/packages/core/src/agent/loopGuards.test.ts
+++ b/packages/core/src/agent/loopGuards.test.ts
@@ -6,6 +6,7 @@
 import { describe, expect, it, vi } from "vitest";
 import type { ChatMessage, OpenRouterClient } from "../llm/openrouter.js";
 import { MemoryStore } from "../memory/store.js";
+import { TaskStore } from "../tasks/store.js";
 import type { BrowserBridge } from "./loop.js";
 import { AgentLoop } from "./loop.js";
 
@@ -149,6 +150,118 @@ describe("repeat-call guard inside the agent loop", () => {
   });
 });
 
+describe("stop checkpoint on abort", () => {
+  it("appends a task summary when stopping with open todo/doing tasks", async () => {
+    const tasks = new TaskStore(`tasks_${crypto.randomUUID()}`);
+    const sessionId = "sess-stop";
+    await tasks.put({
+      id: "t1",
+      title: "Edit FaqPage meta",
+      status: "doing",
+      sessionId,
+      note: "saved FaqPage",
+    });
+    await tasks.put({
+      id: "t2",
+      title: "Edit Row3 meta",
+      status: "todo",
+      sessionId,
+    });
+
+    const llm = mockLlm([
+      {
+        content: null,
+        toolCalls: [
+          { id: "1", name: "click_index", args: JSON.stringify({ index: 2 }) },
+        ],
+      },
+      {
+        content: null,
+        toolCalls: [{ id: "2", name: "get_page", args: "{}" }],
+      },
+      { content: "should not reach" },
+    ]);
+    const runContent = vi.fn(async (req: { op?: string }) => {
+      if (req.op === "click_index") return { ok: true, data: { clickedIndex: 2 } };
+      return { ok: true, data: { title: "t", url: "https://app.test/x", text: "x" } };
+    });
+    const browser = stubBrowser({ runContent });
+    const agent = new AgentLoop(llm, browser, new MemoryStore({ dbName: `g_${crypto.randomUUID()}` }));
+    const controller = new AbortController();
+
+    // Abort after the first tool turn completes (mutation recorded), before the next model call.
+    let toolTurns = 0;
+    const result = await agent.run({
+      model: "mock",
+      approvalMode: "auto_all",
+      userMessage: "edit meta tags",
+      sessionId,
+      tasks,
+      signal: controller.signal,
+      maxSteps: 8,
+      onEvent: (e) => {
+        if (e.type === "tool_result") {
+          toolTurns += 1;
+          if (toolTurns >= 1) controller.abort();
+        }
+      },
+    });
+
+    expect(result.aborted).toBe(true);
+    expect(result.finalText).toMatch(/^Stopped\. Tasks: 0\/2 done; last action:/);
+    expect(result.finalText).toMatch(/clicked index 2/);
+  });
+});
+
+describe("semantic stuck guard inside the agent loop", () => {
+  it("warns after 6 read-only calls and resets on a click", async () => {
+    const runContent = vi.fn(async (req: { op?: string }) => {
+      if (req.op === "click_index") return { ok: true, data: { clickedIndex: 0 } };
+      return { ok: true, data: { title: "t", url: "https://app.test/meta", text: "x", items: [] } };
+    });
+    const browser = stubBrowser({ runContent });
+
+    const reads = Array.from({ length: 6 }, (_, i) => ({
+      id: `r${i}`,
+      name: "get_page",
+      args: JSON.stringify({ filter: `noise-${i}` }),
+    }));
+    const llm = mockLlm([
+      { content: null, toolCalls: reads.slice(0, 3) },
+      { content: null, toolCalls: reads.slice(3, 6) },
+      {
+        content: null,
+        toolCalls: [{ id: "click", name: "click_index", args: JSON.stringify({ index: 0 }) }],
+      },
+      {
+        content: null,
+        toolCalls: [{ id: "after", name: "get_page", args: JSON.stringify({ filter: "after" }) }],
+      },
+      { content: "done" },
+    ]);
+    const agent = new AgentLoop(llm, browser, new MemoryStore({ dbName: `g_${crypto.randomUUID()}` }));
+
+    const results: Array<{ tool?: string; result: unknown }> = [];
+    await agent.run({
+      model: "mock",
+      approvalMode: "auto_all",
+      userMessage: "edit rows",
+      maxSteps: 12,
+      onEvent: (e) => {
+        if (e.type === "tool_result") results.push({ tool: e.tool, result: e.result });
+      },
+    });
+
+    const readResults = results.filter((r) => r.tool === "get_page");
+    const sixth = readResults[5]?.result as { _repeat?: string };
+    expect(sixth?._repeat).toMatch(/observations without changing anything/);
+
+    const afterClick = results.filter((r) => r.tool === "get_page").slice(6);
+    expect(afterClick.length).toBeGreaterThanOrEqual(1);
+    expect((afterClick[0]?.result as { _repeat?: string })?._repeat).toBeUndefined();
+  });
+});
+
 describe("prompt-cache layout", () => {
   it("keeps the volatile task list out of the cached system prefix", async () => {
     const seen: ChatMessage[][] = [];
diff --git a/packages/core/src/agent/repeatGuard.test.ts b/packages/core/src/agent/repeatGuard.test.ts
index 5d892a1..7a4ec25 100644
--- a/packages/core/src/agent/repeatGuard.test.ts
+++ b/packages/core/src/agent/repeatGuard.test.ts
@@ -92,6 +92,60 @@ describe("RepeatGuard", () => {
   });
 });
 
+describe("semantic observation stuck guard", () => {
+  it("warns at 6 consecutive observations with varied args", () => {
+    const g = new RepeatGuard();
+    let last: ReturnType<RepeatGuard["record"]> = { kind: "ok" };
+    for (let i = 0; i < 6; i++) {
+      last = g.record("get_page", { filter: `x${i}` }, { ok: true, data: { text: `t${i}` } });
+    }
+    expect(last.kind).toBe("warn");
+    if (last.kind === "warn") {
+      expect(last.note).toMatch(/6 observations without changing anything/);
+      expect(last.note).toMatch(/list_form_fields|within|excludeSelector/);
+    }
+    expect(g.getObservationStreak()).toBe(6);
+  });
+
+  it("blocks the 9th observation before it runs", () => {
+    const g = new RepeatGuard();
+    for (let i = 0; i < 9; i++) {
+      g.record("find_text", { text: `q${i}` }, { ok: true, matches: [] });
+    }
+    expect(g.getObservationStreak()).toBe(9);
+    const verdict = g.check("get_interactive", { filter: "Save" });
+    expect(verdict.kind).toBe("block");
+    if (verdict.kind === "block") {
+      expect(verdict.result.error).toBe("observation_stuck_blocked");
+    }
+  });
+
+  it("resets the streak on a mutation", () => {
+    const g = new RepeatGuard();
+    for (let i = 0; i < 6; i++) {
+      g.record("get_interactive", { filter: `f${i}` }, { ok: true, items: [] });
+    }
+    expect(g.getObservationStreak()).toBe(6);
+    g.record("click_index", { index: 3 }, { ok: true, clickedIndex: 3 });
+    expect(g.getObservationStreak()).toBe(0);
+    expect(g.record("get_page", {}, { ok: true, data: { text: "x" } }).kind).toBe("ok");
+  });
+
+  it("does not trip when the observed URL is changing", () => {
+    const g = new RepeatGuard();
+    for (let i = 0; i < 8; i++) {
+      const verdict = g.record(
+        "get_page",
+        { offset: i },
+        { ok: true, data: { text: "loading", url: `https://app.test/step/${i}` } },
+      );
+      expect(verdict.kind).toBe("ok");
+    }
+    expect(g.check("get_page", {}).kind).toBe("ok");
+    expect(g.getObservationStreak()).toBe(1);
+  });
+});
+
 describe("annotateRedirect", () => {
   it("flags a silent redirect and names both URLs", () => {
     const out = annotateRedirect(
diff --git a/packages/core/src/agent/repeatGuard.ts b/packages/core/src/agent/repeatGuard.ts
index 70ae694..39a4e4c 100644
--- a/packages/core/src/agent/repeatGuard.ts
+++ b/packages/core/src/agent/repeatGuard.ts
@@ -7,10 +7,17 @@
  * Nothing in the loop noticed that the call was identical AND the outcome was
  * identical, so there was no pressure to change approach.
  *
- * Policy: the first repeat is annotated (the model usually self-corrects), the
- * second is refused with concrete alternatives. Only *identical args producing
- * an identical result* count — legitimately re-polling a changing page (a
- * loading spinner, a queue) never trips the guard.
+ * Follow-up (Base44 meta-tags table, 2026-08-03): ~12 consecutive *different*
+ * read-only calls with zero mutations also burned the budget. The identical-
+ * call guard stayed silent because args varied. Semantic stuck tracking below
+ * catches that class: observation streak with no mutation and no URL change.
+ *
+ * Policy: the first identical repeat is annotated (the model usually
+ * self-corrects), the second is refused with concrete alternatives. Only
+ * *identical args producing an identical result* count for that path —
+ * legitimately re-polling a changing page (a loading spinner, a queue) never
+ * trips it. Separately, ≥6 observations without a mutation/URL change warn;
+ * ≥9 block.
  */
 
 /** Tools whose whole purpose is to re-observe changing state. */
@@ -19,12 +26,47 @@ const POLLING_TOOLS = new Set([
   "get_page",
   "page_digest",
   "get_interactive",
+  "list_form_fields",
   "screenshot",
   "list_tabs",
   "page_metrics",
   "list_tasks",
 ]);
 
+/** Read-only tools that do not change the page (semantic stuck streak). */
+export const OBSERVATION_TOOLS = new Set([
+  "get_page",
+  "page_digest",
+  "get_interactive",
+  "list_form_fields",
+  "find_text",
+  "query_all",
+  "extract",
+  "scrape_tables",
+  "get_links",
+  "scroll",
+  "wait",
+  "screenshot",
+  "screenshot_viewport",
+  "screenshot_element",
+  "screenshot_full",
+]);
+
+/** Tools that mutate the page or navigate — reset the observation streak. */
+export const MUTATION_TOOLS = new Set([
+  "click",
+  "click_index",
+  "type_text",
+  "type_index",
+  "press_key",
+  "navigate",
+  "open_tab",
+  "go_back",
+]);
+
+const STUCK_WARN_AT = 6;
+const STUCK_BLOCK_AT = 9;
+
 export type RepeatVerdict =
   | { kind: "ok" }
   | { kind: "warn"; repeats: number; note: string }
@@ -67,13 +109,13 @@ function alternativesFor(name: string, args: Record<string, unknown>): string {
       return (
         `Reading the same page again returns the same bytes. Change the query instead: ` +
         `get_page({filter:"<keyword>"}) to grep it, get_page({offset:<nextOffset>}) to continue, ` +
-        `or page_digest / find_text to locate the part you need.`
+        `excludeSelector to drop chat/cookie chrome, or page_digest / find_text to locate the part you need.`
       );
     case "get_interactive":
       return (
         `The control list has not changed. Narrow it instead: ` +
-        `get_interactive({filter:"<label>"}), kind:"button", or region:"main". ` +
-        `If you expected an overlay, press_key Escape first, or scope:"page".`
+        `get_interactive({filter:"<label>"}), within:{text:"<row>"}, excludeSelector:"aside", ` +
+        `kind:"button", or region:"main". If you expected an overlay, press_key Escape first, or scope:"page".`
       );
     case "click_index":
     case "click":
@@ -82,7 +124,10 @@ function alternativesFor(name: string, args: Record<string, unknown>): string {
         `Re-read controls (get_interactive({filter:"…"})), scroll to it, or try the dialog scope.`
       );
     case "find_text":
-      return `Same query, same misses. Try a shorter distinctive substring, or get_page({filter:"…"}).`;
+      return (
+        `Same query, same misses. Try a shorter distinctive substring, excludeSelector:"aside", ` +
+        `or get_page({filter:"…"}).`
+      );
     default:
       return (
         `Identical arguments return an identical result. Change the arguments, use a different tool, ` +
@@ -91,8 +136,32 @@ function alternativesFor(name: string, args: Record<string, unknown>): string {
   }
 }
 
+function stuckHint(streak: number): string {
+  return (
+    `${streak} observations without changing anything — either mutate (click/type), ` +
+    `switch tool (list_form_fields for forms, scrape_tables for tables, within/excludeSelector to cut noise), ` +
+    `or report BLOCKED with what you tried.`
+  );
+}
+
+/** Pull a page URL out of a tool result when present. */
+export function extractResultUrl(result: unknown): string | undefined {
+  if (!result || typeof result !== "object" || Array.isArray(result)) return undefined;
+  const obj = result as Record<string, unknown>;
+  if (typeof obj.url === "string" && obj.url) return obj.url;
+  const data = obj.data;
+  if (data && typeof data === "object" && !Array.isArray(data)) {
+    const u = (data as Record<string, unknown>).url;
+    if (typeof u === "string" && u) return u;
+  }
+  return undefined;
+}
+
 export class RepeatGuard {
   private readonly seen = new Map<string, Entry>();
+  /** Consecutive observation-only calls with no mutation and no URL change. */
+  private observationStreak = 0;
+  private lastObservationUrl: string | undefined;
 
   /**
    * Thresholds are in *duplicate outcomes*, so the timeline reads:
@@ -110,11 +179,30 @@ export class RepeatGuard {
     return `${name}#${canonicalize(args)}`;
   }
 
+  /** Current observation-only streak (for tests / stop checkpoint). */
+  getObservationStreak(): number {
+    return this.observationStreak;
+  }
+
   /**
    * Called before executing. Returns `block` once this exact call has produced
-   * the same result twice — the tool is then not run at all.
+   * the same result twice — the tool is then not run at all. Also blocks when
+   * the observation streak has already reached STUCK_BLOCK_AT.
    */
   check(name: string, args: Record<string, unknown>): RepeatVerdict {
+    if (OBSERVATION_TOOLS.has(name) && this.observationStreak >= STUCK_BLOCK_AT) {
+      return {
+        kind: "block",
+        repeats: this.observationStreak,
+        result: {
+          ok: false,
+          error: "observation_stuck_blocked",
+          repeats: this.observationStreak,
+          hint: stuckHint(this.observationStreak),
+        },
+      };
+    }
+
     const entry = this.seen.get(this.key(name, args));
     if (!entry || entry.repeats < RepeatGuard.BLOCK_AT_REPEATS) return { kind: "ok" };
     const calls = entry.repeats + 1;
@@ -134,9 +222,32 @@ export class RepeatGuard {
 
   /**
    * Record an outcome. Returns `warn` when the call+result pair just repeated,
-   * so the caller can attach a nudge to the (still valid) result.
+   * or when the observation streak hits the stuck threshold, so the caller can
+   * attach a nudge to the (still valid) result.
    */
   record(name: string, args: Record<string, unknown>, result: unknown): RepeatVerdict {
+    let stuckWarn: RepeatVerdict | null = null;
+    if (MUTATION_TOOLS.has(name)) {
+      this.observationStreak = 0;
+      this.lastObservationUrl = undefined;
+    } else if (OBSERVATION_TOOLS.has(name)) {
+      const url = extractResultUrl(result);
+      if (url && this.lastObservationUrl && url !== this.lastObservationUrl) {
+        // Page changed under us — polling a redirect/loading URL is productive.
+        this.observationStreak = 1;
+      } else {
+        this.observationStreak += 1;
+      }
+      if (url) this.lastObservationUrl = url;
+      if (this.observationStreak >= STUCK_WARN_AT) {
+        stuckWarn = {
+          kind: "warn",
+          repeats: this.observationStreak,
+          note: stuckHint(this.observationStreak),
+        };
+      }
+    }
+
     // Re-polling a mutating surface is normal; only flag it when the *result*
     // is byte-identical, which means nothing was learned.
     const key = this.key(name, args);
@@ -146,12 +257,12 @@ export class RepeatGuard {
     // A changed result means the retry was productive — reset the streak.
     if (!prev || prev.fingerprint !== fp) {
       this.seen.set(key, { repeats: 0, fingerprint: fp });
-      return { kind: "ok" };
+      return stuckWarn ?? { kind: "ok" };
     }
 
     const repeats = prev.repeats + 1;
     this.seen.set(key, { repeats, fingerprint: fp });
-    if (repeats < RepeatGuard.WARN_AT_REPEATS) return { kind: "ok" };
+    if (repeats < RepeatGuard.WARN_AT_REPEATS) return stuckWarn ?? { kind: "ok" };
     return {
       kind: "warn",
       repeats,
diff --git a/packages/core/src/browser/content-handlers.ts b/packages/core/src/browser/content-handlers.ts
index a6a7df3..583ebc7 100644
--- a/packages/core/src/browser/content-handlers.ts
+++ b/packages/core/src/browser/content-handlers.ts
@@ -25,9 +25,90 @@ const CHROME_SEL =
 const MAIN_SEL =
   'main, [role="main"], article, #main, #content, #main-content, .main-content, [class*="page-content"]';
 
+/**
+ * Row / list / section containers used by `within` scoping — find the pencil in
+ * the table row that contains "FaqPage" without rescanning the whole page.
+ */
+const ROW_CONTAINER_SEL =
+  'tr, [role="row"], li, [role="listitem"], article, section, fieldset';
+
 /** Upper bound on elements scanned per get_interactive call (paging needs a total). */
 const INTERACTIVE_SCAN_CAP = 600;
 
+/** True when `el` is inside (or is) a match for the CSS excludeSelector. */
+function matchesExcludeSelector(el: Element | null, excludeSelector?: string): boolean {
+  const sel = excludeSelector?.trim();
+  if (!el || !sel) return false;
+  try {
+    return el.closest(sel) != null;
+  } catch {
+    return false;
+  }
+}
+
+/** Clone-and-remove helper for text extraction paths. */
+function pruneExcluded(root: HTMLElement, excludeSelector?: string): number {
+  const sel = excludeSelector?.trim();
+  if (!sel) return 0;
+  let removed = 0;
+  try {
+    for (const n of Array.from(root.querySelectorAll(sel))) {
+      removed += (n.textContent ?? "").length;
+      n.remove();
+    }
+  } catch {
+    /* invalid selector — ignore */
+  }
+  return removed;
+}
+
+/**
+ * Row containers that contain a descendant text node matching `needle`
+ * (case-insensitive substring). Used by `within.text`.
+ */
+function rowContainersMatchingText(doc: Document, needle: string): Set<Element> {
+  const out = new Set<Element>();
+  const lower = needle.toLowerCase();
+  const root = doc.body ?? doc;
+  const walker = doc.createTreeWalker(root, NodeFilter.SHOW_TEXT);
+  let node = walker.nextNode();
+  while (node) {
+    const raw = (node.textContent ?? "").trim();
+    if (raw.length > 0 && raw.toLowerCase().includes(lower)) {
+      const parent = node.parentElement;
+      const row = parent?.closest(ROW_CONTAINER_SEL) ?? null;
+      if (row) out.add(row);
+    }
+    node = walker.nextNode();
+  }
+  return out;
+}
+
+/** Post-scan `within` filter — never renumbers absolute interactive indices. */
+function matchesWithin(
+  el: HTMLElement,
+  within: { selector?: string; text?: string } | undefined,
+  textRows: Set<Element> | null,
+): boolean {
+  if (!within) return true;
+  const hasSel = !!within.selector?.trim();
+  const hasText = !!within.text?.trim();
+  if (!hasSel && !hasText) return true;
+  const row = el.closest(ROW_CONTAINER_SEL);
+  if (!row) return false;
+  if (hasSel) {
+    try {
+      if (!row.matches(within.selector!.trim())) return false;
+    } catch {
+      return false;
+    }
+  }
+  if (hasText) {
+    if (!textRows || !textRows.has(row)) return false;
+  }
+  return true;
+}
+
 /**
  * The interactive map keyed off `document` survives client-side navigation in a
  * SPA, so its elements can be detached while the map still looks populated —
@@ -114,13 +195,17 @@ function blockAwareText(root: HTMLElement): string {
  * Text of the primary content region with site chrome removed.
  * Returns the chrome char count so the caller can tell the agent what it skipped.
  */
-function mainText(doc: Document): { text: string; region: string; chromeChars: number } {
+function mainText(
+  doc: Document,
+  excludeSelector?: string,
+): { text: string; region: string; chromeChars: number; excludedChars: number } {
   const body = doc.body;
-  if (!body) return { text: "", region: "none", chromeChars: 0 };
+  if (!body) return { text: "", region: "none", chromeChars: 0, excludedChars: 0 };
   const mainRoot = findMainRoot(doc);
   const source = mainRoot ?? body;
   const clone = source.cloneNode(true) as HTMLElement;
   stripNonText(clone);
+  const excludedChars = pruneExcluded(clone, excludeSelector);
 
   let chromeChars = 0;
   for (const n of Array.from(clone.querySelectorAll(CHROME_SEL))) {
@@ -132,6 +217,7 @@ function mainText(doc: Document): { text: string; region: string; chromeChars: n
     text: normalizeText(blockAwareText(clone)),
     region: mainRoot ? mainRoot.tagName.toLowerCase() : "body-minus-chrome",
     chromeChars,
+    excludedChars,
   };
 }
 
@@ -299,8 +385,22 @@ export function handleContentRequest(request: ContentRequest, doc: Document = do
 
         const useMain = mode === "main" || mode === "snippet";
         const extracted = useMain
-          ? mainText(doc)
-          : { text: visibleText(doc), region: "body", chromeChars: 0 };
+          ? mainText(doc, request.excludeSelector)
+          : (() => {
+              const body = doc.body;
+              if (!body) {
+                return { text: "", region: "body", chromeChars: 0, excludedChars: 0 };
+              }
+              const clone = body.cloneNode(true) as HTMLElement;
+              stripNonText(clone);
+              const excludedChars = pruneExcluded(clone, request.excludeSelector);
+              return {
+                text: normalizeText(blockAwareText(clone)),
+                region: "body",
+                chromeChars: 0,
+                excludedChars,
+              };
+            })();
 
         let text = extracted.text;
         let filterMatched: number | undefined;
@@ -319,6 +419,22 @@ export function handleContentRequest(request: ContentRequest, doc: Document = do
         const cap = mode === "snippet" ? Math.min(maxChars, 2_500) : maxChars;
         const win = windowText(text, request.offset ?? 0, cap);
 
+        const hints: string[] = [];
+        if (win.hasMore) {
+          hints.push(
+            `Showing chars ${win.offset}–${win.offset + win.slice.length} of ${win.totalChars}. Continue with get_page({offset:${win.nextOffset}${mode !== "main" ? `, mode:"${mode}"` : ""}}) or narrow with get_page({filter:"…"}).`,
+          );
+        } else if (useMain && extracted.chromeChars > 0) {
+          hints.push(
+            `Skipped ${extracted.chromeChars} chars of nav/header/footer chrome. Use mode:"full" if you need it.`,
+          );
+        }
+        if (extracted.excludedChars > 0 && request.excludeSelector) {
+          hints.push(
+            `Pruned excludeSelector subtrees (~${extracted.excludedChars} chars).`,
+          );
+        }
+
         return {
           ok: true,
           data: {
@@ -328,6 +444,12 @@ export function handleContentRequest(request: ContentRequest, doc: Document = do
             mode,
             region: extracted.region,
             chromeSkippedChars: extracted.chromeChars || undefined,
+            ...(request.excludeSelector
+              ? {
+                  excludeSelector: request.excludeSelector,
+                  excludedSubtreeChars: extracted.excludedChars || undefined,
+                }
+              : {}),
             ...(filterMatched != null
               ? { filter: request.filter, filterMatchedLines: filterMatched }
               : {}),
@@ -339,11 +461,7 @@ export function handleContentRequest(request: ContentRequest, doc: Document = do
             nextOffset: win.nextOffset,
             hasMore: win.hasMore,
             truncated: win.hasMore,
-            hint: win.hasMore
-              ? `Showing chars ${win.offset}–${win.offset + win.slice.length} of ${win.totalChars}. Continue with get_page({offset:${win.nextOffset}${mode !== "main" ? `, mode:"${mode}"` : ""}}) or narrow with get_page({filter:"…"}).`
-              : useMain && extracted.chromeChars > 0
-                ? `Skipped ${extracted.chromeChars} chars of nav/header/footer chrome. Use mode:"full" if you need it.`
-                : undefined,
+            hint: hints.filter(Boolean).join(" ") || undefined,
           },
         };
       }
@@ -495,6 +613,10 @@ export function handleContentRequest(request: ContentRequest, doc: Document = do
           const raw = (node.textContent ?? "").trim();
           if (raw.length > 1 && raw.toLowerCase().includes(needle)) {
             const parent = node.parentElement;
+            if (matchesExcludeSelector(parent, request.excludeSelector)) {
+              node = walker.nextNode();
+              continue;
+            }
             const host = (parent?.closest(INTERACTIVE_SEL) as HTMLElement | null) ?? null;
             const mapIdx = host ? map.indexOf(host) : -1;
             const body =
@@ -572,6 +694,9 @@ export function handleContentRequest(request: ContentRequest, doc: Document = do
         const wantKind = request.kind ?? "any";
         const wantState = request.state ?? "any";
         let wantRegion = request.region ?? "any";
+        const within = request.within;
+        const textRows =
+          within?.text?.trim() ? rowContainersMatchingText(doc, within.text.trim()) : null;
 
         const byKindAndFilter = all
           .filter((it) => wantKind === "any" || it.kind === wantKind)
@@ -580,13 +705,19 @@ export function handleContentRequest(request: ContentRequest, doc: Document = do
           )
           .filter((it) => !request.requireLabel || it.text.length > 0)
           .filter((it) => !needle || interactiveHaystack(it).includes(needle))
-          .filter((it) => !banned || !interactiveHaystack(it).includes(banned));
+          .filter((it) => !banned || !interactiveHaystack(it).includes(banned))
+          .filter((it) => !matchesExcludeSelector(collected.els[it.i] ?? null, request.excludeSelector))
+          .filter((it) => {
+            const el = collected.els[it.i];
+            return el ? matchesWithin(el, within, textRows) : false;
+          });
 
         // Adaptive default: on console-style pages the nav alone exceeds any
         // sane limit. When the caller did not choose, prefer main content and
         // say so — rather than silently handing back 100 sidebar links.
+        // Skip auto-region when the caller already narrowed with within/excludeSelector.
         let regionAuto = false;
-        if (request.region == null && !needle) {
+        if (request.region == null && !needle && !within && !request.excludeSelector) {
           const mainOnly = byKindAndFilter.filter((it) => it.region === "main");
           if (byKindAndFilter.length > limit && mainOnly.length > 0 && mainOnly.length < byKindAndFilter.length) {
             wantRegion = "main";
@@ -609,6 +740,11 @@ export function handleContentRequest(request: ContentRequest, doc: Document = do
             `Auto-scoped to main content (${matched.length} of ${byKindAndFilter.length} controls; ${navCount} nav/header/footer controls hidden). Pass region:"any" or region:"nav" to see them.`,
           );
         }
+        if (within && matched.length) {
+          hints.push(
+            `within scoped to ${matched.length} control(s) in matching row/list containers; item.i stays absolute for click_index.`,
+          );
+        }
         if (nextOffset != null) {
           hints.push(
             `Showing ${items.length} of ${matched.length}. Page with get_interactive({offset:${nextOffset}}) or jump straight to one with get_interactive({filter:"<label>"}).`,
@@ -616,7 +752,12 @@ export function handleContentRequest(request: ContentRequest, doc: Document = do
         }
         if (needle && !matched.length) {
           hints.push(
-            `No control matches "${request.filter}". Try a shorter substring, region:"any", state:"any", or find_text({text:"…"}) which reports a clickable interactiveIndex.`,
+            `No control matches "${request.filter}". Try a shorter substring, region:"any", state:"any", within:{text:"…"}, or find_text({text:"…"}) which reports a clickable interactiveIndex.`,
+          );
+        }
+        if (within && !matched.length) {
+          hints.push(
+            `within matched no controls. Check the row text/selector, or drop within and use filter/excludeSelector.`,
           );
         }
         const disabledHidden =
@@ -652,6 +793,83 @@ export function handleContentRequest(request: ContentRequest, doc: Document = do
           },
         };
       }
+      case "list_form_fields": {
+        const limit = request.limit ?? 80;
+        const offset = request.offset ?? 0;
+        const scopeMode = request.scope ?? "auto";
+        if (scopeMode === "dialog" && !findTopModal(doc)) {
+          return {
+            ok: false,
+            error: "no open dialog/menu to scope to; use scope=auto or scope=page",
+          };
+        }
+
+        const collected = collectInteractive(doc, INTERACTIVE_SCAN_CAP, scopeMode);
+        interactiveMaps.set(doc, collected.els);
+        const mainRoot = findMainRoot(doc);
+        const within = request.within;
+        const textRows =
+          within?.text?.trim() ? rowContainersMatchingText(doc, within.text.trim()) : null;
+        const needle = request.filter?.trim().toLowerCase() ?? "";
+        const banned = request.exclude?.trim().toLowerCase() ?? "";
+        const wantState = request.state ?? "any";
+        const wantRegion = request.region ?? "any";
+
+        type FormField = {
+          i: number;
+          tag: string;
+          type: string;
+          label: string;
+          name?: string;
+          placeholder?: string;
+          region: "main" | "nav";
+          disabled?: boolean;
+          hasValue: boolean;
+        };
+
+        const all: FormField[] = [];
+        for (let index = 0; index < collected.els.length; index++) {
+          const el = collected.els[index]!;
+          if (!isFormFieldEl(el)) continue;
+          if (matchesExcludeSelector(el, request.excludeSelector)) continue;
+          if (!matchesWithin(el, within, textRows)) continue;
+          const region = regionOf(el, mainRoot);
+          if (wantRegion !== "any" && region !== wantRegion) continue;
+          const disabled = isDisabled(el);
+          if (wantState === "enabled" && disabled) continue;
+          if (wantState === "disabled" && !disabled) continue;
+          const field = describeFormField(el, index, mainRoot);
+          const hay = [field.label, field.name, field.placeholder, field.type, field.tag]
+            .filter(Boolean)
+            .join(" ")
+            .toLowerCase();
+          if (needle && !hay.includes(needle)) continue;
+          if (banned && hay.includes(banned)) continue;
+          all.push(field);
+        }
+
+        const items = all.slice(offset, offset + limit);
+        const nextOffset = offset + items.length < all.length ? offset + items.length : null;
+        return {
+          ok: true,
+          data: {
+            fields: items,
+            count: items.length,
+            matched: all.length,
+            total: collected.els.length,
+            offset,
+            nextOffset,
+            hasMore: nextOffset != null,
+            scope: collected.scope,
+            hint:
+              nextOffset != null
+                ? `Showing ${items.length} of ${all.length} fields. Page with list_form_fields({offset:${nextOffset}}). type_index({index:i}) uses the same handles.`
+                : all.length
+                  ? "type_index({index:i}) types into a field; password fields report hasValue only (never the value)."
+                  : 'No fillable fields visible. Click an edit control first (get_interactive({within:{text:"…"}})), then list_form_fields again.',
+          },
+        };
+      }
       case "press_key": {
         const key = request.key;
         const target =
@@ -893,6 +1111,128 @@ function interactiveHaystack(it: InteractiveItem): string {
     .toLowerCase();
 }
 
+const NON_FILLABLE_INPUT_TYPES = new Set([
+  "button",
+  "submit",
+  "reset",
+  "image",
+  "hidden",
+]);
+
+/** Fillable controls for list_form_fields (subset of the interactive map). */
+function isFormFieldEl(el: HTMLElement): boolean {
+  if (el.tagName === "TEXTAREA" || el.tagName === "SELECT") return true;
+  if (el.isContentEditable) return true;
+  if (el.tagName === "INPUT") {
+    return !NON_FILLABLE_INPUT_TYPES.has(resolveInputType(el as HTMLInputElement));
+  }
+  return false;
+}
+
+function resolveFieldLabel(el: HTMLElement): string {
+  const doc = el.ownerDocument;
+  const id = el.id?.trim();
+  if (id) {
+    try {
+      const esc =
+        typeof CSS !== "undefined" && typeof CSS.escape === "function"
+          ? CSS.escape(id)
+          : id.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+      const byFor = doc.querySelector(`label[for="${esc}"]`);
+      const t = (byFor?.textContent ?? "").trim().replace(/\s+/g, " ");
+      if (t) return t.slice(0, 120);
+    } catch {
+      /* ignore */
+    }
+  }
+  const wrap = el.closest("label");
+  if (wrap) {
+    const clone = wrap.cloneNode(true) as HTMLElement;
+    for (const nested of Array.from(
+      clone.querySelectorAll("input, textarea, select, button"),
+    )) {
+      nested.remove();
+    }
+    const t = (clone.textContent ?? "").trim().replace(/\s+/g, " ");
+    if (t) return t.slice(0, 120);
+  }
+  const aria = el.getAttribute("aria-label")?.trim();
+  if (aria) return aria.slice(0, 120);
+  const labelledBy = el.getAttribute("aria-labelledby")?.trim();
+  if (labelledBy) {
+    const parts = labelledBy
+      .split(/\s+/)
+      .map((ref) => (doc.getElementById(ref)?.textContent ?? "").trim().replace(/\s+/g, " "))
+      .filter(Boolean);
+    if (parts.length) return parts.join(" ").slice(0, 120);
+  }
+  // Nearest preceding label-ish text (dt/th/label/span) in the same row/container.
+  let sib: Element | null = el.previousElementSibling;
+  for (let i = 0; i < 4 && sib; i++, sib = sib.previousElementSibling) {
+    const tag = sib.tagName;
+    if (tag === "LABEL" || tag === "TH" || tag === "DT" || tag === "SPAN" || tag === "DIV") {
+      if (sib.querySelector(INTERACTIVE_SEL)) continue;
+      const t = (sib.textContent ?? "").trim().replace(/\s+/g, " ");
+      if (t && t.length < 80) return t.slice(0, 120);
+    }
+  }
+  const row = el.closest("td, th, [role='cell'], [role='gridcell']");
+  const prevCell = row?.previousElementSibling;
+  if (prevCell && (prevCell.tagName === "TH" || prevCell.tagName === "TD")) {
+    const t = (prevCell.textContent ?? "").trim().replace(/\s+/g, " ");
+    if (t && t.length < 80) return t.slice(0, 120);
+  }
+  return "";
+}
+
+function fieldHasValue(el: HTMLElement): boolean {
+  if (isInputEl(el) || isTextAreaEl(el)) return (el.value ?? "").length > 0;
+  if (el.tagName === "SELECT") {
+    const sel = el as HTMLSelectElement;
+    return (sel.value ?? "").length > 0;
+  }
+  if (el.isContentEditable) return (el.textContent ?? "").trim().length > 0;
+  return false;
+}
+
+function describeFormField(
+  el: HTMLElement,
+  index: number,
+  mainRoot: HTMLElement | null,
+): {
+  i: number;
+  tag: string;
+  type: string;
+  label: string;
+  name?: string;
+  placeholder?: string;
+  region: "main" | "nav";
+  disabled?: boolean;
+  hasValue: boolean;
+} {
+  const type = isInputEl(el)
+    ? resolveInputType(el)
+    : el.tagName === "TEXTAREA"
+      ? "textarea"
+      : el.tagName === "SELECT"
+        ? "select"
+        : el.isContentEditable
+          ? "contenteditable"
+          : el.tagName.toLowerCase();
+  return {
+    i: index,
+    tag: el.tagName.toLowerCase(),
+    type,
+    label: resolveFieldLabel(el),
+    name: el.getAttribute("name") ?? undefined,
+    placeholder:
+      isInputEl(el) || isTextAreaEl(el) ? el.placeholder || undefined : undefined,
+    region: regionOf(el, mainRoot),
+    disabled: isDisabled(el) || undefined,
+    hasValue: fieldHasValue(el),
+  };
+}
+
 /** Inputs that accept free-text titles (not temporal/numeric constrained types). */
 const FREE_TEXT_INPUT_TYPES = new Set([
   "text",
diff --git a/packages/core/src/browser/rowScope.test.ts b/packages/core/src/browser/rowScope.test.ts
new file mode 100644
index 0000000..229edc3
--- /dev/null
+++ b/packages/core/src/browser/rowScope.test.ts
@@ -0,0 +1,177 @@
+/**
+ * Acceptance fixture for the Base44-style failure mode (2026-08-03):
+ * chat column + 5-row meta-tags table with unlabeled pencils + a labeled form.
+ */
+import { beforeEach, describe, expect, it } from "vitest";
+import { handleContentRequest } from "./content-handlers.js";
+import { toolArgsToContentRequest } from "./tools.js";
+
+function renderAcceptanceFixture(): void {
+  document.body.innerHTML = `
+    <div id="app">
+      <aside data-testid="chat-panel">
+        <p>Description: old chat message about FaqPage</p>
+        <p>Description: another chat hit</p>
+        <button>Send chat</button>
+      </aside>
+      <main>
+        <h1>Per-Page Meta Tags</h1>
+        <table>
+          <tbody>
+            <tr><td>HomePage</td><td>Home</td><td>Welcome</td>
+              <td><button class="edit" aria-label=""></button></td></tr>
+            <tr><td>AboutPage</td><td>About</td><td>About us</td>
+              <td><button class="edit" aria-label=""></button></td></tr>
+            <tr><td>Row3</td><td>Row three</td><td>Desc three</td>
+              <td><button class="edit" id="pencil-row3" aria-label=""></button></td></tr>
+            <tr><td>FaqPage</td><td>FAQ</td><td>Answers</td>
+              <td><button class="edit" id="pencil-faq" aria-label=""></button></td></tr>
+            <tr><td>ContactPage</td><td>Contact</td><td>Reach us</td>
+              <td><button class="edit" aria-label=""></button></td></tr>
+          </tbody>
+        </table>
+        <form id="meta-form">
+          <label for="title-input">Page title</label>
+          <input id="title-input" name="title" type="text" value="FAQ" />
+          <label>Description<textarea name="description" placeholder="Meta description"></textarea></label>
+          <input aria-label="Canonical URL" name="canonical" type="url" />
+          <input name="secret" type="password" value="s3cret!" />
+        </form>
+      </main>
+    </div>`;
+}
+
+describe("acceptance: within + excludeSelector + list_form_fields", () => {
+  beforeEach(renderAcceptanceFixture);
+
+  it("get_interactive({within:{text:'Row3'}}) returns exactly that row's pencil with absolute i", () => {
+    const all = handleContentRequest(
+      { op: "get_interactive", scope: "page", region: "any" },
+      document,
+    ).data as { items: { i: number; tag: string; text: string }[]; total: number };
+
+    const scoped = handleContentRequest(
+      { op: "get_interactive", scope: "page", region: "any", within: { text: "Row3" } },
+      document,
+    ).data as { items: { i: number; tag: string }[]; matched: number };
+
+    expect(scoped.matched).toBe(1);
+    expect(scoped.items).toHaveLength(1);
+    const pencil = scoped.items[0]!;
+    expect(pencil.tag).toBe("button");
+    // Absolute index: same handle as in the unfiltered scan.
+    expect(all.items.find((it) => it.i === pencil.i)?.tag).toBe("button");
+    expect(document.getElementById("pencil-row3")).toBeTruthy();
+
+    const clicked = handleContentRequest({ op: "click_index", index: pencil.i }, document);
+    expect(clicked.ok).toBe(true);
+  });
+
+  it("find_text({excludeSelector:'aside'}) drops chat hits and keeps workspace hits", () => {
+    const noisy = handleContentRequest(
+      { op: "find_text", text: "Description", region: "any" },
+      document,
+    ).data as { total: number; matches: { text: string; tag: string }[] };
+    expect(noisy.total).toBeGreaterThanOrEqual(2);
+
+    const clean = handleContentRequest(
+      { op: "find_text", text: "Description", excludeSelector: "aside" },
+      document,
+    ).data as { total: number; matches: { text: string }[] };
+    expect(clean.matches.every((m) => !m.text.includes("old chat"))).toBe(true);
+    expect(clean.total).toBeLessThan(noisy.total);
+  });
+
+  it("get_page({excludeSelector:'aside'}) prunes the chat column", () => {
+    const full = handleContentRequest({ op: "get_page", mode: "full" }, document).data as {
+      text: string;
+    };
+    expect(full.text).toContain("old chat message");
+
+    const pruned = handleContentRequest(
+      { op: "get_page", mode: "full", excludeSelector: "aside,[data-testid='chat-panel']" },
+      document,
+    ).data as { text: string };
+    expect(pruned.text).not.toContain("old chat message");
+    expect(pruned.text).toContain("Per-Page Meta Tags");
+    expect(pruned.text).toContain("FaqPage");
+  });
+
+  it("get_interactive({excludeSelector:'aside'}) hides chat controls but keeps absolute i", () => {
+    const all = handleContentRequest(
+      { op: "get_interactive", scope: "page", region: "any" },
+      document,
+    ).data as { items: { i: number; text: string }[]; total: number };
+    const pruned = handleContentRequest(
+      { op: "get_interactive", scope: "page", region: "any", excludeSelector: "aside" },
+      document,
+    ).data as { items: { i: number; text: string }[]; total: number; matched: number };
+    expect(pruned.total).toBe(all.total);
+    expect(pruned.items.some((it) => it.text.includes("Send chat"))).toBe(false);
+    expect(pruned.matched).toBeLessThan(all.items.length);
+    for (const item of pruned.items) {
+      expect(all.items.find((a) => a.i === item.i)?.text).toBe(item.text);
+    }
+  });
+
+  it("list_form_fields maps 3 labeling styles + password hasValue only", () => {
+    const data = handleContentRequest(
+      { op: "list_form_fields", scope: "page", region: "any" },
+      document,
+    ).data as {
+      fields: Array<{
+        i: number;
+        label: string;
+        type: string;
+        name?: string;
+        hasValue: boolean;
+        value?: unknown;
+      }>;
+    };
+
+    const byName = Object.fromEntries(
+      data.fields.filter((f) => f.name).map((f) => [f.name!, f]),
+    );
+    expect(byName.title?.label).toMatch(/Page title/i);
+    expect(byName.description?.label).toMatch(/Description/i);
+    expect(byName.canonical?.label).toMatch(/Canonical URL/i);
+    expect(byName.secret?.type).toBe("password");
+    expect(byName.secret?.hasValue).toBe(true);
+    expect(byName.secret).not.toHaveProperty("value");
+    // Serialized payload must never leak the password.
+    expect(JSON.stringify(data)).not.toContain("s3cret!");
+
+    // type_index works on the same absolute handle.
+    const title = byName.title!;
+    const typed = handleContentRequest(
+      { op: "type_index", index: title.i, text: "New FAQ title" },
+      document,
+    );
+    expect(typed.ok).toBe(true);
+    expect((document.getElementById("title-input") as HTMLInputElement).value).toBe(
+      "New FAQ title",
+    );
+  });
+
+  it("toolArgsToContentRequest maps within + excludeSelector + list_form_fields", () => {
+    expect(
+      toolArgsToContentRequest("get_interactive", {
+        within: { text: "FaqPage" },
+        excludeSelector: "aside",
+      }),
+    ).toMatchObject({
+      op: "get_interactive",
+      within: { text: "FaqPage" },
+      excludeSelector: "aside",
+    });
+    expect(
+      toolArgsToContentRequest("find_text", {
+        text: "Description",
+        excludeSelector: "aside",
+      }),
+    ).toMatchObject({ excludeSelector: "aside" });
+    expect(
+      toolArgsToContentRequest("list_form_fields", { region: "main", excludeSelector: "aside" }),
+    ).toMatchObject({ op: "list_form_fields", region: "main", excludeSelector: "aside" });
+  });
+});
diff --git a/packages/core/src/browser/tools.test.ts b/packages/core/src/browser/tools.test.ts
index a135438..707ad58 100644
--- a/packages/core/src/browser/tools.test.ts
+++ b/packages/core/src/browser/tools.test.ts
@@ -10,6 +10,7 @@ describe("tool helpers", () => {
         "get_page",
         "page_digest",
         "get_interactive",
+        "list_form_fields",
         "click_index",
         "type_index",
         "query_all",
diff --git a/packages/core/src/browser/tools.ts b/packages/core/src/browser/tools.ts
index 6746966..a6dfb74 100644
--- a/packages/core/src/browser/tools.ts
+++ b/packages/core/src/browser/tools.ts
@@ -8,7 +8,7 @@ export const AGENT_TOOLS: ToolDefinition[] = [
     function: {
       name: "get_page",
       description:
-        "Read the active tab's text. Default mode=main strips nav/header/footer chrome (on app consoles the chrome is most of the page). Reply carries totalChars/nextOffset/hasMore — when hasMore, call again with offset:<nextOffset> instead of giving up. filter:\"word\" keeps only matching lines (grep a long doc). mode=full includes chrome; mode=structure = page_digest; mode=snippet = short main-only peek.",
+        "Read the active tab's text. Default mode=main strips nav/header/footer chrome (on app consoles the chrome is most of the page). Reply carries totalChars/nextOffset/hasMore — when hasMore, call again with offset:<nextOffset> instead of giving up. filter:\"word\" keeps only matching lines (grep a long doc). excludeSelector:\"aside,[data-testid=chat-panel]\" prunes noisy CSS subtrees (chat sidebars, cookie walls) before extraction. mode=full includes chrome; mode=structure = page_digest; mode=snippet = short main-only peek.",
       parameters: {
         type: "object",
         properties: {
@@ -21,6 +21,11 @@ export const AGENT_TOOLS: ToolDefinition[] = [
             description:
               "Drop lines containing this substring. Use it to strip boilerplate that repeats on every read (cookie banners, legal footers, icon-font ligatures).",
           },
+          excludeSelector: {
+            type: "string",
+            description:
+              "CSS selector (comma list ok) — prune matching subtrees before reading. Example: aside,[data-testid='chat-panel'] for a chat column.",
+          },
         },
         additionalProperties: false,
       },
@@ -73,7 +78,7 @@ export const AGENT_TOOLS: ToolDefinition[] = [
     function: {
       name: "get_interactive",
       description:
-        "Indexed list of controls; act with click_index/type_index using item.i. CHERRY-PICK instead of dumping — describe the control you want and let the filters do the work: filter:\"Save\" matches label/aria/name/placeholder/href, exclude drops noise, kind narrows to link|button|input|select, region:\"main\" drops nav/header/footer, state:\"enabled\" hides controls that cannot be clicked yet, requireLabel:true hides bare icon buttons, and fields:[\"text\"] returns only the keys you will read. item.i is an absolute handle into the full scan, so filtering, projecting and paging never break click_index. Reply carries matched/total/nextOffset/regionCounts — when hasMore, page with offset. item.disabled marks dead controls: clicking one wastes a turn. Default scope=auto scopes to the topmost dialog/menu/portal (ignoring rows-per-page listboxes); scope=page forces the full document. Stuck in a menu? press_key Escape then scope:\"page\". Check item.type before type_index (never free-text into type=time).",
+        "Indexed list of controls; act with click_index/type_index using item.i. CHERRY-PICK: filter:\"Save\", kind, region:\"main\", state:\"enabled\", requireLabel, fields:[\"text\"], excludeSelector:\"aside\" (drop chat/cookie chrome), within:{text:\"FaqPage\"} (row scope — the unlabeled pencil in the row containing FaqPage). item.i is an absolute handle into the full scan, so filtering/within/paging never break click_index. Reply carries matched/total/nextOffset/regionCounts. Default scope=auto scopes to the topmost dialog/menu; scope=page forces the full document. Stuck in a menu? press_key Escape then scope:\"page\". Check item.type before type_index (never free-text into type=time).",
       parameters: {
         type: "object",
         properties: {
@@ -122,6 +127,61 @@ export const AGENT_TOOLS: ToolDefinition[] = [
               "Return only these keys per control (i is always included). fields:[\"text\"] makes a 100-control listing tiny.",
           },
           scope: { type: "string", enum: ["auto", "page", "dialog"] },
+          excludeSelector: {
+            type: "string",
+            description:
+              "CSS selector (comma list ok) — drop controls inside matching subtrees. Example: aside,[data-testid='chat-panel'].",
+          },
+          within: {
+            type: "object",
+            description:
+              "Row scope after the full scan. Example: within:{text:\"FaqPage\"} → the pencil in that table row; item.i stays click_index-ready.",
+            properties: {
+              selector: {
+                type: "string",
+                description: "Keep controls whose row container matches this CSS selector",
+              },
+              text: {
+                type: "string",
+                description:
+                  "Keep controls whose row/list container contains this substring (case-insensitive)",
+              },
+            },
+            additionalProperties: false,
+          },
+        },
+        additionalProperties: false,
+      },
+    },
+  },
+  {
+    type: "function",
+    function: {
+      name: "list_form_fields",
+      description:
+        "Inventory of fillable fields on the page (input/textarea/select/contenteditable) with resolved labels — one call for \"what can I fill in?\". Returns {i,tag,type,label,name,placeholder,region,disabled,hasValue}; i is the same absolute handle as get_interactive so type_index works directly. Password fields report hasValue only (never the value). Same scope/region/exclude/excludeSelector/within as get_interactive. Example: list_form_fields({excludeSelector:\"aside\"}) after opening an inline editor.",
+      parameters: {
+        type: "object",
+        properties: {
+          limit: { type: "number" },
+          offset: { type: "number" },
+          filter: { type: "string", description: "Substring of label/name/placeholder/type" },
+          exclude: { type: "string" },
+          region: { type: "string", enum: ["any", "main", "nav"] },
+          state: { type: "string", enum: ["any", "enabled", "disabled"] },
+          scope: { type: "string", enum: ["auto", "page", "dialog"] },
+          excludeSelector: {
+            type: "string",
+            description: "CSS selector — drop fields inside matching subtrees",
+          },
+          within: {
+            type: "object",
+            properties: {
+              selector: { type: "string" },
+              text: { type: "string" },
+            },
+            additionalProperties: false,
+          },
         },
         additionalProperties: false,
       },
@@ -295,7 +355,7 @@ export const AGENT_TOOLS: ToolDefinition[] = [
     function: {
       name: "find_text",
       description:
-        "Search visible text and get back an ACTIONABLE handle: each hit reports region plus interactiveIndex when it sits inside a control, so you can click_index({index:<interactiveIndex>}) straight away. Best way to locate one labelled thing on a huge page — cheaper than get_page. To go straight to a button, pass clickableOnly:true and every hit is click-ready. region:\"main\" ignores the same label repeated in the sidebar; exclude drops known-noisy matches. Carries total/nextOffset for paging; context:N adds surrounding chars.",
+        "Search visible text and get back an ACTIONABLE handle: each hit reports region plus interactiveIndex when it sits inside a control, so you can click_index({index:<interactiveIndex>}) straight away. Best way to locate one labelled thing on a huge page — cheaper than get_page. clickableOnly:true keeps only click-ready hits. region:\"main\" ignores sidebar repeats; excludeSelector:\"aside\" drops chat-column noise (substring exclude cannot). Carries total/nextOffset for paging; context:N adds surrounding chars.",
       parameters: {
         type: "object",
         properties: {
@@ -310,6 +370,11 @@ export const AGENT_TOOLS: ToolDefinition[] = [
           },
           region: { type: "string", enum: ["any", "main", "nav"] },
           exclude: { type: "string", description: "Drop hits whose text contains this substring" },
+          excludeSelector: {
+            type: "string",
+            description:
+              "CSS selector (comma list ok) — skip hits inside matching subtrees. Example: aside,[data-testid='chat-panel'].",
+          },
         },
         required: ["text"],
         additionalProperties: false,
@@ -2206,6 +2271,16 @@ export function toolArgsToContentRequest(
     return kept.length ? kept : undefined;
   };
   const REGIONS = ["any", "main", "nav"] as const;
+  const withinArg = (
+    value: unknown,
+  ): { selector?: string; text?: string } | undefined => {
+    if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
+    const obj = value as Record<string, unknown>;
+    const selector = str(obj.selector);
+    const text = str(obj.text);
+    if (!selector && !text) return undefined;
+    return { ...(selector ? { selector } : {}), ...(text ? { text } : {}) };
+  };
 
   switch (name) {
     case "get_page":
@@ -2222,6 +2297,7 @@ export function toolArgsToContentRequest(
         offset: typeof args.offset === "number" ? Math.max(0, Math.floor(args.offset)) : undefined,
         filter: str(args.filter),
         exclude: str(args.exclude),
+        excludeSelector: str(args.excludeSelector),
       };
     case "page_digest":
       return { op: "page_digest" };
@@ -2286,6 +2362,7 @@ export function toolArgsToContentRequest(
         clickableOnly: flag(args.clickableOnly),
         region: pick(args.region, REGIONS),
         exclude: str(args.exclude),
+        excludeSelector: str(args.excludeSelector),
       };
     case "get_interactive":
       return {
@@ -2312,6 +2389,21 @@ export function toolArgsToContentRequest(
           "disabled",
         ] as const),
         scope: pick(args.scope, ["auto", "page", "dialog"] as const),
+        excludeSelector: str(args.excludeSelector),
+        within: withinArg(args.within),
+      };
+    case "list_form_fields":
+      return {
+        op: "list_form_fields",
+        limit: typeof args.limit === "number" ? args.limit : 80,
+        offset: typeof args.offset === "number" ? Math.max(0, Math.floor(args.offset)) : undefined,
+        filter: str(args.filter),
+        exclude: str(args.exclude),
+        region: pick(args.region, REGIONS),
+        state: pick(args.state, ["any", "enabled", "disabled"] as const),
+        scope: pick(args.scope, ["auto", "page", "dialog"] as const),
+        excludeSelector: str(args.excludeSelector),
+        within: withinArg(args.within),
       };
     case "press_key": {
       const key = args.key;
diff --git a/packages/core/src/protocol/messages.ts b/packages/core/src/protocol/messages.ts
index e1151ac..5714c8c 100644
--- a/packages/core/src/protocol/messages.ts
+++ b/packages/core/src/protocol/messages.ts
@@ -15,6 +15,7 @@ export const BrowserToolNameSchema = z.enum([
   "wait",
   "find_text",
   "get_interactive",
+  "list_form_fields",
   "press_key",
   "click_index",
   "type_index",
@@ -122,6 +123,8 @@ export const ContentRequestSchema = z.discriminatedUnion("op", [
     filter: z.string().max(200).optional(),
     /** Drop lines containing this substring — strips repeated boilerplate. */
     exclude: z.string().max(200).optional(),
+    /** Prune matching CSS subtrees before extraction (chat sidebars, cookie walls). */
+    excludeSelector: z.string().max(500).optional(),
   }),
   z.object({ op: z.literal("page_digest") }),
   z.object({
@@ -176,6 +179,8 @@ export const ContentRequestSchema = z.discriminatedUnion("op", [
     clickableOnly: z.boolean().optional(),
     region: z.enum(["any", "main", "nav"]).optional(),
     exclude: z.string().max(200).optional(),
+    /** Skip hits inside matching CSS subtrees (chat sidebars, cookie walls). */
+    excludeSelector: z.string().max(500).optional(),
   }),
   z.object({
     op: z.literal("get_interactive"),
@@ -199,6 +204,35 @@ export const ContentRequestSchema = z.discriminatedUnion("op", [
       .array(z.enum(["tag", "kind", "region", "role", "text", "href", "type", "placeholder", "name", "title", "disabled"]))
       .max(11)
       .optional(),
+    /** Drop controls inside matching CSS subtrees (chat sidebars, cookie walls). */
+    excludeSelector: z.string().max(500).optional(),
+    /**
+     * Post-scan row scope: keep controls whose row container matches selector
+     * and/or contains text (e.g. the pencil in the row containing "FaqPage").
+     */
+    within: z
+      .object({
+        selector: z.string().max(500).optional(),
+        text: z.string().max(200).optional(),
+      })
+      .optional(),
+  }),
+  z.object({
+    op: z.literal("list_form_fields"),
+    limit: z.number().int().positive().max(120).optional(),
+    scope: z.enum(["auto", "page", "dialog"]).optional(),
+    offset: z.number().int().min(0).max(10_000).optional(),
+    filter: z.string().max(200).optional(),
+    exclude: z.string().max(200).optional(),
+    region: z.enum(["any", "main", "nav"]).optional(),
+    state: z.enum(["any", "enabled", "disabled"]).optional(),
+    excludeSelector: z.string().max(500).optional(),
+    within: z
+      .object({
+        selector: z.string().max(500).optional(),
+        text: z.string().max(200).optional(),
+      })
+      .optional(),
   }),
   z.object({
     op: z.literal("press_key"),
diff --git a/packages/core/src/tools/catalog.ts b/packages/core/src/tools/catalog.ts
index 930725b..84c4fe0 100644
--- a/packages/core/src/tools/catalog.ts
+++ b/packages/core/src/tools/catalog.ts
@@ -346,6 +346,7 @@ const TOOL_GROUP: Record<string, ToolGroup> = {
   page_digest: "browser",
   get_links: "browser",
   get_interactive: "browser",
+  list_form_fields: "browser",
   press_key: "browser",
   click_index: "browser",
   type_index: "browser",
diff --git a/packages/core/src/tools/gating.ts b/packages/core/src/tools/gating.ts
index c22c9ca..89591e2 100644
--- a/packages/core/src/tools/gating.ts
+++ b/packages/core/src/tools/gating.ts
@@ -24,6 +24,7 @@ export const ALWAYS_ON_TOOL_NAMES: readonly string[] = [
   "get_page",
   "get_links",
   "get_interactive",
+  "list_form_fields",
   "press_key",
   "click_index",
   "type_index",