@ai-matrx/chat 0.4.22 → 0.4.26

package/dist/agents/redux/execution-system/messages/messages.slice.js

@@ -349,7 +349,12 @@ const messagesSlice = createSlice({
           // The live receipt link — the persisted receipt wins once the
           // hydrated row carries one (selectMessageContextReceipt).
           ...live?._requestId ? { _requestId: live._requestId } : {},
-          ...live?._liveContextReceipt ? { _liveContextReceipt: live._liveContextReceipt } : {}
+          ...live?._liveContextReceipt ? { _liveContextReceipt: live._liveContextReceipt } : {},
+          // An answer open in the in-place editor stays open: the flag is
+          // client-only, and a re-read of the conversation (a window loading
+          // the conversation the page already loaded) used to drop it, closing
+          // the editor ~1.5s after a double-click and discarding the draft.
+          ...live?._editingInPlace ? { _editingInPlace: live._editingInPlace } : {}
         };
         entry.orderedIds.push(msg.id);
       }

package/dist/agents/redux/execution-system/thunks/await-launching-conversation.d.ts

@@ -0,0 +1,16 @@
+/**
+ * A SEND THAT BEATS ITS LAUNCH WAITS FOR IT.
+ *
+ * A fresh chat's composer is interactive as soon as it mounts, holding the id the launcher
+ * reserved, while the launcher is still creating that conversation (the agent's run controls, the
+ * organization, the mandate are being read). A person who types fast pressed Send in that window
+ * and the send was dropped as "no longer exists in this tab" (P29a canary: a send ~7 s after load,
+ * right after the workspace was chosen). The conversation was not gone; it had not landed yet.
+ *
+ * So the send waits, briefly, for its conversation to appear. A conversation that really was
+ * reaped never appears, and the caller still says so after the wait.
+ */
+import type { ChatRootState } from "../../../../store/root-state.js";
+/** How long a send waits for a launching conversation before calling it gone. */
+export declare const LAUNCHING_CONVERSATION_WAIT_MS = 15000;
+export declare function awaitLaunchingConversation(getState: () => ChatRootState, conversationId: string, timeoutMs?: number): Promise<boolean>;

package/dist/agents/redux/execution-system/thunks/await-launching-conversation.js

@@ -0,0 +1,16 @@
+const LAUNCHING_CONVERSATION_WAIT_MS = 15e3;
+const POLL_MS = 50;
+async function awaitLaunchingConversation(getState, conversationId, timeoutMs = LAUNCHING_CONVERSATION_WAIT_MS) {
+  const exists = () => getState().conversations.byConversationId[conversationId] !== void 0;
+  if (exists()) return true;
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    await new Promise((resolve) => setTimeout(resolve, POLL_MS));
+    if (exists()) return true;
+  }
+  return false;
+}
+export {
+  LAUNCHING_CONVERSATION_WAIT_MS,
+  awaitLaunchingConversation
+};

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

@@ -1,6 +1,10 @@
 import {
   executionRejectionMeta
 } from "./execution-rejection-meta.js";
+import {
+  continuesThroughMandate,
+  takeTurnExtras
+} from "../../../../host/conversation-hooks.js";
 import { isHostConversation } from "../host-conversations/host-conversations.selectors.js";
 import { attributionForSend } from "../../../../host/app-identity.js";
 import { mintClientTempId } from "@ai-matrx/kit/ids";
