@agent-native/core 0.161.23 → 0.163.0

package/corpus/templates/tasks/.agents/skills/sharing/SKILL.md

@@ -18,6 +18,11 @@ Any resource a user **creates** (dashboards, documents, forms, decks, compositio
 
 This is the framework-level primitive. Every ownable resource gets it for free — same API, same UI, same skill.
 
+Workspace apps are the intentional organization-scoped exception: their default
+visibility is `org`, configurable by an organization owner/admin. The creator is
+stored as the app owner, and the creator or an organization owner/admin can
+change the app's visibility or manage its share grants.
+
 ## Concepts
 
 ### Three visibility levels
@@ -26,7 +31,8 @@ This is the framework-level primitive. Every ownable resource gets it for free
 - **`org`** — owner + explicit grants + anyone in the same org (read-only).
 - **`public`** — owner + explicit grants + **anyone with the link** (read-only). Public docs do NOT appear in other users' list/sidebar/search results — `accessFilter` omits them by default. They're reachable by id (`resolveAccess` admits them) so direct links and SSR routes like `/p/:id` keep working. If a list endpoint legitimately needs cross-user public discovery (a template gallery, etc.), pass `accessFilter(table, shares, ctx, minRole, { includePublic: true })`.
 
-Visibility is coarse. Explicit share grants are fine-grained (per user or per org).
+Visibility is coarse. Explicit share grants are fine-grained (per user, reusable
+organization group, or per org).
 
 ### Roles on a share grant
 
@@ -101,6 +107,7 @@ registerShareableResource({
   // ...
   allowPublic: false, // hides "Public" in the share dialog and rejects it server-side
   requireOrgMemberForUserShares: true, // user shares must target an org member or pending invitee
+  supportsGroupShares: true, // enable reusable organization groups for this resource
 });
 ```
 
@@ -111,6 +118,21 @@ Use both for resources that execute code or expose privileged data with the *vie
 
 Defaults match historical behaviour: `allowPublic: true`, `requireOrgMemberForUserShares: false`. Resources that don't set the flags work as before.
 
+### Reusable organization groups
+
+The workspace organization model stores reusable groups in
+`workspace_user_groups`. Organization owners/admins manage the groups and their
+members through the existing group actions. Set `supportsGroupShares: true` on a
+resource registration to enable `principalType: "group"` in the generic share
+actions and the shared popover's autocomplete. Group ids are always checked
+against the resource's organization, and membership is evaluated at access time
+so group changes apply to existing shares.
+
+Workspace apps opt into this flag and use the organization default visibility
+setting. The app creator is the durable `owner_email`, while organization
+owners/admins receive admin access through the registration's
+`canManageAccess` callback.
+
 ## Filter list/read queries
 
 ```ts
@@ -197,6 +219,9 @@ All app share popovers should use the same compact surface contract:
 - Add `ShareAgentsSection` only when the resource has a real agent-readable
   link or prompt. Keep it collapsed by default and supply domain-specific
   content through the shared section shell.
+- When `supportsGroupShares` is enabled, keep the existing people input as the
+  only entry point and include organization groups in its autocomplete. Do not
+  add a separate group-management surface to each resource.
 - App-specific tabs or controls may remain when they represent a real domain
   action (for example, an embed-code editor), but they should retain the same
   trigger, copy-row, access, and spacing language.
@@ -211,7 +236,7 @@ The framework auto-mounts these actions in every template — no per-template bo
 
 | Action                     | Args                                                                           | Purpose                                   |
 | -------------------------- | ------------------------------------------------------------------------------ | ----------------------------------------- |
-| `share-resource`           | `resourceType, resourceId, principalType, principalId, role, notify?, resourceUrl?, message?` | Grant a user or org access. `notify` defaults to true for individual user shares; `resourceUrl` can provide the direct app link and `message` an optional short note for the notification email. |
+| `share-resource`           | `resourceType, resourceId, principalType, principalId, role, notify?, resourceUrl?, message?` | Grant a user, group, or org access. `notify` defaults to true for individual user shares; `resourceUrl` can provide the direct app link and `message` an optional short note for the notification email. |
 | `unshare-resource`         | `resourceType, resourceId, principalType, principalId`                         | Revoke access.                            |
 | `list-resource-shares`     | `resourceType, resourceId`                                                     | Current visibility + all share grants.    |
 | `set-resource-visibility`  | `resourceType, resourceId, visibility`                                         | Change to `private` / `org` / `public`.  |

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/app-config/schema.d.ts

@@ -43,6 +43,7 @@ export declare const appConfigSchema: z.ZodObject<{
         isWorkspace: z.ZodOptional<z.ZodBoolean>;
         appsJson: z.ZodOptional<z.ZodString>;
         gatewayUrl: z.ZodOptional<z.ZodString>;
+        orgDirectoryUrl: z.ZodOptional<z.ZodString>;
         oauthOrigin: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
 }, z.core.$strip>;

package/dist/app-config/workspace.d.ts

@@ -19,5 +19,6 @@ export declare const workspaceConfig: z.ZodObject<{
     isWorkspace: z.ZodOptional<z.ZodBoolean>;
     appsJson: z.ZodOptional<z.ZodString>;
     gatewayUrl: z.ZodOptional<z.ZodString>;
+    orgDirectoryUrl: z.ZodOptional<z.ZodString>;
     oauthOrigin: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;

package/dist/app-config/workspace.js

@@ -42,6 +42,14 @@ export const workspaceConfig = z.object({
         env: ["WORKSPACE_GATEWAY_URL", "VITE_WORKSPACE_GATEWAY_URL"],
         doc: "URL of the workspace gateway fronting this app.",
     }),
+    orgDirectoryUrl: z
+        .string()
+        .min(1)
+        .optional()
+        .meta({
+        env: ["AGENT_NATIVE_ORG_DIRECTORY_URL"],
+        doc: "URL of the authoritative organization Dispatch directory.",
+    }),
     oauthOrigin: z
         .string()
         .min(1)

package/dist/chat-threads/schema.d.ts

@@ -403,14 +403,14 @@ export declare const chatThreadShares: import("drizzle-orm/sqlite-core").SQLiteT
             tableName: string;
             dataType: "string";
             columnType: "SQLiteText";
-            data: "org" | "user";
+            data: "group" | "org" | "user";
             driverParam: string;
             notNull: true;
             hasDefault: false;
             isPrimaryKey: false;
             isAutoincrement: false;
             hasRuntimeDefault: false;
-            enumValues: ["user", "org"];
+            enumValues: ["user", "group", "org"];
             baseColumn: never;
             identity: undefined;
             generated: undefined;

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) => {