@ai-matrx/chat 0.1.74 → 0.2.0

package/dist/cx-conversation/hooks/useConversationSession.js

@@ -0,0 +1,187 @@
+"use client";
+import { useEffect, useRef, useCallback, useMemo } from "react";
+import { v4 as uuidv4 } from "uuid";
+import { useAppDispatch, useAppSelector } from "../../store/hooks.js";
+import { chatConversationsActions } from "../_legacy-stubs.js";
+import { sendMessage } from "../_legacy-stubs.js";
+import { loadConversationHistory } from "../_legacy-stubs.js";
+import {
+  selectMessages,
+  selectIsStreaming,
+  selectIsExecuting,
+  selectSessionStatus,
+  selectSessionError,
+  selectConversationId,
+  selectCurrentInput,
+  selectResources,
+  selectVariableDefaults,
+  selectUIState,
+  selectApiMode
+} from "../_legacy-stubs.js";
+function useConversationSession(config) {
+  const dispatch = useAppDispatch();
+  const sessionIdRef = useRef(config.sessionId ?? uuidv4());
+  const sessionId = sessionIdRef.current;
+  const abortControllersRef = useRef(/* @__PURE__ */ new Map());
+  const initializedRef = useRef(false);
+  useEffect(() => {
+    if (initializedRef.current) return void 0;
+    initializedRef.current = true;
+    dispatch(
+      chatConversationsActions.startSession({
+        sessionId,
+        agentId: config.agentId,
+        apiMode: config.apiMode ?? "agent",
+        chatModeConfig: config.chatModeConfig,
+        conversationId: config.conversationId,
+        variableDefaults: config.variableDefaults,
+        variables: config.variables,
+        requiresVariableReplacement: config.requiresVariableReplacement,
+        modelOverride: config.modelOverride
+      })
+    );
+    if (config.conversationId && config.loadHistory !== false) {
+      dispatch(
+        loadConversationHistory({
+          sessionId,
+          conversationId: config.conversationId,
+          agentId: config.agentId
+        })
+      );
+    }
+    return () => {
+      dispatch(chatConversationsActions.removeSession(sessionId));
+    };
+  }, []);
+  const messages = useAppSelector((s) => selectMessages(s, sessionId));
+  const isStreaming = useAppSelector((s) => selectIsStreaming(s, sessionId));
+  const isExecuting = useAppSelector((s) => selectIsExecuting(s, sessionId));
+  const status = useAppSelector((s) => selectSessionStatus(s, sessionId));
+  const error = useAppSelector((s) => selectSessionError(s, sessionId));
+  const conversationId = useAppSelector(
+    (s) => selectConversationId(s, sessionId)
+  );
+  const currentInput = useAppSelector((s) => selectCurrentInput(s, sessionId));
+  const resources = useAppSelector((s) => selectResources(s, sessionId));
+  const variableDefaults = useAppSelector(
+    (s) => selectVariableDefaults(s, sessionId)
+  );
+  const uiState = useAppSelector((s) => selectUIState(s, sessionId));
+  const apiMode = useAppSelector((s) => selectApiMode(s, sessionId));
+  const send = useCallback(
+    (content, options) => {
+      const callId = uuidv4();
+      const controller = new AbortController();
+      abortControllersRef.current.set(callId, controller);
+      const thunk = dispatch(
+        sendMessage({
+          sessionId,
+          content,
+          resources: options?.resources,
+          variables: options?.variables,
+          signal: controller.signal
+        })
+      );
+      Promise.resolve(thunk).finally(() => {
+        abortControllersRef.current.delete(callId);
+      });
+    },
+    [dispatch, sessionId]
+  );
+  const cancel = useCallback(() => {
+    for (const controller of abortControllersRef.current.values()) {
+      controller.abort();
+    }
+    abortControllersRef.current.clear();
+  }, []);
+  const clearMessages = useCallback(() => {
+    dispatch(chatConversationsActions.clearMessages(sessionId));
+  }, [dispatch, sessionId]);
+  const setInput = useCallback(
+    (input) => {
+      dispatch(chatConversationsActions.setCurrentInput({ sessionId, input }));
+    },
+    [dispatch, sessionId]
+  );
+  const addResource = useCallback(
+    (resource) => {
+      dispatch(chatConversationsActions.addResource({ sessionId, resource }));
+    },
+    [dispatch, sessionId]
+  );
+  const removeResource = useCallback(
+    (resourceId) => {
+      dispatch(
+        chatConversationsActions.removeResource({ sessionId, resourceId })
+      );
+    },
+    [dispatch, sessionId]
+  );
+  const updateUIState = useCallback(
+    (updates) => {
+      dispatch(chatConversationsActions.updateUIState({ sessionId, updates }));
+    },
+    [dispatch, sessionId]
+  );
+  const updateVariable = useCallback(
+    (name, value) => {
+      dispatch(
+        chatConversationsActions.updateVariable({
+          sessionId,
+          variableName: name,
+          value
+        })
+      );
+    },
+    [dispatch, sessionId]
+  );
+  return useMemo(
+    () => ({
+      sessionId,
+      conversationId,
+      apiMode,
+      messages,
+      isStreaming,
+      isExecuting,
+      status,
+      error,
+      currentInput,
+      resources,
+      variableDefaults,
+      uiState,
+      send,
+      cancel,
+      clearMessages,
+      setInput,
+      addResource,
+      removeResource,
+      updateUIState,
+      updateVariable
+    }),
+    [
+      sessionId,
+      conversationId,
+      apiMode,
+      messages,
+      isStreaming,
+      isExecuting,
+      status,
+      error,
+      currentInput,
+      resources,
+      variableDefaults,
+      uiState,
+      send,
+      cancel,
+      clearMessages,
+      setInput,
+      addResource,
+      removeResource,
+      updateUIState,
+      updateVariable
+    ]
+  );
+}
+export {
+  useConversationSession
+};

package/dist/cx-conversation/hooks/useUnsavedChangesGuard.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Registers a `beforeunload` listener that warns the user when they try to
+ * leave/refresh the page while unsaved message edits exist in the session.
+ *
+ * Only active when `selectSessionHasUnsavedChanges` is true.
+ */
+export declare function useUnsavedChangesGuard(sessionId: string): void;

package/dist/cx-conversation/hooks/useUnsavedChangesGuard.js

@@ -0,0 +1,19 @@
+import { useEffect } from "react";
+import { useAppSelector } from "../../store/hooks.js";
+import { selectSessionHasUnsavedChanges } from "../_legacy-stubs.js";
+function useUnsavedChangesGuard(sessionId) {
+  const hasUnsavedChanges = useAppSelector(
+    (state) => selectSessionHasUnsavedChanges(state, sessionId)
+  );
+  useEffect(() => {
+    if (!hasUnsavedChanges) return void 0;
+    const handler = (e) => {
+      e.preventDefault();
+    };
+    window.addEventListener("beforeunload", handler);
+    return () => window.removeEventListener("beforeunload", handler);
+  }, [hasUnsavedChanges]);
+}
+export {
+  useUnsavedChangesGuard
+};

package/dist/cx-conversation/utils/buildContentBlocksForSave.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Builds a CxContentBlock[] array suitable for the cx_message_edit RPC.
+ *
+ * When `rawContent` is available (DB-loaded messages), it preserves non-text blocks
+ * (thinking, tool calls, media, etc.) and replaces only the text blocks with the
+ * current display content. For streamed messages or when rawContent only contains
+ * simple text, it returns a single text block.
+ */
+import type { CxContentBlock } from '../../public-chat/types/cx-tables.js';
+export declare function buildContentBlocksForSave(currentContent: string, rawContent?: unknown[]): CxContentBlock[];

package/dist/cx-conversation/utils/buildContentBlocksForSave.js

@@ -0,0 +1,32 @@
+function buildContentBlocksForSave(currentContent, rawContent) {
+  if (!rawContent || rawContent.length === 0) {
+    return [{ type: "text", text: currentContent }];
+  }
+  const blocks = rawContent;
+  const hasNonTextBlocks = blocks.some((b) => b.type !== "text");
+  if (!hasNonTextBlocks) {
+    return [{ type: "text", text: currentContent }];
+  }
+  const preserved = blocks.filter((b) => b.type !== "text");
+  const textBlock = { type: "text", text: currentContent };
+  const firstTextIndex = blocks.findIndex((b) => b.type === "text");
+  if (firstTextIndex === -1) {
+    return [...preserved, textBlock];
+  }
+  const result = [];
+  let textInserted = false;
+  for (const block of blocks) {
+    if (block.type === "text") {
+      if (!textInserted) {
+        result.push(textBlock);
+        textInserted = true;
+      }
+    } else {
+      result.push(block);
+    }
+  }
+  return result;
+}
+export {
+  buildContentBlocksForSave
+};

package/dist/cx-conversation/utils/html-pages-actions.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The publish feature's "active page" lives in the HOST's `htmlPages` slice
+ * (P22). The package names the action by its type instead of importing the
+ * host slice; a host without that slice ignores it (no reducer answers), and
+ * matrx-frontend's reducer answers it exactly as before.
+ *
+ * Guard: lib/redux/slices/__tests__/html-pages-answers-the-chat-package-action.test.ts
+ * fails if the slice is renamed or the reducer stops answering this type.
+ */
+export declare const setActivePageId: import("@reduxjs/toolkit").ActionCreatorWithPayload<string | null, string>;

package/dist/cx-conversation/utils/html-pages-actions.js

@@ -0,0 +1,7 @@
+import { createAction } from "@reduxjs/toolkit";
+const setActivePageId = createAction(
+  "htmlPages/setActivePageId"
+);
+export {
+  setActivePageId
+};

package/dist/external-store/index.cjs

@@ -17,14 +17,14 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/external-store/index.ts
+// src/compat/external-store/index.ts
 var external_store_exports = {};
 __export(external_store_exports, {
   createExternalThreadSource: () => createExternalThreadSource
 });
 module.exports = __toCommonJS(external_store_exports);
 