@@ -483,7 +487,24 @@ const executeInstance = createAsyncThunk(
       const pendingBypass = dispatch(
         consumePendingCacheBypass(conversationId)
       );
-      if (isContinuation) {
+      const hostExtras = takeTurnExtras(conversationId);
+      if (isContinuation && instance.mandateKey && !instance.initialAgentVersionId && continuesThroughMandate(conversationId)) {
+        const start = resolveStartPath({
+          agentId: instance.agentId,
+          pinnedVersionId: null,
+          mandateKey: instance.mandateKey,
+          overrideConfig: overrideConfig ?? void 0
+        });
+        url = `${baseUrl}${start.path}`;
+        routedPayload = {
+          ...payload,
+          conversation_id: conversationId,
+          is_new: false,
+          store: true,
+          ...retry && { retry: true },
+          ...pendingBypass && { cache_bypass: pendingBypass }
+        };
+      } else if (isContinuation) {
         const convPath = resolveEndpointPath(
           "/ai/conversations/{conversation_id}",
           overrideConfig
@@ -510,6 +531,18 @@ const executeInstance = createAsyncThunk(
           ...pendingBypass && { cache_bypass: pendingBypass }
         };
       }
+      if (hostExtras?.variables) {
+        routedPayload.variables = {
+          ...routedPayload.variables ?? {},
+          ...hostExtras.variables
+        };
+      }
+      if (hostExtras?.context) {
+        routedPayload.context = {
+          ...routedPayload.context ?? {},
+          ...hostExtras.context
+        };
+      }
       {
         const { overrides, error } = resolveRequestOverrides(
           state,

package/dist/agents/redux/execution-system/thunks/process-stream.js

@@ -1,3 +1,4 @@
+import { tapStreamEvent } from "../../../../host/conversation-hooks.js";
 import { selectHostConversation } from "../host-conversations/host-conversations.selectors.js";
 import {
   applyServerUsageState,
@@ -493,8 +494,16 @@ async function processStream({
       }) : rawEvents;
       streamFailure = null;
       let sawTerminalEvent = false;
+      let tapHeld = null;
+      const flushTap = () => {
+        if (!tapHeld) return;
+        const held = tapHeld;
+        tapHeld = null;
+        tapStreamEvent(conversationId, requestId, held.event);
+      };
       try {
         for await (const event of events) {
+          flushTap();
           const stamp = readStreamCursor(event);
           if (stamp !== null) {
             if (!transportCursor.admit(event)) continue;
@@ -506,6 +515,7 @@ async function processStream({
             scheduleBatchEvent();
           }
           totalEvents++;
+          tapHeld = { event };
           const now = performance.now();
           if (activeOnEvent) {
             try {
@@ -2080,6 +2090,7 @@ async function processStream({
       } catch (err) {
         streamFailure = err instanceof Error ? err : new Error(String(err));
       }
+      flushTap();
       if (sawTerminalEvent && streamFailure !== null) {
         streamFailure = null;
       }

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

@@ -6,6 +6,7 @@ import {
   SUBMISSION_REFUSED_AT_ADMISSION
 } from "./execute-instance.thunk.js";
 import { executeManualInstance } from "./execute-manual-instance.thunk.js";
+import { awaitLaunchingConversation } from "./await-launching-conversation.js";
 import { splitInputIntoNewConversation } from "./create-instance.thunk.js";
 import { abortConversation, hasAbortController } from "./abort-registry.js";
 import { setInstanceStatus } from "../conversations/conversations.slice.js";
@@ -65,6 +66,7 @@ import { markResourcesSubmitted } from "../instance-resources/instance-resources
 import { flushRemarkWrites, hasPendingRemarkWrites } from "../instance-resources/remarks.js";
 import { withFreshRemarkRefs } from "../instance-resources/remarks-wire.js";
 import { isOrganizationSelectionCancelled } from "../../../../host/org.js";
+import { runBeforeSend } from "../../../../host/conversation-hooks.js";
 function hasConversationAtExecutionBoundary(state, conversationId) {
   return state.conversations.byConversationId[conversationId] !== void 0;
 }
@@ -152,6 +154,9 @@ function holdBehindInFlightSend(dispatch, getState, args) {
 const smartExecute = createAsyncThunk(
   "instances/smartExecute",
   async ({ conversationId, surfaceKey, whileRunning = "queue", submission: handed }, { getState, dispatch }) => {
+    if (!handed && !hasConversationAtExecutionBoundary(getState(), conversationId)) {
+      await awaitLaunchingConversation(getState, conversationId);
+    }
     const entryState = getState();
     if (!handed) {
       const inputEntry = entryState.instanceUserInput?.byConversationId[conversationId];
@@ -322,6 +327,11 @@ const smartExecute = createAsyncThunk(
         })
       );
       preSendShown = true;
+      const hostGate = await runBeforeSend(conversationId, submission.text);
+      if (!hostGate.ok) {
+        toast.info("Not sent", { description: hostGate.sentence });
+        return;
+      }
       try {
         await dispatch(
           refreshSurfaceScope({ conversationId, composerText: submission.text })

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

@@ -1,8 +1,8 @@
 import { adminLaneOrganizationId } from "../../../../host/server/admin-lane.js";
 import { selectOrganizationId } from "../../../../host/org.js";
+import { selectAccessToken, selectFingerprintId } from "../../../../host/identity.js";
 function isFingerprintGuestExecution(state) {
-  const partial = state;
-  return !partial.userAuth?.accessToken && Boolean(partial.userProfile?.fingerprintId);
+  return !selectAccessToken(state) && Boolean(selectFingerprintId(state));
 }
 function executionOrganizationForRequest(state, conversationId) {
   if (isFingerprintGuestExecution(state)) return void 0;

package/dist/agents/ui-first-tools/redux/build-ambient-context.js

@@ -1,5 +1,6 @@
 import { selectProjectId, selectProjectName, selectTaskId, selectTaskName, selectScopeSelectionsContext } from "../../../context/sources/scopes.js";
 import { selectOrganizationId, selectOrganizationName } from "../../../host/org.js";
+import { selectChatIdentity } from "../../../host/identity.js";
 function snapshotRoute(engineered) {
   if (typeof window === "undefined") {
     return { url: null, title: null, route_kind: "server" };
@@ -18,22 +19,22 @@ function snapshotRoute(engineered) {
   return { url, title, route_kind };
 }
 function buildAmbientContext(state, conversationId) {
-  const auth = state.userAuth;
-  if (!auth?.id) return null;
-  const profile = state.userProfile?.userMetadata;
-  const name = profile?.fullName || profile?.name || profile?.preferredUsername || auth.email || "user";
+  const auth = selectChatIdentity(state);
+  if (!auth.userId) return null;
+  const name = auth.displayName || auth.name || auth.preferredUsername || auth.email || "user";
   const now = /* @__PURE__ */ new Date();
   const timezone = typeof Intl !== "undefined" ? Intl.DateTimeFormat().resolvedOptions().timeZone : "UTC";
   const locale = typeof navigator !== "undefined" && navigator.language ? navigator.language : "en-US";
   const snapshot = {
     user: {
-      id: auth.id,
+      id: auth.userId,
       name,
       email: auth.email ?? null,
       // ADMIN POWER, not identity: an agent on a user page must see an admin
       // exactly as it sees anyone else (utils/supabase/adminLane.ts).
-      is_admin: auth.adminLaneOpen === true && (auth.isAdmin ?? false),
-      admin_level: auth.adminLaneOpen === true ? auth.adminLevel ?? null : null
+      // The identity port's adminLevel is already what the host grants on this page.
+      is_admin: auth.adminLevel !== null,
+      admin_level: auth.adminLevel
     },
     client: {
       surface: "nextjs",

package/dist/host/app-data-slots.d.ts

@@ -76,7 +76,6 @@ export declare const useAnchorRecords: (anchor: {
     type: string;
     id: string;
 } | null, enabled?: boolean) => AnchorRecordsState;
-/** A host with no shape catalog has no shapes to browse: the read says so, the picker shows it. */
 export declare const fetchShapePage: (query: EntityListQuery, sort: EntityListSort) => Promise<EntityListPage<ShapeBrowseRow>>;
 export declare const fetchShapeByKind: (kind: string) => Promise<ShapeBrowseRow | null>;
 /** A host with no Source Inspector opens a web source in a new tab; a file source has no target here. */

package/dist/host/app-data-slots.js

@@ -1,4 +1,6 @@
 import { hostFn, hostSlot } from "./ui-slots.js";
+import { listOrgParam } from "@ai-matrx/records/list";
+import { supabase } from "./db.js";
 const CONVERSATION_ANCHOR_TYPE = "conversation";
 const contentIrKindValidator = hostFn("contentIrKindValidator", () => ({
   validate: async (_value, kind) => ({
@@ -20,11 +22,29 @@ const useAnchorRecords = hostFn("useAnchorRecords", () => ({
   message: null,
   reload: () => void 0
 }));
-const fetchShapePage = hostFn("fetchShapePage", async () => {
-  throw new Error("This host has no shape catalog (registerChatUi fetchShapePage)");
-});
-const fetchShapeByKind = hostFn("fetchShapeByKind", async () => {
-  throw new Error("This host has no shape catalog (registerChatUi fetchShapeByKind)");
+async function readShapePage(query, sort) {
+  const { data, error } = await supabase.rpc("shx_list_scoped", {
+    p_scope: query.scope.kind,
+    p_org_id: listOrgParam(query),
+    p_search: query.search.trim() || void 0,
+    p_deep: query.deep,
+    p_sort: sort.sort,
+    p_dir: sort.direction,
+    p_filters: query.filters,
+    p_limit: sort.pageSize,
+    p_offset: (query.page - 1) * sort.pageSize
+  });
+  if (error) throw new Error(`Could not load the shapes: ${error.message ?? "the database returned an error with no message."}`);
+  const rows = data ?? [];
+  return { rows, total: rows.length > 0 ? Number(rows[0].total_count) : 0 };
+}
+const fetchShapePage = hostFn("fetchShapePage", readShapePage);
+const fetchShapeByKind = hostFn("fetchShapeByKind", async (kind) => {
+  const page = await readShapePage(
+    { scope: { kind: "all" }, orgId: null, search: "", deep: false, archived: "active", filters: { kind: { kind: "text", value: kind } }, page: 1 },
+    { sort: "label", direction: "asc", favoritesFirst: false, pageSize: 50 }
+  );
+  return page.rows.find((row) => row.kind === kind) ?? null;
 });
 const useOpenCitationSource = hostFn("useOpenCitationSource", () => (source) => {
   if (source.url && typeof window !== "undefined") window.open(source.url, "_blank", "noopener,noreferrer");

package/dist/host/bare-host-chrome.js

@@ -8,6 +8,8 @@ import { AgentCatalogProvider } from "@ai-matrx/agents/catalog/react";
 import { createModelCatalog, createModelFavorites } from "@ai-matrx/agents/models";
 import { ModelCatalogProvider } from "@ai-matrx/agents/models/react";
 import { hasChatScopes, registerChatScopes } from "../context/sources/scopes.js";
+import { configureBareFilesHost } from "./defaults/files-host.js";
+import { registerBareReadableBlocks } from "./defaults/bare-block-dispatch.js";
 const SAVE_REASON = "save this";
 function BareHostChrome({ host, children }) {
   const [associations] = useState(
@@ -33,6 +35,8 @@ function BareHostChrome({ host, children }) {
       });
     }
   });
+  useState(() => configureBareFilesHost(host));
+  useState(() => registerBareReadableBlocks());
   const [catalog] = useState(() => host.catalog());
   const [models] = useState(() => ({
     catalog: createModelCatalog({ client: host.db }),

package/dist/host/contract.d.ts

@@ -18,6 +18,7 @@
 import type { SupabaseClient } from "@supabase/supabase-js";
 import type { AnchorHTMLAttributes, ComponentType, ReactNode, Ref } from "react";
 import type { AgentCatalog } from "@ai-matrx/agents/catalog";
+import type { AnyMandateKey } from "@ai-matrx/agents/mandates";
 import type { ChatDatabase } from "./db-types.js";
 import type { ChatWindowId } from "./windows.js";
 import type { CanvasJson } from "@ai-matrx/canvas";
@@ -38,7 +39,7 @@ export type ChatDb = SupabaseClient<ChatDatabase>;
  * (migrations/log_client_error_names_the_feature_too.sql). A value outside it
  * makes the database refuse the row, so the diagnostics default checks it first.
  */
-export declare const CHAT_SOURCE_APPS: readonly ["matrx-frontend", "matrx-extend", "matrx-local", "matrx-mobile"];
+export declare const CHAT_SOURCE_APPS: readonly ["matrx-frontend", "matrx-extend", "matrx-local", "matrx-mobile", "workflow-studio"];
 export type ChatSourceApp = (typeof CHAT_SOURCE_APPS)[number];
 export type ChatAdminLevel = "developer" | "senior_admin" | "super_admin";
 export interface ChatIdentity {
@@ -730,7 +731,12 @@ export interface ChatAppIdentity {
     /** `chat.conversation.source_app` — a producer registered with the server. */
     sourceApp: string;
     /** `source_feature` for every conversation this app starts; absent keeps each screen's own. */
-    sourceFeature?: string;
+    sourceFeature?: string; /**
+     * The mandate that answers this app's new-chat screen and agentless conversations (Matrx Local:
+     * `local.cloud_chat`; Matrx Extend: `extend.browser_chat`). Which agent runs is the database's
+     * answer for that key, never the host's. Absent: `chat.default_new_chat`, as on the web.
+     */
+    defaultChatMandateKey?: AnyMandateKey;
 }
 /**
  * Where each conversation's text may go (lanes/agents-chat-proposal.md W0(a)). The package enforces

package/dist/host/contract.js

@@ -2,7 +2,8 @@ const CHAT_SOURCE_APPS = [
   "matrx-frontend",
   "matrx-extend",
   "matrx-local",
-  "matrx-mobile"
+  "matrx-mobile",
+  "workflow-studio"
 ];
 export {
   CHAT_SOURCE_APPS

package/dist/host/conversation-hooks-react.d.ts

@@ -0,0 +1,2 @@
+/** The sentence holding this conversation's composer (host/conversation-hooks `held`), or null. */
+export declare function useConversationHeld(conversationId: string | null | undefined): string | null;

package/dist/host/conversation-hooks-react.js

@@ -0,0 +1,12 @@
+import { useSyncExternalStore } from "react";
+import { readConversationHeld, subscribeConversationHeld } from "./conversation-hooks.js";
+function useConversationHeld(conversationId) {
+  return useSyncExternalStore(
+    (listener) => subscribeConversationHeld(conversationId, listener),
+    () => readConversationHeld(conversationId),
+    () => null
+  );
+}
+export {
+  useConversationHeld
+};

package/dist/host/conversation-hooks.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Per-conversation host hooks (HOST-OWNED-SOURCE-PLAN §2.6, slice P28f).
+ *
+ * A database-backed host (the workflow studio) runs its conversations through
+ * the package's own doors — the mandate route, the real list, the real
+ * composer — and only adds what is truly its own, per conversation:
+ *
+ *   beforeSend         the pre-send gate. Runs before admission; returns the
+ *                      turn's `variables` + `context`, or refuses with the
+ *                      host's sentence (the words go back in the box).
+ *   held               a sentence that holds the composer ("a change is
+ *                      waiting for you on the canvas"); null = not held.
+ *   onEvent            the stream-event tap: every event of every turn on this
+ *                      conversation, once, in order, after the package applied
+ *                      it. Must not throw (a throw is reported and swallowed).
+ *   startConversation  the host names the next conversation's id; the client
+ *                      never mints one.
+ *   everyTurnThroughMandate
+ *                      every turn (not only turn 1) POSTs the mandate route,
+ *                      with the gate's variables + context — for a mandate
+ *                      whose provision checks guaranteed values on every turn.
+ *
+ * Kept OUT of Redux on purpose: these are functions and subscriptions owned by
+ * a mounted host surface, registered on mount and released on unmount.
+ */
+import type { TypedStreamEvent } from "@ai-matrx/agents/generated/stream-events";
+import { HostSendRefused } from "./source.js";
+export interface HostTurnExtras {
+    variables?: Record<string, unknown>;
+    context?: Record<string, unknown>;
+}
+export interface HostBeforeSendInput {
+    conversationId: string;
+    text: string;
+}
+export interface HostHeld {
+    get(): string | null;
+    subscribe(listener: () => void): () => void;
+}
+export interface HostStreamTapContext {
+    conversationId: string;
+    requestId: string;
+}
+export interface ConversationHostHooks {
+    beforeSend?: (input: HostBeforeSendInput) => Promise<HostTurnExtras | HostSendRefused>;
+    held?: HostHeld;
+    onEvent?: (event: TypedStreamEvent, ctx: HostStreamTapContext) => void;
+    startConversation?: () => Promise<string>;
+    everyTurnThroughMandate?: boolean;
+    /** How a stored user turn reads on screen (display only; the record is unchanged). */
+    displayUserText?: (text: string) => string;
+}
+/** Register a conversation's hooks. Returns the release; a newer registration for the same id wins. */
+export declare function registerConversationHooks(conversationId: string, hooks: ConversationHostHooks): () => void;
+export declare function getConversationHooks(conversationId: string): ConversationHostHooks | undefined;
+export type BeforeSendOutcome = {
+    ok: true;
+} | {
+    ok: false;
+    sentence: string;
+};
+/**
+ * Run the conversation's pre-send gate. A conversation with no gate passes.
+ * A held conversation is refused with the held sentence. The gate's extras are
+ * kept for the request this turn assembles (`takeTurnExtras`).
+ */
+export declare function runBeforeSend(conversationId: string, text: string): Promise<BeforeSendOutcome>;
+/** The extras the gate returned for this turn; consumed once. */
+export declare function takeTurnExtras(conversationId: string): HostTurnExtras | null;
+/** Hand one stream event to the conversation's tap. Never throws. */
+export declare function tapStreamEvent(conversationId: string, requestId: string, event: unknown): void;
+/** Should this conversation's later turns also POST the mandate route? */
+export declare function continuesThroughMandate(conversationId: string): boolean;
+/** Ask the conversation's host for the next conversation id; null when it has no say. */
+export declare function startHostConversation(conversationId: string): Promise<string | null>;
+/** Subscribe to changes of this conversation's held sentence (registry + the host's own source). */
+export declare function subscribeConversationHeld(conversationId: string | null | undefined, listener: () => void): () => void;
+/** The held sentence right now, or null. */
+export declare function readConversationHeld(conversationId: string | null | undefined): string | null;

package/dist/host/conversation-hooks.js

@@ -0,0 +1,91 @@
+import { isHostSendRefused } from "./source.js";
+const hooksByConversation = /* @__PURE__ */ new Map();
+const extrasByConversation = /* @__PURE__ */ new Map();
+const registryListeners = /* @__PURE__ */ new Set();
+function notifyRegistry() {
+  for (const listener of registryListeners) listener();
+}
+function registerConversationHooks(conversationId, hooks) {
+  hooksByConversation.set(conversationId, hooks);
+  notifyRegistry();
+  return () => {
+    if (hooksByConversation.get(conversationId) === hooks) {
+      hooksByConversation.delete(conversationId);
+      extrasByConversation.delete(conversationId);
+      notifyRegistry();
+    }
+  };
+}
+function getConversationHooks(conversationId) {
+  return hooksByConversation.get(conversationId);
+}
+async function runBeforeSend(conversationId, text) {
+  const hooks = hooksByConversation.get(conversationId);
+  if (!hooks) return { ok: true };
+  const heldSentence = hooks.held?.get() ?? null;
+  if (heldSentence) return { ok: false, sentence: heldSentence };
+  if (!hooks.beforeSend) return { ok: true };
+  try {
+    const result = await hooks.beforeSend({ conversationId, text });
+    if (isHostSendRefused(result)) return { ok: false, sentence: result.message };
+    extrasByConversation.set(conversationId, result ?? {});
+    return { ok: true };
+  } catch (error) {
+    if (isHostSendRefused(error)) return { ok: false, sentence: error.message };
+    const message = error instanceof Error ? error.message : String(error);
+    return { ok: false, sentence: message || "This message could not be prepared. Nothing was sent." };
+  }
+}
+function takeTurnExtras(conversationId) {
+  const extras = extrasByConversation.get(conversationId) ?? null;
+  extrasByConversation.delete(conversationId);
+  return extras;
+}
+function tapStreamEvent(conversationId, requestId, event) {
+  const tap = hooksByConversation.get(conversationId)?.onEvent;
+  if (!tap) return;
+  try {
+    tap(event, { conversationId, requestId });
+  } catch (error) {
+    console.error(`[chat] the host's stream tap threw on conversation "${conversationId}"`, error);
+  }
+}
+function continuesThroughMandate(conversationId) {
+  return hooksByConversation.get(conversationId)?.everyTurnThroughMandate === true;
+}
+async function startHostConversation(conversationId) {
+  const start = hooksByConversation.get(conversationId)?.startConversation;
+  return start ? start() : null;
+}
+function subscribeConversationHeld(conversationId, listener) {
+  let release = subscribeOnce(conversationId, onChange);
+  function onChange() {
+    release();
+    release = subscribeOnce(conversationId, onChange);
+    listener();
+  }
+  return () => release();
+}
+function subscribeOnce(conversationId, listener) {
+  registryListeners.add(listener);
+  const held = conversationId ? hooksByConversation.get(conversationId)?.held : void 0;
+  const releaseHeld = held?.subscribe(listener);
+  return () => {
+    registryListeners.delete(listener);
+    releaseHeld?.();
+  };
+}
+function readConversationHeld(conversationId) {
+  return conversationId ? hooksByConversation.get(conversationId)?.held?.get() ?? null : null;
+}
+export {
+  continuesThroughMandate,
+  getConversationHooks,
+  readConversationHeld,
+  registerConversationHooks,
+  runBeforeSend,
+  startHostConversation,
+  subscribeConversationHeld,
+  takeTurnExtras,
+  tapStreamEvent
+};

package/dist/host/defaults/bare-block-dispatch.d.ts

@@ -0,0 +1,6 @@
+/** The block types the bare host gives a readable fallback (the app's cards replace them). */
+export declare const BARE_READABLE_BLOCK_TYPES: readonly ["decision", "artifact", "matrx", "input_remarks", "decision_questions", "decision_answers", "speech_script", "directive_receipt"];
+/** Markup → readable markdown: options become a list, every other tag is dropped, its text kept. */
+export declare function readableMarkup(content: string): string;
+/** Register the readable fallback for each type no host registered (idempotent). */
+export declare function registerBareReadableBlocks(): void;

package/dist/host/defaults/bare-block-dispatch.js

@@ -0,0 +1,60 @@
+"use client";
+import {
+  registerBlockDispatch,
+  resolveBlockDispatch
+} from "@ai-matrx/rich-content/display/chat-markdown/block-registry/block-dispatch";
+const BARE_READABLE_BLOCK_TYPES = [
+  "decision",
+  "artifact",
+  "matrx",
+  "input_remarks",
+  "decision_questions",
+  "decision_answers",
+  "speech_script",
+  "directive_receipt"
+];
+function attr(tag, name) {
+  return tag.match(new RegExp(`${name}\\s*=\\s*"([^"]*)"`, "i"))?.[1] ?? null;
+}
+function readableMarkup(content) {
+  return content.replace(/<option\b([^>]*)>([\s\S]*?)<\/option>/gi, (_m, attrs, text) => {
+    const label = attr(attrs, "label");
+    const body = text.trim();
+    return `
+- ${label && body && label !== body ? `**${label}** ${body}` : label || body}`;
+  }).replace(/<option\b([^>]*)\/>/gi, (_m, attrs) => `
+- ${attr(attrs, "label") ?? ""}`).replace(/<\/?[a-z_][\w:.-]*(?:\s[^>]*)?\/?>/gi, "").replace(/\n{3,}/g, "\n\n").trim();
+}
+function asJsonFence(value) {
+  return "```json\n" + JSON.stringify(value, null, 2) + "\n```";
+}
+function readable(ctx) {
+  const { block } = ctx;
+  const content = typeof block.content === "string" ? block.content : "";
+  const meta = block.metadata ?? {};
+  if (block.type === "matrx") {
+    try {
+      return ctx.renderBasicMarkdown(asJsonFence(JSON.parse(content)));
+    } catch {
+      return ctx.renderBasicMarkdown("```\n" + content + "\n```");
+    }
+  }
+  const title = typeof meta.artifactTitle === "string" ? `**${meta.artifactTitle}**
+
+` : "";
+  const text = readableMarkup(content);
+  if (text) return ctx.renderBasicMarkdown(title + text);
+  if (block.serverData !== void 0 && block.serverData !== null) return ctx.renderBasicMarkdown(title + asJsonFence(block.serverData));
+  return ctx.renderBasicMarkdown(title);
+}
+const READABLE = (ctx) => readable(ctx);
+function registerBareReadableBlocks() {
+  const missing = {};
+  for (const type of BARE_READABLE_BLOCK_TYPES) if (!resolveBlockDispatch(type)) missing[type] = READABLE;
+  if (Object.keys(missing).length) registerBlockDispatch(missing);
+}
+export {
+  BARE_READABLE_BLOCK_TYPES,
+  readableMarkup,
+  registerBareReadableBlocks
+};

package/dist/host/defaults/files-host.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The files engine's host for a bare chat host (P29a finding 3): a host that gave chat only a db
+ * still uploads attachments. `BareHostChrome` configures `@ai-matrx/media`'s files engine ONCE with
+ * the chat host's db, its server port (bearer + organization headers), the chat store (which mounts
+ * the `cloudFiles` slice) and its organization/identity/notify ports. A host that configured the
+ * engine itself (matrx-frontend: `features/files/files-host.ts`) is never overridden.
+ */
+import { type FilesServerClient, type FilesShareLinks } from "@ai-matrx/media/files/engine/host/configure";
+import type { ResolvedChatHost } from "../contract.js";
+/** The standalone files service (`matrx-files`): the routes it owns go there, everything else to the chat server. */
+export declare const DEFAULT_FILES_SERVICE_URL = "https://files.matrxserver.com";
+export declare function isFilesServiceRoute(path: string, method?: string): boolean;
+/** A failed call, carrying the status and the server's own words. */
+export declare class FilesRequestError extends Error {
+    readonly status: number | null;
+    readonly code: string;
+    readonly userMessage: string;
+    constructor(status: number | null, message: string, code?: string);
+}
+export declare function createDefaultFilesServer(host: () => ResolvedChatHost): FilesServerClient;
+/** Where a share link opens (the platform's own `/s/<token>` page). */
+export declare const DEFAULT_SHARE_LINK_ORIGIN = "https://aimatrx.com";
+/** Share links through the platform's own RPCs over the host's db (an attachment upload mints one). */
+export declare function createDefaultShareLinks(host: () => ResolvedChatHost): FilesShareLinks;
+/** Wire the files engine to a bare chat host, unless the host (or a test) already did. */
+export declare function configureBareFilesHost(host: ResolvedChatHost): void;