@ai-matrx/chat 0.7.11 → 0.7.13

package/CHANGELOG.md

@@ -1,5 +1,33 @@
 # @ai-matrx/chat
 
+## 0.7.13
+### Unreleased
+### a refused answer fails the run's own row (lane F13)
+
+- **`recordRunOutputRefused(runRowId, reason, requestId?)`** writes against the `chat.user_request` row id the server announced
+  (`record_reserved`), read with the new **`runRowIdOf(state, requestId)`**. 0.7.10 wrote against the client's Redux key
+  (`req_<uuid>`), which no row has: every refused run on Make stayed `completed`, error null (live 2026-10-09). A refusal with
+  no row id is a `console.error`, never a silent no-op.
+- Tests: `a-refused-answer-fails-the-servers-run-row.test.ts`.
+- **Consumer action:** none (`useHeadlessAgentJson` is the only caller).
+
+## 0.7.12
+### Unreleased
+### The variables a run used (Agent Factory R59)
+
+- **`selectVariablesTheRunUsed(conversationId)`** (instance-variable-values selectors): the values a run's first turn was sent
+  with, frozen at send; before a send, the request merge. The builder's Side Chat helper reads it so a later edit of the field
+  cannot rewrite what the run was given.
+- **Consumer action:** none.
+
+### A persisted answer paints with its markdown (spend register item 32, cold-load CLS at 1440)
+
+- **`MarkdownStream`**: the engine chunk is requested when a conversation surface's module loads (`preloadMarkdownStream`), kept once
+  resolved, and rendered synchronously on the first render of a new instance. The per-instance `mounted` effect gate (an extra commit
+  after paint) is now `useSyncExternalStore` (still client-only: server and hydration render nothing). Before, the answer block painted
+  as a 36 px header and grew to its full height ~200 ms later, shifting everything below it (CLS 0.06-0.28 at 1440).
+- **Consumer action:** none.
+
 ## 0.7.11
 ### continue-agent-json is exported again
 

package/dist/agents/components/messages-display/assistant/AgentAssistantMessage.js

@@ -6,7 +6,7 @@ import {
   useState,
   useEffect
 } from "react";
-import MarkdownStream from "../../../../ui/markdown-stream/MarkdownStream.js";
+import MarkdownStream, { preloadMarkdownStream } from "../../../../ui/markdown-stream/MarkdownStream.js";
 import "../rich-document/chat-message-source.js";
 import { RecordAnnotations, annotationRecordOf } from "@ai-matrx/rich-content/host/app-bindings";
 import { useAppDispatch, useAppSelector } from "../../../../store/hooks.js";
@@ -91,6 +91,7 @@ import {
 } from "../../../../host/ui-slots.js";
 import { ErrorAlchemyMenu } from "../../../../host/ui-slots.js";
 import { useInPlaceTrigger } from "@ai-matrx/rich-editor/in-place/EditInPlace";
+void preloadMarkdownStream();
 const _NO_LIVE_SOURCES = [];
 const _selectNoLiveSources = () => _NO_LIVE_SOURCES;
 function retryErrorMessage(err) {

package/dist/agents/hooks/useFloatingAgentRun.d.ts

@@ -1,4 +1,4 @@
-import { type LiveAgentRunOptions } from "./useLiveAgentRun.js";
+import { type LiveAgentReattachOptions, type LiveAgentRunOptions } from "./useLiveAgentRun.js";
 /**
  * The words a failed launch shows in its window: the server's own reason when
  * the run carried one (a Mandate with no Holder names the rungs it checked),
@@ -83,6 +83,16 @@ export interface UseFloatingAgentRun {
     run: <T = unknown>(opts: LiveAgentRunOptions<T> & {
         label?: string;
     }) => Promise<T>;
+    /**
+     * Pick an EXISTING run back up — a reload or a paused tab must never start a
+     * second one. The conversation id is what `onConversationCreated` handed out
+     * at launch. Resolves with the finished result when the run is done, or
+     * follows it to the end when it is still going, in the same window. No run is
+     * started.
+     */
+    reattach: <T = unknown>(conversationId: string, opts: LiveAgentReattachOptions<T> & {
+        label?: string;
+    }) => Promise<T>;
     isRunning: boolean;
     error: string | null;
     conversationId: string | null;

package/dist/agents/hooks/useFloatingAgentRun.js

@@ -123,8 +123,20 @@ function useFloatingAgentRun(options = {}) {
       throw error;
     }
   }
