@agent-native/core 0.127.3 → 0.128.0

package/src/a2a/artifact-response.ts

@@ -50,6 +50,11 @@ const ARTIFACT_IDENTITY_WRITE_TOOLS = new Set([
   "create-deck",
   "duplicate-deck",
   "add-slide",
+  "update-slide",
+  "patch-deck",
+  "save-deck",
+  "import-pptx",
+  "restore-deck-version",
   "update-dashboard",
   "rename-dashboard",
   "save-analysis",
@@ -513,27 +518,43 @@ function addImageArtifact(
   });
 }
 
-function isReadyDeckArtifact(parsed: Record<string, unknown>): boolean {
-  const slideCount = numberValue(parsed.slideCount);
-  if (slideCount !== undefined) return slideCount > 0;
-  if (Array.isArray(parsed.slides)) return parsed.slides.length > 0;
-  return true;
-}
-
 function addDeckArtifact(
   decks: Map<string, CreatedDeckArtifact>,
   parsed: Record<string, unknown>,
-  options: { requireReady: boolean },
 ): void {
   const id = deckIdValue(parsed);
   if (!id) return;
-  if (options.requireReady && !isReadyDeckArtifact(parsed)) return;
   decks.set(id, {
     id,
     url: stringValue(parsed.url) ?? stringValue(parsed.urlPath),
   });
 }
 