-// src/config.ts
+// src/compat/config.ts
 var CHAT_PLATFORM_DEFAULTS = Object.freeze({
   sendKey: "enter",
   density: "comfortable",
@@ -57,7 +57,7 @@ function stripUndefined(value) {
   return out;
 }
 
-// src/external-store/index.ts
+// src/compat/external-store/index.ts
 function createExternalThreadSource(config) {
   const features = resolveChatFeatures(config.features);
   const threadListeners = /* @__PURE__ */ new Set();

package/dist/external-store/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/external-store/index.ts","../../src/config.ts"],"sourcesContent":["/**\n * `@ai-matrx/chat/external-store` — THE HOST ALREADY HAS THE STATE.\n *\n * assistant-ui's `ExternalStoreRuntime` answer, in our vocabulary. The host\n * supplies `getSnapshot` / `subscribe` / `onSubmit` / `onCancel`; this module\n * returns something shaped exactly like a `ChatThreadStore`, so every hook,\n * part and shell in `/react` renders over the host's own state with ZERO store\n * migration.\n *\n * This is why the migration is a strangler and not a rewrite:\n *  - matrx-frontend binds it to its `execution-system` Redux selectors on day\n *    one, proves parity live, and only THEN flips the source to the native\n *    kernel and deletes 62,872 lines of thunks;\n *  - matrx-extend binds it to its MV3 offscreen relay, whose stream cannot be\n *    a fetch at all.\n *\n * 🚨 This export ships WITH A DEPRECATION INTENT. It exists to retire a host's\n * store, not to become a permanent second way to hold chat state — see the\n * design's risk 2 and the `RootState` ratchet that goes with it.\n */\n\nimport type {\n  ChatMessage,\n  ChatThreadSnapshot,\n  ChatThreadStatus,\n} from \"../model\";\nimport { resolveChatFeatures, type ChatConfigLayers, type ChatFeatures } from \"../config\";\nimport type { ChatSendInput, ChatSendResult, ChatThreadStore } from \"../store\";\nimport type { ChatToolAnswer, ChatToolSettlement } from \"../tool-state\";\n\n/** What the host must be able to answer about its own state, right now. */\nexport interface ExternalThreadState {\n  messages: readonly ChatMessage[];\n  status: ChatThreadStatus;\n  conversationId: string | null;\n  requestId?: string | null | undefined;\n  phase?: string | null | undefined;\n  /** Whether the host is persisting. Absent ⇒ treated as persisted, because a\n   *  host with its own store almost always is; a host that is NOT must say so\n   *  rather than let the screen imply durability it does not have. */\n  ephemeral?: boolean | undefined;\n  ephemeralReason?: string | null | undefined;\n  error?: ChatThreadSnapshot[\"error\"] | undefined;\n}\n\nexport interface ExternalThreadSourceConfig {\n  getSnapshot(): ExternalThreadState;\n  subscribe(listener: () => void): () => void;\n  onSubmit(input: ChatSendInput): Promise<void> | void;\n  onCancel?: (() => Promise<void> | void) | undefined;\n  onLoadConversation?: ((conversationId: string) => Promise<void> | void) | undefined;\n  /**\n   * Start a fresh conversation in the HOST's state. Its presence is the\n   * capability: absent, `canStartNewConversation` is false and the shells\n   * render no New control rather than one that throws (Law 4).\n   */\n  onStartNewConversation?: (() => Promise<void> | void) | undefined;\n  /** Optional: the host can replace its own transcript (history load). */\n  onSetMessages?: ((messages: readonly ChatMessage[]) => void) | undefined;\n  /**\n   * Settle a tool call the CLIENT answered, in the HOST's state. Hosts whose\n   * transcript is derived (a Redux slice, an MV3 relay) mark the call done\n   * there; `settleToolAnswer` is exported for hosts that hold plain messages.\n   */\n  onSettleToolCall?: ((answer: ChatToolAnswer) => ChatToolSettlement) | undefined;\n  features?: ChatConfigLayers | undefined;\n}\n\n/**\n * Wrap host-owned state as a `ChatThreadStore`.\n *\n * The per-message subscription is honoured for real: this module diffs message\n * IDENTITY across host notifications and wakes only the message subscribers\n * whose object actually changed. A host that rebuilds every message object per\n * token gets no benefit from that and will re-render the list — which is the\n * host's own defect, reported here rather than hidden, because a seam that\n * silently makes a host slow is worse than one that says so.\n */\nexport function createExternalThreadSource(\n  config: ExternalThreadSourceConfig,\n): ChatThreadStore {\n  const features: ChatFeatures = resolveChatFeatures(config.features);\n  const threadListeners = new Set<() => void>();\n  const messageListeners = new Map<string, Set<() => void>>();\n\n  let revision = 0;\n  let previousById = new Map<string, ChatMessage>();\n  let snapshot = project(config.getSnapshot());\n  previousById = indexOf(snapshot.messages);\n\n  function indexOf(messages: readonly ChatMessage[]): Map<string, ChatMessage> {\n    const map = new Map<string, ChatMessage>();\n    for (const message of messages) map.set(message.id, message);\n    return map;\n  }\n\n  function project(state: ExternalThreadState): ChatThreadSnapshot {\n    const ephemeral = state.ephemeral === true;\n    return {\n      conversationId: state.conversationId,\n      messages: state.messages,\n      status: state.status,\n      requestId: state.requestId ?? null,\n      phase: state.phase ?? null,\n      ephemeral,\n      ephemeralReason: ephemeral\n        ? (state.ephemeralReason ??\n          \"This conversation is not being saved by the application hosting it.\")\n        : null,\n      revision,\n      error: state.error ?? null,\n    };\n  }\n\n  let unsubscribeHost: (() => void) | null = config.subscribe(() => {\n    revision += 1;\n    snapshot = project(config.getSnapshot());\n    const nextById = indexOf(snapshot.messages);\n    for (const [id, listeners] of messageListeners) {\n      if (previousById.get(id) === nextById.get(id)) continue;\n      for (const listener of listeners) listener();\n    }\n    previousById = nextById;\n    for (const listener of threadListeners) listener();\n  });\n\n  return {\n    getSnapshot: () => snapshot,\n    subscribe(listener) {\n      threadListeners.add(listener);\n      return () => {\n        threadListeners.delete(listener);\n      };\n    },\n    subscribeToMessage(messageId, listener) {\n      const existing = messageListeners.get(messageId) ?? new Set<() => void>();\n      existing.add(listener);\n      messageListeners.set(messageId, existing);\n      return () => {\n        existing.delete(listener);\n        if (existing.size === 0) messageListeners.delete(messageId);\n      };\n    },\n    getMessageSnapshot: (messageId) =>\n      snapshot.messages.find((m) => m.id === messageId),\n    features,\n    async send(input: ChatSendInput): Promise<ChatSendResult> {\n      await config.onSubmit(input);\n      return { accepted: true, refusal: null };\n    },\n    async cancel() {\n      await config.onCancel?.();\n    },\n    setMessages(messages) {\n      if (!config.onSetMessages) {\n        throw new Error(\n          \"This chat thread's state is owned by the host application, which did not provide onSetMessages. \" +\n            \"Replace the transcript through the host's own store, or provide onSetMessages.\",\n        );\n      }\n      config.onSetMessages(messages);\n    },\n    async loadConversation(conversationId) {\n      if (!config.onLoadConversation) {\n        throw new Error(\n          \"This chat thread's state is owned by the host application, which did not provide onLoadConversation. \" +\n            \"Open the conversation through the host's own routing, or provide onLoadConversation.\",\n        );\n      }\n      await config.onLoadConversation(conversationId);\n    },\n    canStartNewConversation: config.onStartNewConversation !== undefined,\n    settleToolCall(answer) {\n      // The host owns the transcript, so the host settles it. Without a\n      // handler the answer cannot land here, and saying so out loud is the\n      // honest alternative to a card that stays on \"Working…\".\n      if (config.onSettleToolCall) return config.onSettleToolCall(answer);\n      return {\n        messages: snapshot.messages,\n        messageId: null,\n        applied: false,\n        refusal:\n          \"This chat thread's state is owned by the host application, which did not provide onSettleToolCall. \" +\n          \"Mark the tool call done in the host's own store when it answers, or provide onSettleToolCall.\",\n      };\n    },\n    async startNewConversation() {\n      if (!config.onStartNewConversation) {\n        throw new Error(\n          \"This chat thread's state is owned by the host application, which did not provide onStartNewConversation. \" +\n            \"Start a new conversation through the host's own store, or provide onStartNewConversation.\",\n        );\n      }\n      await config.onStartNewConversation();\n    },\n    dispose() {\n      unsubscribeHost?.();\n      unsubscribeHost = null;\n      threadListeners.clear();\n      messageListeners.clear();\n    },\n  };\n}\n","/**\n * OPINIONS BECOME KNOBS (Law 6) — resolved in the kernel, never hardcoded and\n * never a question for a customer.\n *\n * Four layers, lowest to highest: **platform default → organization setting →\n * surface config → per-user preference**. Every knob has a platform default,\n * so a host that sets nothing still gets the platform's taste.\n *\n * One of these knobs is a SAFETY RULE and it lives here on purpose (C22):\n * `routing` carries matrx-local's \"a confidential thread never reaches a cloud\n * provider\". In the kernel it is a thread-level constraint the store ENFORCES\n * with a refusal — it never silently falls back to a cloud target.\n */\n\nexport type ChatSendKey = \"enter\" | \"mod-enter\";\nexport type ChatDensity = \"comfortable\" | \"compact\";\n\n/**\n * Where a thread's text is allowed to go.\n * - `\"any\"` — the platform default: any target the host offers.\n * - `\"local-only\"` — CONFIDENTIAL. The thread refuses a cloud target and says\n *   why. This is the highest-severity rule in the design (§12 risk 4).\n */\nexport type ChatRoutingPolicy = \"any\" | \"local-only\";\n\n/** What a transport declares about itself so the kernel can judge it. */\nexport type ChatTargetLocality = \"local\" | \"cloud\";\n\nexport interface ChatFeatures {\n  /** Enter sends, or Cmd/Ctrl+Enter sends. */\n  sendKey: ChatSendKey;\n  density: ChatDensity;\n  /** Reasoning parts visible without a click. */\n  showReasoningByDefault: boolean;\n  /** Tool cards start expanded. */\n  expandToolCardsByDefault: boolean;\n  /** Transcript sticks to the bottom while the reader is at the bottom. */\n  autoScroll: boolean;\n  /** Read new assistant turns aloud as they arrive. */\n  readAloudAutoPlay: boolean;\n  /** Keep an unsent composer draft per conversation across reloads. */\n  retainDrafts: boolean;\n  /**\n   * The composer may send while an answer is still arriving. OFF by the\n   * platform default (a kernel thread runs one turn at a time). A host whose\n   * send QUEUES the message behind the live turn — a coding session, where\n   * the engine holds a per-session queue — turns it on; the composer then\n   * shows Send (queue) beside Stop instead of Stop alone.\n   */\n  sendWhileBusy: boolean;\n  /** THE ARCHIVED-ITEMS LAW: the conversation list hides archived by default. */\n  hideArchivedConversations: boolean;\n  /**\n   * The per-turn action bar (copy, ask again, edit and send again, plus the\n   * host's own). ON by the platform default — every serious chat has one, and\n   * a reader who cannot copy an answer retypes it. An organization that does\n   * not want it turns it OFF here rather than a host forking the transcript.\n   */\n  messageActions: boolean;\n  /** Largest attachment the composer accepts, in BYTES. */\n  attachmentMaxBytes: number;\n  /**\n   * How the platform's inline reasoning sentinel is treated.\n   *\n   * Ground truth (captured live 2026-09-17): the Google path does NOT emit\n   * `reasoning_chunk`. It emits `reasoning {state:\"started\"}`, then ordinary\n   * `chunk` frames whose text opens with `<reasoning>` and closes with\n   * `</reasoning>`, then `reasoning {state:\"stopped\"}`.\n   *\n   * - `\"split\"` (platform default) — that span becomes a `reasoning` part, so\n   *   a reader never sees the raw sentinel in the answer.\n   * - `\"inline\"` — the span stays in the answer text, byte-for-byte identical\n   *   to `@ai-matrx/agents/projection/request`'s `answer`. This exists so the\n   *   parity harness can prove EXACT equality with the shipped projection, and\n   *   so a host mid-migration can keep its current screen.\n   */\n  reasoningSentinel: \"split\" | \"inline\";\n  /** Where this thread's text may go. */\n  routing: ChatRoutingPolicy;\n}\n\nexport const CHAT_PLATFORM_DEFAULTS: Readonly<ChatFeatures> = Object.freeze({\n  sendKey: \"enter\",\n  density: \"comfortable\",\n  showReasoningByDefault: false,\n  expandToolCardsByDefault: false,\n  autoScroll: true,\n  readAloudAutoPlay: false,\n  retainDrafts: true,\n  sendWhileBusy: false,\n  hideArchivedConversations: true,\n  messageActions: true,\n  attachmentMaxBytes: 25 * 1024 * 1024,\n  reasoningSentinel: \"split\",\n  routing: \"any\",\n});\n\nexport interface ChatConfigLayers {\n  /** Organization setting rows, resolved by the host. */\n  organization?: Partial<ChatFeatures>;\n  /** This surface's configuration (a dock is not the full page). */\n  surface?: Partial<ChatFeatures>;\n  /** This person's preference. */\n  user?: Partial<ChatFeatures>;\n}\n\n/** Resolve the four layers. Later layers win, key by key. */\nexport function resolveChatFeatures(layers: ChatConfigLayers = {}): ChatFeatures {\n  return {\n    ...CHAT_PLATFORM_DEFAULTS,\n    ...stripUndefined(layers.organization),\n    ...stripUndefined(layers.surface),\n    ...stripUndefined(layers.user),\n  };\n}\n\nfunction stripUndefined(\n  value: Partial<ChatFeatures> | undefined,\n): Partial<ChatFeatures> {\n  if (!value) return {};\n  const out: Record<string, unknown> = {};\n  for (const [key, entry] of Object.entries(value)) {\n    if (entry !== undefined) out[key] = entry;\n  }\n  return out as Partial<ChatFeatures>;\n}\n\n/** The refusal a confidential thread produces instead of a silent fallback. */\nexport interface ChatRoutingRefusal {\n  readonly allowed: false;\n  readonly code: \"confidential_thread_cloud_target_refused\";\n  readonly userMessage: string;\n  readonly remedy: string;\n}\n\nexport type ChatRoutingDecision = { readonly allowed: true } | ChatRoutingRefusal;\n\n/**\n * THE CONFIDENTIAL-ROUTING RULE, in the kernel where it belongs.\n *\n * A thread pinned `local-only` REFUSES a cloud target. It does not downgrade,\n * it does not warn-and-send, and it does not quietly pick a different target:\n * the send fails with a named reason and a remedy. Re-deriving this per host\n * is how private text reaches a provider.\n */\nexport function decideRouting(\n  policy: ChatRoutingPolicy,\n  target: ChatTargetLocality,\n): ChatRoutingDecision {\n  if (policy === \"local-only\" && target === \"cloud\") {\n    return {\n      allowed: false,\n      code: \"confidential_thread_cloud_target_refused\",\n      userMessage:\n        \"This conversation is marked confidential, so it cannot be sent to a cloud AI provider.\",\n      remedy:\n        \"Choose a local engine for this conversation, or start a new conversation that is not marked confidential.\",\n    };\n  }\n  return { allowed: true };\n}\n"],"mappings":"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","names":[]}
+{"version":3,"sources":["../../src/compat/external-store/index.ts","../../src/compat/config.ts"],"sourcesContent":["/**\n * `@ai-matrx/chat/external-store` — THE HOST ALREADY HAS THE STATE.\n *\n * assistant-ui's `ExternalStoreRuntime` answer, in our vocabulary. The host\n * supplies `getSnapshot` / `subscribe` / `onSubmit` / `onCancel`; this module\n * returns something shaped exactly like a `ChatThreadStore`, so every hook,\n * part and shell in `/react` renders over the host's own state with ZERO store\n * migration.\n *\n * This is why the migration is a strangler and not a rewrite:\n *  - matrx-frontend binds it to its `execution-system` Redux selectors on day\n *    one, proves parity live, and only THEN flips the source to the native\n *    kernel and deletes 62,872 lines of thunks;\n *  - matrx-extend binds it to its MV3 offscreen relay, whose stream cannot be\n *    a fetch at all.\n *\n * 🚨 This export ships WITH A DEPRECATION INTENT. It exists to retire a host's\n * store, not to become a permanent second way to hold chat state — see the\n * design's risk 2 and the `RootState` ratchet that goes with it.\n */\n\nimport type {\n  ChatMessage,\n  ChatThreadSnapshot,\n  ChatThreadStatus,\n} from \"../model\";\nimport { resolveChatFeatures, type ChatConfigLayers, type ChatFeatures } from \"../config\";\nimport type { ChatSendInput, ChatSendResult, ChatThreadStore } from \"../store\";\nimport type { ChatToolAnswer, ChatToolSettlement } from \"../tool-state\";\n\n/** What the host must be able to answer about its own state, right now. */\nexport interface ExternalThreadState {\n  messages: readonly ChatMessage[];\n  status: ChatThreadStatus;\n  conversationId: string | null;\n  requestId?: string | null | undefined;\n  phase?: string | null | undefined;\n  /** Whether the host is persisting. Absent ⇒ treated as persisted, because a\n   *  host with its own store almost always is; a host that is NOT must say so\n   *  rather than let the screen imply durability it does not have. */\n  ephemeral?: boolean | undefined;\n  ephemeralReason?: string | null | undefined;\n  error?: ChatThreadSnapshot[\"error\"] | undefined;\n}\n\nexport interface ExternalThreadSourceConfig {\n  getSnapshot(): ExternalThreadState;\n  subscribe(listener: () => void): () => void;\n  onSubmit(input: ChatSendInput): Promise<void> | void;\n  onCancel?: (() => Promise<void> | void) | undefined;\n  onLoadConversation?: ((conversationId: string) => Promise<void> | void) | undefined;\n  /**\n   * Start a fresh conversation in the HOST's state. Its presence is the\n   * capability: absent, `canStartNewConversation` is false and the shells\n   * render no New control rather than one that throws (Law 4).\n   */\n  onStartNewConversation?: (() => Promise<void> | void) | undefined;\n  /** Optional: the host can replace its own transcript (history load). */\n  onSetMessages?: ((messages: readonly ChatMessage[]) => void) | undefined;\n  /**\n   * Settle a tool call the CLIENT answered, in the HOST's state. Hosts whose\n   * transcript is derived (a Redux slice, an MV3 relay) mark the call done\n   * there; `settleToolAnswer` is exported for hosts that hold plain messages.\n   */\n  onSettleToolCall?: ((answer: ChatToolAnswer) => ChatToolSettlement) | undefined;\n  features?: ChatConfigLayers | undefined;\n}\n\n/**\n * Wrap host-owned state as a `ChatThreadStore`.\n *\n * The per-message subscription is honoured for real: this module diffs message\n * IDENTITY across host notifications and wakes only the message subscribers\n * whose object actually changed. A host that rebuilds every message object per\n * token gets no benefit from that and will re-render the list — which is the\n * host's own defect, reported here rather than hidden, because a seam that\n * silently makes a host slow is worse than one that says so.\n */\nexport function createExternalThreadSource(\n  config: ExternalThreadSourceConfig,\n): ChatThreadStore {\n  const features: ChatFeatures = resolveChatFeatures(config.features);\n  const threadListeners = new Set<() => void>();\n  const messageListeners = new Map<string, Set<() => void>>();\n\n  let revision = 0;\n  let previousById = new Map<string, ChatMessage>();\n  let snapshot = project(config.getSnapshot());\n  previousById = indexOf(snapshot.messages);\n\n  function indexOf(messages: readonly ChatMessage[]): Map<string, ChatMessage> {\n    const map = new Map<string, ChatMessage>();\n    for (const message of messages) map.set(message.id, message);\n    return map;\n  }\n\n  function project(state: ExternalThreadState): ChatThreadSnapshot {\n    const ephemeral = state.ephemeral === true;\n    return {\n      conversationId: state.conversationId,\n      messages: state.messages,\n      status: state.status,\n      requestId: state.requestId ?? null,\n      phase: state.phase ?? null,\n      ephemeral,\n      ephemeralReason: ephemeral\n        ? (state.ephemeralReason ??\n          \"This conversation is not being saved by the application hosting it.\")\n        : null,\n      revision,\n      error: state.error ?? null,\n    };\n  }\n\n  let unsubscribeHost: (() => void) | null = config.subscribe(() => {\n    revision += 1;\n    snapshot = project(config.getSnapshot());\n    const nextById = indexOf(snapshot.messages);\n    for (const [id, listeners] of messageListeners) {\n      if (previousById.get(id) === nextById.get(id)) continue;\n      for (const listener of listeners) listener();\n    }\n    previousById = nextById;\n    for (const listener of threadListeners) listener();\n  });\n\n  return {\n    getSnapshot: () => snapshot,\n    subscribe(listener) {\n      threadListeners.add(listener);\n      return () => {\n        threadListeners.delete(listener);\n      };\n    },\n    subscribeToMessage(messageId, listener) {\n      const existing = messageListeners.get(messageId) ?? new Set<() => void>();\n      existing.add(listener);\n      messageListeners.set(messageId, existing);\n      return () => {\n        existing.delete(listener);\n        if (existing.size === 0) messageListeners.delete(messageId);\n      };\n    },\n    getMessageSnapshot: (messageId) =>\n      snapshot.messages.find((m) => m.id === messageId),\n    features,\n    async send(input: ChatSendInput): Promise<ChatSendResult> {\n      await config.onSubmit(input);\n      return { accepted: true, refusal: null };\n    },\n    async cancel() {\n      await config.onCancel?.();\n    },\n    setMessages(messages) {\n      if (!config.onSetMessages) {\n        throw new Error(\n          \"This chat thread's state is owned by the host application, which did not provide onSetMessages. \" +\n            \"Replace the transcript through the host's own store, or provide onSetMessages.\",\n        );\n      }\n      config.onSetMessages(messages);\n    },\n    async loadConversation(conversationId) {\n      if (!config.onLoadConversation) {\n        throw new Error(\n          \"This chat thread's state is owned by the host application, which did not provide onLoadConversation. \" +\n            \"Open the conversation through the host's own routing, or provide onLoadConversation.\",\n        );\n      }\n      await config.onLoadConversation(conversationId);\n    },\n    canStartNewConversation: config.onStartNewConversation !== undefined,\n    settleToolCall(answer) {\n      // The host owns the transcript, so the host settles it. Without a\n      // handler the answer cannot land here, and saying so out loud is the\n      // honest alternative to a card that stays on \"Working…\".\n      if (config.onSettleToolCall) return config.onSettleToolCall(answer);\n      return {\n        messages: snapshot.messages,\n        messageId: null,\n        applied: false,\n        refusal:\n          \"This chat thread's state is owned by the host application, which did not provide onSettleToolCall. \" +\n          \"Mark the tool call done in the host's own store when it answers, or provide onSettleToolCall.\",\n      };\n    },\n    async startNewConversation() {\n      if (!config.onStartNewConversation) {\n        throw new Error(\n          \"This chat thread's state is owned by the host application, which did not provide onStartNewConversation. \" +\n            \"Start a new conversation through the host's own store, or provide onStartNewConversation.\",\n        );\n      }\n      await config.onStartNewConversation();\n    },\n    dispose() {\n      unsubscribeHost?.();\n      unsubscribeHost = null;\n      threadListeners.clear();\n      messageListeners.clear();\n    },\n  };\n}\n","/**\n * OPINIONS BECOME KNOBS (Law 6) — resolved in the kernel, never hardcoded and\n * never a question for a customer.\n *\n * Four layers, lowest to highest: **platform default → organization setting →\n * surface config → per-user preference**. Every knob has a platform default,\n * so a host that sets nothing still gets the platform's taste.\n *\n * One of these knobs is a SAFETY RULE and it lives here on purpose (C22):\n * `routing` carries matrx-local's \"a confidential thread never reaches a cloud\n * provider\". In the kernel it is a thread-level constraint the store ENFORCES\n * with a refusal — it never silently falls back to a cloud target.\n */\n\nexport type ChatSendKey = \"enter\" | \"mod-enter\";\nexport type ChatDensity = \"comfortable\" | \"compact\";\n\n/**\n * Where a thread's text is allowed to go.\n * - `\"any\"` — the platform default: any target the host offers.\n * - `\"local-only\"` — CONFIDENTIAL. The thread refuses a cloud target and says\n *   why. This is the highest-severity rule in the design (§12 risk 4).\n */\nexport type ChatRoutingPolicy = \"any\" | \"local-only\";\n\n/** What a transport declares about itself so the kernel can judge it. */\nexport type ChatTargetLocality = \"local\" | \"cloud\";\n\nexport interface ChatFeatures {\n  /** Enter sends, or Cmd/Ctrl+Enter sends. */\n  sendKey: ChatSendKey;\n  density: ChatDensity;\n  /** Reasoning parts visible without a click. */\n  showReasoningByDefault: boolean;\n  /** Tool cards start expanded. */\n  expandToolCardsByDefault: boolean;\n  /** Transcript sticks to the bottom while the reader is at the bottom. */\n  autoScroll: boolean;\n  /** Read new assistant turns aloud as they arrive. */\n  readAloudAutoPlay: boolean;\n  /** Keep an unsent composer draft per conversation across reloads. */\n  retainDrafts: boolean;\n  /**\n   * The composer may send while an answer is still arriving. OFF by the\n   * platform default (a kernel thread runs one turn at a time). A host whose\n   * send QUEUES the message behind the live turn — a coding session, where\n   * the engine holds a per-session queue — turns it on; the composer then\n   * shows Send (queue) beside Stop instead of Stop alone.\n   */\n  sendWhileBusy: boolean;\n  /** THE ARCHIVED-ITEMS LAW: the conversation list hides archived by default. */\n  hideArchivedConversations: boolean;\n  /**\n   * The per-turn action bar (copy, ask again, edit and send again, plus the\n   * host's own). ON by the platform default — every serious chat has one, and\n   * a reader who cannot copy an answer retypes it. An organization that does\n   * not want it turns it OFF here rather than a host forking the transcript.\n   */\n  messageActions: boolean;\n  /** Largest attachment the composer accepts, in BYTES. */\n  attachmentMaxBytes: number;\n  /**\n   * How the platform's inline reasoning sentinel is treated.\n   *\n   * Ground truth (captured live 2026-09-17): the Google path does NOT emit\n   * `reasoning_chunk`. It emits `reasoning {state:\"started\"}`, then ordinary\n   * `chunk` frames whose text opens with `<reasoning>` and closes with\n   * `</reasoning>`, then `reasoning {state:\"stopped\"}`.\n   *\n   * - `\"split\"` (platform default) — that span becomes a `reasoning` part, so\n   *   a reader never sees the raw sentinel in the answer.\n   * - `\"inline\"` — the span stays in the answer text, byte-for-byte identical\n   *   to `@ai-matrx/agents/projection/request`'s `answer`. This exists so the\n   *   parity harness can prove EXACT equality with the shipped projection, and\n   *   so a host mid-migration can keep its current screen.\n   */\n  reasoningSentinel: \"split\" | \"inline\";\n  /** Where this thread's text may go. */\n  routing: ChatRoutingPolicy;\n}\n\nexport const CHAT_PLATFORM_DEFAULTS: Readonly<ChatFeatures> = Object.freeze({\n  sendKey: \"enter\",\n  density: \"comfortable\",\n  showReasoningByDefault: false,\n  expandToolCardsByDefault: false,\n  autoScroll: true,\n  readAloudAutoPlay: false,\n  retainDrafts: true,\n  sendWhileBusy: false,\n  hideArchivedConversations: true,\n  messageActions: true,\n  attachmentMaxBytes: 25 * 1024 * 1024,\n  reasoningSentinel: \"split\",\n  routing: \"any\",\n});\n\nexport interface ChatConfigLayers {\n  /** Organization setting rows, resolved by the host. */\n  organization?: Partial<ChatFeatures>;\n  /** This surface's configuration (a dock is not the full page). */\n  surface?: Partial<ChatFeatures>;\n  /** This person's preference. */\n  user?: Partial<ChatFeatures>;\n}\n\n/** Resolve the four layers. Later layers win, key by key. */\nexport function resolveChatFeatures(layers: ChatConfigLayers = {}): ChatFeatures {\n  return {\n    ...CHAT_PLATFORM_DEFAULTS,\n    ...stripUndefined(layers.organization),\n    ...stripUndefined(layers.surface),\n    ...stripUndefined(layers.user),\n  };\n}\n\nfunction stripUndefined(\n  value: Partial<ChatFeatures> | undefined,\n): Partial<ChatFeatures> {\n  if (!value) return {};\n  const out: Record<string, unknown> = {};\n  for (const [key, entry] of Object.entries(value)) {\n    if (entry !== undefined) out[key] = entry;\n  }\n  return out as Partial<ChatFeatures>;\n}\n\n/** The refusal a confidential thread produces instead of a silent fallback. */\nexport interface ChatRoutingRefusal {\n  readonly allowed: false;\n  readonly code: \"confidential_thread_cloud_target_refused\";\n  readonly userMessage: string;\n  readonly remedy: string;\n}\n\nexport type ChatRoutingDecision = { readonly allowed: true } | ChatRoutingRefusal;\n\n/**\n * THE CONFIDENTIAL-ROUTING RULE, in the kernel where it belongs.\n *\n * A thread pinned `local-only` REFUSES a cloud target. It does not downgrade,\n * it does not warn-and-send, and it does not quietly pick a different target:\n * the send fails with a named reason and a remedy. Re-deriving this per host\n * is how private text reaches a provider.\n */\nexport function decideRouting(\n  policy: ChatRoutingPolicy,\n  target: ChatTargetLocality,\n): ChatRoutingDecision {\n  if (policy === \"local-only\" && target === \"cloud\") {\n    return {\n      allowed: false,\n      code: \"confidential_thread_cloud_target_refused\",\n      userMessage:\n        \"This conversation is marked confidential, so it cannot be sent to a cloud AI provider.\",\n      remedy:\n        \"Choose a local engine for this conversation, or start a new conversation that is not marked confidential.\",\n    };\n  }\n  return { allowed: true };\n}\n"],"mappings":"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","names":[]}

package/dist/external-store/index.js

@@ -1,4 +1,4 @@
-// src/config.ts
+// src/compat/config.ts
 var CHAT_PLATFORM_DEFAULTS = Object.freeze({
   sendKey: "enter",
   density: "comfortable",
@@ -31,7 +31,7 @@ function stripUndefined(value) {
   return out;
 }
 
-// src/external-store/index.ts
+// src/compat/external-store/index.ts
 function createExternalThreadSource(config) {
   const features = resolveChatFeatures(config.features);
   const threadListeners = /* @__PURE__ */ new Set();

package/dist/external-store/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/config.ts","../../src/external-store/index.ts"],"sourcesContent":["/**\n * OPINIONS BECOME KNOBS (Law 6) — resolved in the kernel, never hardcoded and\n * never a question for a customer.\n *\n * Four layers, lowest to highest: **platform default → organization setting →\n * surface config → per-user preference**. Every knob has a platform default,\n * so a host that sets nothing still gets the platform's taste.\n *\n * One of these knobs is a SAFETY RULE and it lives here on purpose (C22):\n * `routing` carries matrx-local's \"a confidential thread never reaches a cloud\n * provider\". In the kernel it is a thread-level constraint the store ENFORCES\n * with a refusal — it never silently falls back to a cloud target.\n */\n\nexport type ChatSendKey = \"enter\" | \"mod-enter\";\nexport type ChatDensity = \"comfortable\" | \"compact\";\n\n/**\n * Where a thread's text is allowed to go.\n * - `\"any\"` — the platform default: any target the host offers.\n * - `\"local-only\"` — CONFIDENTIAL. The thread refuses a cloud target and says\n *   why. This is the highest-severity rule in the design (§12 risk 4).\n */\nexport type ChatRoutingPolicy = \"any\" | \"local-only\";\n\n/** What a transport declares about itself so the kernel can judge it. */\nexport type ChatTargetLocality = \"local\" | \"cloud\";\n\nexport interface ChatFeatures {\n  /** Enter sends, or Cmd/Ctrl+Enter sends. */\n  sendKey: ChatSendKey;\n  density: ChatDensity;\n  /** Reasoning parts visible without a click. */\n  showReasoningByDefault: boolean;\n  /** Tool cards start expanded. */\n  expandToolCardsByDefault: boolean;\n  /** Transcript sticks to the bottom while the reader is at the bottom. */\n  autoScroll: boolean;\n  /** Read new assistant turns aloud as they arrive. */\n  readAloudAutoPlay: boolean;\n  /** Keep an unsent composer draft per conversation across reloads. */\n  retainDrafts: boolean;\n  /**\n   * The composer may send while an answer is still arriving. OFF by the\n   * platform default (a kernel thread runs one turn at a time). A host whose\n   * send QUEUES the message behind the live turn — a coding session, where\n   * the engine holds a per-session queue — turns it on; the composer then\n   * shows Send (queue) beside Stop instead of Stop alone.\n   */\n  sendWhileBusy: boolean;\n  /** THE ARCHIVED-ITEMS LAW: the conversation list hides archived by default. */\n  hideArchivedConversations: boolean;\n  /**\n   * The per-turn action bar (copy, ask again, edit and send again, plus the\n   * host's own). ON by the platform default — every serious chat has one, and\n   * a reader who cannot copy an answer retypes it. An organization that does\n   * not want it turns it OFF here rather than a host forking the transcript.\n   */\n  messageActions: boolean;\n  /** Largest attachment the composer accepts, in BYTES. */\n  attachmentMaxBytes: number;\n  /**\n   * How the platform's inline reasoning sentinel is treated.\n   *\n   * Ground truth (captured live 2026-09-17): the Google path does NOT emit\n   * `reasoning_chunk`. It emits `reasoning {state:\"started\"}`, then ordinary\n   * `chunk` frames whose text opens with `<reasoning>` and closes with\n   * `</reasoning>`, then `reasoning {state:\"stopped\"}`.\n   *\n   * - `\"split\"` (platform default) — that span becomes a `reasoning` part, so\n   *   a reader never sees the raw sentinel in the answer.\n   * - `\"inline\"` — the span stays in the answer text, byte-for-byte identical\n   *   to `@ai-matrx/agents/projection/request`'s `answer`. This exists so the\n   *   parity harness can prove EXACT equality with the shipped projection, and\n   *   so a host mid-migration can keep its current screen.\n   */\n  reasoningSentinel: \"split\" | \"inline\";\n  /** Where this thread's text may go. */\n  routing: ChatRoutingPolicy;\n}\n\nexport const CHAT_PLATFORM_DEFAULTS: Readonly<ChatFeatures> = Object.freeze({\n  sendKey: \"enter\",\n  density: \"comfortable\",\n  showReasoningByDefault: false,\n  expandToolCardsByDefault: false,\n  autoScroll: true,\n  readAloudAutoPlay: false,\n  retainDrafts: true,\n  sendWhileBusy: false,\n  hideArchivedConversations: true,\n  messageActions: true,\n  attachmentMaxBytes: 25 * 1024 * 1024,\n  reasoningSentinel: \"split\",\n  routing: \"any\",\n});\n\nexport interface ChatConfigLayers {\n  /** Organization setting rows, resolved by the host. */\n  organization?: Partial<ChatFeatures>;\n  /** This surface's configuration (a dock is not the full page). */\n  surface?: Partial<ChatFeatures>;\n  /** This person's preference. */\n  user?: Partial<ChatFeatures>;\n}\n\n/** Resolve the four layers. Later layers win, key by key. */\nexport function resolveChatFeatures(layers: ChatConfigLayers = {}): ChatFeatures {\n  return {\n    ...CHAT_PLATFORM_DEFAULTS,\n    ...stripUndefined(layers.organization),\n    ...stripUndefined(layers.surface),\n    ...stripUndefined(layers.user),\n  };\n}\n\nfunction stripUndefined(\n  value: Partial<ChatFeatures> | undefined,\n): Partial<ChatFeatures> {\n  if (!value) return {};\n  const out: Record<string, unknown> = {};\n  for (const [key, entry] of Object.entries(value)) {\n    if (entry !== undefined) out[key] = entry;\n  }\n  return out as Partial<ChatFeatures>;\n}\n\n/** The refusal a confidential thread produces instead of a silent fallback. */\nexport interface ChatRoutingRefusal {\n  readonly allowed: false;\n  readonly code: \"confidential_thread_cloud_target_refused\";\n  readonly userMessage: string;\n  readonly remedy: string;\n}\n\nexport type ChatRoutingDecision = { readonly allowed: true } | ChatRoutingRefusal;\n\n/**\n * THE CONFIDENTIAL-ROUTING RULE, in the kernel where it belongs.\n *\n * A thread pinned `local-only` REFUSES a cloud target. It does not downgrade,\n * it does not warn-and-send, and it does not quietly pick a different target:\n * the send fails with a named reason and a remedy. Re-deriving this per host\n * is how private text reaches a provider.\n */\nexport function decideRouting(\n  policy: ChatRoutingPolicy,\n  target: ChatTargetLocality,\n): ChatRoutingDecision {\n  if (policy === \"local-only\" && target === \"cloud\") {\n    return {\n      allowed: false,\n      code: \"confidential_thread_cloud_target_refused\",\n      userMessage:\n        \"This conversation is marked confidential, so it cannot be sent to a cloud AI provider.\",\n      remedy:\n        \"Choose a local engine for this conversation, or start a new conversation that is not marked confidential.\",\n    };\n  }\n  return { allowed: true };\n}\n","/**\n * `@ai-matrx/chat/external-store` — THE HOST ALREADY HAS THE STATE.\n *\n * assistant-ui's `ExternalStoreRuntime` answer, in our vocabulary. The host\n * supplies `getSnapshot` / `subscribe` / `onSubmit` / `onCancel`; this module\n * returns something shaped exactly like a `ChatThreadStore`, so every hook,\n * part and shell in `/react` renders over the host's own state with ZERO store\n * migration.\n *\n * This is why the migration is a strangler and not a rewrite:\n *  - matrx-frontend binds it to its `execution-system` Redux selectors on day\n *    one, proves parity live, and only THEN flips the source to the native\n *    kernel and deletes 62,872 lines of thunks;\n *  - matrx-extend binds it to its MV3 offscreen relay, whose stream cannot be\n *    a fetch at all.\n *\n * 🚨 This export ships WITH A DEPRECATION INTENT. It exists to retire a host's\n * store, not to become a permanent second way to hold chat state — see the\n * design's risk 2 and the `RootState` ratchet that goes with it.\n */\n\nimport type {\n  ChatMessage,\n  ChatThreadSnapshot,\n  ChatThreadStatus,\n} from \"../model\";\nimport { resolveChatFeatures, type ChatConfigLayers, type ChatFeatures } from \"../config\";\nimport type { ChatSendInput, ChatSendResult, ChatThreadStore } from \"../store\";\nimport type { ChatToolAnswer, ChatToolSettlement } from \"../tool-state\";\n\n/** What the host must be able to answer about its own state, right now. */\nexport interface ExternalThreadState {\n  messages: readonly ChatMessage[];\n  status: ChatThreadStatus;\n  conversationId: string | null;\n  requestId?: string | null | undefined;\n  phase?: string | null | undefined;\n  /** Whether the host is persisting. Absent ⇒ treated as persisted, because a\n   *  host with its own store almost always is; a host that is NOT must say so\n   *  rather than let the screen imply durability it does not have. */\n  ephemeral?: boolean | undefined;\n  ephemeralReason?: string | null | undefined;\n  error?: ChatThreadSnapshot[\"error\"] | undefined;\n}\n\nexport interface ExternalThreadSourceConfig {\n  getSnapshot(): ExternalThreadState;\n  subscribe(listener: () => void): () => void;\n  onSubmit(input: ChatSendInput): Promise<void> | void;\n  onCancel?: (() => Promise<void> | void) | undefined;\n  onLoadConversation?: ((conversationId: string) => Promise<void> | void) | undefined;\n  /**\n   * Start a fresh conversation in the HOST's state. Its presence is the\n   * capability: absent, `canStartNewConversation` is false and the shells\n   * render no New control rather than one that throws (Law 4).\n   */\n  onStartNewConversation?: (() => Promise<void> | void) | undefined;\n  /** Optional: the host can replace its own transcript (history load). */\n  onSetMessages?: ((messages: readonly ChatMessage[]) => void) | undefined;\n  /**\n   * Settle a tool call the CLIENT answered, in the HOST's state. Hosts whose\n   * transcript is derived (a Redux slice, an MV3 relay) mark the call done\n   * there; `settleToolAnswer` is exported for hosts that hold plain messages.\n   */\n  onSettleToolCall?: ((answer: ChatToolAnswer) => ChatToolSettlement) | undefined;\n  features?: ChatConfigLayers | undefined;\n}\n\n/**\n * Wrap host-owned state as a `ChatThreadStore`.\n *\n * The per-message subscription is honoured for real: this module diffs message\n * IDENTITY across host notifications and wakes only the message subscribers\n * whose object actually changed. A host that rebuilds every message object per\n * token gets no benefit from that and will re-render the list — which is the\n * host's own defect, reported here rather than hidden, because a seam that\n * silently makes a host slow is worse than one that says so.\n */\nexport function createExternalThreadSource(\n  config: ExternalThreadSourceConfig,\n): ChatThreadStore {\n  const features: ChatFeatures = resolveChatFeatures(config.features);\n  const threadListeners = new Set<() => void>();\n  const messageListeners = new Map<string, Set<() => void>>();\n\n  let revision = 0;\n  let previousById = new Map<string, ChatMessage>();\n  let snapshot = project(config.getSnapshot());\n  previousById = indexOf(snapshot.messages);\n\n  function indexOf(messages: readonly ChatMessage[]): Map<string, ChatMessage> {\n    const map = new Map<string, ChatMessage>();\n    for (const message of messages) map.set(message.id, message);\n    return map;\n  }\n\n  function project(state: ExternalThreadState): ChatThreadSnapshot {\n    const ephemeral = state.ephemeral === true;\n    return {\n      conversationId: state.conversationId,\n      messages: state.messages,\n      status: state.status,\n      requestId: state.requestId ?? null,\n      phase: state.phase ?? null,\n      ephemeral,\n      ephemeralReason: ephemeral\n        ? (state.ephemeralReason ??\n          \"This conversation is not being saved by the application hosting it.\")\n        : null,\n      revision,\n      error: state.error ?? null,\n    };\n  }\n\n  let unsubscribeHost: (() => void) | null = config.subscribe(() => {\n    revision += 1;\n    snapshot = project(config.getSnapshot());\n    const nextById = indexOf(snapshot.messages);\n    for (const [id, listeners] of messageListeners) {\n      if (previousById.get(id) === nextById.get(id)) continue;\n      for (const listener of listeners) listener();\n    }\n    previousById = nextById;\n    for (const listener of threadListeners) listener();\n  });\n\n  return {\n    getSnapshot: () => snapshot,\n    subscribe(listener) {\n      threadListeners.add(listener);\n      return () => {\n        threadListeners.delete(listener);\n      };\n    },\n    subscribeToMessage(messageId, listener) {\n      const existing = messageListeners.get(messageId) ?? new Set<() => void>();\n      existing.add(listener);\n      messageListeners.set(messageId, existing);\n      return () => {\n        existing.delete(listener);\n        if (existing.size === 0) messageListeners.delete(messageId);\n      };\n    },\n    getMessageSnapshot: (messageId) =>\n      snapshot.messages.find((m) => m.id === messageId),\n    features,\n    async send(input: ChatSendInput): Promise<ChatSendResult> {\n      await config.onSubmit(input);\n      return { accepted: true, refusal: null };\n    },\n    async cancel() {\n      await config.onCancel?.();\n    },\n    setMessages(messages) {\n      if (!config.onSetMessages) {\n        throw new Error(\n          \"This chat thread's state is owned by the host application, which did not provide onSetMessages. \" +\n            \"Replace the transcript through the host's own store, or provide onSetMessages.\",\n        );\n      }\n      config.onSetMessages(messages);\n    },\n    async loadConversation(conversationId) {\n      if (!config.onLoadConversation) {\n        throw new Error(\n          \"This chat thread's state is owned by the host application, which did not provide onLoadConversation. \" +\n            \"Open the conversation through the host's own routing, or provide onLoadConversation.\",\n        );\n      }\n      await config.onLoadConversation(conversationId);\n    },\n    canStartNewConversation: config.onStartNewConversation !== undefined,\n    settleToolCall(answer) {\n      // The host owns the transcript, so the host settles it. Without a\n      // handler the answer cannot land here, and saying so out loud is the\n      // honest alternative to a card that stays on \"Working…\".\n      if (config.onSettleToolCall) return config.onSettleToolCall(answer);\n      return {\n        messages: snapshot.messages,\n        messageId: null,\n        applied: false,\n        refusal:\n          \"This chat thread's state is owned by the host application, which did not provide onSettleToolCall. \" +\n          \"Mark the tool call done in the host's own store when it answers, or provide onSettleToolCall.\",\n      };\n    },\n    async startNewConversation() {\n      if (!config.onStartNewConversation) {\n        throw new Error(\n          \"This chat thread's state is owned by the host application, which did not provide onStartNewConversation. \" +\n            \"Start a new conversation through the host's own store, or provide onStartNewConversation.\",\n        );\n      }\n      await config.onStartNewConversation();\n    },\n    dispose() {\n      unsubscribeHost?.();\n      unsubscribeHost = null;\n      threadListeners.clear();\n      messageListeners.clear();\n    },\n  };\n}\n"],"mappings":"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","names":[]}
+{"version":3,"sources":["../../src/compat/config.ts","../../src/compat/external-store/index.ts"],"sourcesContent":["/**\n * OPINIONS BECOME KNOBS (Law 6) — resolved in the kernel, never hardcoded and\n * never a question for a customer.\n *\n * Four layers, lowest to highest: **platform default → organization setting →\n * surface config → per-user preference**. Every knob has a platform default,\n * so a host that sets nothing still gets the platform's taste.\n *\n * One of these knobs is a SAFETY RULE and it lives here on purpose (C22):\n * `routing` carries matrx-local's \"a confidential thread never reaches a cloud\n * provider\". In the kernel it is a thread-level constraint the store ENFORCES\n * with a refusal — it never silently falls back to a cloud target.\n */\n\nexport type ChatSendKey = \"enter\" | \"mod-enter\";\nexport type ChatDensity = \"comfortable\" | \"compact\";\n\n/**\n * Where a thread's text is allowed to go.\n * - `\"any\"` — the platform default: any target the host offers.\n * - `\"local-only\"` — CONFIDENTIAL. The thread refuses a cloud target and says\n *   why. This is the highest-severity rule in the design (§12 risk 4).\n */\nexport type ChatRoutingPolicy = \"any\" | \"local-only\";\n\n/** What a transport declares about itself so the kernel can judge it. */\nexport type ChatTargetLocality = \"local\" | \"cloud\";\n\nexport interface ChatFeatures {\n  /** Enter sends, or Cmd/Ctrl+Enter sends. */\n  sendKey: ChatSendKey;\n  density: ChatDensity;\n  /** Reasoning parts visible without a click. */\n  showReasoningByDefault: boolean;\n  /** Tool cards start expanded. */\n  expandToolCardsByDefault: boolean;\n  /** Transcript sticks to the bottom while the reader is at the bottom. */\n  autoScroll: boolean;\n  /** Read new assistant turns aloud as they arrive. */\n  readAloudAutoPlay: boolean;\n  /** Keep an unsent composer draft per conversation across reloads. */\n  retainDrafts: boolean;\n  /**\n   * The composer may send while an answer is still arriving. OFF by the\n   * platform default (a kernel thread runs one turn at a time). A host whose\n   * send QUEUES the message behind the live turn — a coding session, where\n   * the engine holds a per-session queue — turns it on; the composer then\n   * shows Send (queue) beside Stop instead of Stop alone.\n   */\n  sendWhileBusy: boolean;\n  /** THE ARCHIVED-ITEMS LAW: the conversation list hides archived by default. */\n  hideArchivedConversations: boolean;\n  /**\n   * The per-turn action bar (copy, ask again, edit and send again, plus the\n   * host's own). ON by the platform default — every serious chat has one, and\n   * a reader who cannot copy an answer retypes it. An organization that does\n   * not want it turns it OFF here rather than a host forking the transcript.\n   */\n  messageActions: boolean;\n  /** Largest attachment the composer accepts, in BYTES. */\n  attachmentMaxBytes: number;\n  /**\n   * How the platform's inline reasoning sentinel is treated.\n   *\n   * Ground truth (captured live 2026-09-17): the Google path does NOT emit\n   * `reasoning_chunk`. It emits `reasoning {state:\"started\"}`, then ordinary\n   * `chunk` frames whose text opens with `<reasoning>` and closes with\n   * `</reasoning>`, then `reasoning {state:\"stopped\"}`.\n   *\n   * - `\"split\"` (platform default) — that span becomes a `reasoning` part, so\n   *   a reader never sees the raw sentinel in the answer.\n   * - `\"inline\"` — the span stays in the answer text, byte-for-byte identical\n   *   to `@ai-matrx/agents/projection/request`'s `answer`. This exists so the\n   *   parity harness can prove EXACT equality with the shipped projection, and\n   *   so a host mid-migration can keep its current screen.\n   */\n  reasoningSentinel: \"split\" | \"inline\";\n  /** Where this thread's text may go. */\n  routing: ChatRoutingPolicy;\n}\n\nexport const CHAT_PLATFORM_DEFAULTS: Readonly<ChatFeatures> = Object.freeze({\n  sendKey: \"enter\",\n  density: \"comfortable\",\n  showReasoningByDefault: false,\n  expandToolCardsByDefault: false,\n  autoScroll: true,\n  readAloudAutoPlay: false,\n  retainDrafts: true,\n  sendWhileBusy: false,\n  hideArchivedConversations: true,\n  messageActions: true,\n  attachmentMaxBytes: 25 * 1024 * 1024,\n  reasoningSentinel: \"split\",\n  routing: \"any\",\n});\n\nexport interface ChatConfigLayers {\n  /** Organization setting rows, resolved by the host. */\n  organization?: Partial<ChatFeatures>;\n  /** This surface's configuration (a dock is not the full page). */\n  surface?: Partial<ChatFeatures>;\n  /** This person's preference. */\n  user?: Partial<ChatFeatures>;\n}\n\n/** Resolve the four layers. Later layers win, key by key. */\nexport function resolveChatFeatures(layers: ChatConfigLayers = {}): ChatFeatures {\n  return {\n    ...CHAT_PLATFORM_DEFAULTS,\n    ...stripUndefined(layers.organization),\n    ...stripUndefined(layers.surface),\n    ...stripUndefined(layers.user),\n  };\n}\n\nfunction stripUndefined(\n  value: Partial<ChatFeatures> | undefined,\n): Partial<ChatFeatures> {\n  if (!value) return {};\n  const out: Record<string, unknown> = {};\n  for (const [key, entry] of Object.entries(value)) {\n    if (entry !== undefined) out[key] = entry;\n  }\n  return out as Partial<ChatFeatures>;\n}\n\n/** The refusal a confidential thread produces instead of a silent fallback. */\nexport interface ChatRoutingRefusal {\n  readonly allowed: false;\n  readonly code: \"confidential_thread_cloud_target_refused\";\n  readonly userMessage: string;\n  readonly remedy: string;\n}\n\nexport type ChatRoutingDecision = { readonly allowed: true } | ChatRoutingRefusal;\n\n/**\n * THE CONFIDENTIAL-ROUTING RULE, in the kernel where it belongs.\n *\n * A thread pinned `local-only` REFUSES a cloud target. It does not downgrade,\n * it does not warn-and-send, and it does not quietly pick a different target:\n * the send fails with a named reason and a remedy. Re-deriving this per host\n * is how private text reaches a provider.\n */\nexport function decideRouting(\n  policy: ChatRoutingPolicy,\n  target: ChatTargetLocality,\n): ChatRoutingDecision {\n  if (policy === \"local-only\" && target === \"cloud\") {\n    return {\n      allowed: false,\n      code: \"confidential_thread_cloud_target_refused\",\n      userMessage:\n        \"This conversation is marked confidential, so it cannot be sent to a cloud AI provider.\",\n      remedy:\n        \"Choose a local engine for this conversation, or start a new conversation that is not marked confidential.\",\n    };\n  }\n  return { allowed: true };\n}\n","/**\n * `@ai-matrx/chat/external-store` — THE HOST ALREADY HAS THE STATE.\n *\n * assistant-ui's `ExternalStoreRuntime` answer, in our vocabulary. The host\n * supplies `getSnapshot` / `subscribe` / `onSubmit` / `onCancel`; this module\n * returns something shaped exactly like a `ChatThreadStore`, so every hook,\n * part and shell in `/react` renders over the host's own state with ZERO store\n * migration.\n *\n * This is why the migration is a strangler and not a rewrite:\n *  - matrx-frontend binds it to its `execution-system` Redux selectors on day\n *    one, proves parity live, and only THEN flips the source to the native\n *    kernel and deletes 62,872 lines of thunks;\n *  - matrx-extend binds it to its MV3 offscreen relay, whose stream cannot be\n *    a fetch at all.\n *\n * 🚨 This export ships WITH A DEPRECATION INTENT. It exists to retire a host's\n * store, not to become a permanent second way to hold chat state — see the\n * design's risk 2 and the `RootState` ratchet that goes with it.\n */\n\nimport type {\n  ChatMessage,\n  ChatThreadSnapshot,\n  ChatThreadStatus,\n} from \"../model\";\nimport { resolveChatFeatures, type ChatConfigLayers, type ChatFeatures } from \"../config\";\nimport type { ChatSendInput, ChatSendResult, ChatThreadStore } from \"../store\";\nimport type { ChatToolAnswer, ChatToolSettlement } from \"../tool-state\";\n\n/** What the host must be able to answer about its own state, right now. */\nexport interface ExternalThreadState {\n  messages: readonly ChatMessage[];\n  status: ChatThreadStatus;\n  conversationId: string | null;\n  requestId?: string | null | undefined;\n  phase?: string | null | undefined;\n  /** Whether the host is persisting. Absent ⇒ treated as persisted, because a\n   *  host with its own store almost always is; a host that is NOT must say so\n   *  rather than let the screen imply durability it does not have. */\n  ephemeral?: boolean | undefined;\n  ephemeralReason?: string | null | undefined;\n  error?: ChatThreadSnapshot[\"error\"] | undefined;\n}\n\nexport interface ExternalThreadSourceConfig {\n  getSnapshot(): ExternalThreadState;\n  subscribe(listener: () => void): () => void;\n  onSubmit(input: ChatSendInput): Promise<void> | void;\n  onCancel?: (() => Promise<void> | void) | undefined;\n  onLoadConversation?: ((conversationId: string) => Promise<void> | void) | undefined;\n  /**\n   * Start a fresh conversation in the HOST's state. Its presence is the\n   * capability: absent, `canStartNewConversation` is false and the shells\n   * render no New control rather than one that throws (Law 4).\n   */\n  onStartNewConversation?: (() => Promise<void> | void) | undefined;\n  /** Optional: the host can replace its own transcript (history load). */\n  onSetMessages?: ((messages: readonly ChatMessage[]) => void) | undefined;\n  /**\n   * Settle a tool call the CLIENT answered, in the HOST's state. Hosts whose\n   * transcript is derived (a Redux slice, an MV3 relay) mark the call done\n   * there; `settleToolAnswer` is exported for hosts that hold plain messages.\n   */\n  onSettleToolCall?: ((answer: ChatToolAnswer) => ChatToolSettlement) | undefined;\n  features?: ChatConfigLayers | undefined;\n}\n\n/**\n * Wrap host-owned state as a `ChatThreadStore`.\n *\n * The per-message subscription is honoured for real: this module diffs message\n * IDENTITY across host notifications and wakes only the message subscribers\n * whose object actually changed. A host that rebuilds every message object per\n * token gets no benefit from that and will re-render the list — which is the\n * host's own defect, reported here rather than hidden, because a seam that\n * silently makes a host slow is worse than one that says so.\n */\nexport function createExternalThreadSource(\n  config: ExternalThreadSourceConfig,\n): ChatThreadStore {\n  const features: ChatFeatures = resolveChatFeatures(config.features);\n  const threadListeners = new Set<() => void>();\n  const messageListeners = new Map<string, Set<() => void>>();\n\n  let revision = 0;\n  let previousById = new Map<string, ChatMessage>();\n  let snapshot = project(config.getSnapshot());\n  previousById = indexOf(snapshot.messages);\n\n  function indexOf(messages: readonly ChatMessage[]): Map<string, ChatMessage> {\n    const map = new Map<string, ChatMessage>();\n    for (const message of messages) map.set(message.id, message);\n    return map;\n  }\n\n  function project(state: ExternalThreadState): ChatThreadSnapshot {\n    const ephemeral = state.ephemeral === true;\n    return {\n      conversationId: state.conversationId,\n      messages: state.messages,\n      status: state.status,\n      requestId: state.requestId ?? null,\n      phase: state.phase ?? null,\n      ephemeral,\n      ephemeralReason: ephemeral\n        ? (state.ephemeralReason ??\n          \"This conversation is not being saved by the application hosting it.\")\n        : null,\n      revision,\n      error: state.error ?? null,\n    };\n  }\n\n  let unsubscribeHost: (() => void) | null = config.subscribe(() => {\n    revision += 1;\n    snapshot = project(config.getSnapshot());\n    const nextById = indexOf(snapshot.messages);\n    for (const [id, listeners] of messageListeners) {\n      if (previousById.get(id) === nextById.get(id)) continue;\n      for (const listener of listeners) listener();\n    }\n    previousById = nextById;\n    for (const listener of threadListeners) listener();\n  });\n\n  return {\n    getSnapshot: () => snapshot,\n    subscribe(listener) {\n      threadListeners.add(listener);\n      return () => {\n        threadListeners.delete(listener);\n      };\n    },\n    subscribeToMessage(messageId, listener) {\n      const existing = messageListeners.get(messageId) ?? new Set<() => void>();\n      existing.add(listener);\n      messageListeners.set(messageId, existing);\n      return () => {\n        existing.delete(listener);\n        if (existing.size === 0) messageListeners.delete(messageId);\n      };\n    },\n    getMessageSnapshot: (messageId) =>\n      snapshot.messages.find((m) => m.id === messageId),\n    features,\n    async send(input: ChatSendInput): Promise<ChatSendResult> {\n      await config.onSubmit(input);\n      return { accepted: true, refusal: null };\n    },\n    async cancel() {\n      await config.onCancel?.();\n    },\n    setMessages(messages) {\n      if (!config.onSetMessages) {\n        throw new Error(\n          \"This chat thread's state is owned by the host application, which did not provide onSetMessages. \" +\n            \"Replace the transcript through the host's own store, or provide onSetMessages.\",\n        );\n      }\n      config.onSetMessages(messages);\n    },\n    async loadConversation(conversationId) {\n      if (!config.onLoadConversation) {\n        throw new Error(\n          \"This chat thread's state is owned by the host application, which did not provide onLoadConversation. \" +\n            \"Open the conversation through the host's own routing, or provide onLoadConversation.\",\n        );\n      }\n      await config.onLoadConversation(conversationId);\n    },\n    canStartNewConversation: config.onStartNewConversation !== undefined,\n    settleToolCall(answer) {\n      // The host owns the transcript, so the host settles it. Without a\n      // handler the answer cannot land here, and saying so out loud is the\n      // honest alternative to a card that stays on \"Working…\".\n      if (config.onSettleToolCall) return config.onSettleToolCall(answer);\n      return {\n        messages: snapshot.messages,\n        messageId: null,\n        applied: false,\n        refusal:\n          \"This chat thread's state is owned by the host application, which did not provide onSettleToolCall. \" +\n          \"Mark the tool call done in the host's own store when it answers, or provide onSettleToolCall.\",\n      };\n    },\n    async startNewConversation() {\n      if (!config.onStartNewConversation) {\n        throw new Error(\n          \"This chat thread's state is owned by the host application, which did not provide onStartNewConversation. \" +\n            \"Start a new conversation through the host's own store, or provide onStartNewConversation.\",\n        );\n      }\n      await config.onStartNewConversation();\n    },\n    dispose() {\n      unsubscribeHost?.();\n      unsubscribeHost = null;\n      threadListeners.clear();\n      messageListeners.clear();\n    },\n  };\n}\n"],"mappings":"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","names":[]}

package/dist/host/builder-door.d.ts

@@ -0,0 +1,50 @@
+/**
+ * host/builder-door — the agent BUILDER's write thunks, reached from the chat package's
+ * agent headers (options menu, save action, lifecycle actions, duplicate flow).
+ *
+ * The builder owns these writes (matrx-frontend: features/agents/redux/builder-tier.thunks.ts);
+ * the package draws the controls and must not import them (PACKAGE-INDEPENDENCE.md P25).
+ * The host registers once at startup (`registerBuilderDoor`, providers/chatUiRegistration.ts).
+ * A bare host registers nothing: `getBuilderDoor()` answers null and reports ONCE through the
+ * host diagnostics port, and every control that needs the door is ABSENT — never a button that
+ * does nothing (Law 4).
+ */
+import type { AsyncThunkAction } from "@reduxjs/toolkit";
+import type { ChatDispatch, ChatRootState } from "../store/root-state.js";
+import type { AgentDefinition } from "../agents/types/agent-definition.types.js";
+type Cfg = {
+    dispatch: ChatDispatch;
+    state: ChatRootState;
+};
+type Door<Arg, Ret> = (arg: Arg) => AsyncThunkAction<Ret, Arg, Cfg>;
+export interface DuplicateAgentOptions {
+    agentId: string;
+    asSystem?: boolean;
+    organizationId?: string;
+    followsSource?: boolean;
+}
+export type CreateAgentInput = Partial<Omit<AgentDefinition, "id" | "createdBy" | "createdAt" | "updatedAt" | "isVersion" | "parentAgentId" | "version" | "changedAt" | "changeNote">>;
+export interface BuilderDoor {
+    saveAgent: Door<string, void>;
+    saveAgentField: Door<{
+        agentId: string;
+        field: keyof AgentDefinition;
+        value: AgentDefinition[keyof AgentDefinition];
+    }, void>;
+    createAgent: Door<CreateAgentInput, string>;
+    deleteAgent: Door<string, void>;
+    duplicateAgent: Door<string | DuplicateAgentOptions, string>;
+    setAgentFavorite: Door<{
+        agentId: string;
+        isFavorite: boolean;
+    }, void>;
+}
+/** The host's registration (idempotent). */
+export declare function registerBuilderDoor(next: BuilderDoor): void;
+/** Test seam: forget the registration. */
+export declare function resetBuilderDoorForTests(): void;
+/** The registered builder door, or null (reported once: the agent builder's controls are absent here). */
+export declare function getBuilderDoor(): BuilderDoor | null;
+/** The door, for a handler that only runs when the control was drawn (so the door was present). */
+export declare function requireBuilderDoor(): BuilderDoor;
+export {};

package/dist/host/builder-door.js

@@ -0,0 +1,25 @@
+import { reportUnregisteredHostSlot } from "./diagnostics.js";
+let door = null;
+function registerBuilderDoor(next) {
+  door = next;
+}
+function resetBuilderDoorForTests() {
+  door = null;
+}
+function getBuilderDoor() {
+  if (!door) {
+    reportUnregisteredHostSlot("builder", "the agent options, save and lifecycle controls are absent");
+  }
+  return door;
+}
+function requireBuilderDoor() {
+  const d = getBuilderDoor();
+  if (!d) throw new Error('The host registered no "builder" door for the chat package (registerBuilderDoor).');
+  return d;
+}
+export {
+  getBuilderDoor,
+  registerBuilderDoor,
+  requireBuilderDoor,
+  resetBuilderDoorForTests
+};

package/dist/host/canvas-tabs.d.ts

@@ -0,0 +1,61 @@
+/**
+ * The canvas tabs the package opens by NAME — one identity per thing.
+ *
+ * A conversation's documents are ONE tab, `conversation-documents` keyed by
+ * the conversation id (the host registers its body, the DocumentsWorkspace);
+ * the person's scratchpad is ONE tab, `global-scratchpad` keyed "default"
+ * (the host's ScratchpadQuickPanel on the active scratchpad). The package
+ * opens them through the windows port (`openWorkingDocumentPanel`,
+ * `openScratchpadPanel`) and recognises them on the canvas by these ids, so
+ * every door — the header Canvas button, the composer rail, a tool's result
+ * bar, the editor's "Open in Canvas" — lands on the same tab.
+ *
+ * Until 2026-10-02 the same documents also opened as the artifact content
+ * types `working_document` / `scratchpad` keyed `wd:<scope>:<kind>`: two tabs
+ * for one thing, each with its own body.
+ */
+export declare const CONVERSATION_DOCUMENTS_KIND = "conversation-documents";
+export declare const SCRATCHPAD_KIND = "global-scratchpad";
+/**
+ * Everything a conversation's next turn carries, with full control (the
+ * composer's value chip opens it): ONE tab per conversation, keyed by its id.
+ * The tab's `selected` field is the value it shows.
+ */
+export declare const CONVERSATION_CONTEXT_KIND = "conversation-context";
+/** A conversation's agent lists (plan, agent tasks, the person's todos): ONE tab per conversation. */
+export declare const CONVERSATION_LISTS_KIND = "conversation-lists";
+/** An agent's unsaved edits as a diff against its saved version: ONE tab per agent. */
+export declare const AGENT_UNSAVED_CHANGES_KIND = "agent-unsaved-changes";
+/**
+ * The attachments one chip host shows (a sent message's strip, the composer's
+ * resources, a conversation's attached documents): ONE tab per host, keyed by
+ * it. `items` is the host's list, `selected` the one on screen; the tab pages
+ * through the list in place.
+ */
+export declare const CONTEXT_ITEMS_KIND = "context-items";
+/**
+ * One context value a sent message carried, in full (key, type, policy, the
+ * frozen value): ONE tab per conversation, keyed by its id. `selected` names
+ * the value on screen (its key plus a hash of the snapshot).
+ */
+export declare const CONTEXT_VALUE_KIND = "context-value";
+/** A conversation's working-document version history: ONE tab per conversation. */
+export declare const WORKING_DOCUMENT_HISTORY_KIND = "working-document-history";
+/**
+ * What a SENT turn actually delivered (the server's context receipt), with
+ * every value's delivered text one click in: ONE tab per message, keyed by
+ * the message id.
+ */
+export declare const MESSAGE_CONTEXT_RECEIPT_KIND = "message-context-receipt";
+/** Every tab kind the package opens by name through `canvas.useTab`. */
+export type ChatCanvasTabKind = typeof CONVERSATION_CONTEXT_KIND | typeof CONVERSATION_LISTS_KIND | typeof AGENT_UNSAVED_CHANGES_KIND | typeof CONTEXT_ITEMS_KIND | typeof MESSAGE_CONTEXT_RECEIPT_KIND | typeof CONTEXT_VALUE_KIND | typeof WORKING_DOCUMENT_HISTORY_KIND;
+/** The scratchpad tab follows the ACTIVE scratchpad, so there is exactly one. */
+export declare const SCRATCHPAD_TAB_KEY = "default";
+/** The canvas tab id of a conversation's Documents tab. */
+export declare function conversationDocumentsTabId(conversationId: string): string;
+/** The canvas tab id of the scratchpad tab. */
+export declare function scratchpadTabId(): string;
+/** The canvas tab id of a conversation's context tab. */
+export declare function conversationContextTabId(conversationId: string): string;
+/** The canvas tab id of a conversation's agent lists tab. */
+export declare function conversationListsTabId(conversationId: string): string;