+  async function reattach(existingConversationId, opts) {
+    const { label, ...reattachOptions } = opts;
+    const bound = floating.start(label ?? options.label ?? "AI is working");
+    bound.bind(existingConversationId);
+    try {
+      return await live.reattach(existingConversationId, reattachOptions);
+    } catch (error) {
+      bound.fail(floatingFailureReason(error));
+      throw error;
+    }
+  }
   return {
     run,
+    reattach,
     isRunning: live.isRunning,
     error: live.error,
     conversationId: live.conversationId,

package/dist/agents/hooks/useHeadlessAgentJson.d.ts

@@ -1,3 +1,4 @@
+import { type ReattachHeadlessAgentJsonOptions } from "../redux/execution-system/thunks/reattach-headless-agent-json.js";
 import { type HeadlessAgentJsonOptions, type HeadlessAgentJsonResult } from "../redux/execution-system/thunks/run-headless-agent-json.js";
 /**
  * What `run()` throws. It carries the run's TECHNICAL reason (when the run
@@ -27,8 +28,21 @@ export interface HeadlessAgentJsonRunOptions<T> extends HeadlessAgentJsonOptions
      */
     coerce?: (value: unknown, result: HeadlessAgentJsonResult) => T;
 }
+/**
+ * Reopen a run that ALREADY exists (running or finished) — never starts one.
+ * `conversationId` is what `onConversationCreated` handed out at launch.
+ */
+export interface HeadlessAgentJsonReattachOptions<T> extends Omit<ReattachHeadlessAgentJsonOptions, "conversationId"> {
+    coerce?: (value: unknown, result: HeadlessAgentJsonResult) => T;
+}
 export interface UseHeadlessAgentJson {
     run: <T = unknown>(opts: HeadlessAgentJsonRunOptions<T>) => Promise<T>;
+    /**
+     * Pick an existing run back up: its finished result when it is done, or
+     * follow it to the end when it is still going. No new run is ever started.
+     * Throws exactly like `run`.
+     */
+    reattach: <T = unknown>(conversationId: string, opts: HeadlessAgentJsonReattachOptions<T>) => Promise<T>;
     isRunning: boolean;
     error: string | null;
     /** Conversation id of the in-flight run — set BEFORE the stream starts. */

package/dist/agents/hooks/useHeadlessAgentJson.js

@@ -3,7 +3,10 @@ import { useCallback, useState } from "react";
 import { useAppDispatch, useAppSelector, useAppStore } from "../../store/hooks.js";
 import { selectConversationRequestIds } from "../redux/execution-system/active-requests/active-requests.selectors.js";
 import { useRetainRequestForViewer } from "../redux/execution-system/active-requests/useRetainRequestForViewer.js";
-import { recordRunOutputRefused } from "../redux/execution-system/thunks/record-run-output-refused.js";
+import { recordRunOutputRefused, runRowIdOf } from "../redux/execution-system/thunks/record-run-output-refused.js";
+import {
+  reattachHeadlessAgentJson
+} from "../redux/execution-system/thunks/reattach-headless-agent-json.js";
 import {
   runHeadlessAgentJson
 } from "../redux/execution-system/thunks/run-headless-agent-json.js";
@@ -31,33 +34,29 @@ function useHeadlessAgentJson() {
     return ids.length > 0 ? ids[ids.length - 1] : null;
   });
   useRetainRequestForViewer(activeRequestId, "useHeadlessAgentJson");
