@agent-native/core 0.161.23 → 0.162.0

package/dist/agent/engine/translate-anthropic.js

@@ -261,17 +261,42 @@ export function backfillEngineMessagesToolResults(messages) {
 // ---------------------------------------------------------------------------
 // EngineMessage → Anthropic.MessageParam
 // ---------------------------------------------------------------------------
+/**
+ * A thinking block replays only with the signature Anthropic issued for it, or
+ * (redacted) with its encrypted payload. An empty signature is not a fallback:
+ * the native API rejects the whole request, so a turn that streamed fine dies
+ * with a provider error pointing nowhere near the cause. Drop the unsendable
+ * block and say so instead of coercing it into a guaranteed 400.
+ *
+ * Not applied to the Builder gateway: its tolerance for an unsigned thinking
+ * block is unverified, so that path keeps its existing behavior rather than
+ * trading a working request for an untested one.
+ */
+function replayableAnthropicPart(part) {
+    if (part.type !== "thinking")
+        return true;
+    if (part.redactedData || part.signature)
+        return true;
+    console.warn("[anthropic-engine] dropping a thinking block with no signature; it cannot be replayed");
+    return false;
+}
 export function engineMessageToAnthropic(msg, opts) {
     const builderGateway = opts?.builderGateway === true;
+    const content = builderGateway
+        ? msg.content
+        : msg.content.filter(replayableAnthropicPart);
     return {
         role: msg.role,
-        content: msg.content.map((p) => enginePartToAnthropic(p, builderGateway)),
+        content: content.map((p) => enginePartToAnthropic(p, builderGateway)),
     };
 }
 /** Messages for the Anthropic HTTP API (strict schema — no extra tool_result fields). */
 export function engineMessagesToAnthropic(messages) {
     const normalized = backfillEngineMessagesToolResults(messages);
-    return normalized.map((m) => engineMessageToAnthropic(m));
+    return normalized.flatMap((m) => {
+        const translated = engineMessageToAnthropic(m);
+        return translated.content.length > 0 ? [translated] : [];
+    });
 }
 /**
  * Messages for the Builder LLM gateway (Gemini-backed). Same Anthropic-shaped

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

@@ -700,7 +700,7 @@ export interface ExecuteAgentToolCallOptions {
     threadId?: string;
     turnId?: string;
     approvedToolCalls?: string[];
-    onApprovalRequired?: (binding: AgentApprovalBinding) => Promise<void>;
+    onApprovalRequired?: (binding: AgentApprovalBinding) => Promise<string | void>;
     consumeApproval?: (binding: AgentApprovalBinding) => Promise<boolean>;
     send?: (event: AgentChatEvent) => void;
 }
@@ -877,7 +877,7 @@ export declare function runAgentLoop(opts: {
      * so client-supplied history is never the authorization source; direct loop
      * callers may omit them when they own the surrounding approval boundary.
      */
-    onApprovalRequired?: (binding: AgentApprovalBinding) => Promise<void>;
+    onApprovalRequired?: (binding: AgentApprovalBinding) => Promise<string | void>;
     consumeApproval?: (binding: AgentApprovalBinding) => Promise<boolean>;
     /**
      * In-loop processor seam (see `processors.ts`). Each processor can observe

package/dist/agent/production-agent.js

@@ -4331,7 +4331,14 @@ export async function runAgentLoop(opts) {
                     mustApprove = true;
                 }
                 if (mustApprove) {
-                    await opts.onApprovalRequired?.(approvalBinding);
+                    // `askId` identifies THIS gate hit, distinct from any earlier ask
+                    // for the same approvalKey/toolCallId. A failed resume (expired
+                    // grant, turn-id mismatch) re-enters this branch and mints a new
+                    // askId, which is how the client tells "an already-approved card
+                    // re-rendered" apart from "a fresh ask after the grant didn't land"
+                    // — without it, a stale client-side "approved" mark permanently
+                    // hides Approve/Deny with no way to retry.
+                    const askId = (await opts.onApprovalRequired?.(approvalBinding)) || undefined;
                     send({
                         type: "tool_start",
                         id: toolCall.id,
@@ -4343,6 +4350,7 @@ export async function runAgentLoop(opts) {
                         tool: toolCall.name,
                         input: toolCall.input,
                         approvalKey,
+                        ...(askId ? { askId } : {}),
                         ...(toolCall.id ? { toolCallId: toolCall.id } : {}),
                     });
                     // Audit the blocked attempt: the action did NOT run, but "the agent
@@ -7194,7 +7202,7 @@ export function createProductionAgentHandler(options) {
         };
         const approvalHooks = {
             onApprovalRequired: async (binding) => {
-                await createAgentToolApproval(approvalStoreBinding(binding));
+                return createAgentToolApproval(approvalStoreBinding(binding));
             },
             consumeApproval: async (binding) => {
                 if (!ownerEmail)
@@ -7234,12 +7242,12 @@ export function createProductionAgentHandler(options) {
                 const { threadDataToEngineMessages } = await import("./thread-data-builder.js");
                 const priorThreadData = (await getThread(effectiveThreadId))
                     ?.threadData;
-                // `threadDataToEngineMessages` takes one argument and flattens tool
-                // calls to text by design. The second argument never existed anywhere
-                // in the repo, so this failed `tsc` and broke every production build
-                // between 16:29 and now -- it reached main only because admin merges
-                // do not wait for the typecheck that would have caught it.
-                const resumed = threadDataToEngineMessages(priorThreadData);
+                // Replay what earlier chunks DID, not just what they said: the default
+                // text-only rebuild drops every tool call and result, so the next chunk
+                // re-runs work already committed and cannot see its output.
+                const resumed = threadDataToEngineMessages(priorThreadData, {
+                    includeToolCalls: true,
+                });
                 if (resumed.length > 0) {
                     const actionPreparationTool = typeof backgroundRunMarker?.actionPreparationTool === "string" &&
                         backgroundRunMarker.actionPreparationTool.trim()

package/dist/agent/thread-data-builder.d.ts

@@ -21,6 +21,7 @@ interface ContentPart {
     approval?: {
         approvalKey: string;
         dismissed?: boolean;
+        askId?: string;
     };
 }
 interface BuildAssistantMessageOptions {

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

@@ -144,7 +144,10 @@ export function buildAssistantMessage(events, runId, options = {}) {
             const matchingIndex = findApprovalToolCallIndex(content, event.tool ?? "unknown", event.toolCallId);
             const part = content[matchingIndex];
             if (part?.type === "tool-call") {
-                part.approval = { approvalKey: event.approvalKey };
+                part.approval = {
+                    approvalKey: event.approvalKey,
+                    ...(event.askId ? { askId: event.askId } : {}),
+                };
             }
             continue;
         }
@@ -744,14 +747,13 @@ function assistantReplayContent(message, text) {
             ? part.args
             : {};
         assistant.push({ type: "tool-call", id, name, input });
-        if (part.result === undefined)
-            continue;
+        const result = part.result === undefined ? INTERRUPTED_TOOL_RESULT : part.result;
         results.push({
             type: "tool-result",
             toolCallId: id,
             toolName: name,
             toolInput: stringifyToolUseInputForGateway(input),
-            content: replayedToolResultContent(part.result),
+            content: replayedToolResultContent(result),
             ...(part.isError === true ? { isError: true } : {}),
         });
     }

package/dist/agent/tool-approval-store.d.ts

@@ -21,7 +21,16 @@ export declare function resolveAgentToolApprovalTurnId(binding: {
     requestedTurnId?: string | null;
     approvalKeys: readonly string[];
 }): Promise<string | null>;
-export declare function createAgentToolApproval(binding: AgentToolApprovalBinding): Promise<void>;
+/**
+ * Creates the durable pending-approval row and returns its id as the "ask"
+ * identity for this specific gate hit. Every call is a fresh row (a fresh
+ * id), including a second gate hit for the same `approvalKey` after a prior
+ * grant failed to be consumed — so the id doubles as the signal the client
+ * needs to tell "this approval_required is the one I already approved,
+ * re-rendered" apart from "this is a NEW ask for the same tool call". See
+ * `ApprovalAffordance` in client/chat/tool-call-display.tsx.
+ */
+export declare function createAgentToolApproval(binding: AgentToolApprovalBinding): Promise<string>;
 /**
  * Atomically consume the server-created approval for one logical tool call.
  * The model's call id is transport metadata and can change when Dispatch

package/dist/agent/tool-approval-store.js

@@ -2,7 +2,13 @@ import { createHash, randomUUID } from "node:crypto";
 import { getDbExec, isPostgres, retryOnDdlRace } from "../db/client.js";
 import { ensureIndexExists, ensureTableExists } from "../db/ddl-guard.js";
 import { AGENT_TOOL_APPROVAL_INDEX_SQL, AGENT_TOOL_APPROVAL_LOGICAL_INDEX_SQL, AGENT_TOOL_APPROVAL_RECOVERY_INDEX_SQL, AGENT_TOOL_APPROVAL_TABLE_SQL, } from "./tool-approval-migrations.js";
-const APPROVAL_TTL_MS = 15 * 60_000;
+// 15 minutes was too short in practice: a user who steps away mid-approval
+// (switching tabs to update their client, checking something else) comes back
+// to a silently expired grant with no visible error — clicking Approve just
+// does nothing, because `consumeAgentToolApproval`'s `expires_at > ?` no
+// longer matches. An hour gives real human latency room while still bounding
+// how long a stale grant can be replayed.
+const APPROVAL_TTL_MS = 60 * 60_000;
 const APPROVAL_CLEANUP_AGE_MS = 24 * 60 * 60_000;
 let initPromise;
 async function ensureAgentToolApprovalTable() {
@@ -74,17 +80,27 @@ export async function resolveAgentToolApprovalTurnId(binding) {
         return requestedTurnId;
     return turnIds.size === 1 ? [...turnIds][0] : null;
 }
+/**
+ * Creates the durable pending-approval row and returns its id as the "ask"
+ * identity for this specific gate hit. Every call is a fresh row (a fresh
+ * id), including a second gate hit for the same `approvalKey` after a prior
+ * grant failed to be consumed — so the id doubles as the signal the client
+ * needs to tell "this approval_required is the one I already approved,
+ * re-rendered" apart from "this is a NEW ask for the same tool call". See
+ * `ApprovalAffordance` in client/chat/tool-call-display.tsx.
+ */
 export async function createAgentToolApproval(binding) {
     await ensureAgentToolApprovalTable();
     const now = Date.now();
     const expiresAt = binding.expiresAt ?? now + APPROVAL_TTL_MS;
+    const id = `agent-tool-approval-${randomUUID()}`;
     await getDbExec().execute({
         sql: `INSERT INTO agent_tool_approvals
       (id, owner_email, org_id, thread_id, turn_id, tool_name, call_id,
        approval_key_hash, status, expires_at, consumed_at, created_at, updated_at)
       VALUES (?, ?, ?, ?, ?, ?, ?, ?, 'pending', ?, NULL, ?, ?)`,
         args: [
-            `agent-tool-approval-${randomUUID()}`,
+            id,
             binding.ownerEmail,
             binding.orgId ?? null,
             binding.threadId ?? null,
@@ -110,6 +126,7 @@ export async function createAgentToolApproval(binding) {
     catch (error) {
         console.warn("[agent] Could not clean expired tool approval records", error);
     }
+    return id;
 }
 /**
  * Atomically consume the server-created approval for one logical tool call.

package/dist/agent/types.d.ts

@@ -305,6 +305,15 @@ export type AgentChatEvent = {
     approvalKey: string;
     /** The model-side tool-call id for this paused call, when available. */
     toolCallId?: string;
+    /**
+     * Identifies THIS gate hit, distinct from any earlier ask carrying the
+     * same `approvalKey`/`toolCallId`. A failed resume (expired grant,
+     * turn-id mismatch) re-emits `approval_required` for the same call with
+     * a fresh `askId`; the client uses the change to tell that apart from
+     * the same ask simply re-rendering, so a stale "approved" mark can't
+     * permanently hide Approve/Deny with no way to retry.
+     */
+    askId?: string;
 } | {
     type: "agent_call";
     agent: string;

package/dist/client/AssistantChat.js

@@ -1371,8 +1371,16 @@ export function useAutoResumeStatus(tabId, forceStopped) {
     }, [clearAutoResume, forceStopped]);
     return { isAutoResuming, clearAutoResume };
 }
-function approvalResolutionIdentity(approvalKey, toolCallId) {
-    return `${toolCallId ?? ""}\u0000${approvalKey}`;
+function approvalResolutionIdentity(approvalKey, toolCallId, 
+// Included so a NEW `approval_required` ask for the same toolCallId/
+// approvalKey (the server re-emitting after a failed resume never
+// consumed the earlier grant) looks up as unresolved instead of
+// inheriting the earlier ask's retained "approved" mark forever. Two
+// asks sharing no askId (older events, non-production-agent approval
+// sources) still collapse onto the same identity, preserving the
+// existing remount-survives-as-approved behavior for them.
+askId) {
+    return `${toolCallId ?? ""}\u0000${approvalKey}\u0000${askId ?? ""}`;
 }
 const AssistantChatInner = forwardRef(function AssistantChatInner({ emptyStateText, suggestions, dynamicSuggestions, threadFooterSlot, emptyStateAddon, showHeader = true, onSwitchToCli, className, apiUrl, tabId, browserTabId, threadId, contextScope, contextNamespace, isActiveComposer = true, onMessageCountChange, onSaveThread, onGenerateTitle, composerSlot, onComposerTextChange, composerAreaClassName, composerPlaceholder, missingApiKeySetupLayout = "default", composerLayoutVariant = "default", centerComposerWhenEmpty = false, emptyStateDisplay = "default", composerToolbarSlot, composerExtraActionButton, showModelSelector = true, composerDisabled = false, composerDisabledPlaceholder, isNewThread, isThreadStateLoading, onSlashCommand, execMode, onExecModeChange, approvalActions, planModeDisabled, planModeDisabledReason, selectedModel, defaultModel, selectedEngine, selectedEffort, availableModels, modelListLoading, onModelChange, onEffortChange, availableAgents, selectedAgent, hostedHarness, onAgentChange, imageModelMenu, onForkChat, onConnectProvider, onConnectLocalRuntime, plusMenuMode = "full", providerStatusChecksEnabled = true, loadHistoryRepository, historyReloadKey, externalStreaming = false, agentChatSurface = "app", suppressInlineOpenApp = false, }, ref) {
     const t = useT();
@@ -4131,19 +4139,19 @@ const AssistantChatInner = forwardRef(function AssistantChatInner({ emptyStateTe
         scope: approvalResolutionScope,
         byIdentity: new Map(),
     }));
-    const getApprovalResolution = useCallback((approvalKey, toolCallId) => {
+    const getApprovalResolution = useCallback((approvalKey, toolCallId, askId) => {
         if (approvalResolutionState.scope !== approvalResolutionScope) {
             return null;
         }
-        return (approvalResolutionState.byIdentity.get(approvalResolutionIdentity(approvalKey, toolCallId)) ?? null);
+        return (approvalResolutionState.byIdentity.get(approvalResolutionIdentity(approvalKey, toolCallId, askId)) ?? null);
     }, [approvalResolutionScope, approvalResolutionState]);
-    const recordApprovalResolution = useCallback((approvalKey, resolution, toolCallId) => {
+    const recordApprovalResolution = useCallback((approvalKey, resolution, toolCallId, askId) => {
         setApprovalResolutionState((previous) => {
             const byIdentity = previous.scope === approvalResolutionScope
                 ? previous.byIdentity
                 : new Map();
             const next = new Map(byIdentity);
-            next.set(approvalResolutionIdentity(approvalKey, toolCallId), resolution);
+            next.set(approvalResolutionIdentity(approvalKey, toolCallId, askId), resolution);
             return { scope: approvalResolutionScope, byIdentity: next };
         });
     }, [approvalResolutionScope]);

package/dist/client/EnvironmentBadge.d.ts

@@ -0,0 +1,15 @@
+import type { AgentNativeDeploymentEnvironment, AgentNativeConfig } from "../config.js";
+export interface EnvironmentBadgeTargets {
+    betaHost: string;
+    productionHost: string;
+}
+export declare function isBuilderIoEmployee(email: string | null | undefined): boolean;
+export declare function resolveEnvironmentTargets(hostname: string | undefined): EnvironmentBadgeTargets | null;
+export declare function resolveEnvironmentChannel(config: AgentNativeConfig, hostname: string | undefined): Extract<AgentNativeDeploymentEnvironment, "beta" | "production"> | null;
+export declare function buildEnvironmentUrl(sourceHref: string, targetHost: string): string | null;
+/**
+ * Small internal-only lane switcher for first-party hosted Agent-Native apps.
+ * It is mounted inside the authenticated AppProviders shell so public pages,
+ * embeds, and signed-out visitors never receive environment navigation.
+ */
+export declare function EnvironmentBadge(): import("react").JSX.Element | null;

package/dist/client/EnvironmentBadge.js

@@ -0,0 +1,79 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Button } from "@agent-native/toolkit/ui/button";
+import { Popover, PopoverContent, PopoverTrigger, } from "@agent-native/toolkit/ui/popover";
+import { IconExternalLink, IconGitBranch } from "@tabler/icons-react";
+import { useMemo } from "react";
+import { injectedAgentNativeConfig } from "./app-config.js";
+import { useSession } from "./use-session.js";
+export function isBuilderIoEmployee(email) {
+    return email?.trim().toLowerCase().endsWith("@builder.io") ?? false;
+}
+export function resolveEnvironmentTargets(hostname) {
+    const normalized = hostname?.trim().toLowerCase().replace(/\.$/, "");
+    if (!normalized)
+        return null;
+    const productionHost = normalized.replace(/^beta\./, "");
+    const isFirstPartyHost = productionHost.endsWith(".agent-native.com") ||
+        productionHost === "agent-workspace.builder.io";
+    if (!isFirstPartyHost)
+        return null;
+    return {
+        betaHost: `beta.${productionHost}`,
+        productionHost,
+    };
+}
+export function resolveEnvironmentChannel(config, hostname) {
+    const configured = config.deployment?.environment;
+    if (configured === "beta" || configured === "production") {
+        return configured;
+    }
+    const targets = resolveEnvironmentTargets(hostname);
+    if (!targets || !hostname)
+        return null;
+    return hostname.trim().toLowerCase().startsWith("beta.")
+        ? "beta"
+        : "production";
+}
+export function buildEnvironmentUrl(sourceHref, targetHost) {
+    try {
+        const target = new URL(sourceHref);
+        target.protocol = "https:";
+        target.hostname = targetHost;
+        target.port = "";
+        return target.toString();
+    }
+    catch {
+        // coercion-ok: Invalid navigation input is an explicit absent target.
+        return null;
+    }
+}
+function EnvironmentLink({ label, href }) {
+    return (_jsx(Button, { asChild: true, className: "w-full justify-start px-2", size: "sm", variant: "ghost", children: _jsxs("a", { href: href, children: [_jsx(IconExternalLink, { "aria-hidden": "true" }), label] }) }));
+}
+/**
+ * Small internal-only lane switcher for first-party hosted Agent-Native apps.
+ * It is mounted inside the authenticated AppProviders shell so public pages,
+ * embeds, and signed-out visitors never receive environment navigation.
+ */
+export function EnvironmentBadge() {
+    const { session, status } = useSession();
+    const config = useMemo(injectedAgentNativeConfig, []);
+    const environment = resolveEnvironmentChannel(config, typeof window === "undefined" ? undefined : window.location.hostname);
+    const targets = resolveEnvironmentTargets(typeof window === "undefined" ? undefined : window.location.hostname);
+    if (typeof window === "undefined" ||
+        window.parent !== window ||
+        status !== "authenticated" ||
+        !isBuilderIoEmployee(session?.email) ||
+        !environment ||
+        !targets) {
+        return null;
+    }
+    const currentHref = window.location.href;
+    const betaHref = buildEnvironmentUrl(currentHref, targets.betaHost);
+    const productionHref = buildEnvironmentUrl(currentHref, targets.productionHost);
+    if (!betaHref || !productionHref)
+        return null;
+    const label = environment === "beta" ? "beta" : "prod";
+    const title = environment === "beta" ? "Beta environment" : "Production environment";
+    return (_jsxs(Popover, { children: [_jsx(PopoverTrigger, { asChild: true, children: _jsxs(Button, { "aria-label": `Open ${title.toLowerCase()} switcher`, className: "fixed bottom-3 right-3 z-[100] h-7 rounded-full border-border/80 bg-background/95 px-2.5 text-[11px] font-semibold uppercase tracking-[0.12em] shadow-sm backdrop-blur-sm", size: "sm", variant: environment === "beta" ? "secondary" : "outline", children: [_jsx("span", { "aria-hidden": "true", className: `size-1.5 rounded-full ${environment === "beta" ? "bg-primary" : "bg-muted-foreground"}` }), label] }) }), _jsxs(PopoverContent, { align: "end", className: "w-64 p-3", side: "top", children: [_jsxs("div", { className: "mb-2 flex items-center gap-2 text-sm font-medium", children: [_jsx(IconGitBranch, { "aria-hidden": "true", className: "size-4 text-muted-foreground" }), title] }), _jsx("div", { className: "grid gap-1", children: environment === "beta" ? (_jsx(EnvironmentLink, { href: productionHref, label: "Go to production" })) : (_jsx(EnvironmentLink, { href: betaHref, label: "Go to beta" })) })] })] }));
+}

package/dist/client/MultiTabAssistantChat.js

@@ -291,6 +291,22 @@ const DEFAULT_AGENT_TEAM_POLL_MS = 3000;
 const DEFAULT_THREAD_URL_PARAM = "thread";
 const THREAD_URL_CHANGED_EVENT = "agent-chat:url-thread-changed";
 const hasOwn = Object.prototype.hasOwnProperty;
+// A duplicated id in `openTabIds` makes two tab-bar entries share one
+// underlying thread: closing either one filters that id out of the array
+// entirely, so both disappear at once. De-duplicate at every boundary the
+// array crosses (localStorage read and write) so a corrupted persisted list
+// self-heals instead of reproducing the phantom tab on every reload.
+function dedupeIds(ids) {
+    const seen = new Set();
+    const result = [];
+    for (const id of ids) {
+        if (seen.has(id))
+            continue;
+        seen.add(id);
+        result.push(id);
+    }
+    return result;
+}
 // The history patch is installed once and shared via a ref count so that
 // multiple synced chats (or a remount) don't restore a stale `pushState`
 // reference and silently drop a wrapper installed by another instance.
@@ -794,7 +810,7 @@ export function MultiTabAssistantChat({ showTabBar = true, renderHeader, renderO
     // (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(() => {
+    const [openTabIds, setOpenTabIdsRaw] = useState(() => {
         if (!restoreActiveThread && activeThreadId) {
             for (const id of [activeThreadId])
                 mountedTabsRef.current.add(id);
@@ -805,16 +821,35 @@ export function MultiTabAssistantChat({ showTabBar = true, renderHeader, renderO
             if (saved) {
                 const parsed = JSON.parse(saved);
                 if (Array.isArray(parsed) && parsed.length > 0) {
+                    const deduped = dedupeIds(parsed);
                     // Mark restored tabs as mounted
-                    for (const id of parsed)
+                    for (const id of deduped)
                         mountedTabsRef.current.add(id);
-                    return parsed;
+                    return deduped;
                 }
             }
         }
         catch { }
         return [];
     });
+    // Every writer routes through here so a duplicate id can never reach state.
+    // A `.includes()` guard evaluated outside the updater cannot prevent one: a
+    // synchronous burst of writes (the mount-time replay of buffered open
+    // requests dispatches its whole backlog in one loop) has every handler read
+    // the same pre-render list, so each one appends. Two tab-bar entries then
+    // share a single thread id and `closeTab`'s filter removes both at once.
+    // Returning `prev` unchanged is load-bearing, not an optimization — callers
+    // rely on identity bail-outs to keep effects that depend on `openTabIds`
+    // from re-running forever.
+    const setOpenTabIds = useCallback((value) => {
+        setOpenTabIdsRaw((prev) => {
+            const next = dedupeIds(typeof value === "function" ? value(prev) : value);
+            return next.length === prev.length &&
+                next.every((id, i) => id === prev[i])
+                ? prev
+                : next;
+        });
+    }, []);
     const openTabIdsRef = useRef(openTabIds);
     openTabIdsRef.current = openTabIds;
     const initializedRef = useRef(false);
@@ -982,6 +1017,7 @@ export function MultiTabAssistantChat({ showTabBar = true, renderHeader, renderO
     // optimistic id for a brand-new session); the activeThreadId effect above
     // adds it to openTabIds without spinning up a duplicate thread.
     const autoCreatingRef = useRef(false);
+    const lastTabReplacementInFlightRef = useRef(false);
     useEffect(() => {
         if (isLoading || autoCreatingRef.current)
             return;
@@ -1435,25 +1471,45 @@ export function MultiTabAssistantChat({ showTabBar = true, renderHeader, renderO
         });
     }, []);
     const closeTab = useCallback((tabId) => {
-        setOpenTabIds((prev) => {
-            if (prev.length <= 1) {
-                // Last tab — create a new one and replace the old tab atomically
-                createThread().then((newId) => {
+        // Read the current list from the ref rather than a `setOpenTabIds`
+        // updater callback — `createThread()`/`switchThread()` below set
+        // `activeThreadId` synchronously as a side effect, and calling them
+        // from inside an updater left `openTabIds` and `activeThreadId`
+        // inconsistent for a render: the "ensure active thread is in open
+        // tabs" effect would then re-add the just-closed id, so the tab
+        // appeared to reopen itself right after closing.
+        const prev = openTabIdsRef.current;
+        if (prev.length <= 1) {
+            if (lastTabReplacementInFlightRef.current)
+                return;
+            lastTabReplacementInFlightRef.current = true;
+            // Last tab — create a new one and replace the old tab once ready;
+            // the old tab stays visible in the meantime so the bar is never empty.
+            cleanupClosedTab(tabId);
+            void (async () => {
+                try {
+                    const newId = await createThread();
                     if (newId) {
                         newThreadIds.current.add(newId);
                         setOpenTabIds([newId]);
                         writeThreadUrl(null);
                     }
-                });
-                return prev; // Keep old tab until new one is ready
-            }
-            const next = prev.filter((id) => id !== tabId);
-            if (tabId === activeThreadIdRef.current && next.length > 0) {
-                const idx = prev.indexOf(tabId);
-                switchThread(next[Math.min(idx, next.length - 1)]);
-            }
-            return next;
-        });
+                }
+                catch (error) {
+                    console.error("[agent-chat] failed to replace the closed final tab", error);
+                }
+                finally {
+                    lastTabReplacementInFlightRef.current = false;
+                }
+            })();
+            return;
+        }
+        const next = prev.filter((id) => id !== tabId);
+        if (tabId === activeThreadIdRef.current && next.length > 0) {
+            const idx = prev.indexOf(tabId);
+            switchThread(next[Math.min(idx, next.length - 1)]);
+        }
+        setOpenTabIds(next);
         cleanupClosedTab(tabId);
     }, [switchThread, createThread, cleanupClosedTab, writeThreadUrl]);
     const closeOtherTabs = useCallback((tabId) => {

package/dist/client/agent-chat-adapter.js

@@ -65,7 +65,17 @@ const MAX_HISTORY_ATTACHMENT_CHARS = 60_000;
 // the trailing truncation notice still makes a pathological multi-MB paste
 // visibly (not silently) capped.
 const MAX_OUTBOUND_ATTACHMENT_CHARS = 200_000;
-const MAX_HISTORY_MESSAGES = 24;
+// An array-length backstop, NOT the reduction policy. Reducing a long thread is
+// Observational Memory's job: it folds older turns into observations/reflections
+// and replaces the raw prefix with a memory block plus a recent-raw window
+// (agent/observational-memory/). But its Observer only engages once a thread
+// passes 30k unobserved tokens, and a count cap of 24 bit long before that — so
+// turns were evicted from the request while compaction still had nothing to say
+// about them, and only reached the model again once thread_data was observed a
+// turn or more later. The two char budgets below are the real bound (they cap
+// what a request can carry regardless of message count); this cap only keeps the
+// array from growing without limit.
+const MAX_HISTORY_MESSAGES = 80;
 // Every provider prompt cache matches a byte-identical PREFIX. A window that
 // ends at the newest message and starts MAX_HISTORY_MESSAGES back moves its
 // START by one message per turn, so from the first turn past the cap onward no

package/dist/client/api-path.js

@@ -48,7 +48,20 @@ function workspacePathBasePath() {
     const segment = window.location.pathname.split("/").find(Boolean);
     if (!segment || segment === "_agent-native" || segment === "api")
         return "";
-    return normalizeBasePath(segment);
+    const basePath = normalizeBasePath(segment);
+    // Guard against treating an app-local route (e.g. a client-rendered
+    // "/settings" page reached via stale client-side navigation) as if it
+    // were a sibling app's workspace mount — that built URLs like
+    // "/settings/_agent-native/builder/connect", which the workspace gateway
+    // 404s (no app is mounted at "/settings") into its app-picker page instead
+    // of the real target route. Only trust the segment when it matches a
+    // known mount from the deployed app manifest; when the manifest can't be
+    // read, fall back to the prior blind-trust behavior (e.g. the same build
+    // reused across sibling app ids without a manifest).
+    const mounts = workspaceAppMountPaths();
+    if (mounts && !mounts.has(basePath))
+        return "";
+    return basePath;
 }
 function externalEmbedTargetBasePath() {
     if (typeof window === "undefined")

package/dist/client/app-providers.js

@@ -57,6 +57,7 @@ import { useInRouterContext } from "react-router";
 import { isHumanReadableDocumentTitle, normalizeDocumentTitle, } from "../shared/document-title.js";
 import { ClientOnly } from "./ClientOnly.js";
 import { DefaultSpinner } from "./DefaultSpinner.js";
+import { EnvironmentBadge } from "./EnvironmentBadge.js";
 import { AgentNativeI18nProvider, } from "./i18n.js";
 import { FirstRunOnboardingStartupGate } from "./onboarding/first-run-startup-gate.js";
 import { RequireSession } from "./require-session.js";
@@ -151,5 +152,5 @@ export function AppProviders({ queryClient, isPublicPath = false, clientOnlyFall
     if (isPublicPath) {
         return (_jsx(ProvidersInner, { queryClient: queryClient, defaultTheme: defaultTheme, themeAttribute: themeAttribute, tooltipDelayDuration: tooltipDelayDuration, toaster: toaster, disableThemeTransitions: disableThemeTransitions, i18n: i18n, documentTitleFallback: documentTitleFallback, children: children }));
     }
-    return (_jsx(ClientOnly, { fallback: fallback, children: _jsx(ProvidersInner, { queryClient: queryClient, defaultTheme: defaultTheme, themeAttribute: themeAttribute, tooltipDelayDuration: tooltipDelayDuration, toaster: toaster, disableThemeTransitions: disableThemeTransitions, i18n: i18n, documentTitleFallback: documentTitleFallback, children: _jsx(RequireSession, { bypass: sessionBypass, fallback: fallback, children: sessionBypass ? (children) : (_jsx(FirstRunOnboardingStartupGate, { children: children })) }) }) }));
+    return (_jsx(ClientOnly, { fallback: fallback, children: _jsx(ProvidersInner, { queryClient: queryClient, defaultTheme: defaultTheme, themeAttribute: themeAttribute, tooltipDelayDuration: tooltipDelayDuration, toaster: toaster, disableThemeTransitions: disableThemeTransitions, i18n: i18n, documentTitleFallback: documentTitleFallback, children: _jsx(RequireSession, { bypass: sessionBypass, fallback: fallback, children: sessionBypass ? (children) : (_jsxs(FirstRunOnboardingStartupGate, { children: [children, _jsx(EnvironmentBadge, {})] })) }) }) }));
 }

package/dist/client/chat/tool-call-display.d.ts

@@ -34,9 +34,17 @@ export type ApprovalContextValue = {
      * Keep the visible resolution stable while the chat repository refreshes or
      * remounts the message containing this approval card.
      */
-    onApprovalResolved?: (approvalKey: string, resolution: ApprovalResolution, toolCallId?: string) => void;
+    onApprovalResolved?: (approvalKey: string, resolution: ApprovalResolution, toolCallId?: string, 
+    /**
+     * Identifies the specific `approval_required` ask being resolved. A
+     * remount that replays the SAME ask (e.g. a chat repository refresh)
+     * omits nothing new here, so the retained resolution still matches; a
+     * fresh ask after a failed resume carries a different `askId` and so
+     * looks up as unresolved. See `ApprovalAffordance` below.
+     */
+    askId?: string) => void;
     /** Read a resolution retained by the owning chat surface. */
-    getApprovalResolution?: (approvalKey: string, toolCallId?: string) => ApprovalResolution | null;
+    getApprovalResolution?: (approvalKey: string, toolCallId?: string, askId?: string) => ApprovalResolution | null;
     /**
      * Optional host hook invoked in addition to the local "denied" state, e.g.
      * so a Code session can also resolve its own pending approval as denied.
@@ -97,6 +105,7 @@ export declare function ToolCallDisplay({ toolName, toolCallId, argsText, args,
     approval?: {
         approvalKey: string;
         dismissed?: boolean;
+        askId?: string;
     };
     repeatCount?: number;
     /** The latest tool shown while the overall chat turn is still active. */
@@ -113,6 +122,7 @@ export declare function ToolCallFallback({ toolName, toolCallId, args, argsText,
     approval?: {
         approvalKey: string;
         dismissed?: boolean;
+        askId?: string;
     };
     repeatCount?: number;
     isLatestRunning?: boolean;