+// Deck writes are spread across a dozen actions (create-deck, add-slide,
+// patch-deck, save-deck, update-slide, import-*, restore-deck-version), so a
+// per-tool allow-list refuses a real deck URL every time an action is added.
+// Trust any successful result that names a deck the way the deck routes do: an
+// explicit deckId, or a canonical /deck/<id> URL the action itself returned.
+function addDeckArtifactFromAnyResult(
+  decks: Map<string, CreatedDeckArtifact>,
+  parsed: Record<string, unknown>,
+): void {
+  const url = stringValue(parsed.url) ?? stringValue(parsed.urlPath);
+  const deckId = stringValue(parsed.deckId);
+  if (deckId) {
+    decks.set(deckId, {
+      id: deckId,
+      url:
+        url && artifactUrlReferencesId(url, "deck", deckId) ? url : undefined,
+    });
+  }
+
+  const reference = url ? parseArtifactReferenceUrl(url) : null;
+  if (reference?.kind === "deck") {
+    decks.set(reference.id, { id: reference.id, url });
+  }
+}
+
 function addListedDeckArtifacts(
   decks: Map<string, CreatedDeckArtifact>,
   parsed: Record<string, unknown>,
@@ -543,7 +564,7 @@ function addListedDeckArtifacts(
   for (const item of items) {
     const deck = asRecord(item);
     if (!deck) continue;
-    addDeckArtifact(decks, deck, { requireReady: false });
+    addDeckArtifact(decks, deck);
   }
 }
 
@@ -617,6 +638,8 @@ function collectArtifacts(results: A2AToolResultSummary[]): {
     const parsed = parseToolResultJson(toolResult.result);
     if (!parsed) continue;
 
+    addDeckArtifactFromAnyResult(decks, parsed);
+
     if (toolResult.tool === "save-monitor") {
       const id = stringValue(parsed.id);
       const url = stringValue(parsed.monitorAppUrl);
@@ -711,14 +734,10 @@ function collectArtifacts(results: A2AToolResultSummary[]): {
 
     if (
       toolResult.tool === "create-deck" ||
-      toolResult.tool === "duplicate-deck"
+      toolResult.tool === "duplicate-deck" ||
+      toolResult.tool === "get-deck"
     ) {
-      addDeckArtifact(decks, parsed, { requireReady: true });
-      continue;
-    }
-
-    if (toolResult.tool === "get-deck") {
-      addDeckArtifact(decks, parsed, { requireReady: false });
+      addDeckArtifact(decks, parsed);
       continue;
     }
 
@@ -727,18 +746,6 @@ function collectArtifacts(results: A2AToolResultSummary[]): {
       continue;
     }
 
-    if (toolResult.tool === "add-slide") {
-      const id = stringValue(parsed.deckId);
-      const slideCount = numberValue(parsed.slideCount);
-      if (id && slideCount !== undefined && slideCount > 0) {
-        decks.set(id, {
-          id,
-          url: stringValue(parsed.url) ?? stringValue(parsed.urlPath),
-        });
-      }
-      continue;
-    }
-
     if (
       toolResult.tool === "update-dashboard" ||
       toolResult.tool === "rename-dashboard" ||

package/src/action.ts

@@ -123,6 +123,19 @@ export interface ActionRunContext {
   turnId?: string;
 }
 
+/**
+ * Pre-run authorization gate. Throw to deny with a specific message (the
+ * framework's `ForbiddenError` carries a 403), or return `false` for a generic
+ * denial. Returning `undefined` allows the call — a guard that forgets to
+ * return is therefore permissive, which is why `false` is honoured at all:
+ * `(args) => someCheck(args)` written against a boolean helper would otherwise
+ * pass silently on every denial.
+ */
+export type ActionAuthorize<TArgs> = (
+  args: TArgs,
+  ctx?: ActionRunContext,
+) => void | boolean | Promise<void | boolean>;
+
 export interface AgentActionStopOptions {
   /** Optional stable code surfaced in run metadata and tests. */
   errorCode?: string;
@@ -466,6 +479,30 @@ interface DefineActionWithSchema<
         args: StandardSchemaV1.InferOutput<TSchema>,
         ctx?: ActionRunContext,
       ) => boolean | Promise<boolean>);
+  /**
+   * Authorization gate that runs before `run()` on **every** caller — agent
+   * tool, HTTP, frontend, MCP, A2A, and CLI. It wraps `run` itself rather than
+   * hanging off the action entry, because a flag consulted by the dispatcher
+   * only guards the dispatchers that remember to consult it.
+   *
+   * This is *authorization*, not approval: `needsApproval` asks a human to
+   * bless one call the caller is already allowed to make, while `authorize`
+   * decides whether they are allowed at all. It also does not replace
+   * `accessFilter` / `assertAccess` — those scope which rows a permitted caller
+   * may see; this decides whether the operation is open to them.
+   *
+   * ```ts
+   * import { coachAccess } from "../lib/access.js";
+   *
+   * export default defineAction({
+   *   description: "Archive a training plan.",
+   *   schema,
+   *   authorize: coachAccess.requireAny("coach-admin"),
+   *   run: async (args) => { ... },
+   * });
+   * ```
+   */
+  authorize?: ActionAuthorize<StandardSchemaV1.InferOutput<TSchema>>;
   /**
    * Audit-log configuration. **Default-on for mutating actions** — you only
    * need this to tune capture: declare the mutated `target` (so the change
@@ -556,6 +593,9 @@ interface DefineActionWithParams<
         args: InferParams<TParams>,
         ctx?: ActionRunContext,
       ) => boolean | Promise<boolean>);
+  /** Pre-run authorization gate applied to every caller. See the schema
+   *  overload above for full semantics. */
+  authorize?: ActionAuthorize<InferParams<TParams>>;
   /** Audit-log configuration (default-on for mutations). See the schema
    *  overload above and the `audit-log` skill. */
   audit?: ActionAuditConfig;
@@ -714,12 +754,21 @@ export function defineAction(options: any) {
     );
   }
 
+  // Authorization sits INSIDE input validation, so a gate that inspects `args`
+  // is handed the parsed, coerced value its type promises rather than whatever
+  // shape the caller sent. Putting it outside would have every guard reading
+  // attacker-shaped input while typed as though it were validated.
+  const guardedRun =
+    typeof options.authorize === "function"
+      ? wrapRunWithAuthorize(options.run, options.authorize)
+      : options.run;
+
   // Wrap run() with INPUT validation when schema is provided.
   // Pass toolParameters so the validation error can echo the expected signature
   // (required vs optional fields) and help the caller self-correct.
   const inputValidatedRun = hasSchema
-    ? wrapWithValidation(options.schema, options.run, toolParameters)
-    : options.run;
+    ? wrapWithValidation(options.schema, guardedRun, toolParameters)
+    : guardedRun;
 
   // Then wrap with OUTPUT validation when an outputSchema is provided. This
   // composes AROUND the input-validated run so the order is: validate input →
@@ -877,6 +926,38 @@ export function defineAction(options: any) {
   };
 }
 
+/**
+ * Wrap an action's run with its `authorize` gate.
+ *
+ * The gate is applied here, around `run`, rather than exposed as a flag on the
+ * action entry: `run` is the one thing all six dispatch sites (agent loop, HTTP
+ * route, frontend, MCP, A2A, CLI) go through, so there is no caller that can
+ * reach the body without passing the check. `needsApproval` took the flag route
+ * and is consequently honoured only inside the agent loop.
+ *
+ * Composed so the full order is: validate input → authorize → run → validate
+ * output → audit. The audit wrapper is outermost, so a denial is still recorded
+ * as an attempt — which is precisely what an audit trail is for.
+ *
+ * A guard that throws denies with its own message. A guard that returns `false`
+ * denies generically. Anything else — including `undefined` — allows.
+ */
+function wrapRunWithAuthorize(
+  run: (args: any, ctx?: ActionRunContext) => any,
+  authorize: ActionAuthorize<any>,
+): (args: any, ctx?: ActionRunContext) => Promise<any> {
+  return async function authorizedRun(args: any, ctx?: ActionRunContext) {
+    const verdict = await authorize(args, ctx);
+    if (verdict === false) {
+      const err = new Error("Not authorized") as Error & { statusCode: number };
+      err.name = "ForbiddenError";
+      err.statusCode = 403;
+      throw err;
+    }
+    return run(args, ctx);
+  };
+}
+
 /**
  * Wrap an action's (already input/output-validated) run so each call records an
  * audit event after it resolves — on success and on error. Best-effort: the

package/src/chat-threads/store.ts

@@ -159,9 +159,6 @@ async function ensureTable(): Promise<void> {
           "chat_thread_shares_resource_idx",
           CHAT_THREAD_SHARES_RESOURCE_INDEX_SQL,
         );
-        // One-time backfill of message_count for legacy rows written before
-        // the column was maintained.
-        await backfillLegacyMessageCounts(client);
         return;
       }
 
@@ -221,15 +218,6 @@ async function ensureTable(): Promise<void> {
           // Index already exists or the dialect rejected a duplicate.
         }
       }
-      // One-time backfill of message_count for legacy rows written before
-      // the column was maintained. The list/summary path now reads
-      // message_count directly (instead of re-parsing the thread_data blob)
-      // and filters on `message_count > 0`, so any legacy row that has
-      // messages but a stale `message_count = 0` would otherwise vanish from
-      // the sidebar. Recompute the count from thread_data and persist it so
-      // the hot path can stay blob-free. Idempotent: only touches rows where
-      // the count is still 0 but the blob clearly contains a messages array.
-      await backfillLegacyMessageCounts(client);
     })().catch((err) => {
       // Retry init on the next call after a failed startup.
       _initPromise = undefined;
@@ -240,28 +228,47 @@ async function ensureTable(): Promise<void> {
 }
 
 /**
- * Recompute `message_count` from `thread_data` for legacy rows that still
- * have a stale `message_count = 0` despite carrying a messages array in the
- * blob. Without this, dropping the `thread_data` payload (and the
- * `OR thread_data LIKE '%"messages"%'` filter) from the list path would make
- * those rows disappear from the sidebar. Runs once at table bootstrap and is
- * idempotent — after the first pass no row matches the WHERE clause again.
+ * Explicitly repair `message_count` for legacy rows written before the count
+ * was maintained. This must never run from table/bootstrap initialization:
+ * serverless isolates would each scan the full `thread_data` blob column on
+ * cold start. Operators may invoke it once when upgrading an old database.
  */
-async function backfillLegacyMessageCounts(
-  client: ReturnType<typeof getDbExec>,
-): Promise<void> {
-  const { rows } = await client.execute({
-    sql: `SELECT id, thread_data, message_count FROM chat_threads WHERE message_count = 0 AND thread_data LIKE '%"messages"%'`,
-    args: [],
-  });
-  for (const r of rows) {
-    const count = deriveMessageCount(r.thread_data, 0);
-    if (count <= 0) continue;
-    await client.execute({
-      sql: `UPDATE chat_threads SET message_count = ? WHERE id = ? AND message_count = 0`,
-      args: [count, r.id as string],
+export async function repairLegacyChatThreadMessageCounts(
+  options: {
+    batchSize?: number;
+  } = {},
+): Promise<{ scanned: number; updated: number }> {
+  await ensureTable();
+  const client = getDbExec();
+  const batchSize = Math.max(1, Math.min(options.batchSize ?? 100, 1_000));
+  let afterId = "";
+  let scanned = 0;
+  let updated = 0;
+  while (true) {
+    const { rows } = await client.execute({
+      sql: `SELECT id, thread_data, message_count FROM chat_threads
+            WHERE message_count = 0
+              AND thread_data LIKE '%"messages"%'
+              AND id > ?
+            ORDER BY id
+            LIMIT ?`,
+      args: [afterId, batchSize],
     });
+    if (rows.length === 0) break;
+    for (const row of rows) {
+      afterId = String(row.id);
+      scanned++;
+      const count = deriveMessageCount(row.thread_data, 0);
+      if (count <= 0) continue;
+      const result = await client.execute({
+        sql: `UPDATE chat_threads SET message_count = ? WHERE id = ? AND message_count = 0`,
+        args: [count, afterId],
+      });
+      if (result.rowsAffected > 0) updated++;
+    }
+    if (rows.length < batchSize) break;
   }
+  return { scanned, updated };
 }
 
 function generateId(): string {
@@ -407,8 +414,8 @@ function rowToThread(r: Record<string, unknown>): ChatThread {
 
 function rowToSummary(r: Record<string, unknown>): ChatThreadSummary | null {
   // The summary path never loads `thread_data`; the count comes from the
-  // dedicated `message_count` column (maintained on write, backfilled for
-  // legacy rows at bootstrap). Empty threads are filtered out of the list.
+  // dedicated `message_count` column maintained on write. Empty threads are
+  // filtered out of the list.
   const messageCount = Number(r.message_count);
   if (!Number.isFinite(messageCount) || messageCount <= 0) return null;
   return {
@@ -475,9 +482,8 @@ const THREAD_COLUMNS = `id, owner_email, title, preview, thread_data, message_co
 // message-history JSON blob and selecting it for every row turns "open the
 // sidebar" into "download every conversation". The summary derives nothing
 // from the blob anymore — preview and message_count are dedicated columns
-// (message_count is maintained on write and backfilled for legacy rows at
-// bootstrap). The detail path (`THREAD_COLUMNS` / `getThread`) still returns
-// the full blob.
+// (message_count is maintained on write). The detail path (`THREAD_COLUMNS` /
+// `getThread`) still returns the full blob.
 const SUMMARY_COLUMNS = `id, title, preview, message_count, created_at, updated_at, scope_type, scope_id, scope_label, pinned_at, archived_at, org_id, visibility`;
 
 export function registerChatThreadsShareable(): void {
@@ -684,10 +690,9 @@ export async function listThreads(
   const limit = opts.limit ?? 50;
   const offset = opts.offset ?? 0;
   const client = getDbExec();
-  // `message_count > 0` is the authoritative "has messages" signal: it is
-  // maintained on every write and backfilled for legacy rows at bootstrap,
-  // so the old `OR thread_data LIKE '%"messages"%'` substring scan over the
-  // full blob is no longer needed here.
+  // `message_count > 0` is the authoritative "has messages" signal maintained
+  // on every write, so the old `OR thread_data LIKE '%"messages"%'` substring
+  // scan over the full blob is no longer needed here.
   const access = chatThreadAccessSql(
     ownerEmail,
     opts.orgId ?? getRequestOrgId(),
@@ -731,9 +736,9 @@ export async function searchThreads(
   await ensureTable();
   const client = getDbExec();
   const pattern = `%${escapeLike(query)}%`;
-  // The count-guard uses the maintained/backfilled `message_count` column
-  // (same as listThreads). The content match still scans `thread_data` —
-  // search legitimately needs to look inside message history.
+  // The count-guard uses the maintained `message_count` column (same as
+  // listThreads). The content match still scans `thread_data` — search
+  // legitimately needs to look inside message history.
   const access = chatThreadAccessSql(
     ownerEmail,
     options.orgId ?? getRequestOrgId(),

package/src/cli/skills-content/design-visual-edit-skill.ts

@@ -25,6 +25,32 @@ hosted Design MCP connector together. The open Skills CLI path
 (\`npx skills@latest add BuilderIO/agent-native --skill visual-edit\`) installs
 exported instructions only, with no MCP connector registration.
 
+## Put Design Beside The Chat
+
+After \`open-visual-edit\` returns \`openUrl\`, open that URL in the coding host's
+inline browser when one is available. This is the preferred working surface:
+the user can keep Design's canvas beside the conversation, inspect the same
+screens as the agent, and iterate without switching apps.
+
+- In Codex Desktop, use the in-app Browser tool to open \`openUrl\`. The built-in
+  browser is the right surface for localhost and public pages that should stay
+  inside the app.
+- In Claude Code Desktop's Code tab, open or preview \`openUrl\` in the Browser
+  pane. Ask Claude to preview it rather than opening the system browser.
+- In VS Code, use the Agent Native Design webview/deep link described below.
+- Inline browser availability is host-dependent. CLI, remote, or restricted
+  sessions may not expose one. If the inline surface is unavailable or disabled,
+  return the normal **Open design** link instead of claiming it opened.
+
+Prefer the host's browser/preview tool over telling the user to press a keyboard
+shortcut. Keep the canvas pane beside chat when the host supports rearrangeable
+panes.
+
+Inside Design, use **Show/Hide UI** from the \`Cmd+K\` menu or press
+\`Cmd+Shift+\\\` on Apple platforms / \`Ctrl+Shift+\\\` elsewhere to toggle all
+editing chrome so only the canvas remains. The same action is available from
+Design's empty-canvas context menu.
+
 ## Core Model
 
 - Each screen is a URL-backed iframe, not copied HTML.
@@ -54,6 +80,23 @@ exported instructions only, with no MCP connector registration.
   \`localhost:1234/onboarding/1\` means
   \`http://localhost:1234/onboarding/1\`.
 
+## Useful Canvas Sets
+
+Translate the user's requested review into the smallest useful set of frames:
+
+- **Multi-step flow:** one ordered frame per route or query state, such as cart,
+  shipping, payment, and confirmation.
+- **Multiple pages:** one frame per meaningful route, such as home, pricing,
+  docs, and account settings.
+- **Responsive comparison:** repeat the same route at the requested desktop,
+  tablet, and mobile viewports so they align in one row.
+- **State review:** repeat a route for meaningful URL-addressable states such as
+  empty, loading, error, modal-open, or selected-item views.
+
+Do not expand every discovered route or every viewport unless the user asks for
+an exhaustive audit. Preserve the user's labels and sequence so the canvas reads
+like the workflow they described.
+
 ## Select And Reprompt
 
 When a chat message begins with \`[Reprompt selection]\`, the selected subtree is
@@ -275,9 +318,9 @@ Fallback, only when \`open-visual-edit\` is unavailable:
 ## Open The Design Surface
 
 - Use the \`link\`, \`deepLink\`, or MCP App embed returned by Design actions so
-  the user sees the canvas. In Codex Desktop or VS Code, prefer opening that
-  Design URL in the available preview/webview panel; otherwise surface the
-  "Open design" link.
+  the user sees the canvas. Follow **Put Design Beside The Chat**: prefer the
+  host's inline Browser, preview, or webview panel; otherwise surface the
+  **Open design** link.
 - Return or open the \`openUrl\` / action link, not a hand-built
   \`/design/:id?_session=...\` URL.
 - If the user is working in VS Code, the Agent Native extension can open the

package/src/client/AgentPanel.tsx

@@ -198,7 +198,9 @@ type PanelMode = "chat" | "cli" | "resources" | "settings";
 export function normalizeAgentPanelModeForSurface(
   mode: PanelMode,
   allowSettingsMode: boolean,
+  chatOnly = false,
 ): PanelMode {
+  if (chatOnly) return "chat";
   return mode === "settings" && !allowSettingsMode ? "chat" : mode;
 }
 const AGENT_PANEL_FONT_FAMILY =
@@ -597,6 +599,8 @@ export interface AgentPanelProps extends Omit<
   showPageNewChatButton?: boolean;
   /** Allow the sidebar settings view to render inside this panel. Default: true. */
   allowSettingsMode?: boolean;
+  /** Keep this surface on chat even when mode controls are hidden. */
+  chatOnly?: boolean;
   /** Optional link shown in Resources and Settings modes for the full Agent page. */
   agentPageHref?: string;
   /** Capability gate for source edits and CLI access. */
@@ -754,6 +758,7 @@ function AgentPanelInner({
   showTabBar = true,
   showPageNewChatButton = false,
   allowSettingsMode = true,
+  chatOnly = false,
   agentPageHref,
   codeAccess,
   ...assistantChatProps
@@ -807,9 +812,17 @@ function AgentPanelInner({
         saved === "resources" ||
         saved === "settings"
       )
-        return normalizeAgentPanelModeForSurface(saved, allowSettingsMode);
+        return normalizeAgentPanelModeForSurface(
+          saved,
+          allowSettingsMode,
+          chatOnly,
+        );
     } catch {}
-    return normalizeAgentPanelModeForSurface(defaultMode, allowSettingsMode);
+    return normalizeAgentPanelModeForSurface(
+      defaultMode,
+      allowSettingsMode,
+      chatOnly,
+    );
   });
   useEffect(() => {
     try {
@@ -823,15 +836,21 @@ function AgentPanelInner({
   const switchMode = useCallback(
     (m: PanelMode) => {
       startTransition(() =>
-        setMode(normalizeAgentPanelModeForSurface(m, allowSettingsMode)),
+        setMode(
+          normalizeAgentPanelModeForSurface(m, allowSettingsMode, chatOnly),
+        ),
       );
     },
-    [allowSettingsMode],
+    [allowSettingsMode, chatOnly],
   );
   useEffect(() => {
-    const nextMode = normalizeAgentPanelModeForSurface(mode, allowSettingsMode);
+    const nextMode = normalizeAgentPanelModeForSurface(
+      mode,
+      allowSettingsMode,
+      chatOnly,
+    );
     if (nextMode !== mode) switchMode(nextMode);
-  }, [mode, allowSettingsMode, switchMode]);
+  }, [mode, allowSettingsMode, chatOnly, switchMode]);
   const openRunThread = useCallback(
     (threadId: string, run?: AgentRun) => {
       switchMode("chat");
@@ -3349,6 +3368,7 @@ export function AgentSidebar({
             threadUrlSync={threadUrlSync}
             agentPageHref={agentPageHref}
             allowSettingsMode={false}
+            chatOnly
           />
         </div>
       </div>

package/src/client/AssistantChat.tsx

@@ -333,8 +333,16 @@ function activeRunStuckThresholdMs(runInfo: ActiveRunLookup): number {
 }
 
 function activeRunLooksStale(runInfo: ActiveRunLookup): boolean {
+  // A run killed before it emitted anything has no `lastProgressAt`. Falling
+  // back to the heartbeat keeps that case from reading as perpetually fresh —
+  // "never reported progress" is the worst case, not an exemption from the
+  // staleness check.
   const lastProgressAt =
-    typeof runInfo.lastProgressAt === "number" ? runInfo.lastProgressAt : null;
+    typeof runInfo.lastProgressAt === "number"
+      ? runInfo.lastProgressAt
+      : typeof runInfo.heartbeatAt === "number"
+        ? runInfo.heartbeatAt
+        : null;
   const nowMs =
     typeof runInfo.serverNow === "number" ? runInfo.serverNow : Date.now();
   const thresholdMs = activeRunStuckThresholdMs(runInfo);
@@ -345,6 +353,16 @@ function activeRunLooksStale(runInfo: ActiveRunLookup): boolean {
   );
 }
 
+/**
+ * The stored active run is what keeps the "Thinking…" spinner up across a
+ * reload, and the `/runs/active` probe is the only path that clears it. A 5xx
+ * or a network drop there means "couldn't determine", NOT "still running" —
+ * collapsing the two is what strands the spinner forever when the server is
+ * briefly unreachable, because no caller reschedules the probe. Retry inside
+ * the call, then give up loudly.
+ */
+const ACTIVE_RUN_PROBE_RETRY_DELAYS_MS = [400, 1200];
+
 /**
  * Decide whether a reconnect should give up with "no progress". The signal is
  * *time since the last streamed event*, NOT total reconnect duration: a healthy
@@ -3440,12 +3458,50 @@ const AssistantChatInner = forwardRef<
       if (isRuntimeRunningRef.current || isAutoResumingRef.current) {
         return false;
       }
+      const storedActiveRun = getActiveRun();
+      let runRes: Response | null = null;
+      for (let attempt = 0; ; attempt += 1) {
+        try {
+          const res = await fetch(
+            `${apiUrl}/runs/active?threadId=${encodeURIComponent(threadId)}`,
+          );
+          if (res.ok) {
+            runRes = res;
+            break;
+          }
+        } catch {
+          // Fall through to the retry/give-up path below.
+        }
+        const retryDelayMs = ACTIVE_RUN_PROBE_RETRY_DELAYS_MS[attempt];
+        if (retryDelayMs === undefined) break;
+        await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+      }
+
+      if (!runRes) {
+        // Still unreachable. Only a stored run for this thread is holding the
+        // spinner up, so that is also the only case worth interrupting the user
+        // for — drop it and say why, rather than leaving "Thinking…" forever.
+        if (storedActiveRun?.threadId === threadId) {
+          clearActiveRunIfMatches(threadId, storedActiveRun.runId);
+          window.dispatchEvent(
+            new CustomEvent("agent-chat:run-error", {
+              detail: {
+                message:
+                  "Couldn't reach the server to check whether the agent is still working. Send your message again to retry.",
+                errorCode: "run_status_unavailable",
+                recoverable: true,
+                ...(storedActiveRun.runId
+                  ? { runId: storedActiveRun.runId }
+                  : {}),
+                ...(tabId ? { tabId } : {}),
+              },
+            }),
+          );
+        }
+        return false;
+      }
+
       try {
-        const storedActiveRun = getActiveRun();
-        const runRes = await fetch(
-          `${apiUrl}/runs/active?threadId=${encodeURIComponent(threadId)}`,
-        );
-        if (!runRes.ok) return false;
         const runInfo = (await runRes.json()) as ActiveRunLookup;
         if (
           !runInfo.active ||
@@ -3464,7 +3520,7 @@ const AssistantChatInner = forwardRef<
       } catch {
         return false;
       }
-    }, [apiUrl, refreshThreadFromServer, startReconnectToRun, threadId]);
+    }, [apiUrl, refreshThreadFromServer, startReconnectToRun, tabId, threadId]);
 
   useEffect(() => {
     if (!threadId || !isNewThread) return;