-  async function run(opts) {
+  async function settle(result, coerce) {
+    if (!result.success) {
+      throw new HeadlessAgentRunError(result.error ?? "The agent run failed", {
+        ...result.errorDetail ? { detail: result.errorDetail } : {},
+        ...result.requestId ? { requestId: result.requestId } : {},
+        ...result.conversationId ? { conversationId: result.conversationId } : {}
+      });
+    }
+    if (!coerce) return result.data;
+    try {
+      return coerce(result.data, result);
+    } catch (refused) {
+      const why = refused instanceof Error ? refused.message : String(refused);
+      const rowId = result.requestId ? runRowIdOf(store.getState(), result.requestId) : null;
+      void recordRunOutputRefused(rowId, why, result.requestId);
+      throw refused;
+    }
+  }
+  async function guarded(work) {
     setIsRunning(true);
     setError(null);
-    setConversationId(null);
     try {
-      const result = await runHeadlessAgentJson(dispatch, store.getState, {
-        ...opts,
-        onConversationCreated: (cid) => {
-          setConversationId(cid);
-          opts.onConversationCreated?.(cid);
-        }
-      });
-      if (!result.success) {
-        throw new HeadlessAgentRunError(result.error ?? "The agent run failed", {
-          ...result.errorDetail ? { detail: result.errorDetail } : {},
-          ...result.requestId ? { requestId: result.requestId } : {},
-          ...result.conversationId ? { conversationId: result.conversationId } : {}
-        });
-      }
-      if (!opts.coerce) return result.data;
-      try {
-        return opts.coerce(result.data, result);
-      } catch (refused) {
-        const why = refused instanceof Error ? refused.message : String(refused);
-        if (result.requestId) void recordRunOutputRefused(result.requestId, why);
-        throw refused;
-      }
+      return await work();
     } catch (e) {
       const message = e instanceof Error ? e.message : "Failed to run the agent";
       setError(message);
@@ -66,11 +65,34 @@ function useHeadlessAgentJson() {
       setIsRunning(false);
     }
   }
+  async function run(opts) {
+    setConversationId(null);
+    return guarded(async () => {
+      const result = await runHeadlessAgentJson(dispatch, store.getState, {
+        ...opts,
+        onConversationCreated: (cid) => {
+          setConversationId(cid);
+          opts.onConversationCreated?.(cid);
+        }
+      });
+      return settle(result, opts.coerce);
+    });
+  }
+  async function reattach(existingConversationId, opts) {
+    setConversationId(existingConversationId);
+    return guarded(async () => {
+      const result = await reattachHeadlessAgentJson(dispatch, store.getState, {
+        ...opts,
+        conversationId: existingConversationId
+      });
+      return settle(result, opts.coerce);
+    });
+  }
   const reset = useCallback(() => {
     setError(null);
     setConversationId(null);
   }, []);
-  return { run, isRunning, error, conversationId, activeRequestId, reset };
+  return { run, reattach, isRunning, error, conversationId, activeRequestId, reset };
 }
 export {
   HeadlessAgentRunError,

package/dist/agents/hooks/useLiveAgentRun.d.ts

@@ -1,6 +1,13 @@
-import { type HeadlessAgentJsonRunOptions } from "./useHeadlessAgentJson.js";
+import { type HeadlessAgentJsonReattachOptions, type HeadlessAgentJsonRunOptions } from "./useHeadlessAgentJson.js";
 export type LiveAgentRunOptions<T> = Omit<HeadlessAgentJsonRunOptions<T>, "displayMode" | "keepInstance">;
+export type LiveAgentReattachOptions<T> = Omit<HeadlessAgentJsonReattachOptions<T>, "keepInstance">;
 export interface UseLiveAgentRun {
+    /**
+     * Pick an EXISTING run back up (a reload, a paused tab) — its finished
+     * result, or follow it to the end. Never starts a run; the live handle
+     * (`conversationId`) is set before anything is read.
+     */
+    reattach: <T = unknown>(conversationId: string, opts: LiveAgentReattachOptions<T>) => Promise<T>;
     /** Run the agent; the live handle (`conversationId`) is set before the stream. */
     run: <T = unknown>(opts: LiveAgentRunOptions<T>) => Promise<T>;
     isRunning: boolean;

package/dist/agents/hooks/useLiveAgentRun.js

@@ -38,6 +38,20 @@ function useLiveAgentRun() {
       }
     }
   }
+  async function reattach(existingConversationId, opts) {
+    if (ownedConversationRef.current !== existingConversationId) releaseOwned();
+    setDismissed(false);
+    dismissedRef.current = false;
+    ownedConversationRef.current = existingConversationId;
+    try {
+      return await headless.reattach(existingConversationId, {
+        ...opts,
+        keepInstance: true
+      });
+    } finally {
+      if (dismissedRef.current) releaseOwned();
+    }
+  }
   const dismiss = () => {
     setDismissed(true);
     dismissedRef.current = true;
@@ -58,6 +72,7 @@ function useLiveAgentRun() {
   );
   return {
     run,
+    reattach,
     dismiss,
     isRunning: headless.isRunning,
     error: headless.error,

package/dist/agents/redux/execution-system/instance-variable-values/instance-variable-values.selectors.d.ts

@@ -105,6 +105,76 @@ export declare const selectOwnVariableValues: (conversationId: string) => ((stat
     memoize: typeof import("reselect").weakMapMemoize;
     argsMemoize: typeof import("reselect").weakMapMemoize;
 };
+/**
+ * The variables a run USED: the values its first turn was sent with — frozen at
+ * send, host-wired names included — so a later edit of the variable field never
+ * rewrites what the run was given. Before any send it is what the next send would
+ * carry (the request merge, defaults included). Read by the agent builder's Side
+ * Chat helper to judge a test run.
+ */
+export declare const selectVariablesTheRunUsed: (conversationId: string) => ((state: {
+    voiceAgent: import("../../../../voice-agent/types.js").VoiceAgentState;
+    agentDefinition: import("../../../types/agent-definition.types.js").AgentDefinitionSliceState;
+    conversationList: import("../../conversation-list/conversation-list.types.js").ConversationListState;
+    conversationHistory: import("../../conversation-history/types.js").ConversationHistoryState;
+    agentShortcut: import("../../agent-shortcuts/types.js").AgentShortcutSliceState;
+    agentShortcutCategory: import("../../agent-shortcut-categories/types.js").AgentShortcutCategorySliceState;
+    surfaceUserState: import("../../../../surfaces/redux/userStateSlice.js").SurfaceUserStateSlice;
+    conversations: import("../conversations/conversations.slice.js").ConversationsState;
+    chatIncognito: import("../../chat/chat-incognito.slice.js").ChatIncognitoState;
+    chatRoute: import("../../chat/chat-route.slice.js").ChatRouteState;
+    instanceModelOverrides: import("../instance-model-overrides/instance-model-overrides.slice.js").InstanceModelOverridesState;
+    instanceInputCapabilities: import("../instance-input-capabilities/instance-input-capabilities.slice.js").InstanceInputCapabilitiesState;
+    instanceVariableValues: import("./instance-variable-values.slice.js").InstanceVariableValuesState;
+    instanceResources: import("../instance-resources/instance-resources.slice.js").InstanceResourcesState;
+    instanceContext: import("../instance-context/instance-context.slice.js").InstanceContextState;
+    instanceWorkingDocument: import("../instance-working-document/instance-working-document.slice.js").InstanceWorkingDocumentSliceState;
+    instanceUserInput: import("../instance-user-input/instance-user-input.slice.js").InstanceUserInputSliceState;
+    instanceClientTools: import("../instance-client-tools/instance-client-tools.slice.js").InstanceClientToolsState;
+    pendingAsks: import("../../../ui-first-tools/redux/pending-asks.slice.js").PendingAsksState;
+    conversationInbox: import("../inbox/inbox.slice.js").ConversationInboxState;
+    agentLists: import("../../../ui-first-tools/redux/agent-lists.slice.js").AgentListsState;
+    instanceUIState: import("../instance-ui-state/instance-ui-state.slice.js").InstanceUIStateSlice;
+    activeTools: import("../active-tools/active-tools.slice.js").ActiveToolsState;
+    activeRequests: import("../active-requests/active-requests.slice.js").ActiveRequestsState;
+    runSets: import("../run-sets/run-sets.slice.js").RunSetsState;
+    messages: import("../messages/messages.slice.js").MessagesState;
+    observability: import("../observability/observability.slice.js").ObservabilityState;
+    contextState: import("../context-state/context-state.slice.js").ContextStateSliceState;
+    observationalMemory: import("../observational-memory/observational-memory.slice.js").ObservationalMemoryState;
+    cacheBypass: import("../message-crud/cache-bypass.slice.js").CacheBypassState;
+    conversationFocus: import("../conversation-focus/conversation-focus.slice.js").ConversationFocusState;
+    surfaces: import("../../surfaces/surfaces.slice.js").SurfacesState;
+    surfacesCatalog: import("../../../../surfaces/redux/surfacesCatalogSlice.js").SurfacesCatalogSliceState;
+    agentSurfaceBindings: import("../../../../surfaces/redux/agentSurfaceBindingsSlice.js").AgentSurfaceBindingsSliceState;
+    surfaceConfig: import("../../../../surfaces/redux/surfaceConfigSlice.js").SurfaceConfigSliceState;
+    agentAssistantMarkdownDraft: import("../../agent-assistant-markdown-draft.slice.js").AgentAssistantMarkdownDraftState;
+    mcp: import("../../mcp/mcp.slice.js").McpSliceState;
+    proposedDirectives: import("../../proposed-directives/proposedDirectivesSlice.js").ProposedDirectivesState;
+    conversationAttachments: import("../../../connectors/attachments.slice.js").AttachmentsSliceState;
+    chatHost: import("../../../../store/chat-host.slice.js").ChatHostState;
+    hostConversations: import("../host-conversations/host-conversations.slice.js").HostConversationsState;
+} & import("../../../../store/root-state.js").ChatHostReadSlices) => Record<string, unknown>) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: import("./instance-variable-values.slice.js").InstanceVariableValuesEntry) => Record<string, unknown>;
+    memoizedResultFunc: ((resultFuncArgs_0: import("./instance-variable-values.slice.js").InstanceVariableValuesEntry) => Record<string, unknown>) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => Record<string, unknown>;
+    dependencies: [(state: ChatRootState) => import("./instance-variable-values.slice.js").InstanceVariableValuesEntry];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").weakMapMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};
 /** Immutable first-turn values, excluding names the host supplied. */
 export declare const selectOwnSubmittedFirstTurnValues: (conversationId: string) => ((state: {
     voiceAgent: import("../../../../voice-agent/types.js").VoiceAgentState;

package/dist/agents/redux/execution-system/instance-variable-values/instance-variable-values.selectors.js

@@ -25,6 +25,19 @@ const selectOwnVariableValues = (conversationId) => createSelector(
     return Object.keys(own).length === 0 ? EMPTY_RECORD : own;
   }
 );
+const selectVariablesTheRunUsed = (conversationId) => createSelector(
+  (state) => state.instanceVariableValues.byConversationId[conversationId],
+  (entry) => {
+    if (!entry) return EMPTY_RECORD;
+    if (entry.submittedFirstTurnValues) return entry.submittedFirstTurnValues;
+    const merged = resolveVariablesForRequest({
+      definitions: entry.definitions,
+      userValues: entry.userValues,
+      scopeValues: entry.scopeValues
+    });
+    return Object.keys(merged).length > 0 ? merged : EMPTY_RECORD;
+  }
+);
 const selectOwnSubmittedFirstTurnValues = (conversationId) => createSelector(
   (state) => state.instanceVariableValues.byConversationId[conversationId],
   (entry) => {
@@ -134,5 +147,6 @@ export {
   selectScopeVariableValues,
   selectUserVariableValues,
   selectVariableProvenance,
-  selectVariablesForRequest
+  selectVariablesForRequest,
+  selectVariablesTheRunUsed
 };

package/dist/agents/redux/execution-system/thunks/reattach-headless-agent-json.d.ts

@@ -0,0 +1,29 @@
+/**
+ * reattachHeadlessAgentJson — the sibling of `runHeadlessAgentJson` for a run
+ * that is ALREADY running or finished: a reload or a paused tab must never
+ * start a second paid run, it picks the first one back up.
+ *
+ * It owns no run path of its own. Every step is an existing primitive:
+ *
+ *  1. `loadConversation`             — the saved conversation (a finished run's
+ *                                      last message is read from it)
+ *  2. `surfaceColdPendingCalls`      — a delegated tool prompt nobody answered
+ *  3. `reconnectServerOperation`     — `/runtime/operations/by-link/conversation`:
+ *                                      if the server is still working, rejoin
+ *                                      and follow it to terminal through the
+ *                                      canonical stream pipeline (so the same
+ *                                      LiveRunWindow bound to this conversation
+ *                                      streams it), then reload the saved turn
+ *  4. `adoptHeadlessAgentJson`       — THE result-resolution rule, over the
+ *                                      request that is now in Redux
+ *
+ * A stream this very page still owns (`hasAbortController`) is never re-read:
+ * a reload would clobber it, so steps 1–3 are skipped and the live request is
+ * simply waited on. Never throws — resolves a structured result.
+ */
+import type { ChatDispatch, ChatRootState } from "../../../../store/root-state.js";
+import { type AdoptedAgentJsonOptions, type HeadlessAgentJsonResult } from "./run-headless-agent-json.js";
+export interface ReattachHeadlessAgentJsonOptions extends Omit<AdoptedAgentJsonOptions, "requestId" | "conversationId"> {
+    conversationId: string;
+}
+export declare function reattachHeadlessAgentJson(dispatch: ChatDispatch, getState: () => ChatRootState, opts: ReattachHeadlessAgentJsonOptions): Promise<HeadlessAgentJsonResult>;

package/dist/agents/redux/execution-system/thunks/reattach-headless-agent-json.js

@@ -0,0 +1,89 @@
+import { extractErrorMessage } from "@ai-matrx/data/net";
+import { extractFirstJson } from "@ai-matrx/content-ir/json-extract";
+import { captureError } from "../../../../host/diagnostics.js";
+import { reconnectServerOperation } from "../../../runtime-reconnect/reconnect-server-operation.thunk.js";
+import { selectRequestStatus } from "../active-requests/active-requests.selectors.js";
+import { selectLatestAnswerText as selectCommittedAnswerText } from "../messages/messages.selectors.js";
+import { selectLatestRequestId } from "../selectors/aggregate.selectors.js";
+import { hasAbortController } from "./abort-registry.js";
+import { loadConversation } from "./load-conversation.thunk.js";
+import { surfaceColdPendingCalls } from "./surface-cold-pending-calls.thunk.js";
+import {
+  adoptHeadlessAgentJson
+} from "./run-headless-agent-json.js";
+const REATTACH_SETTLE_MS = 300;
+async function reattachHeadlessAgentJson(dispatch, getState, opts) {
+  const { conversationId } = opts;
+  const failure = (error, errorDetail) => ({
+    success: false,
+    data: null,
+    fullResponse: selectCommittedAnswerText(conversationId)(getState()),
+    error,
+    errorDetail,
+    conversationId
+  });
+  if (!hasAbortController(conversationId)) {
+    try {
+      await dispatch(loadConversation({ conversationId })).unwrap();
+    } catch (err) {
+      const detail = extractErrorMessage(err);
+      captureError({
+        source: "agent-json-result",
+        message: `Reattach could not read conversation ${conversationId}: ${detail}`,
+        conversationId,
+        raw: { surfaceKey: opts.surfaceKey, detail }
+      });
+      return failure("That run could not be opened again.", detail);
+    }
+    void dispatch(surfaceColdPendingCalls(conversationId));
+    try {
+      await dispatch(
+        reconnectServerOperation({ conversationId, source: "cold-load" })
+      ).unwrap();
+    } catch (err) {
+      const detail = extractErrorMessage(err);
+      captureError({
+        source: "agent-json-result",
+        message: `Reattach could not follow conversation ${conversationId}: ${detail}`,
+        conversationId,
+        raw: { surfaceKey: opts.surfaceKey, detail }
+      });
+      return failure("That run could not be followed to its end.", detail);
+    }
+  }
+  const requestId = selectLatestRequestId(conversationId)(getState());
+  const status = requestId ? selectRequestStatus(requestId)(getState()) : void 0;
+  const fullResponse = selectCommittedAnswerText(conversationId)(getState());
+  const finished = status === void 0 || status === "complete";
+  if (fullResponse.trim() && finished && !hasAbortController(conversationId)) {
+    const expect = opts.expect ?? "json";
+    const data = expect === "text" ? fullResponse.trim() : extractFirstJson(fullResponse, { allowFuzzy: true })?.value ?? null;
+    if (data != null) {
+      const result = {
+        success: true,
+        data,
+        fullResponse,
+        conversationId,
+        ...requestId ? { requestId } : {}
+      };
+      await opts.onResult?.(result);
+      return result;
+    }
+  }
+  if (requestId) {
+    return adoptHeadlessAgentJson(dispatch, getState, {
+      ...opts,
+      requestId,
+      settleMs: opts.settleMs ?? REATTACH_SETTLE_MS,
+      // The window keeps showing the finished run; the hook owns teardown.
+      keepInstance: opts.keepInstance ?? true
+    });
+  }
+  return failure(
+    "That run has no saved result to open.",
+    "reattach: the conversation holds no request and no readable answer"
+  );
+}
+export {
+  reattachHeadlessAgentJson
+};

package/dist/agents/redux/execution-system/thunks/record-run-output-refused.d.ts

@@ -10,5 +10,14 @@
  *
  * Never silent: a write that does not land is a `console.error` naming the run.
  */
+import type { ChatRootState } from "../../../../store/root-state.js";
 export declare const OUTPUT_REFUSED_METADATA_KEY = "output_refused";
-export declare function recordRunOutputRefused(requestId: string, reason: string): Promise<boolean>;
+/**
+ * The run's own `chat.user_request` row id, as the server announced it (`record_reserved` for the
+ * `user_request` table, or a message reservation's `parent_refs.user_request_id`). The client's
+ * `requestId` (`req_<uuid>`) is a Redux key the database has never seen — writing against it matched
+ * no row, so every refusal before 0.7.12 left the run `completed` (Make's describe box, 2026-10-09).
+ * Null when the stream announced no row.
+ */
+export declare function runRowIdOf(state: ChatRootState, requestId: string): string | null;
+export declare function recordRunOutputRefused(runRowId: string | null, reason: string, requestId?: string): Promise<boolean>;

package/dist/agents/redux/execution-system/thunks/record-run-output-refused.js

@@ -2,17 +2,34 @@ import { mergeJsonColumn } from "@ai-matrx/data/db";
 import { supabase } from "../../../../host/db.js";
 import { hasBrowserSession } from "../../../../host/identity.js";
 const OUTPUT_REFUSED_METADATA_KEY = "output_refused";
-async function recordRunOutputRefused(requestId, reason) {
-  if (!requestId || !await hasBrowserSession()) return false;
+const ROW_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function runRowIdOf(state, requestId) {
+  const reservations = state.activeRequests.byRequestId[requestId]?.reservations;
+  if (!reservations) return null;
+  const all = Object.values(reservations);
+  const own = all.find((r) => r.table === "user_request" && ROW_ID.test(r.recordId));
+  if (own) return own.recordId;
+  const parent = all.map((r) => r.parentRefs?.user_request_id).find((id) => typeof id === "string" && ROW_ID.test(id));
+  return parent ?? null;
+}
+async function recordRunOutputRefused(runRowId, reason, requestId) {
+  if (!runRowId || !ROW_ID.test(runRowId)) {
+    console.error(
+      `[run-output-refused] Run ${requestId ?? "?"} announced no chat.user_request row id (got ${runRowId ?? "none"}); the refusal cannot be recorded and the run still reads as completed. Reason: ${reason}`
+    );
+    return false;
+  }
+  const requestRow = runRowId;
+  if (!await hasBrowserSession()) return false;
   const result = await mergeJsonColumn({
-    fetchCurrent: () => supabase.schema("chat").from("user_request").select("id, version, metadata").eq("id", requestId).maybeSingle(),
+    fetchCurrent: () => supabase.schema("chat").from("user_request").select("id, version, metadata").eq("id", requestRow).maybeSingle(),
     readColumn: (row) => row.metadata,
     merge: (current) => ({ ...current, [OUTPUT_REFUSED_METADATA_KEY]: { reason, at: (/* @__PURE__ */ new Date()).toISOString() } }),
-    applyUpdate: ({ value, expectedVersion, nextVersion }) => supabase.schema("chat").from("user_request").update({ metadata: value, version: nextVersion, status: "failed", error: reason.slice(0, 500) }).eq("id", requestId).eq("version", expectedVersion).select("id, version, metadata").maybeSingle()
+    applyUpdate: ({ value, expectedVersion, nextVersion }) => supabase.schema("chat").from("user_request").update({ metadata: value, version: nextVersion, status: "failed", error: reason.slice(0, 500) }).eq("id", requestRow).eq("version", expectedVersion).select("id, version, metadata").maybeSingle()
   });
   if (result.status !== "saved") {
     console.error(
-      `[run-output-refused] Could not record the refusal on run ${requestId}: ` + (result.status === "error" ? String(result.error) : `write ${result.status}`) + `. The run still reads as completed. Reason: ${reason}`
+      `[run-output-refused] Could not record the refusal on run ${requestRow}: ` + (result.status === "error" ? String(result.error) : `write ${result.status}`) + `. The run still reads as completed. Reason: ${reason}`
     );
     return false;
   }
@@ -20,5 +37,6 @@ async function recordRunOutputRefused(requestId, reason) {
 }
 export {
   OUTPUT_REFUSED_METADATA_KEY,
-  recordRunOutputRefused
+  recordRunOutputRefused,
+  runRowIdOf
 };

package/dist/ui/markdown-stream/MarkdownStream.d.ts

@@ -83,6 +83,7 @@ export interface MarkdownStreamProps {
      */
     imagePolicy?: "self" | "other" | "ai" | "inherit";
 }
-declare function MarkdownStream(props: MarkdownStreamProps): import("react").FunctionComponentElement<import("react").SuspenseProps> | null;
+export declare function preloadMarkdownStream(): Promise<void>;
+declare function MarkdownStream(props: MarkdownStreamProps): import("react").FunctionComponentElement<import("react").SuspenseProps> | import("react").ReactElement<MarkdownStreamProps, string | import("react").JSXElementConstructor<any>> | null;
 export { MarkdownStream };
 export default MarkdownStream;

package/dist/ui/markdown-stream/MarkdownStream.js

@@ -1,14 +1,33 @@
 "use client";
-import { createElement, lazy, Suspense, useEffect, useState } from "react";
+import { createElement, lazy, Suspense, useSyncExternalStore } from "react";
 const MarkdownStreamImpl = lazy(() => import("./MarkdownStreamImpl.js"));
+let loadedImpl = null;
+let loading = null;
+const readyListeners = /* @__PURE__ */ new Set();
+function preloadMarkdownStream() {
+  if (typeof window === "undefined") return Promise.resolve();
+  loading ??= import("./MarkdownStreamImpl.js").then((m) => {
+    loadedImpl = m.default;
+    for (const notify of readyListeners) notify();
+  });
+  return loading;
+}
+const subscribeReady = (notify) => {
+  readyListeners.add(notify);
+  return () => readyListeners.delete(notify);
+};
+const clientReady = () => true;
+const serverNotReady = () => false;
 function MarkdownStream(props) {
-  const [mounted, setMounted] = useState(false);
-  useEffect(() => setMounted(true), []);
-  if (!mounted) return null;
+  const client = useSyncExternalStore(subscribeReady, clientReady, serverNotReady);
+  if (!client) return null;
+  if (loadedImpl) return createElement(loadedImpl, props);
+  void preloadMarkdownStream();
   return createElement(Suspense, { fallback: null }, createElement(MarkdownStreamImpl, props));
 }
 var MarkdownStream_default = MarkdownStream;
 export {
   MarkdownStream,
-  MarkdownStream_default as default
+  MarkdownStream_default as default,
+  preloadMarkdownStream
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-matrx/chat",
-  "version": "0.7.11",
+  "version": "0.7.13",
   "description": "THE one AI Matrx person-to-agent chat system: the full chat (running agents, conversations, tool calls, streaming, context, surfaces, voice) as explicit per-module subpaths @ai-matrx/chat/<domain>/<module> (no wildcards: scripts/public-modules.json) over a host contract (/host, /host/react) whose only required value is a db. One chat, one renderer: the old kernel entries (., /external-store, /matrx, /react, /tools, styles.css, tokens.css) are retired.",
   "type": "module",
   "license": "MIT",
@@ -4686,20 +4686,20 @@
     "@ai-matrx/browser-audio": "latest",
     "@ai-matrx/canvas": "latest",
     "@ai-matrx/content-ir": "latest",
-    "@ai-matrx/agents": "latest",
     "@ai-matrx/content-ir-react": "latest",
-    "@ai-matrx/data": "latest",
+    "@ai-matrx/agents": "latest",
     "@ai-matrx/design-system": "latest",
+    "@ai-matrx/diff": "latest",
     "@ai-matrx/icons": "latest",
     "@ai-matrx/kit": "latest",
     "@ai-matrx/media": "latest",
-    "@ai-matrx/print": "latest",
     "@ai-matrx/realtime": "latest",
     "@ai-matrx/records": "latest",
-    "@ai-matrx/records-ui": "latest",
+    "@ai-matrx/data": "latest",
     "@ai-matrx/rich-content": "latest",
+    "@ai-matrx/print": "latest",
     "@ai-matrx/rich-editor": "latest",
-    "@ai-matrx/diff": "latest"
+    "@ai-matrx/records-ui": "latest"
   },
   "devDependencies": {
     "@arethetypeswrong/cli": "^0.18.5",
@@ -4818,5 +4818,5 @@
     "check:side-effects": "node ../scripts/check-side-effects-listed.mjs . && node ../scripts/check-side-effects-listed.mjs --self-test",
     "check:public-surface": "node ./scripts/sync-public-surface.mjs --check && node ./scripts/sync-public-surface.mjs --self-test"
   },
-  "gitHead": "db3bd1fad7851f7648e0aeee094cf4df6152b3ae"
+  "gitHead": "b49e03c743ac750bc1615fd9635bdc5a4796a241"
 }