@agent-native/core 0.161.4 → 0.161.6

package/corpus/templates/analytics/actions/update-dashboard.ts

@@ -9,6 +9,7 @@ import { z } from "zod";
 import { interpolate } from "../app/pages/adhoc/sql-dashboard/interpolate";
 import { dryRunQuery } from "../server/lib/bigquery";
 import { queueDashboardCollabSync } from "../server/lib/dashboard-collab-sync";
+import { serializeProgramDescriptorInput } from "../server/lib/dashboard-panel-query";
 import { validateFirstPartyDashboardTimeScope } from "../server/lib/dashboard-time-scope";
 import {
   upsertDashboard,
@@ -362,6 +363,13 @@ export function validateDashboardConfig(
     if (!isSection && !isExtension && !validSources.has(p.source as string)) {
       return `panel[${i}].source must be 'bigquery', 'ga4', 'amplitude', 'first-party', 'demo', 'prometheus', or 'program' (got '${p.source}'). source selects the backend — put the PromQL/SQL/table name or program descriptor in sql, not here.`;
     }
+    if (p.source === "program") {
+      try {
+        serializeProgramDescriptorInput(p.sql);
+      } catch (e: any) {
+        return `panel[${i}] "${p.title || p.id}" program descriptor is invalid: ${e?.message ?? e}`;
+      }
+    }
     if (isExtension) {
       const cfg = p.config as Record<string, unknown> | undefined;
       const extensionId =

package/corpus/templates/forms/server/lib/public-form-ssr.ts

@@ -601,6 +601,9 @@ function renderFormPage(
         if (v) data[f.id] = parseInt(v);
       } else if (f.type === "scale") {
         data[f.id] = parseInt(el.querySelector(".slider").value);
+      } else if (f.type === "radio") {
+        var checked = el.querySelector('input[type="radio"]:checked');
+        if (checked && checked.value) data[f.id] = checked.value;
       } else {
         var input = el.querySelector("input, textarea, select");
         if (input && input.value) data[f.id] = input.value;

package/corpus/templates/slides/app/components/editor/SlideEditor.tsx

@@ -965,11 +965,13 @@ function MultiSelectOutline({
 }
 
 /** Translucent rectangle drawn while marquee-dragging */
+type MarqueeSelectionRect = { x: number; y: number; w: number; h: number };
+
 function MarqueeRect({
   rect,
   viewportRect,
 }: {
-  rect: { x: number; y: number; w: number; h: number };
+  rect: MarqueeSelectionRect;
   viewportRect: DOMRect | null;
 }) {
   return (
@@ -1204,12 +1206,7 @@ export default function SlideEditor({
   /** Anchor rect for the floating chip (the slide canvas) */
   const [chipAnchorRect, setChipAnchorRect] = useState<DOMRect | null>(null);
   /** Active marquee rectangle (viewport coords). null = not dragging. */
-  const [marquee, setMarquee] = useState<{
-    x: number;
-    y: number;
-    w: number;
-    h: number;
-  } | null>(null);
+  const [marquee, setMarquee] = useState<MarqueeSelectionRect | null>(null);
   const [activeAlignmentGuides, setActiveAlignmentGuides] = useState<{
     guides: SlideAlignmentGuide[];
     viewport: AlignmentGuideViewport;
@@ -1502,6 +1499,8 @@ export default function SlideEditor({
   }, [overflowInfo, slide.id, dims.width, dims.height]);
   /** Marquee origin (viewport coords). Set on pointerdown. */
   const marqueeOriginRef = useRef<{ x: number; y: number } | null>(null);
+  /** Latest marquee geometry, readable by the stable window pointer handlers. */
+  const marqueeRef = useRef<MarqueeSelectionRect | null>(null);
   /** Set right before placing a text box so the click event that follows the
    *  placing pointerdown doesn't fall through to click-to-select/deselect
    *  logic and steal focus back off the freshly created box. */
@@ -4432,7 +4431,12 @@ export default function SlideEditor({
       marqueeOriginRef.current = { x: e.clientX, y: e.clientY };
       marqueeAdditiveRef.current = e.shiftKey || e.metaKey || e.ctrlKey;
       marqueePrevSelectionRef.current = new Set(multiSelection);
-      setMarquee({ x: e.clientX, y: e.clientY, w: 0, h: 0 });
+      const initialMarquee = { x: e.clientX, y: e.clientY, w: 0, h: 0 };
+      marqueeRef.current = initialMarquee;
+      setMarquee(initialMarquee);
+      if (e.pointerId >= 0) {
+        e.currentTarget.setPointerCapture(e.pointerId);
+      }
 
       // Clear single-select feedback when starting a marquee on whitespace
       // (non-additive). Additive marquee preserves the existing selection.
@@ -4462,25 +4466,28 @@ export default function SlideEditor({
     ],
   );
 
-  // Window-level pointermove / pointerup so the drag still tracks if the
-  // pointer leaves the slide.
+  // Keep these listeners stable while React re-renders the marquee overlay.
+  // Re-attaching them whenever marquee state changes can lose a fast
+  // pointermove/pointerup between the effect cleanup and re-install.
   useEffect(() => {
-    if (!marquee) return;
     const onMove = (e: PointerEvent) => {
       const origin = marqueeOriginRef.current;
-      if (!origin) return;
+      if (!origin || !marqueeRef.current) return;
       const x = Math.min(origin.x, e.clientX);
       const y = Math.min(origin.y, e.clientY);
       const w = Math.abs(e.clientX - origin.x);
       const h = Math.abs(e.clientY - origin.y);
-      setMarquee({ x, y, w, h });
+      const nextMarquee = { x, y, w, h };
+      marqueeRef.current = nextMarquee;
+      setMarquee(nextMarquee);
     };
-    const onUp = () => {
+    const finish = (cancelled: boolean) => {
       const origin = marqueeOriginRef.current;
-      const current = marquee;
+      const current = marqueeRef.current;
       marqueeOriginRef.current = null;
+      marqueeRef.current = null;
       setMarquee(null);
-      if (!origin || !current) return;
+      if (cancelled || !origin || !current) return;
 
       const slideContent = getSlideContent();
       if (!slideContent) return;
@@ -4518,13 +4525,18 @@ export default function SlideEditor({
 
       applyMultiSelection(hits);
     };
+
+    const onUp = () => finish(false);
+    const onCancel = () => finish(true);
     window.addEventListener("pointermove", onMove);
     window.addEventListener("pointerup", onUp);
+    window.addEventListener("pointercancel", onCancel);
     return () => {
       window.removeEventListener("pointermove", onMove);
       window.removeEventListener("pointerup", onUp);
+      window.removeEventListener("pointercancel", onCancel);
     };
-  }, [marquee, getSlideContent, applyMultiSelection]);
+  }, [getSlideContent, applyMultiSelection]);
 
   /** Send the current selection to the agent chat composer */
   const sendSelectionToAgent = useCallback(() => {

package/dist/agent/production-agent.d.ts

@@ -935,6 +935,52 @@ export declare function runAgentLoopWithMainChatInternalContinuations(opts: Para
  * background invocations forever, mirroring `MAX_AGENT_TEAM_CONTINUATIONS`.
  */
 export declare const MAX_BACKGROUND_RUN_CONTINUATIONS = 20;
+/**
+ * Consecutive chunks allowed to end on the SAME terminal error code having
+ * produced nothing before the chain stops.
+ *
+ * Two, because two independent recovery layers multiply here and neither can
+ * see the other: the engine already retried this identical request 3x with
+ * backoff before the error was ever emitted, and a recoverable error is also a
+ * continuation boundary, so every chunk that fails costs 4 gateway attempts
+ * and dispatches a fresh one. A production turn spent 27 background runs and
+ * 15 minutes on one message this way. The first repeat is the retry this path
+ * exists for; a second identical failure that moved nothing is evidence the
+ * retrying itself is what is broken, not the request.
+ */
+export declare const MAX_CONSECUTIVE_NO_PROGRESS_CONTINUATIONS = 2;
+/** Consecutive-identical-failure state for one chunk of a background chain. */
+export interface BackgroundNoProgressRepeat {
+    /** This chunk's terminal error code, when it ended having produced nothing. */
+    errorCode?: string;
+    /** Chunks in a row that ended on that code with no forward progress. */
+    count: number;
+    /** True once the streak reaches `MAX_CONSECUTIVE_NO_PROGRESS_CONTINUATIONS`. */
+    tripped: boolean;
+}
+/**
+ * Advance the no-progress streak across a chunk boundary. A chunk that emitted
+ * any text or tool activity resets it even when it still ended in an error —
+ * that turn IS moving, and cutting it off is what would weaken recovery for
+ * truncated streams. So does a different error code, and so does a boundary
+ * with no error at all (a soft-timeout `auto_continue` is the run-manager's
+ * no-progress backstop to bound, not this one).
+ */
+export declare function resolveBackgroundNoProgressRepeat(opts: {
+    run: ActiveRun;
+    priorErrorCode?: string;
+    priorCount?: number;
+}): BackgroundNoProgressRepeat;
+/**
+ * The single honest failure the breaker leaves behind. Keeps the underlying
+ * code and the gateway's own message (which carries its `ERROR ID:` reference)
+ * so the failure stays diagnosable, and marks it non-recoverable so neither
+ * this chain nor the client's continuation path re-enters it.
+ */
+export declare function backgroundNoProgressTerminalEvent(run: ActiveRun, repeat: BackgroundNoProgressRepeat): Extract<AgentChatEvent, {
+    type: "error";
+}> | null;
+export declare function installBackgroundNoProgressTerminalEvent(run: ActiveRun, repeat: BackgroundNoProgressRepeat): boolean;
 /**
  * Whether this run should self-fire the next server-driven continuation chunk
  * instead of depending on the client to re-POST `auto_continue`. True for
@@ -949,7 +995,9 @@ export declare const MAX_BACKGROUND_RUN_CONTINUATIONS = 20;
  *     the durable background worker (`dispatchedToBackground` false) — a run
  *     already headed to the durable background path chains via the
  *     `isBackgroundWorker` branch above, never both.
- * Aborted / user-stopped runs do NOT chain either way.
+ * Aborted / user-stopped runs do NOT chain either way, and neither does a run
+ * whose no-progress streak has tripped
+ * (`MAX_CONSECUTIVE_NO_PROGRESS_CONTINUATIONS`).
  */
 export declare function shouldChainBackgroundContinuation(opts: {
     isBackgroundWorker: boolean;
@@ -970,6 +1018,10 @@ export declare function shouldChainBackgroundContinuation(opts: {
      * owned by the background circuit-breaker, not this path.
      */
     dispatchedToBackground?: boolean;
+    /** Streak state carried on the continuation marker — see
+     *  `resolveBackgroundNoProgressRepeat`. Absent on the first chunk. */
+    priorNoProgressErrorCode?: string;
+    priorNoProgressCount?: number;
 }): boolean;
 /**
  * Minimum remaining budget (ms) a synchronous self-chain continuation chunk
@@ -1275,6 +1327,9 @@ export declare function chainServerDrivenContinuation(opts: {
      *  is derived from it (marker stripped, `internalContinuation` set). */
     requestBody: Record<string, unknown>;
     backgroundContinuationCount: number;
+    /** This chunk's no-progress streak, carried to the successor so the breaker
+     *  can see a repeat across the invocation boundary. */
+    noProgressRepeat?: BackgroundNoProgressRepeat;
     /**
      * Input tokens this logical turn has consumed across every chunk so far,
      * carried on the successor's body so the per-turn token ceiling is a real

package/dist/agent/production-agent.js

@@ -5422,6 +5422,87 @@ function endsAtContinuationBoundary(run) {
  * background invocations forever, mirroring `MAX_AGENT_TEAM_CONTINUATIONS`.
  */
 export const MAX_BACKGROUND_RUN_CONTINUATIONS = 20;
+/**
+ * Consecutive chunks allowed to end on the SAME terminal error code having
+ * produced nothing before the chain stops.
+ *
+ * Two, because two independent recovery layers multiply here and neither can
+ * see the other: the engine already retried this identical request 3x with
+ * backoff before the error was ever emitted, and a recoverable error is also a
+ * continuation boundary, so every chunk that fails costs 4 gateway attempts
+ * and dispatches a fresh one. A production turn spent 27 background runs and
+ * 15 minutes on one message this way. The first repeat is the retry this path
+ * exists for; a second identical failure that moved nothing is evidence the
+ * retrying itself is what is broken, not the request.
+ */
+export const MAX_CONSECUTIVE_NO_PROGRESS_CONTINUATIONS = 2;
+/**
+ * Forward progress inside ONE chunk, read from the events it actually emitted:
+ * assistant text or tool activity. Same evidence the agent-teams no-progress
+ * budget counts (`agent-teams.ts`), and the same events
+ * `endsAfterCompletedToolWithoutAssistantFinal` reads to tell an unfinished
+ * turn from a finished one.
+ */
+function chunkMadeForwardProgress(run) {
+    return run.events.some(({ event }) => (event.type === "text" && event.text.trim().length > 0) ||
+        event.type === "tool_start" ||
+        event.type === "tool_done");
+}
+/**
+ * Advance the no-progress streak across a chunk boundary. A chunk that emitted
+ * any text or tool activity resets it even when it still ended in an error —
+ * that turn IS moving, and cutting it off is what would weaken recovery for
+ * truncated streams. So does a different error code, and so does a boundary
+ * with no error at all (a soft-timeout `auto_continue` is the run-manager's
+ * no-progress backstop to bound, not this one).
+ */
+export function resolveBackgroundNoProgressRepeat(opts) {
+    const last = opts.run.events.at(-1)?.event;
+    const errorCode = last?.type === "error" ? (last.errorCode ?? "").trim() : "";
+    if (!errorCode || chunkMadeForwardProgress(opts.run)) {
+        return { count: 0, tripped: false };
+    }
+    const prior = opts.priorErrorCode === errorCode &&
+        typeof opts.priorCount === "number" &&
+        Number.isFinite(opts.priorCount)
+        ? Math.max(0, Math.floor(opts.priorCount))
+        : 0;
+    const count = prior + 1;
+    return {
+        errorCode,
+        count,
+        tripped: count >= MAX_CONSECUTIVE_NO_PROGRESS_CONTINUATIONS,
+    };
+}
+/**
+ * The single honest failure the breaker leaves behind. Keeps the underlying
+ * code and the gateway's own message (which carries its `ERROR ID:` reference)
+ * so the failure stays diagnosable, and marks it non-recoverable so neither
+ * this chain nor the client's continuation path re-enters it.
+ */
+export function backgroundNoProgressTerminalEvent(run, repeat) {
+    const last = run.events.at(-1)?.event;
+    if (last?.type !== "error")
+        return null;
+    return {
+        ...last,
+        error: `${last.error}\n\nThis failed ${repeat.count} times in a row without ` +
+            `making any progress, so I stopped instead of retrying again.`,
+        recoverable: false,
+    };
+}
+export function installBackgroundNoProgressTerminalEvent(run, repeat) {
+    const terminalEvent = backgroundNoProgressTerminalEvent(run, repeat);
+    const lastRunEvent = run.events.at(-1);
+    if (!terminalEvent || lastRunEvent?.event.type !== "error")
+        return false;
+    run.events = [
+        ...run.events.slice(0, -1),
+        { ...lastRunEvent, event: terminalEvent },
+    ];
+    run.continuationTerminalEvent = terminalEvent;
+    return true;
+}
 /**
  * Whether this run should self-fire the next server-driven continuation chunk
  * instead of depending on the client to re-POST `auto_continue`. True for
@@ -5436,7 +5517,9 @@ export const MAX_BACKGROUND_RUN_CONTINUATIONS = 20;
  *     the durable background worker (`dispatchedToBackground` false) — a run
  *     already headed to the durable background path chains via the
  *     `isBackgroundWorker` branch above, never both.
- * Aborted / user-stopped runs do NOT chain either way.
+ * Aborted / user-stopped runs do NOT chain either way, and neither does a run
+ * whose no-progress streak has tripped
+ * (`MAX_CONSECUTIVE_NO_PROGRESS_CONTINUATIONS`).
  */
 export function shouldChainBackgroundContinuation(opts) {
     const eligible = opts.isBackgroundWorker ||
@@ -5445,7 +5528,12 @@ export function shouldChainBackgroundContinuation(opts) {
     return (eligible &&
         opts.run.status !== "aborted" &&
         endsAtContinuationBoundary(opts.run) &&
-        opts.continuationCount < MAX_BACKGROUND_RUN_CONTINUATIONS);
+        opts.continuationCount < MAX_BACKGROUND_RUN_CONTINUATIONS &&
+        !resolveBackgroundNoProgressRepeat({
+            run: opts.run,
+            priorErrorCode: opts.priorNoProgressErrorCode,
+            priorCount: opts.priorNoProgressCount,
+        }).tripped);
 }
 /**
  * Minimum remaining budget (ms) a synchronous self-chain continuation chunk
@@ -5885,6 +5973,12 @@ export async function chainServerDrivenContinuation(opts) {
         continuationCount: opts.backgroundContinuationCount + 1,
         continuationReason,
         ...(actionPreparationTool ? { actionPreparationTool } : {}),
+        ...(opts.noProgressRepeat?.errorCode
+            ? {
+                noProgressErrorCode: opts.noProgressRepeat.errorCode,
+                noProgressCount: opts.noProgressRepeat.count,
+            }
+            : {}),
         backgroundFunctionRuntimeExpected: continuationExpectsNetlifyBackgroundFunction,
     };
     // Strip this chunk's own marker before persisting/forwarding — the next
@@ -6237,6 +6331,15 @@ export function createProductionAgentHandler(options) {
             Number.isFinite(backgroundRunMarker.continuationCount)
             ? Math.max(0, Math.floor(backgroundRunMarker.continuationCount))
             : 0;
+        // No-progress streak so far, carried on the marker: this invocation has no
+        // other memory of what the previous chunk failed with.
+        const priorNoProgressErrorCode = typeof backgroundRunMarker?.noProgressErrorCode === "string"
+            ? backgroundRunMarker.noProgressErrorCode
+            : undefined;
+        const priorNoProgressCount = typeof backgroundRunMarker?.noProgressCount === "number" &&
+            Number.isFinite(backgroundRunMarker.noProgressCount)
+            ? Math.max(0, Math.floor(backgroundRunMarker.noProgressCount))
+            : 0;
         let backgroundRunClaimedEarly = false;
         if (isBackgroundWorker && bgRunId) {
             const earlyClaim = await claimBackgroundWorkerRunEarly({
@@ -7312,12 +7415,19 @@ export function createProductionAgentHandler(options) {
             typeof threadId === "string" &&
             threadId.trim().length > 0 &&
             isAgentChatForegroundSelfChainEnabled();
+        const noProgressRepeatForRun = (run) => resolveBackgroundNoProgressRepeat({
+            run,
+            priorErrorCode: priorNoProgressErrorCode,
+            priorCount: priorNoProgressCount,
+        });
         const willChainBackgroundContinuation = (run) => shouldChainBackgroundContinuation({
             isBackgroundWorker,
             run,
             continuationCount: backgroundContinuationCount,
             foregroundSelfChainEligible,
             dispatchedToBackground: dispatchToBackground,
+            priorNoProgressErrorCode,
+            priorNoProgressCount,
         });
         const completeTrackedProgressRun = async (run, completionError) => {
             if (!trackedProgressRunId || !trackedProgressOwner)
@@ -7404,6 +7514,14 @@ export function createProductionAgentHandler(options) {
                         ? `${errEvent.errorCode ?? ""} ${errEvent.error ?? ""}`.trim()
                         : "run ended in errored state").catch(() => { });
                 }
+                const noProgressRepeat = noProgressRepeatForRun(run);
+                if (noProgressRepeat.tripped) {
+                    // Install the replacement before the thread writer runs. The
+                    // writer builds durable thread_data from events, so changing
+                    // only continuationTerminalEvent afterwards leaves the original
+                    // recoverable error persisted and eligible for another retry.
+                    installBackgroundNoProgressTerminalEvent(run, noProgressRepeat);
+                }
                 // Persist the (partial) assistant turn to thread_data FIRST — the
                 // server-driven continuation below rebuilds from it, so it must be
                 // committed before we re-fire.
@@ -7434,7 +7552,14 @@ export function createProductionAgentHandler(options) {
                 // succeeded — a dispatch fast-fail degrades to the inline
                 // foreground fallback, which is not a worker and rides the
                 // connected client's auto_continue instead.)
-                if (willChainBackgroundContinuation(run)) {
+                if (noProgressRepeat.tripped) {
+                    if (run.continuationTerminalEvent?.type === "error") {
+                        console.error(`[agent-chat] stopping background chain: ${noProgressRepeat.errorCode} ` +
+                            `failed ${noProgressRepeat.count}x with no progress`, run.runId);
+                        await recordRunDiagnostic(run.runId, RUN_DIAG_STAGE.workerThrew, `chain_stopped_no_progress code=${noProgressRepeat.errorCode} count=${noProgressRepeat.count}`).catch(() => { });
+                    }
+                }
+                else if (willChainBackgroundContinuation(run)) {
                     // Full handoff discipline lives in
                     // `chainServerDrivenContinuation` (exported + unit-tested):
                     // per-turn SQL run budget, successor row PRE-INSERTED before
@@ -7447,6 +7572,7 @@ export function createProductionAgentHandler(options) {
                         effectiveTurnId,
                         requestBody: body,
                         backgroundContinuationCount,
+                        noProgressRepeat,
                         turnInputTokens,
                         // Re-evaluate the durable gate rather than keying off
                         // isBackgroundWorker: a successor chunk of a FOREGROUND

package/dist/agent/run-manager.d.ts

@@ -11,13 +11,18 @@ export interface ActiveRun {
     abort: AbortController;
     abortReason?: string;
     /**
-     * Terminal event to emit when a server-driven continuation has been handed
-     * off successfully. The continuation runs outside this process, so the
-     * normal loop-level auto_continue event is not sent through this run's
-     * `send` callback.
+     * Terminal event the completion callback installs in place of the one the
+     * loop stashed: `auto_continue` when a server-driven continuation has been
+     * handed off successfully (that continuation runs outside this process, so
+     * the loop-level auto_continue never goes through this run's `send`), or
+     * `error` when the callback decided the turn must stop here instead — the
+     * stashed error is recoverable by construction, so leaving it in place
+     * re-enters the very chain the callback just refused to continue.
      */
     continuationTerminalEvent?: Extract<AgentChatEvent, {
         type: "auto_continue";
+    } | {
+        type: "error";
     }>;
     startedAt: number;
 }

package/dist/agent/run-manager.js

@@ -1282,6 +1282,13 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
                     }
                     : run;
                 await onComplete(completionRun);
+                // `completionRun` is a shallow COPY whenever the loop stashed a
+                // terminal event, so a callback that installs its own terminal
+                // event writes it to the copy and `resolveTerminalEventForCompletion`
+                // below never sees it — the run then emits the pre-callback event
+                // the callback was overriding.
+                run.continuationTerminalEvent ??=
+                    completionRun.continuationTerminalEvent;
             }
             catch (err) {
                 completionError = err;

package/dist/agent/thread-data-builder.js

@@ -9,6 +9,13 @@ function isInternalContinuationError(event) {
     const msg = event.error.toLowerCase();
     if (code === "builder_gateway_error")
         return false;
+    // An explicit `recoverable: false` outranks the code and message inference
+    // below, matching `isRecoverableContinuationError`. The background
+    // no-progress breaker stops a turn while PRESERVING the underlying transient
+    // code, so reading the code instead of the flag drops the one error the user
+    // was supposed to see out of the persisted turn.
+    if (event.recoverable === false)
+        return false;
     return (event.recoverable === true ||
         code === "builder_gateway_timeout" ||
         // Carries what `msg.includes("stream ended")` below used to: a

package/dist/agent/types.d.ts

@@ -175,6 +175,16 @@ export interface AgentChatRequest {
          * boundary and refuses to chain past `MAX_BACKGROUND_RUN_CONTINUATIONS`.
          */
         continuationCount?: number;
+        /**
+         * Terminal error code the previous chunk failed with, plus how many chunks
+         * in a row have now ended on that same code having emitted no assistant
+         * text and no tool activity. Carried on the marker because each chunk is a
+         * separate invocation with no memory of the last one — without it the
+         * no-progress circuit breaker in `shouldChainBackgroundContinuation`
+         * cannot see a repeat at all.
+         */
+        noProgressErrorCode?: string;
+        noProgressCount?: number;
         /**
          * True when the dispatcher expects the self-POST to land in a real
          * Netlify `-background` function rather than the ~60s synchronous function.

package/dist/cli/code-agent-connector.js

@@ -163,6 +163,9 @@ class RemoteCodeAgentConnector {
                 ok: false,
                 error: err instanceof Error ? err.message : String(err),
             }));
+            if (result.ok === false) {
+                this.output.write(`Remote command ${command.id} failed: ${typeof result.error === "string" ? result.error : "Unknown connector error."}\n`);
+            }
             await this.postCommandResult(command, result);
         }
     }
@@ -334,7 +337,9 @@ class RemoteCodeAgentConnector {
                     commandId: command.id,
                     deviceId: this.config.deviceId,
                     relayUrl: this.relayUrl,
-                    ...(portalWorkspace ? { remoteRunId: run.id } : {}),
+                    ...(portalWorkspace && requestedRunId
+                        ? { remoteRunId: requestedRunId }
+                        : {}),
                 },
                 ...(portalWorkspace
                     ? {

package/dist/client/MultiTabAssistantChat.js

@@ -789,7 +789,11 @@ export function MultiTabAssistantChat({ showTabBar = true, renderHeader, renderO
         catch { }
     }, [subAgentNames, SUB_AGENT_NAMES_KEY]);
     // Open tabs — persisted to localStorage so they survive refresh.
-    const OPEN_TABS_KEY = `agent-chat-open-tabs${keyPrefix}`;
+    // Per-scope, for the same reason the active thread is: the tab list must
+    // follow the resource in view, so one resource's tabs never stay mounted
+    // (and rebroadcasting their run state) while another resource is open.
+    const scopeKeyPart = scope ? `:scope:${scope.type}:${scope.id}` : "";
+    const OPEN_TABS_KEY = `agent-chat-open-tabs${keyPrefix}${scopeKeyPart}`;
     const [openTabIds, setOpenTabIds] = useState(() => {
         if (!restoreActiveThread && activeThreadId) {
             for (const id of [activeThreadId])
@@ -814,7 +818,35 @@ export function MultiTabAssistantChat({ showTabBar = true, renderHeader, renderO
     const openTabIdsRef = useRef(openTabIds);
     openTabIdsRef.current = openTabIds;
     const initializedRef = useRef(false);
+    // Rehydrate open tabs when the scope flips. Read the new key before the
+    // persistence effect can write the current (now-wrong) tab list under it.
     const openTabsKeyRef = useRef(OPEN_TABS_KEY);
+    useEffect(() => {
+        if (openTabsKeyRef.current === OPEN_TABS_KEY)
+            return;
+        openTabsKeyRef.current = OPEN_TABS_KEY;
+        initializedRef.current = false;
+        if (!restoreActiveThread) {
+            setOpenTabIds(activeThreadId ? [activeThreadId] : []);
+            return;
+        }
+        try {
+            const saved = localStorage.getItem(OPEN_TABS_KEY);
+            if (saved) {
+                const parsed = JSON.parse(saved);
+                if (Array.isArray(parsed)) {
+                    for (const id of parsed)
+                        mountedTabsRef.current.add(id);
+                    setOpenTabIds(parsed);
+                    return;
+                }
+            }
+        }
+        catch {
+            // coercion-ok: malformed persisted tab data is an absent tab list.
+        }
+        setOpenTabIds([]);
+    }, [OPEN_TABS_KEY, activeThreadId, restoreActiveThread]);
     useBrowserLayoutEffect(() => {
         const nextScope = scope;
         if (!nextScope)

package/dist/client/sse-event-processor.js

@@ -473,6 +473,17 @@ async function readChunkWithProgressTimeout(reader, lastMeaningfulEventAt, noPro
 function isAutoRecoverableError(ev, errMsg) {
     const code = String(ev.errorCode ?? "").toLowerCase();
     const msg = errMsg.toLowerCase();
+    // An explicit `recoverable: false` outranks EVERY inference below — the code
+    // list as well as the message sniff — matching the server's own precedence in
+    // `isRecoverableContinuationError`. The repeat guards stop a turn with a
+    // message that names the looping tool, so a stop on
+    // `list-workspace-connections` matched the "connection" sniff and
+    // auto-continued the very loop it was emitted to break; the background
+    // no-progress breaker stops one while PRESERVING the underlying transient
+    // code (so the failure stays diagnosable), so reading the code instead of the
+    // flag re-POSTs the exact chain the server just refused to continue.
+    if (ev.recoverable === false)
+        return false;
     if (code === "context_length_exceeded" ||
         code === "input_too_long" ||
         code.startsWith("credits-limit") ||
@@ -548,13 +559,6 @@ function isAutoRecoverableError(ev, errMsg) {
     }
     if (ev.recoverable === true)
         return true;
-    // An explicit flag outranks the message sniff below, which exists only for
-    // events that carry no flag at all. The repeat guards stop a turn with
-    // `recoverable: false` and a message that names the looping tool, so a stop
-    // on `list-workspace-connections` matched the "connection" sniff and
-    // auto-continued the very loop it was emitted to break.
-    if (ev.recoverable === false)
-        return false;
     if (msg.includes("daily gateway request cap"))
         return false;
     // The engine's structural verdict, checked after every terminal code above so

package/dist/client/use-chat-threads.js

@@ -467,9 +467,9 @@ export function useChatThreads(apiUrl = agentNativePath("/_agent-native/agent-ch
     //   it; the server hasn't seen it yet because there's no POST anymore,
     //   the row gets written when the user sends a message.
     // - savedId is set but not on the current page → look it up directly. A
-    //   found thread stays active. An unavailable lookup keeps the saved id so
-    //   the detail surface can preserve cached state and offer recovery instead
-    //   of replacing a shared/reopened conversation with a blank local tab.
+    //   found thread stays active. An unavailable lookup keeps the saved id for
+    //   list-only readers and explicit routes, while a normal home surface drops
+    //   a dead local pointer instead of opening with a restore error.
     // - No savedId → synthesize a fresh local id (no POST; server creates the
     //   row on first message). The server may contain chats from another
     //   branch, preview, or project that shares the same user/database, so
@@ -511,12 +511,12 @@ export function useChatThreads(apiUrl = agentNativePath("/_agent-native/agent-ch
             const restoredIsUnavailable = restoredThread === null && lookupRestored && !restoredOnPage;
             const restoredBelongsElsewhere = Boolean(restoredThread &&
                 !threadCanStayVisibleInScope(restoredThread.scope ?? null, scopeRef.current));
-            // Keep the saved id when the direct lookup says 404. AssistantChat owns
-            // the detail restore and can show a retryable error while preserving any
-            // cached transcript or composer draft. Replacing the id here silently
-            // turns a shared/reopened conversation into a new blank chat after the
-            // slower lookup finishes.
-            const restoredNeedsReplacement = restoredBelongsElsewhere;
+            // A missing saved id is stale local UI state on a normal home surface,
+            // not a reason to show an error above a fresh composer. Preserve it for
+            // explicit routes and list-only readers, where the caller still owns
+            // recovery for a deliberately selected thread.
+            const restoredNeedsReplacement = restoredBelongsElsewhere ||
+                (restoredIsUnavailable && autoCreate && !routeControlsActiveThread);
             if (restoredNeedsReplacement)
                 setActiveThreadId(null);
             const savedId = restoredNeedsReplacement ? null : restoredId;

package/dist/collab/struct-routes.d.ts

@@ -13,8 +13,8 @@
  * Body: { json: any, fieldName?: string, type?: "map"|"array", requestSource?: string }
  */
 export declare const postCollabJson: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    error: string;
     ok?: undefined;
+    error: string;
 } | {
     error?: undefined;
     ok: boolean;

package/dist/file-upload/actions/upload-image.d.ts

@@ -17,11 +17,11 @@ declare const _default: import("../../action.js").ActionDefinition<{
     id?: undefined;
     provider?: undefined;
 } | {
+    error?: undefined;
     configured?: undefined;
     connectPath?: undefined;
     url: string;
     id: string;
     provider: string;
-    error?: undefined;
 }>;
 export default _default;

package/dist/observability/routes.d.ts

@@ -42,22 +42,22 @@ export declare function createObservabilityHandler(): import("h3").EventHandlerW
     avgEvalScore: number;
 } | {
     error?: undefined;
+    ok?: undefined;
     summary: import("./types.js").TraceSummary;
     spans: import("./types.js").TraceSpan[];
     id?: undefined;
-    ok?: undefined;
 } | {
     error?: undefined;
+    ok?: undefined;
     summary?: undefined;
     spans?: undefined;
     id: string;
-    ok?: undefined;
 } | {
+    ok?: undefined;
     summary?: undefined;
     spans?: undefined;
     id?: undefined;
     error: any;
-    ok?: undefined;
 } | {
     error?: undefined;
     summary?: undefined;

package/dist/progress/routes.d.ts

@@ -15,6 +15,6 @@ export declare function createProgressHandler(): import("h3").EventHandlerWithFe
     error: string;
     ok?: undefined;
 } | {
-    ok: boolean;
     error?: undefined;
+    ok: boolean;
 }>>;

package/dist/resources/handlers.d.ts

@@ -48,8 +48,8 @@ export declare function handleUpdateResource(event: any): Promise<import("./stor
 }>;
 /** DELETE /_agent-native/resources/:id — delete a resource */
 export declare function handleDeleteResource(event: any): Promise<{
-    error: string;
     ok?: undefined;
+    error: string;
 } | {
     error?: undefined;
     ok: boolean;

package/dist/secrets/routes.d.ts

@@ -34,37 +34,37 @@ export declare function createListSecretsHandler(): import("h3").EventHandlerWit
 /** POST /_agent-native/secrets/:key — write a secret. */
 export declare function createWriteSecretHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
     error: string;
-    status?: undefined;
     ok?: undefined;
+    status?: undefined;
 } | {
+    error?: undefined;
     ok: boolean;
     status: string;
-    error?: undefined;
 } | {
+    ok?: undefined;
     error: string;
     removed?: undefined;
-    ok?: undefined;
 } | {
+    error?: undefined;
     ok: boolean;
     removed: boolean;
-    error?: undefined;
 }>>;
 /**
  * POST /_agent-native/secrets/:key/test — validate an optional candidate value
  * or the current stored value without changing anything.
  */
 export declare function createTestSecretHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
+    ok?: undefined;
     error: string;
     note?: undefined;
-    ok?: undefined;
 } | {
+    error?: undefined;
     ok: boolean;
     note?: undefined;
-    error?: undefined;
 } | {
+    error?: undefined;
     ok: boolean;
     note: string;
-    error?: undefined;
 } | {
     note?: undefined;
     ok: boolean;
@@ -95,11 +95,11 @@ export interface AdHocSecretPayload {
 export declare function createAdHocSecretHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<AdHocSecretPayload[] | {
     error: string;
 } | {
+    error?: undefined;
     ok: boolean;
     key: string;
-    error?: undefined;
 } | {
+    error?: undefined;
     ok: boolean;
     removed: boolean;
-    error?: undefined;
 }>>;

package/dist/server/realtime-token.d.ts

@@ -26,8 +26,8 @@ export declare function createRealtimeTokenHandler(): import("h3").EventHandlerW
     expiresAt?: undefined;
     ttlSeconds?: undefined;
 } | {
+    error?: undefined;
     token: string;
     expiresAt: string;
     ttlSeconds: number;
-    error?: undefined;
 }>>;

package/dist/server/transcribe-voice.d.ts

@@ -20,6 +20,6 @@ export declare function createTranscribeVoiceHandler(): import("h3").EventHandle
     error: string;
     text?: undefined;
 } | {
-    text: string;
     error?: undefined;
+    text: string;
 }>>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-native/core",
-  "version": "0.161.4",
+  "version": "0.161.6",
   "description": "Framework for agent-native application development — where AI agents and UI share SQL state, actions, and context",
   "homepage": "https://github.com/BuilderIO/agent-native#readme",
   "bugs": {
@@ -427,8 +427,8 @@
     "y-protocols": "^1.0.7",
     "yjs": "^13.6.31",
     "zod": "^4.3.6",
-    "@agent-native/recap-cli": "0.5.4",
-    "@agent-native/toolkit": "^0.16.4"
+    "@agent-native/toolkit": "^0.16.4",
+    "@agent-native/recap-cli": "0.5.4"
   },
   "devDependencies": {
     "@ai-sdk/anthropic": "^3.0.71",