@ai-matrx/chat 0.7.6 → 0.7.8

package/dist/agents/redux/execution-system/selectors/aggregate.selectors.js

@@ -11,6 +11,7 @@ import {
   selectShowAutoClearToggle
 } from "../instance-ui-state/instance-ui-state.selectors.js";
 import { assembleRequest } from "../thunks/execute-instance.thunk.js";
+import { selectAppContext } from "../../../../context/sources/scopes.js";
 import {
   contextItemBindingOf,
   isCustomDataBinding
@@ -170,49 +171,33 @@ const selectIsInstanceReady = (conversationId) => {
   return selector;
 };
 function makeSelectAssembledRequest(conversationId) {
-  return createSelector(
-    [
-      (s) => s.conversations,
-      (s) => s.instanceUIState,
-      (s) => s.instanceUserInput,
-      (s) => s.instanceResources,
-      (s) => s.instanceVariableValues,
-      (s) => s.instanceModelOverrides,
-      (s) => s.instanceContext,
-      (s) => s.instanceClientTools,
-      (s) => s.appContext,
-      // Identity, active org and the person's preferences (P7/P8): the package's own host slice.
-      (s) => s.chatHost,
-      // The context door (buildRequestContext) reads these too: the agent's
-      // policies + kill switch, the person's saved context rules, whether this
-      // is the first turn, and who is signed in (first-turn system values).
-      (s) => s.agentDefinition,
-      (s) => s.surfaceUserState,
-      (s) => s.messages,
-      (s) => s.userAuth,
-      (s) => s.userProfile
-    ],
-    (conversations, instanceUIState, instanceUserInput, instanceResources, instanceVariableValues, instanceModelOverrides, instanceContext, instanceClientTools, appContext, chatHost, agentDefinition, surfaceUserState, messages, userAuth, userProfile) => {
-      const state = {
-        conversations,
-        instanceUIState,
-        instanceUserInput,
-        instanceResources,
-        instanceVariableValues,
-        instanceModelOverrides,
-        instanceContext,
-        instanceClientTools,
-        appContext,
-        chatHost,
-        agentDefinition,
-        surfaceUserState,
-        messages,
-        userAuth,
-        userProfile
-      };
-      return assembleRequest(state, conversationId);
-    }
-  );
+  const inputs = [
+    (s) => s.conversations,
+    (s) => s.instanceUIState,
+    (s) => s.instanceUserInput,
+    (s) => s.instanceResources,
+    (s) => s.instanceVariableValues,
+    (s) => s.instanceModelOverrides,
+    (s) => s.instanceContext,
+    (s) => s.instanceClientTools,
+    (s) => selectAppContext(s),
+    (s) => s.chatHost,
+    // The context door (buildRequestContext) reads these too: the agent's
+    // policies + kill switch, the person's saved context rules, whether this
+    // is the first turn.
+    (s) => s.agentDefinition,
+    (s) => s.surfaceUserState,
+    (s) => s.messages
+  ];
+  let lastInputs = null;
+  let lastResult = null;
+  return (state) => {
+    const current = inputs.map((read) => read(state));
+    if (lastInputs && current.every((value, i) => value === lastInputs[i])) return lastResult;
+    lastInputs = current;
+    lastResult = assembleRequest(state, conversationId);
+    return lastResult;
+  };
 }
 const selectAssembledRequest = makeSelectAssembledRequest;
 const selectInstanceSummary = (conversationId) => createSelector(

package/dist/agents/redux/execution-system/thunks/call-conversation-api.d.ts

@@ -0,0 +1,44 @@
+/**
+ * THE CONVERSATION DOOR for every JSON request that names a conversation (Audit B family 8).
+ *
+ * A turn resolves where it goes and what it carries in `resolveBackendForConversation`: the
+ * conversation's channel (global / sandbox override / local engine / EC2-dedicated, under the
+ * confidential-routing rule), THE ONE header builder and THE ORG RULE. Until 2026-10-08 the calls
+ * that ride beside a turn on the same conversation — the inbox, tool results, pending calls,
+ * memory cost, cancel — went through the host's general `callApi` instead: another base URL (no
+ * sandbox / local override), another organization precedence (the tab's selection, not the
+ * conversation's), and in one host no session at all (the inbox sent without auth). This door
+ * makes them the turn's twin: same resolver, so the same server, credential and organization.
+ *
+ * Result shape and error classification are the shared pipeline's (`executeMatrxCall`,
+ * `normalizeMatrxError` in `@ai-matrx/agents/matrx`) — the same `{ data } | { error }` the call
+ * sites already read from `callApi`. Guard: `__tests__/conversation-calls-name-the-turns-org.test.ts`.
+ */
+import { type MatrxCancelResponse, type MatrxCallResult, type MatrxQueryParams } from "@ai-matrx/agents/matrx";
+import type { ChatRootState } from "../../../../store/root-state.js";
+export type ConversationCallMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+export interface ConversationCallConfig {
+    /** Path template; `{conversation_id}` is filled from the door's conversation. */
+    path: string;
+    method: ConversationCallMethod;
+    /** Other path parameters (never `conversation_id`). */
+    pathParams?: Record<string, string>;
+    queryParams?: MatrxQueryParams;
+    body?: unknown;
+    signal?: AbortSignal;
+    /** HTTP statuses this call site handles as expected outcomes (not logged as failures). */
+    expectedErrorStatuses?: readonly number[];
+    connectTimeoutMs?: number;
+    totalTimeoutMs?: number | null;
+}
+type AnyDispatch = (action: never) => unknown;
+/** Send one JSON request on `conversationId`'s own channel, credential and organization. */
+export declare function callConversationApi<T = unknown>(conversationId: string, config: ConversationCallConfig): (dispatch: AnyDispatch, getState: () => ChatRootState) => Promise<MatrxCallResult<T>>;
+/**
+ * Stop (or interrupt) one server run of `conversationId` on the conversation's own channel,
+ * credential and organization — never the tab's. `seenSeq` is the last wire `stream_seq` the page
+ * APPLIED before Stop; the server cuts the stopped answer there, so the saved text never outgrows
+ * the screen.
+ */
+export declare function cancelConversationRun(conversationId: string, requestId: string, mode?: "cancel" | "interrupt", seenSeq?: number): (dispatch: AnyDispatch, getState: () => ChatRootState) => Promise<MatrxCallResult<MatrxCancelResponse>>;
+export {};

package/dist/agents/redux/execution-system/thunks/call-conversation-api.js

@@ -0,0 +1,78 @@
+import {
+  cancelAgentRun,
+  buildMatrxRequestBody,
+  buildMatrxRequestUrl,
+  executeMatrxCall,
+  normalizeMatrxError,
+  resolveEndpointPath
+} from "@ai-matrx/agents/matrx";
+import { selectEndpointOverrideConfig } from "../../../../host/server/api-config.js";
+import { conversationRequestOrganizationId } from "../utils/required-organization.js";
+import { resolveBackendForConversation } from "./resolve-base-url.js";
+import { createMatrxTransportForConversation } from "./matrx-transport-for-conversation.js";
+function callConversationApi(conversationId, config) {
+  return async (_dispatch, getState) => {
+    try {
+      const state = getState();
+      const backend = resolveBackendForConversation(state, conversationId);
+      if (!backend) {
+        return {
+          error: {
+            type: "network_error",
+            message: "No AI Matrx server is configured for this conversation. The request was not sent."
+          }
+        };
+      }
+      const organizationId = conversationRequestOrganizationId(state, conversationId);
+      const path = resolveEndpointPath(config.path, selectEndpointOverrideConfig(state));
+      const result = await executeMatrxCall({
+        url: buildMatrxRequestUrl(
+          backend.baseUrl,
+          path,
+          { ...config.pathParams ?? {}, conversation_id: conversationId },
+          config.queryParams
+        ),
+        method: config.method,
+        headers: { ...backend.headers, Accept: "application/json" },
+        body: buildMatrxRequestBody(
+          config.body,
+          organizationId ? { organization_id: organizationId } : {}
+        ),
+        ...config.signal ? { signal: config.signal } : {},
+        ...config.connectTimeoutMs !== void 0 ? { connectTimeoutMs: config.connectTimeoutMs } : {},
+        ...config.totalTimeoutMs !== void 0 ? { totalTimeoutMs: config.totalTimeoutMs } : {}
+      });
+      const status = result.error?.status;
+      if (result.error && !(status !== void 0 && config.expectedErrorStatuses?.includes(status))) {
+        console.warn(`[conversation-call] ${config.method} ${config.path} failed`, {
+          conversationId,
+          channel: backend.channel,
+          error: result.error
+        });
+      }
+      return result;
+    } catch (error) {
+      return { error: normalizeMatrxError(error) };
+    }
+  };
+}
+function cancelConversationRun(conversationId, requestId, mode = "cancel", seenSeq) {
+  return async (_dispatch, getState) => {
+    try {
+      const base = createMatrxTransportForConversation(getState, conversationId, {
+        source: "matrxTransport:cancel"
+      });
+      const transport = seenSeq === void 0 ? base : {
+        fetch: (path, init) => base.fetch(`${path}${path.includes("?") ? "&" : "?"}seen_seq=${seenSeq}`, init)
+      };
+      const data = await cancelAgentRun(transport, requestId, { mode });
+      return { data, requestId: data.request_id };
+    } catch (error) {
+      return { error: normalizeMatrxError(error) };
+    }
+  };
+}
+export {
+  callConversationApi,
+  cancelConversationRun
+};

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

@@ -0,0 +1,41 @@
+/**
+ * continueAgentJson — the NEXT turn of a conversation whose first turn ran headlessly
+ * (`runHeadlessAgentJson` with `keepInstance`), waited on exactly like the first.
+ *
+ * ONE CONVERSATION, MANY ROUNDS. A surface that builds something with an agent and then keeps
+ * talking about it (the Applet builder: build → automatic fix round → "Change it" → the person's
+ * replies) continues THAT conversation instead of starting a new one per round, so the person can
+ * read and answer it in one place and the agent sees every earlier round.
+ *
+ * A turn is either the person's words (`userInput` — only what a human typed, THE USER-INPUT LAW)
+ * or a turn the host writes (`hostTurn` — an activation line + which feature wrote it; never quoted
+ * as the person). Structured content for the turn rides `context` (named entries on the instance —
+ * a `null` value removes the key), never the message.
+ *
+ * It reuses THE machinery: `executeInstance` sends the continuation (`POST /ai/conversations/{id}`),
+ * `adoptHeadlessAgentJson` waits on it (polling, settle window, one result rule, the persistence
+ * seam). A conversation not in this tab yet (a refresh) is read first through `loadConversation`.
+ * Never throws: resolves a structured result, exactly like `runHeadlessAgentJson`.
+ */
+import type { ChatDispatch, ChatRootState } from "../../../../store/root-state.js";
+import type { RequestInitiation } from "../../../types/instance.types.js";
+import { type HostTurnInput } from "./execute-instance.thunk.js";
+import { type AdoptedAgentJsonOptions, type HeadlessAgentJsonResult } from "./run-headless-agent-json.js";
+export interface ContinueAgentJsonOptions extends Pick<AdoptedAgentJsonOptions, "surfaceKey" | "timeoutMs" | "pollIntervalMs" | "settleMs" | "expect" | "onResult" | "signal" | "failureMessages"> {
+    conversationId: string;
+    /** What the person typed for this turn. Exclusive with `hostTurn`. */
+    userInput?: string;
+    /** A turn the host writes (the person said nothing). Exclusive with `userInput`. */
+    hostTurn?: HostTurnInput;
+    /** Per-turn named context: each key is written on the instance; `null` removes it. */
+    context?: Record<string, unknown>;
+    /** "user" when the person pressed send; "auto" for a host-started round. Default by turn kind. */
+    initiation?: RequestInitiation;
+    /** Fires the instant the turn's request exists (a live view binds to it). */
+    onRequestId?: (requestId: string) => void;
+    /** Keep the instance after the turn (the live view owns teardown). Default true. */
+    keepInstance?: boolean;
+}
+/** Which of the two turn kinds this is — exactly one, or a sentence why not. */
+export declare function continuationTurnProblem(opts: Pick<ContinueAgentJsonOptions, "userInput" | "hostTurn">): string | null;
+export declare function continueAgentJson(dispatch: ChatDispatch, getState: () => ChatRootState, opts: ContinueAgentJsonOptions): Promise<HeadlessAgentJsonResult>;

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

@@ -0,0 +1,66 @@
+import { removeContextEntry, setContextEntries } from "../instance-context/instance-context.slice.js";
+import { setUserInputText } from "../instance-user-input/instance-user-input.slice.js";
+import { executeInstance } from "./execute-instance.thunk.js";
+import { loadConversation } from "./load-conversation.thunk.js";
+import {
+  adoptHeadlessAgentJson
+} from "./run-headless-agent-json.js";
+function continuationTurnProblem(opts) {
+  const typed = typeof opts.userInput === "string" && opts.userInput.trim().length > 0;
+  if (typed && opts.hostTurn) return "A turn is the person's words or a host turn, never both.";
+  if (!typed && !opts.hostTurn) return "Nothing to send: the turn has neither the person's words nor a host turn.";
+  if (opts.hostTurn && (!opts.hostTurn.text.trim() || !opts.hostTurn.reason.trim())) return "A host turn needs its text and its reason.";
+  return null;
+}
+async function continueAgentJson(dispatch, getState, opts) {
+  const { conversationId } = opts;
+  const problem = continuationTurnProblem(opts);
+  if (problem) return { success: false, data: null, fullResponse: "", error: problem, conversationId };
+  try {
+    if (!getState().conversations.byConversationId[conversationId]) {
+      await dispatch(loadConversation({ conversationId })).unwrap();
+    }
+    const context = Object.entries(opts.context ?? {});
+    const writes = context.filter(([, value]) => value !== null && value !== void 0);
+    for (const [key] of context.filter(([, value]) => value === null)) dispatch(removeContextEntry({ conversationId, key }));
+    if (writes.length) dispatch(setContextEntries({ conversationId, entries: writes.map(([key, value]) => ({ key, value })) }));
+    if (opts.userInput) dispatch(setUserInputText({ conversationId, text: opts.userInput }));
+    let requestId = null;
+    const sent = await dispatch(
+      executeInstance({
+        conversationId,
+        initiation: opts.initiation ?? (opts.hostTurn ? "auto" : "user"),
+        ...opts.hostTurn ? { hostTurn: opts.hostTurn } : {},
+        onRequestId: (id) => {
+          requestId = id;
+          opts.onRequestId?.(id);
+        }
+      })
+    );
+    if (executeInstance.rejected.match(sent)) {
+      const reason = typeof sent.payload === "string" ? sent.payload : sent.error.message ?? "The turn could not be sent.";
+      return { success: false, data: null, fullResponse: "", error: reason, conversationId, ...requestId ? { requestId } : {} };
+    }
+    return await adoptHeadlessAgentJson(dispatch, getState, {
+      requestId: sent.payload.requestId,
+      conversationId,
+      surfaceKey: opts.surfaceKey,
+      keepInstance: opts.keepInstance ?? true,
+      ...opts.timeoutMs !== void 0 ? { timeoutMs: opts.timeoutMs } : {},
+      ...opts.pollIntervalMs !== void 0 ? { pollIntervalMs: opts.pollIntervalMs } : {},
+      ...opts.settleMs !== void 0 ? { settleMs: opts.settleMs } : {},
+      ...opts.expect ? { expect: opts.expect } : {},
+      ...opts.onResult ? { onResult: opts.onResult } : {},
+      ...opts.signal ? { signal: opts.signal } : {},
+      ...opts.failureMessages ? { failureMessages: opts.failureMessages } : {}
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error("[continueAgentJson] the turn failed before it ran", { conversationId, err });
+    return { success: false, data: null, fullResponse: "", error: message, conversationId };
+  }
+}
+export {
+  continuationTurnProblem,
+  continueAgentJson
+};

package/dist/agents/redux/execution-system/thunks/execute-instance.thunk.d.ts

@@ -36,6 +36,8 @@ export declare function isEmptyUserInput(userInput: unknown): boolean;
  */
 export declare function refusesEmptyTurn(args: {
     retry: boolean;
+    /** A host-written turn is a message even with no `user_input`. */
+    hostTurn?: boolean;
     hasPriorTurns: boolean;
     cacheOnly: boolean;
     isEphemeral: boolean;
@@ -123,6 +125,24 @@ interface ExecuteInstanceArgs {
      * composer: the person may already be typing the next message in it.
      */
     submission?: FrozenSubmission;
+    /**
+     * A turn the HOST writes on a persisted conversation — never something the
+     * person typed (THE USER-INPUT LAW). Sent as `host_turn` instead of
+     * `user_input`: a short activation line the model reads, plus which host
+     * feature wrote it; the turn's content rides `context`. Only a continuation
+     * (the conversation already has turns). The Applet builder's automatic fix
+     * round is one (lane F6b).
+     */
+    hostTurn?: HostTurnInput;
+}
+/** `ConversationContinueRequest.host_turn` — what a host-written turn carries. */
+export interface HostTurnInput {
+    /** The activation line the model reads. */
+    text: string;
+    /** Which host feature wrote it (≤80 chars). */
+    reason: string;
+    /** Extra stamps for the stored message. */
+    metadata?: Record<string, unknown>;
 }
 interface ExecuteInstanceResult {
     requestId: string;

package/dist/agents/redux/execution-system/thunks/execute-instance.thunk.js

@@ -155,7 +155,7 @@ function isEmptyUserInput(userInput) {
   });
 }
 function refusesEmptyTurn(args) {
-  if (args.retry || !args.hasPriorTurns) return false;
+  if (args.retry || args.hostTurn || !args.hasPriorTurns) return false;
   if (!shouldContinuePersistedConversation(
     args.cacheOnly,
     args.hasPriorTurns,
@@ -254,7 +254,8 @@ const executeInstance = createAsyncThunk(
     initiation,
     onRequestId,
     surfaceRefreshed = false,
-    submission
+    submission,
+    hostTurn
   }, { getState, dispatch, rejectWithValue: reject }) => {
     const requestId = generateRequestId();
     const rejectWithValue = (value, originalErrorName) => reject(
@@ -340,6 +341,7 @@ const executeInstance = createAsyncThunk(
       }
       if (refusesEmptyTurn({
         retry,
+        hostTurn: Boolean(hostTurn),
         hasPriorTurns: selectMessageCount(conversationId)(state) > 0,
         cacheOnly: instance.cacheOnly,
         isEphemeral: instance.isEphemeral === true,
@@ -535,11 +537,16 @@ const executeInstance = createAsyncThunk(
         ).replace("{conversation_id}", encodeURIComponent(conversationId));
         url = `${baseUrl}${convPath}`;
         routedPayload = buildContinuationBody(payload, {
+          hostTurn,
           retry: Boolean(retry),
           debug: Boolean(debug),
           cacheBypass: pendingBypass
         });
       } else {
+        if (hostTurn) {
+          console.error(`[execute-instance] a host turn ("${hostTurn.reason}") was sent on conversation "${conversationId}", which has no persisted turns \u2014 nothing was sent.`);
+          return rejectWithValue("A host turn continues a conversation; this one has no turns yet");
+        }
         const start = resolveStartPath({
           agentId: instance.agentId,
           pinnedVersionId: instance.initialAgentVersionId ?? null,

package/dist/agents/redux/execution-system/thunks/launch-agent-execution.thunk.js

@@ -26,10 +26,7 @@ import { alwaysOnSurfaceKeys } from "../../../../surfaces/utils/always-on-contex
 import {
   fetchAgentRunTier
 } from "../../agent-definition/thunks.js";
-import {
-  isSignedOutVisitor,
-  NotAuthenticatedError
-} from "../../../../host/identity.js";
+import { isSignedOutVisitor, NotAuthenticatedError, selectAccessToken } from "../../../../host/identity.js";
 import { applyLaunchModelOverrides } from "../instance-model-overrides/launch-model-overrides.js";
 import { selectAgentRunTier, selectAgentById } from "../../agent-definition/selectors.js";
 import { getShortcutRecordFromState } from "../../agent-shortcuts/selectors.js";
@@ -84,8 +81,9 @@ import {
   resolvePerLaunchMappings
 } from "./surface-scope-mapping.js";
 import { ensureAgentCatalog } from "../../../identity/agent-identity.js";
+import { selectOrganizationId } from "../../../../host/org.js";
 function hasSignedInSession(state) {
-  return Boolean(state.userAuth?.accessToken);
+  return Boolean(selectAccessToken(state));
 }
 const INTERACTIVE_MODES = /* @__PURE__ */ new Set([
   "modal-full",
@@ -144,7 +142,7 @@ const launchAgentExecution = createAsyncThunk("instances/launch", async (options
       );
     }
     if (!agentId) {
-      const selectedOrganizationId = adminLaneOrganizationId() ?? getState().appContext?.organization_id ?? null;
+      const selectedOrganizationId = adminLaneOrganizationId() ?? selectOrganizationId(getState());
       const questionOrganizationId = organizationId ?? selectedOrganizationId ?? await (await import("../../../../host/org.js")).ensureOrgId(null);
       const displayKey = mandateKey;
       const resolved = await resolveMandate(displayKey, { organizationId: questionOrganizationId });

package/dist/agents/redux/execution-system/thunks/notify-and-play-dispatcher.d.ts

@@ -34,11 +34,7 @@ export interface NotifyAndPlayEntry<S> {
         run: (args: never, ctx: NotifyAndPlayContext<S>) => Promise<unknown>;
     };
 }
-export declare function createNotifyAndPlayDispatcher<S extends {
-    userAuth?: {
-        id?: string | null;
-    } | null;
-}>(options: {
+export declare function createNotifyAndPlayDispatcher<S>(options: {
     /** Redux action type prefix, e.g. "scribeTools/dispatch". */
     typePrefix: string;
     /** Human label used in the unknown-tool message, e.g. "scribe". */

package/dist/agents/redux/execution-system/thunks/notify-and-play-dispatcher.js

@@ -1,12 +1,13 @@
 import { createAsyncThunk } from "@reduxjs/toolkit";
 import { extractErrorMessage } from "@ai-matrx/data/net";
 import { postDelegatedToolOutcome } from "./post-delegated-tool-outcome.js";
+import { selectUserId } from "../../../../host/identity.js";
 function createNotifyAndPlayDispatcher(options) {
   const { typePrefix, family, isToolName, getEntry } = options;
   return createAsyncThunk(
     typePrefix,
     async ({ conversationId, requestId, callId, toolName, args }, { dispatch, getState }) => {
-      const userId = getState().userAuth?.id ?? null;
+      const userId = selectUserId(getState());
       const base = { conversationId, requestId, callId, toolName };
       const fail = (errorType, message, durationMs) => postDelegatedToolOutcome(dispatch, {
         ...base,

package/dist/agents/redux/execution-system/thunks/resolve-base-url.js

@@ -1,5 +1,5 @@
-import { adminLaneHeadersFor, adminLaneOrganizationId } from "../../../../host/server/admin-lane.js";
-import { adminSeatReplyOrganizationId } from "../utils/required-organization.js";
+import { chatRequestHeaders } from "../../../../host/request-headers.js";
+import { conversationRequestOrganizationId } from "../utils/required-organization.js";
 import {
   selectResolvedBaseUrl,
   selectActiveServer
@@ -14,7 +14,6 @@ import {
   getCachedLocalEngine,
   supportsLocalAgentExecution
 } from "../../../../host/server/local-engine.js";
-import { selectOrganizationId } from "../../../../host/org.js";
 import { getChatHost, isChatHostConfigured } from "../../../../host/configure.js";
 import {
   ConfidentialRoutingRefusedError,
@@ -86,21 +85,12 @@ function resolveBackendUnchecked(state, conversationId) {
   const entry = state.instanceUIState?.byConversationId?.[conversationId] ?? null;
   const overrideUrl = entry?.serverOverrideUrl ?? null;
   const headers = {
-    "Content-Type": "application/json"
+    "Content-Type": "application/json",
+    ...chatRequestHeaders(
+      { accessToken: selectAccessToken(state), fingerprintId: selectFingerprintId(state) },
+      conversationRequestOrganizationId(state, conversationId)
+    )
   };
-  const accessToken = selectAccessToken(state);
-  const fingerprintId = selectFingerprintId(state);
-  if (accessToken) {
-    headers["Authorization"] = `Bearer ${accessToken}`;
-  } else if (fingerprintId) {
-    headers["X-Fingerprint-ID"] = fingerprintId;
-  }
-  const conversationOrganizationId = state.conversations?.byConversationId?.[conversationId]?.organizationId ?? null;
-  const organizationId = adminSeatReplyOrganizationId(state, conversationId) ?? conversationOrganizationId ?? adminLaneOrganizationId() ?? selectOrganizationId(state);
-  if (organizationId) {
-    headers["X-Organization-Id"] = organizationId;
-    Object.assign(headers, adminLaneHeadersFor(organizationId));
-  }
   if (overrideUrl) {
     const ref = resolveAgentSandboxRef(state, conversationId);
     if (ref && ref.kind !== "local-pc") {

package/dist/agents/redux/execution-system/thunks/settle-after-stop.thunk.js

@@ -1,5 +1,5 @@
 import { createAsyncThunk } from "@reduxjs/toolkit";
-import { cancelAgentRunRequest } from "../../../../host/server/matrx-transport.js";
+import { cancelConversationRun } from "./call-conversation-api.js";
 import { fetchOperationsByLink } from "../../../runtime-reconnect/api.js";
 import { resolveBackendForConversation } from "./resolve-base-url.js";
 import { loadConversation } from "./load-conversation.thunk.js";
@@ -82,7 +82,7 @@ const settleAfterStop = createAsyncThunk(
       }
       if (op && !op.is_terminal && !cancelSentFor && op.request_id) {
         cancelSentFor = op.request_id;
-        const result = await dispatch(cancelAgentRunRequest(op.request_id));
+        const result = await dispatch(cancelConversationRun(conversationId, op.request_id));
         if (result.error) {
           console.warn("[settle-after-stop] late server cancel failed", {
             conversationId,

package/dist/agents/redux/execution-system/thunks/smart-execute.thunk.js

@@ -37,7 +37,7 @@ import {
   selectInFlightRequestIds,
   settleAfterStop
 } from "./settle-after-stop.thunk.js";
-import { cancelAgentRunRequest } from "../../../../host/server/matrx-transport.js";
+import { cancelConversationRun } from "./call-conversation-api.js";
 import { toast } from "../../../../host/notify.js";
 import { selectHostConversation } from "../host-conversations/host-conversations.selectors.js";
 import { sendToHost, stopHostTurn } from "../host-conversations/host-conversation.thunks.js";
@@ -508,7 +508,7 @@ const cancelExecution = createAsyncThunk(
         serverRequestId
       );
       void dispatch(
-        cancelAgentRunRequest(serverRequestId, "cancel", seenSeq)
+        cancelConversationRun(conversationId, serverRequestId, "cancel", seenSeq)
       ).then((result) => {
         if (result.error) {
           console.warn(
@@ -564,7 +564,7 @@ const interruptAndSend = createAsyncThunk(
         serverRequestId
       );
       void dispatch(
-        cancelAgentRunRequest(serverRequestId, "interrupt", seenSeq)
+        cancelConversationRun(conversationId, serverRequestId, "interrupt", seenSeq)
       ).then(
         (result) => {
           if (result.error) {

package/dist/agents/redux/execution-system/utils/continuation-body.d.ts

@@ -56,11 +56,17 @@ export declare const CONTINUATION_FIELD_ROUTING: {
     readonly max_iterations: "not assembled by this thunk";
     readonly max_retries_per_iteration: "not assembled by this thunk";
     readonly responder_agent_id: "coding-mirror replies only; not assembled by this thunk";
-    readonly host_turn: "host-owned turns only; not assembled by this thunk";
+    readonly host_turn: "set by the builder from the hostTurn option (never copied from the payload)";
 };
 export interface ContinuationBodyOptions {
     retry: boolean;
+    /** A host-written turn: sent as `host_turn`, and `user_input` is omitted (the person said nothing). */
+    hostTurn?: {
+        text: string;
+        reason: string;
+        metadata?: Record<string, unknown>;
+    };
     debug: boolean;
     cacheBypass: unknown;
 }
-export declare function buildContinuationBody(payload: AssembledAgentStartRequest, { retry, debug, cacheBypass }: ContinuationBodyOptions): Record<string, unknown>;
+export declare function buildContinuationBody(payload: AssembledAgentStartRequest, { retry, debug, cacheBypass, hostTurn }: ContinuationBodyOptions): Record<string, unknown>;

package/dist/agents/redux/execution-system/utils/continuation-body.js

@@ -50,12 +50,12 @@ const CONTINUATION_FIELD_ROUTING = {
   max_iterations: "not assembled by this thunk",
   max_retries_per_iteration: "not assembled by this thunk",
   responder_agent_id: "coding-mirror replies only; not assembled by this thunk",
-  host_turn: "host-owned turns only; not assembled by this thunk"
+  host_turn: "set by the builder from the hostTurn option (never copied from the payload)"
 };
 const EMPTY_IS_MEANINGFUL = /* @__PURE__ */ new Set(["tools", "output_kinds"]);
 const FALSE_IS_MEANINGFUL = /* @__PURE__ */ new Set(["memory", "tools_replace", "context_withheld"]);
-function buildContinuationBody(payload, { retry, debug, cacheBypass }) {
-  const body = retry ? { retry: true } : { user_input: payload.user_input };
+function buildContinuationBody(payload, { retry, debug, cacheBypass, hostTurn }) {
+  const body = retry ? { retry: true } : hostTurn ? { host_turn: hostTurn } : { user_input: payload.user_input };
   body.stream = true;
   const source = payload;
   for (const [key, route] of Object.entries(CONTINUATION_FIELD_ROUTING)) {

package/dist/agents/redux/execution-system/utils/required-organization.d.ts

@@ -80,4 +80,22 @@ export declare function launchAsksForOrganizationBeforeOpen(launch: {
     opensWindow: boolean;
 }): boolean;
 export declare function ensureExecutionOrganization(state: ChatRootState, conversationId: string): Promise<string | null>;
+/**
+ * THE ORG RULE (Audit B family 26): which organization a request on this conversation names.
+ * ONE function, read by the turn (`requireExecutionOrganizationId`) and by the conversation door
+ * every conversation-bound call rides (`resolveBackendForConversation`), so a turn and an inbox /
+ * tool-result / pending-calls / memory-cost / cancel call on the same conversation can never name
+ * different organizations. Guard: `__tests__/one-org-rule-per-conversation.test.ts`.
+ *
+ * - Not yet persisted (`cacheOnly !== false`, or not in the store): the organization a launcher
+ *   declared, then the admin seat's platform tenant (only in a host with a database), then the
+ *   app-selected organization.
+ * - Persisted: the row owns its organization forever. The one exception is a platform admin
+ *   replying from the admin seat to a conversation they reach only as an admin: the request names
+ *   the platform tenant (the admin lane admits nothing else); the row's own organization is
+ *   restored server-side and never changes.
+ *
+ * Returns null when nothing names one (the caller decides whether that refuses).
+ */
+export declare function conversationRequestOrganizationId(state: ChatRootState, conversationId: string): string | null;
 export declare function requireExecutionOrganizationId(state: ChatRootState, conversationId: string): string;