@agent-native/core-corpus 0.210.2 → 0.211.0

package/corpus/templates/design/e2e/global-setup.ts

@@ -28,6 +28,46 @@ const STATE_PATH = path.join(AUTH_DIR, "state.json");
 const SEED_PATH = path.join(AUTH_DIR, "seed.json");
 const BROWSER_CHANNEL = process.env.E2E_BROWSER_CHANNEL;
 const LOOPBACK_INSTANCE_HEADER = "x-agent-native-loopback-instance";
+const GLOBAL_SETUP_BUDGET_MS = 11 * 60_000;
+const SEED_BUDGET_MS = 2 * 60_000;
+const HOME_WARMUP_BUDGET_MS = 6 * 60_000;
+const HOME_RECOVERY_DETECTION_BUDGET_MS = 30_000;
+const HOME_RECOVERY_RETRY_BUDGET_MS = 2 * 60_000;
+const HOME_INITIAL_NAVIGATION_BUDGET_MS =
+  HOME_WARMUP_BUDGET_MS -
+  HOME_RECOVERY_DETECTION_BUDGET_MS -
+  HOME_RECOVERY_RETRY_BUDGET_MS;
+const EDITOR_WARMUP_BUDGET_MS = 3 * 60_000;
+
+async function withDeadline<T>(
+  label: string,
+  deadline: number,
+  action: () => Promise<T>,
+): Promise<T> {
+  const remainingMs = deadline - Date.now();
+  if (remainingMs <= 0) throw new Error(`${label} budget expired`);
+
+  let timeout: ReturnType<typeof setTimeout> | undefined;
+  try {
+    return await Promise.race([
+      action(),
+      new Promise<never>((_, reject) => {
+        timeout = setTimeout(
+          () => reject(new Error(`${label} budget expired`)),
+          remainingMs,
+        );
+      }),
+    ]);
+  } finally {
+    if (timeout) clearTimeout(timeout);
+  }
+}
+
+function timeoutBefore(deadline: number, requestedMs: number): number {
+  const remainingMs = deadline - Date.now();
+  if (remainingMs <= 0) throw new Error("the warmup budget expired");
+  return Math.min(requestedMs, remainingMs);
+}
 
 export async function startLoopbackProvider(port: number): Promise<void> {
   const runRoot = designE2eRunRoot(path.resolve(import.meta.dirname, ".."));
@@ -331,6 +371,7 @@ async function seedMentionMember(
 }
 
 export default async function globalSetup(config: FullConfig) {
+  const globalSetupDeadline = Date.now() + GLOBAL_SETUP_BUDGET_MS;
   if (process.env.E2E_AI_SIDEBAR_LOOPBACK === "1") {
     await startLoopbackProvider(config.metadata.sidebarLoopbackPort as number);
     await startHttpsAttachmentStorage(
@@ -348,79 +389,165 @@ export default async function globalSetup(config: FullConfig) {
   const context = await browser.newContext();
 
   try {
-    const registration = await context.request.post(
-      `${baseURL}/_agent-native/auth/register`,
-      {
-        data: {
-          email: E2E_EMAIL,
-          password: E2E_PASSWORD,
-        },
-        headers: { "Content-Type": "application/json" },
-      },
+    const seedDeadline = Math.min(
+      Date.now() + SEED_BUDGET_MS,
+      globalSetupDeadline - HOME_WARMUP_BUDGET_MS - EDITOR_WARMUP_BUDGET_MS,
     );
-    if (!registration.ok() && registration.status() !== 409) {
-      throw new Error(
-        `registration failed: ${registration.status()} ${await registration.text()}`,
-      );
-    }
+    const designId = await withDeadline(
+      "Design E2E seeding",
+      seedDeadline,
+      async () => {
+        const registration = await context.request.post(
+          `${baseURL}/_agent-native/auth/register`,
+          {
+            data: {
+              email: E2E_EMAIL,
+              password: E2E_PASSWORD,
+            },
+            headers: { "Content-Type": "application/json" },
+          },
+        );
+        if (!registration.ok() && registration.status() !== 409) {
+          throw new Error(
+            `registration failed: ${registration.status()} ${await registration.text()}`,
+          );
+        }
 
-    const login = await context.request.post(
-      `${baseURL}/_agent-native/auth/login`,
-      {
-        data: {
-          email: E2E_EMAIL,
-          password: E2E_PASSWORD,
-        },
-        headers: { "Content-Type": "application/json" },
-      },
-    );
-    if (!login.ok()) {
-      throw new Error(`login failed: ${login.status()} ${await login.text()}`);
-    }
+        const login = await context.request.post(
+          `${baseURL}/_agent-native/auth/login`,
+          {
+            data: {
+              email: E2E_EMAIL,
+              password: E2E_PASSWORD,
+            },
+            headers: { "Content-Type": "application/json" },
+          },
+        );
+        if (!login.ok()) {
+          throw new Error(
+            `login failed: ${login.status()} ${await login.text()}`,
+          );
+        }
 
-    await context.storageState({ path: STATE_PATH });
+        await context.storageState({ path: STATE_PATH });
 
-    const created = await postAction(
-      context.request,
-      baseURL,
-      "create-design",
-      {
-        title: SEED_TITLE,
-        projectType: "prototype",
+        const created = await postAction(
+          context.request,
+          baseURL,
+          "create-design",
+          {
+            title: SEED_TITLE,
+            projectType: "prototype",
+          },
+        );
+        const createdDesignId: string =
+          created?.id ?? created?.data?.id ?? created?.design?.id;
+        if (!createdDesignId) {
+          throw new Error(
+            `create-design did not return an id: ${JSON.stringify(created)}`,
+          );
+        }
+        await seedMentionMember(browser, context, baseURL);
+        await postAction(context.request, baseURL, "create-file", {
+          designId: createdDesignId,
+          filename: "index.html",
+          content: FIXTURE_HTML,
+          fileType: "html",
+        });
+        await postAction(context.request, baseURL, "index-components", {
+          designId: createdDesignId,
+        });
+
+        await writeFile(
+          SEED_PATH,
+          JSON.stringify({ designId: createdDesignId }, null, 2),
+        );
+        // eslint-disable-next-line no-console
+        console.log(`[e2e] seeded design ${createdDesignId} for ${E2E_EMAIL}`);
+        return createdDesignId;
       },
     );
-    const designId: string =
-      created?.id ?? created?.data?.id ?? created?.design?.id;
-    if (!designId) {
-      throw new Error(
-        `create-design did not return an id: ${JSON.stringify(created)}`,
-      );
-    }
-    await seedMentionMember(browser, context, baseURL);
-    await postAction(context.request, baseURL, "create-file", {
-      designId,
-      filename: "index.html",
-      content: FIXTURE_HTML,
-      fileType: "html",
-    });
-    await postAction(context.request, baseURL, "index-components", {
-      designId,
-    });
-
-    await writeFile(SEED_PATH, JSON.stringify({ designId }, null, 2));
-    // eslint-disable-next-line no-console
-    console.log(`[e2e] seeded design ${designId} for ${E2E_EMAIL}`);
 
+    const homeDeadline = Math.min(
+      Date.now() + HOME_WARMUP_BUDGET_MS,
+      globalSetupDeadline - EDITOR_WARMUP_BUDGET_MS,
+    );
+    const homeRecoveryDeadline = homeDeadline - HOME_RECOVERY_RETRY_BUDGET_MS;
+    const homeInitialNavigationDeadline =
+      homeRecoveryDeadline - HOME_RECOVERY_DETECTION_BUDGET_MS;
     const warmupPage = await context.newPage();
     try {
+      const homeURL = `${baseURL}/home`;
+      const homeComposer = warmupPage.locator("[data-design-home-composer]");
+      let homeComposerWarmed = false;
+      try {
+        await warmupPage.goto(homeURL, {
+          waitUntil: "domcontentloaded",
+          timeout: timeoutBefore(
+            homeInitialNavigationDeadline,
+            HOME_INITIAL_NAVIGATION_BUDGET_MS,
+          ),
+        });
+        const homeRecoveryDetectionDeadline = Math.min(
+          homeRecoveryDeadline,
+          Date.now() + HOME_RECOVERY_DETECTION_BUDGET_MS,
+        );
+        await homeComposer.waitFor({
+          state: "visible",
+          timeout: timeoutBefore(
+            homeRecoveryDetectionDeadline,
+            HOME_RECOVERY_DETECTION_BUDGET_MS,
+          ),
+        });
+        homeComposerWarmed = true;
+      } catch (error) {
+        const hasViteRecoveryMarker = new URL(
+          warmupPage.url(),
+        ).searchParams.has("__an_vite_dev_recovery");
+        if (hasViteRecoveryMarker) {
+          try {
+            await warmupPage.goto(homeURL, {
+              waitUntil: "domcontentloaded",
+              timeout: timeoutBefore(homeDeadline, HOME_WARMUP_BUDGET_MS),
+            });
+            await homeComposer.waitFor({
+              state: "visible",
+              timeout: timeoutBefore(homeDeadline, HOME_WARMUP_BUDGET_MS),
+            });
+            homeComposerWarmed = true;
+          } catch (recoveryError) {
+            // eslint-disable-next-line no-console
+            console.warn(
+              `[e2e] home warmup did not finish after Vite recovery (${(recoveryError as Error).message.split("\n")[0]}); ` +
+                "the first test touching /home will pay the compile.",
+            );
+          }
+        } else {
+          // Home tests remain responsible for reporting any warmup failure.
+          // eslint-disable-next-line no-console
+          console.warn(
+            `[e2e] home warmup did not finish (${(error as Error).message.split("\n")[0]}); ` +
+              "the first test touching /home will pay the compile.",
+          );
+        }
+      }
+      if (homeComposerWarmed) {
+        // eslint-disable-next-line no-console
+        console.log("[e2e] home composer warm");
+      }
+
+      const editorDeadline = Math.min(
+        Date.now() + EDITOR_WARMUP_BUDGET_MS,
+        globalSetupDeadline,
+      );
       try {
         await warmupPage.goto(`${baseURL}/design/${designId}`, {
           waitUntil: "domcontentloaded",
-          timeout: 180_000,
+          timeout: timeoutBefore(editorDeadline, 180_000),
         });
         await warmupPage
           .getByRole("button", { name: "Move", exact: true })
-          .waitFor({ timeout: 180_000 });
+          .waitFor({ timeout: timeoutBefore(editorDeadline, 180_000) });
         // eslint-disable-next-line no-console
         console.log("[e2e] editor warm");
       } catch (error) {
@@ -432,33 +559,6 @@ export default async function globalSetup(config: FullConfig) {
             "the first test will pay the compile.",
         );
       }
-
-      if (process.env.E2E_AI_SIDEBAR_LOOPBACK === "1") {
-        const homeURL = `${baseURL}/home`;
-        const homeComposer = warmupPage.locator("[data-design-home-composer]");
-        await warmupPage.goto(homeURL, {
-          waitUntil: "domcontentloaded",
-          timeout: 180_000,
-        });
-        try {
-          await homeComposer.waitFor({ state: "visible", timeout: 30_000 });
-        } catch (error) {
-          if (
-            !new URL(warmupPage.url()).searchParams.has(
-              "__an_vite_dev_recovery",
-            )
-          ) {
-            throw error;
-          }
-          await warmupPage.goto(homeURL, {
-            waitUntil: "domcontentloaded",
-            timeout: 180_000,
-          });
-          await homeComposer.waitFor({ state: "visible", timeout: 30_000 });
-        }
-        // eslint-disable-next-line no-console
-        console.log("[e2e] home composer warm");
-      }
     } finally {
       await warmupPage.close();
     }

package/corpus/templates/dispatch/.agents/skills/actions/references/action-fields.md

@@ -95,9 +95,9 @@ MCP clients see no `outputSchema` by default. Set `mcpOutputSchema: true` (requi
 
 `authorize` decides whether the caller may run the action at all. It wraps
 `run`, so it holds at **all six dispatch sites** — agent tool, HTTP, frontend
-hook, MCP, A2A, CLI — unlike `needsApproval`, which is honoured only in the
-agent loop. Use `authorize` for "not everyone may do this"; use `needsApproval`
-to ask a human to bless one call a permitted caller is already allowed to make.
+hook, MCP, A2A, CLI. Use `authorize` for "not everyone may do this"; use
+`needsApproval` to ask a human to bless one call a permitted caller is already
+allowed to make.
 
 ```ts
 import { coachAccess } from "../lib/access.js"; // defineAppRoles(...)
@@ -140,4 +140,6 @@ export default defineAction({
 
 When the gate is truthy and the call isn't yet approved, the loop emits an `approval_required` event and **stops the turn — `run()` never executes**. A predicate gates conditionally (e.g. only external recipients) and **fails closed**: a throw is treated as "approval required". It receives its own copy of the prepared snapshot of the validated arguments, defaults applied, and the approval binds to the snapshot's hash, so an approved call runs only with the arguments that were approved (a Date binds by its time). The human approves via the chat UI's Approve affordance, which re-issues the turn with the call's `approvalKey`, and only then does the action run.
 
+Approval is given in the app, so HTTP never grants it. The HTTP action route and the generated Workers entry run a gated call only for the proven app UI (a frontend call from the signed-in user, same origin, holding the short-lived UI capability; `isProvenUiRequest`, the proof `uiOnly` uses) or the app's MCP directory widget. Every other HTTP caller (bearer or API key, MCP OAuth token, org service token, A2A, extension iframe, mobile app) gets `409 approval_required`, and a service identity can never approve. The shared client presents the capability with every write from a signed-in session (minted once per user, reused for nine minutes, never for reads or public pages), so a gated button works on its first request. A call without proof gets `403 ui_capability_required`; the client then re-mints and retries once, which is only the fallback for an expired or rejected capability. Every surface evaluates the gate through `preparedCallNeedsApproval`, so a throwing predicate asks there too. A caller that must run unattended needs a different action, never a bypass of the gate.
+
 **Keep approvals rare** — the default is off and almost every action should leave it off. The canonical example is Mail's `send-email` (`needsApproval: true`). See the `security` skill and the Human Approval doc.

package/corpus/templates/dispatch/CHANGELOG.md

@@ -9,6 +9,10 @@ time from the command menu (Cmd+K → "What's new").
 
 - Apps no longer keep server functions and databases warm by default; set `AGENT_NATIVE_ENABLE_KEEP_WARM=1` to opt in.
 
+### Security
+
+- Vault secrets, grants, link tokens, app access, and workspace connections now ask you to approve each change the agent or another app makes.
+
 ## 2026-10-14
 
 ### Fixed

package/corpus/templates/dispatch/actions/apply-workspace-connection-setup.ts

@@ -118,6 +118,10 @@ export default defineAction({
       .optional()
       .describe("Workspace user group IDs allowed to use the connection."),
   }),
+  // It creates, changes, or revokes a credential or who may use one: every
+  // call needs the user's approval, and "always allow" is not offered.
+  needsApproval: true,
+  allowPersistentApproval: false,
   run: async (args, ctx) => {
     const provider = getWorkspaceConnectionProvider(args.provider);
     if (!provider) {

package/corpus/templates/dispatch/actions/delete-workspace-connection.ts

@@ -27,6 +27,10 @@ export default defineAction({
   schema: z.object({
     id: z.string().describe("Workspace connection ID to delete."),
   }),
+  // It creates, changes, or revokes a credential or who may use one: every
+  // call needs the user's approval, and "always allow" is not offered.
+  needsApproval: true,
+  allowPersistentApproval: false,
   run: async ({ id }, ctx) => {
     const connection = await getWorkspaceConnection(id);
     if (!connection) {

package/corpus/templates/dispatch/actions/set-workspace-connection-grant.ts

@@ -73,6 +73,10 @@ export default defineAction({
         "Known workspace app IDs. Used when converting an all-app connection into selected-app grants.",
       ),
   }),
+  // It creates, changes, or revokes a credential or who may use one: every
+  // call needs the user's approval, and "always allow" is not offered.
+  needsApproval: true,
+  allowPersistentApproval: false,
   run: async (args, ctx) => {
     const connection = await getWorkspaceConnection(args.connectionId);
     if (!connection) {

package/corpus/templates/dispatch/actions/upsert-workspace-connection.ts

@@ -209,6 +209,10 @@ export default defineAction({
       ),
     lastError: z.string().nullable().optional(),
   }),
+  // It creates, changes, or revokes a credential or who may use one: every
+  // call needs the user's approval, and "always allow" is not offered.
+  needsApproval: true,
+  allowPersistentApproval: false,
   run: async (args, ctx) => {
     await assertWorkspaceConnectionManager(ctx, args.allowedApps);
     const provider = getWorkspaceConnectionProvider(args.provider);

package/corpus/templates/dispatch/changelog/2026-10-19-vault-secrets-grants-link-tokens-app-access-and-workspace-co.md

@@ -0,0 +1,6 @@
+---
+type: security
+date: 2026-10-19
+---
+
+Vault secrets, grants, link tokens, app access, and workspace connections now ask you to approve each change the agent or another app makes.

package/corpus/templates/factory/.agents/skills/actions/references/action-fields.md

@@ -95,9 +95,9 @@ MCP clients see no `outputSchema` by default. Set `mcpOutputSchema: true` (requi
 
 `authorize` decides whether the caller may run the action at all. It wraps
 `run`, so it holds at **all six dispatch sites** — agent tool, HTTP, frontend
-hook, MCP, A2A, CLI — unlike `needsApproval`, which is honoured only in the
-agent loop. Use `authorize` for "not everyone may do this"; use `needsApproval`
-to ask a human to bless one call a permitted caller is already allowed to make.
+hook, MCP, A2A, CLI. Use `authorize` for "not everyone may do this"; use
+`needsApproval` to ask a human to bless one call a permitted caller is already
+allowed to make.
 
 ```ts
 import { coachAccess } from "../lib/access.js"; // defineAppRoles(...)
@@ -140,4 +140,6 @@ export default defineAction({
 
 When the gate is truthy and the call isn't yet approved, the loop emits an `approval_required` event and **stops the turn — `run()` never executes**. A predicate gates conditionally (e.g. only external recipients) and **fails closed**: a throw is treated as "approval required". It receives its own copy of the prepared snapshot of the validated arguments, defaults applied, and the approval binds to the snapshot's hash, so an approved call runs only with the arguments that were approved (a Date binds by its time). The human approves via the chat UI's Approve affordance, which re-issues the turn with the call's `approvalKey`, and only then does the action run.
 
+Approval is given in the app, so HTTP never grants it. The HTTP action route and the generated Workers entry run a gated call only for the proven app UI (a frontend call from the signed-in user, same origin, holding the short-lived UI capability; `isProvenUiRequest`, the proof `uiOnly` uses) or the app's MCP directory widget. Every other HTTP caller (bearer or API key, MCP OAuth token, org service token, A2A, extension iframe, mobile app) gets `409 approval_required`, and a service identity can never approve. The shared client presents the capability with every write from a signed-in session (minted once per user, reused for nine minutes, never for reads or public pages), so a gated button works on its first request. A call without proof gets `403 ui_capability_required`; the client then re-mints and retries once, which is only the fallback for an expired or rejected capability. Every surface evaluates the gate through `preparedCallNeedsApproval`, so a throwing predicate asks there too. A caller that must run unattended needs a different action, never a bypass of the gate.
+
 **Keep approvals rare** — the default is off and almost every action should leave it off. The canonical example is Mail's `send-email` (`needsApproval: true`). See the `security` skill and the Human Approval doc.

package/corpus/templates/factory/.agents/skills/review-latest-feedback/SKILL.md

@@ -21,7 +21,25 @@ Four phases, in order. Phase 0 comes before any investigation, not after.
 2. **Fix** what the evidence actually proves, at the owning boundary.
 3. **Reply** with useful questions, then recap.
 
-Output is fixes. For every report root this task owns, keep one concise, current same-actor status reply after the latest human message. It names every verified `✅` scope and its evidence, every open scope, and each `🎫` action and owner (or why a mark does not apply). Add and read back root `✅` as soon as direct post-change proof verifies a scope, and root `🎫` as soon as another person or team must act. An `👀` alone never completes the status. Preserve all reaction history, and follow [`slack-reaction-replies.md`](references/slack-reaction-replies.md). Do not reply on person-assigned or `:mag:` items.
+Output is fixes. For every unheld in-scope report root this task owns, keep one concise, current same-actor status reply after the latest human message. It names every verified `✅` scope and its evidence, every open scope, and each `🎫` action and owner (or why a mark does not apply). Add and read back root `✅` as soon as direct post-change proof verifies a scope, and root `🎫` as soon as another person or team must act. An `👀` alone never completes the status. Preserve all reaction history, and follow [`slack-reaction-replies.md`](references/slack-reaction-replies.md). Do not reply on held, person-assigned, or `:mag:` items.
+
+### Read the root marks as history; use the reply for current status
+
+- `👀` records this workflow's claim. It does not mean the report is still open.
+- `✅` records a scope that passed direct post-change proof. Add it as soon as
+  any scope passes, even when another scope remains open; name the verified
+  scope and evidence in the status reply.
+- `🎫` records a distinct action another person must take, including a reporter
+  request. Keep the reaction as history after that action is completed,
+  answered, or abandoned; the current reply must say whether the action is
+  still open or historical.
+- Every owned root needs one current same-actor reply after the latest human
+  reply. Reuse it while the disposition and evidence remain current; do not
+  send a duplicate progress reply on every sweep. The reply names verified
+  scopes, open scopes, human actions and owners, and why either `✅` or `🎫` is
+  absent. An eye-only root is correct when no scope is verified and no separate
+  human action is pending; say whether the next step is this workflow's
+  investigation or no further action.
 
 ## Slack channels and ownership
 
@@ -34,44 +52,93 @@ channel. For a permalink, its channel ID identifies only where the exact linked
 root must appear; it does not limit the cutoff or channel scope. For an
 explicitly narrowed sweep, verify that the active request names every selected
 channel, then record its exact text and IDs in the separate scope-confirmation
-file. `#dev-agent-native-feedback` is not excluded.
+file. A request can select exactly two channels by linking one report in the
+first and directly asking for “the same in” the second, without saying “only.”
+The checker permits one adjacent-transposition typo in that target only when it
+uniquely matches a selected canonical channel; it rejects incidental or quoted
+mentions and prefixes. See [`channel-inventory.md`](references/channel-inventory.md)
+for the scope gate and its confirmation requirements. `#dev-agent-native-feedback`
+is not excluded.
 
 In every scoped channel, run the complete bot-inclusive `slack_search_public`
 scan with only the channel filter and that channel's inclusive lower bound.
-Exhaust every cursor; `slack_read_channel` cannot replace this inventory. Resolve
-each row to its true parent. Read each report's full thread, attachments, and
-root reactions before classifying, claiming, or skipping it. Follow
+Freeze one `windowEndTs` at sweep start and use it for every channel and
+owned-mark search. Messages newer than it belong to the next scheduled sweep;
+never move the boundary to chase arrivals. Exhaust every cursor;
+`slack_read_channel` cannot replace this inventory. Resolve
+each row to its true parent and read the root reactions before opening the thread.
+If another actor owns any workflow mark (`👀`, `✅`, or `🎫`), or this actor owns
+`:mag:`, apply the held-thread boundary below: do not read the thread, react, or
+reply. Otherwise read the report's full thread and attachments before
+classifying or claiming it. Follow
 [`channel-inventory.md`](references/channel-inventory.md) for exact query
-arguments, raw-page receipts, cap recovery, root classification, all-history
-searches for this actor's `👀`, `✅`, and `🎫`, and checker requirements.
+arguments, raw-page receipts, cap recovery, root classification, fixed-window
+source scans, bounded ownership searches for this actor's `👀`, `✅`, and `🎫`,
+and checker requirements. Owned-mark searches use Slack's exact syntax
+`hasmy::eyes:`, `hasmy::white_check_mark:`, or `hasmy::ticket:` with the channel
+filter and the same inclusive `after` and `before` as that channel's source
+scan. Do not widen a finite catch-up request into an all-history audit. A root
+older than `after` is in scope only when an in-window reply links to it. A
+missing trailing colon is not a valid ownership query.
 
 Only the invoking Slack actor's root marks are owned here. Another task's eye
 plus its current open status remains theirs; an explicit handoff naming this
 task and scope is required to transfer investigation. An eye is a permanent
 claim, not proof of open or completed work. A mark on a reply never claims or
-checks off its parent. Before exit, reconcile every owned root in the full
-inventory, including older marks: latest human reply, current status reply,
-verified scopes, open scopes, human/team actions, and exact root reactions.
-Never let a high eye count hide an unchecked verified scope or a missing
-current reply.
+checks off its parent. Before exit, reconcile every in-window root carrying
+this actor's `👀`, `✅`, or `🎫` found by the bounded searches. Also reconcile an
+older root when an in-window reply links to it. For every owned root, compare
+the latest human reply, current status, verified scopes, open scopes, human
+actions, and exact root reactions.
+Never let a high eye count hide a verified scope without `✅` or a missing
+current status reply.
+
+**Held-thread boundary:** A direct root reaction read showing another person's
+`👀`, `✅`, or `🎫` means the thread belongs to that workflow; this actor's
+`:mag:` means this actor opted out. Record the exact root, reaction owners, and
+one reason (`foreign_workflow_mark` or `mag_opt_out`) in `ownershipSkip`, with
+`Skipped` disposition. When this actor owns both `:mag:` and a workflow mark,
+use `mag_opt_out` and preserve the exact root reaction-owner record as history.
+Do not open/read that thread, inspect reply reactions, add or remove reactions,
+or post a reply. Apply the same skip to channel reply
+rows linked to that root. A linked pre-window root without source text remains
+`unclassified`; do not infer its original report from the reply. This explicit
+exception keeps ownership boundaries intact while allowing the rest of the
+window to be reconciled. A foreign `👀` without current status is still held;
+do not read it to decide whether its owner is active.
 
 Only Steve's `:mag:` and `:yes-party:` count (`U0GCV21HC`). When Steve invokes,
-exhaust `hasmy::mag:` and `hasmy::yes-party:` searches; otherwise inspect root
-reactions. `:mag:` opts out and wins over `:yes-party:`. The latter authorizes
-only an otherwise review-only item; it never overrides an assignment or another
+exhaust `hasmy::mag:` and `hasmy::yes-party:` searches within each channel's
+same inclusive cutoff; otherwise inspect root reactions in the requested
+window. `:mag:` opts out and wins over `:yes-party:`. The latter authorizes only
+an otherwise review-only item; it never overrides an assignment or another
 task's claim.
 
 ## Phase 0: claim and reconcile
 
 Resolve known duplicates before claiming. Check ownership, then add and read
 back this task's root `👀` before investigating an eligible unowned report.
-Reconcile every root this actor already owns, including eyes, checks, and
-handoffs from prior runs, before discovering new questions. Keep one concise
-canonical status by the same actor after the latest human message; read back the
-visible reply and root reactions after each write. Use
+Reconcile only owned roots inside this invocation's fixed window and older
+roots explicitly linked by an in-window reply. Never expand a finite sweep to
+all historical roots just because this actor owns an old mark; widen the range
+only when the invocation explicitly requests it or hands off exact roots. Finish
+this bounded reconciliation before discovering new questions. Keep one
+concise canonical status by the same actor after the latest human message; read
+back the visible reply and root reactions after each write. Use
 [`slack-reaction-replies.md`](references/slack-reaction-replies.md) for exact
 status and reaction rules.
 
+**Bounded exit gate:** enumerate the complete candidate set from the fixed
+source window, the three matching owned-mark searches, and older roots linked
+by in-window replies. For every unheld owned root, compare the latest human
+message, current status reply, verified scopes, open scopes, and root marks.
+Add and read back `✅` for each newly verified scope and `🎫` for each distinct
+pending human action; the status reply must follow the latest human message and
+name current evidence, remaining work, and owners. An `👀` with a verified
+scope missing `✅`, a pending human action missing `🎫`, or no current status is
+unfinished. Finish the complete bounded set once, then stop; do not chase
+unrelated historical marks.
+
 Split reports into distinct scopes. Add root `✅` as soon as any named scope
 passes direct post-change proof, even while its PR is open; say **Verified
 locally** and that merge is pending. Use **Fixed** only after merge and direct
@@ -97,11 +164,14 @@ action and owner. Use **Skipped** only for non-defects.
 
 Phase 0 handles new human replies on owned roots first; never hide a newer
 reporter reply behind a mark. Then find prior unanswered questions using the
-exact bot disclosure and the saved channel reply cursor. On a first run, scan
-available history. Exhaust pages, use a one-day overlap for date-only cursors,
-resolve every hit to its parent, and read the full thread after checking
-reactions. Follow [`slack-reaction-replies.md`](references/slack-reaction-replies.md)
-for exact searches, legacy identity handling, and answer criteria.
+exact bot disclosure and the saved channel reply cursor, bounded by this
+invocation's fixed window. On a first run, use the same default five-day window;
+never scan all available history to initialize the cursor. Exhaust pages, use a
+one-day overlap for date-only cursors, resolve every hit to its parent, and read
+the full thread after checking reactions. An older root is eligible only when
+an in-window reply links to it. Follow
+[`slack-reaction-replies.md`](references/slack-reaction-replies.md) for exact
+searches, legacy identity handling, and answer criteria.
 
 A valid answer is a human post after the question, without this workflow's
 disclosure, that addresses the question. Rebuild the evidence and attempt the
@@ -316,15 +386,17 @@ send one concise disposition covering done, remaining, and next action/owner.
 Do not reply again to announce merge, publication, or live beta; answer direct
 reporter follow-ups. End Slack replies with `this was sent from a bot.`.
 
-Replies are one or two sentences: the change or question, its limit, and the next step. Never explain reactions, ledgers, or tickets. Never send **Open**/**pending** or a symptom recap. Ask for reporter input only when it changes the next step; never request supplied evidence or internal access. Keep hashes, branches, CI, publisher, and run details in the recap.
-
-That brevity rule is for a reporter-facing reply. Separately, every root this
-actor marks with `👀`, `✅`, or `🎫` still needs the current same-actor status
-reply required by the Slack reaction reference. One concise reply may serve both
-purposes when it answers the reporter and records the current disposition,
-verified/open scopes, owner/action, and any missing-proof reason. A Slack `🎫`
-reaction tracks a distinct unfinished human/team action; it does not mean an
-external tracker ticket was created or assigned. Never imply that it was.
+Reporter-facing replies are one or two sentences: the change or question, its limit, and the next step. Do not explain workflow mechanics, ledgers, or external tracker tickets. Never send **Open**/**pending** or a symptom recap. Ask for reporter input only when it changes the next step; never request supplied evidence or internal access. Keep hashes, branches, CI, publisher, and run details in the recap.
+
+Every root this actor marks with `👀`, `✅`, or `🎫` also needs the current
+same-actor status reply required by the Slack reaction reference. One concise
+reply may serve both purposes when it answers the reporter and records the
+current disposition, verified/open scopes, owner/action, and any reason a mark
+is absent. This status requirement takes precedence over the reporter-facing
+brevity rule only for those facts; do not explain ledger mechanics or external
+tracker tickets. A Slack `🎫` reaction tracks a distinct human action, not an
+external ticket, and remains as history after the action closes. Never imply
+that an external ticket was created or assigned.
 
 Keep publisher and beta checks in the internal recap after the disposition;
 they do not trigger a second reporter reply.