@ai-matrx/chat 0.3.33 → 0.4.2

package/dist/agents/redux/execution-system/host-conversations/host-conversations.selectors.d.ts

@@ -0,0 +1,28 @@
+/**
+ * The two reads every door and control makes (HOST-OWNED-SOURCE-PLAN §2.3):
+ *
+ *  - `selectHostConversation(id)` — is this conversation carried by a host-owned
+ *    source? Every db-touching thunk reachable from the conversation column
+ *    branches on it FIRST (guard: scripts/check-host-source-doors.mjs).
+ *  - `selectConversationAbilities(id)` — (host has a db) × (source handlers
+ *    present). Every db-backed control reads it and is ABSENT, never dead.
+ */
+import type { ChatRootState } from "../../../../store/root-state.js";
+import type { HostConversationEntry } from "./host-conversations.slice.js";
+export declare function selectHostConversation(conversationId: string | null | undefined): (state: ChatRootState) => HostConversationEntry | null;
+/** Non-curried form for thunks. */
+export declare function isHostConversation(state: ChatRootState, conversationId: string): boolean;
+export interface ConversationAbilities {
+    /** Carried by a host-owned source. */
+    hosted: boolean;
+    /** Edit, fork, delete, pins, flags, annotations, share, pickers, attachments, history rows. */
+    database: boolean;
+    send: boolean;
+    stop: boolean;
+    retry: boolean;
+    answer: boolean;
+    whileBusy: "queue" | "steer" | "refuse";
+}
+/** A database-backed conversation: everything present. */
+export declare const FULL_CONVERSATION_ABILITIES: ConversationAbilities;
+export declare function selectConversationAbilities(conversationId: string | null | undefined): (state: ChatRootState) => ConversationAbilities;

package/dist/agents/redux/execution-system/host-conversations/host-conversations.selectors.js

@@ -0,0 +1,41 @@
+function selectHostConversation(conversationId) {
+  return (state) => (conversationId ? state.hostConversations?.byConversationId[conversationId] : void 0) ?? null;
+}
+function isHostConversation(state, conversationId) {
+  return selectHostConversation(conversationId)(state) !== null;
+}
+const FULL_CONVERSATION_ABILITIES = Object.freeze({
+  hosted: false,
+  database: true,
+  send: true,
+  stop: true,
+  retry: true,
+  answer: true,
+  whileBusy: "queue"
+});
+const cache = /* @__PURE__ */ new WeakMap();
+function selectConversationAbilities(conversationId) {
+  return (state) => {
+    const entry = selectHostConversation(conversationId)(state);
+    if (!entry) return FULL_CONVERSATION_ABILITIES;
+    const hit = cache.get(entry);
+    if (hit) return hit;
+    const abilities = Object.freeze({
+      hosted: true,
+      database: entry.database,
+      send: entry.canSend,
+      stop: entry.canStop,
+      retry: entry.canRetry,
+      answer: entry.canAnswer,
+      whileBusy: entry.whileBusy
+    });
+    cache.set(entry, abilities);
+    return abilities;
+  };
+}
+export {
+  FULL_CONVERSATION_ABILITIES,
+  isHostConversation,
+  selectConversationAbilities,
+  selectHostConversation
+};

package/dist/agents/redux/execution-system/host-conversations/host-conversations.slice.d.ts

@@ -0,0 +1,43 @@
+/**
+ * hostConversations — which conversations a host-owned message source carries
+ * (HOST-OWNED-SOURCE-PLAN §2.3, P28a).
+ *
+ * Plain data only: the source itself (functions) lives in the non-Redux
+ * registry beside this file (`source-registry.ts`), like `abort-registry.ts`.
+ * What is here is what selectors need: which source, what it can do (capability
+ * by presence), whether its conversations are saved and where, and the
+ * composer's held sentence.
+ */
+import type { HostPersistence } from "../../../../host/source.js";
+export interface HostConversationEntry {
+    sourceId: string;
+    whileBusy: "queue" | "steer" | "refuse";
+    persistence: HostPersistence;
+    /** The host's sentence while the composer waits; null when it does not. */
+    held: string | null;
+    /** The host's sentence when its history could not be read. */
+    unavailable: string | null;
+    /** Does the host ALSO have a database (both given)? */
+    database: boolean;
+    canSend: boolean;
+    canStop: boolean;
+    canRetry: boolean;
+    canAnswer: boolean;
+    hasConversationList: boolean;
+}
+export interface HostConversationsState {
+    byConversationId: Record<string, HostConversationEntry>;
+}
+export declare const hostConversationBound: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    conversationId: string;
+    entry: HostConversationEntry;
+}, "hostConversations/hostConversationBound">, hostConversationUnbound: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "hostConversations/hostConversationUnbound">, hostConversationHeld: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    conversationId: string;
+    reason: string | null;
+}, "hostConversations/hostConversationHeld">, hostConversationUnavailable: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    conversationId: string;
+    reason: string | null;
+}, "hostConversations/hostConversationUnavailable">;
+export declare const hostConversationsReducer: import("redux").Reducer<HostConversationsState>;
+declare const _default: import("redux").Reducer<HostConversationsState>;
+export default _default;

package/dist/agents/redux/execution-system/host-conversations/host-conversations.slice.js

@@ -0,0 +1,38 @@
+import { createSlice } from "@reduxjs/toolkit";
+const initialState = { byConversationId: {} };
+const hostConversationsSlice = createSlice({
+  name: "hostConversations",
+  initialState,
+  reducers: {
+    hostConversationBound(state, action) {
+      state.byConversationId[action.payload.conversationId] = action.payload.entry;
+    },
+    hostConversationUnbound(state, action) {
+      delete state.byConversationId[action.payload];
+    },
+    hostConversationHeld(state, action) {
+      const entry = state.byConversationId[action.payload.conversationId];
+      if (entry) entry.held = action.payload.reason;
+    },
+    hostConversationUnavailable(state, action) {
+      const entry = state.byConversationId[action.payload.conversationId];
+      if (entry) entry.unavailable = action.payload.reason;
+    }
+  }
+});
+const {
+  hostConversationBound,
+  hostConversationUnbound,
+  hostConversationHeld,
+  hostConversationUnavailable
+} = hostConversationsSlice.actions;
+const hostConversationsReducer = hostConversationsSlice.reducer;
+var host_conversations_slice_default = hostConversationsSlice.reducer;
+export {
+  host_conversations_slice_default as default,
+  hostConversationBound,
+  hostConversationHeld,
+  hostConversationUnavailable,
+  hostConversationUnbound,
+  hostConversationsReducer
+};

package/dist/agents/redux/execution-system/host-conversations/source-registry.d.ts

@@ -0,0 +1,9 @@
+/**
+ * conversationId → the host-owned message source carrying it. Functions stay
+ * out of Redux state (the same reason `abort-registry.ts` exists); the
+ * `hostConversations` slice holds the plain-data half.
+ */
+import type { ChatMessageSource } from "../../../../host/source.js";
+export declare function registerHostSource(conversationId: string, source: ChatMessageSource): void;
+export declare function unregisterHostSource(conversationId: string, source?: ChatMessageSource): void;
+export declare function getHostSource(conversationId: string): ChatMessageSource | null;

package/dist/agents/redux/execution-system/host-conversations/source-registry.js

@@ -0,0 +1,15 @@
+const sources = /* @__PURE__ */ new Map();
+function registerHostSource(conversationId, source) {
+  sources.set(conversationId, source);
+}
+function unregisterHostSource(conversationId, source) {
+  if (!source || sources.get(conversationId) === source) sources.delete(conversationId);
+}
+function getHostSource(conversationId) {
+  return sources.get(conversationId) ?? null;
+}
+export {
+  getHostSource,
+  registerHostSource,
+  unregisterHostSource
+};

package/dist/agents/redux/execution-system/host-conversations/useHostConversation.d.ts

@@ -0,0 +1,4 @@
+import type { ChatMessageSource } from "../../../../host/source.js";
+export declare function useHostConversation(source: ChatMessageSource | null | undefined, conversationId: string | null | undefined, options?: {
+    surfaceKey?: string;
+}): void;

package/dist/agents/redux/execution-system/host-conversations/useHostConversation.js

@@ -0,0 +1,24 @@
+"use client";
+import { useEffect } from "react";
+import { useAppDispatch, useAppStore } from "../../../../store/hooks.js";
+import { useChatHost } from "../../../../host/react.js";
+import { bindHostConversation } from "./host-conversation.thunks.js";
+function useHostConversation(source, conversationId, options = {}) {
+  const dispatch = useAppDispatch();
+  const store = useAppStore();
+  const host = useChatHost();
+  const bound = source ?? host.source;
+  const { surfaceKey } = options;
+  useEffect(() => {
+    if (!bound || !conversationId) return;
+    return bindHostConversation(dispatch, () => store.getState(), {
+      conversationId,
+      source: bound,
+      database: host.hasDatabase,
+      surfaceKey
+    });
+  }, [bound, conversationId, dispatch, store, host.hasDatabase, surfaceKey]);
+}
+export {
+  useHostConversation
+};

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

@@ -42,8 +42,8 @@ export declare const selectInstanceContextEntries: (conversationId: string) => (
     proposedDirectives: import("../../proposed-directives/proposedDirectivesSlice.js").ProposedDirectivesState;
     agentSettings: import("../../agent-settings/types.js").AgentSettingsState;
     conversationAttachments: import("../../../connectors/attachments.slice.js").AttachmentsSliceState;
-    modelRegistry: import("../../../model-registry/modelRegistrySlice.js").ModelRegistryState;
     chatHost: import("../../../../store/chat-host.slice.js").ChatHostState;
+    hostConversations: import("../host-conversations/host-conversations.slice.js").HostConversationsState;
 } & import("../../../../store/root-state.js").ChatHostReadSlices) => InstanceContextEntry[]) & {
     clearCache: () => void;
     resultsCount: () => number;
@@ -111,8 +111,8 @@ export declare const selectSlotMatchedContext: (conversationId: string) => ((sta
     proposedDirectives: import("../../proposed-directives/proposedDirectivesSlice.js").ProposedDirectivesState;
     agentSettings: import("../../agent-settings/types.js").AgentSettingsState;
     conversationAttachments: import("../../../connectors/attachments.slice.js").AttachmentsSliceState;
-    modelRegistry: import("../../../model-registry/modelRegistrySlice.js").ModelRegistryState;
     chatHost: import("../../../../store/chat-host.slice.js").ChatHostState;
+    hostConversations: import("../host-conversations/host-conversations.slice.js").HostConversationsState;
 } & import("../../../../store/root-state.js").ChatHostReadSlices) => InstanceContextEntry[]) & {
     clearCache: () => void;
     resultsCount: () => number;
@@ -179,8 +179,8 @@ export declare const selectAdHocContext: (conversationId: string) => ((state: {
     proposedDirectives: import("../../proposed-directives/proposedDirectivesSlice.js").ProposedDirectivesState;
     agentSettings: import("../../agent-settings/types.js").AgentSettingsState;
     conversationAttachments: import("../../../connectors/attachments.slice.js").AttachmentsSliceState;
-    modelRegistry: import("../../../model-registry/modelRegistrySlice.js").ModelRegistryState;
     chatHost: import("../../../../store/chat-host.slice.js").ChatHostState;
+    hostConversations: import("../host-conversations/host-conversations.slice.js").HostConversationsState;
 } & import("../../../../store/root-state.js").ChatHostReadSlices) => InstanceContextEntry[]) & {
     clearCache: () => void;
     resultsCount: () => number;

package/dist/agents/redux/execution-system/instance-resources/default-remark-durability.d.ts

@@ -0,0 +1,22 @@
+/**
+ * default-remark-durability — how a bare host keeps UNSENT chips (a comment, an edit, a choice)
+ * server-side, so they survive a reload and ride the next send.
+ *
+ * The same table and doors the main frontend's richer port uses: `platform.block_states`, kind
+ * `remark`, block key `remark:<chip key>`, through `block_state_set` / `block_state_list_staged` /
+ * `block_state_dismiss_chip` over `host.db`. A chip is due by the server's rule
+ * (state_version > sent_version, not dismissed at that version) and carries `blockStateRef` so the
+ * server marks it sent with the message. A chip belongs to the conversation it was staged into.
+ * Registered by `<ChatProvider>` for a private store when the host registered no port of its own.
+ * Not in this default: the live feed from another tab (the next mount lists again).
+ */
+import type { ChatDb } from "../../../../host/contract.js";
+import type { ChatDispatch } from "../../../../store/root-state.js";
+import { type RemarkDurability } from "./remarks.js";
+export interface DefaultRemarkDurabilityOptions {
+    db: ChatDb;
+    dispatch: ChatDispatch;
+    /** A write that failed: say so (the host's notify + console). */
+    onFailure: (message: string, error: unknown) => void;
+}
+export declare function createDbRemarkDurability({ db, dispatch, onFailure }: DefaultRemarkDurabilityOptions): RemarkDurability;

package/dist/agents/redux/execution-system/instance-resources/default-remark-durability.js

@@ -0,0 +1,164 @@
+import { durableRecordId } from "@ai-matrx/kit/ids";
+import {
+  attachRemarkRef,
+  readStoredRemarks,
+  restageRemarks,
+  unstageRemark
+} from "./remarks.js";
+const DEBOUNCE_MS = 800;
+function rowOf(value) {
+  if (!value || typeof value !== "object") return null;
+  const r = value;
+  if (typeof r.id !== "string" || typeof r.state_version !== "number") return null;
+  return {
+    id: r.id,
+    kind: String(r.kind ?? ""),
+    state_version: r.state_version,
+    sent_version: typeof r.sent_version === "number" ? r.sent_version : 0,
+    state: r.state && typeof r.state === "object" ? r.state : {},
+    metadata: r.metadata && typeof r.metadata === "object" ? r.metadata : null
+  };
+}
+function isDue(row) {
+  if (row.state_version <= row.sent_version) return false;
+  const dismissed = row.metadata?.chip_dismissed_version;
+  return !(typeof dismissed === "number" && dismissed >= row.state_version);
+}
+function entityOf(item) {
+  const messageId = durableRecordId(item.target.messageId);
+  if (messageId) return { entityType: "message", entityId: messageId };
+  const record = item.target.record;
+  if (record?.token && record.id) return { entityType: record.token, entityId: record.id };
+  return null;
+}
+function stripRef(item) {
+  const { blockStateRef: _ref, ...rest } = item;
+  return rest;
+}
+function createDbRemarkDurability({ db, dispatch, onFailure }) {
+  const rpc = (name, args) => db.rpc(name, args);
+  const slots = /* @__PURE__ */ new Map();
+  const restored = /* @__PURE__ */ new Set();
+  const restoring = /* @__PURE__ */ new Set();
+  const idOf = (conversationId, key) => `${conversationId}\0${key}`;
+  const slotFor = (conversationId, key) => {
+    const id = idOf(conversationId, key);
+    let slot = slots.get(id);
+    if (!slot) {
+      slot = { timer: null, chain: Promise.resolve(), inFlight: 0, rowId: null, latest: null };
+      slots.set(id, slot);
+    }
+    return slot;
+  };
+  const slotsOf = (conversationId) => [...slots.entries()].filter(([id]) => id.startsWith(`${conversationId}\0`));
+  const write = (conversationId, key, slot) => {
+    const latest = slot.latest;
+    if (!latest) return;
+    const entity = entityOf(latest.item);
+    if (!entity) {
+      console.warn("[remarks] a chip with no answer or record to belong to is not kept:", key);
+      return;
+    }
+    slot.inFlight += 1;
+    slot.chain = slot.chain.then(async () => {
+      try {
+        const { data, error } = await rpc("block_state_set", {
+          p_entity_type: entity.entityType,
+          p_entity_id: entity.entityId,
+          p_block_key: `remark:${key}`,
+          p_kind: "remark",
+          p_scope: "viewer",
+          p_patch: {
+            remark: stripRef(latest.item),
+            coalesceKey: latest.coalesceKey,
+            stagedIn: latest.conversationId,
+            resourceId: latest.resourceId
+          },
+          p_client_request_id: crypto.randomUUID()
+        });
+        const row = error ? null : rowOf(data);
+        if (!row) throw new Error(error?.message ?? "The server returned no saved state.");
+        slot.rowId = row.id;
+        dispatch(attachRemarkRef(latest.conversationId, latest.resourceId, { id: row.id, stateVersion: row.state_version }));
+      } catch (error) {
+        onFailure("Your note on this answer is not saved. Try again.", error);
+      } finally {
+        slot.inFlight -= 1;
+      }
+    });
+  };
+  return {
+    save(conversationId, resourceId, coalesceKey, item) {
+      const key = coalesceKey ?? resourceId;
+      const slot = slotFor(conversationId, key);
+      slot.latest = { conversationId, resourceId, coalesceKey, item };
+      if (slot.timer) clearTimeout(slot.timer);
+      slot.timer = setTimeout(() => {
+        slot.timer = null;
+        write(conversationId, key, slot);
+      }, DEBOUNCE_MS);
+    },
+    retire(conversationId, resourceId, coalesceKey, item) {
+      const slot = slotFor(conversationId, coalesceKey ?? resourceId);
+      if (slot.timer) {
+        clearTimeout(slot.timer);
+        slot.timer = null;
+      }
+      slot.latest = null;
+      slot.chain = slot.chain.then(async () => {
+        const rowId = slot.rowId ?? item.blockStateRef?.id ?? null;
+        if (!rowId) return;
+        const { error } = await rpc("block_state_dismiss_chip", { p_id: rowId });
+        if (error) onFailure("Your note on this answer is not saved. Try again.", error);
+      });
+    },
+    hasPending(conversationId) {
+      return slotsOf(conversationId).some(([, slot]) => slot.timer !== null || slot.inFlight > 0);
+    },
+    async flush(conversationId) {
+      for (const [id, slot] of slotsOf(conversationId)) {
+        if (!slot.timer) continue;
+        clearTimeout(slot.timer);
+        slot.timer = null;
+        write(conversationId, id.slice(conversationId.length + 1), slot);
+      }
+      await Promise.all(slotsOf(conversationId).map(([, slot]) => slot.chain));
+    },
+    restore(conversationId) {
+      if (restored.has(conversationId) || restoring.has(conversationId)) return;
+      restoring.add(conversationId);
+      void (async () => {
+        try {
+          const { data, error } = await rpc("block_state_list_staged", { p_conversation_id: conversationId });
+          if (error) throw new Error(error.message);
+          restored.add(conversationId);
+          const rows = (Array.isArray(data) ? data : []).flatMap((entry) => {
+            const row = rowOf(entry);
+            return row ? [row] : [];
+          });
+          const mine = rows.filter((r) => r.kind === "remark" && r.state.stagedIn === conversationId && r.state.remark && typeof r.state.remark === "object");
+          for (const r of mine) {
+            if (!isDue(r) && typeof r.state.coalesceKey === "string") {
+              dispatch(unstageRemark(conversationId, r.state.coalesceKey, { retire: false }));
+            }
+          }
+          const stored = readStoredRemarks(
+            mine.filter(isDue).map((r) => ({
+              resourceId: typeof r.state.resourceId === "string" ? r.state.resourceId : r.id,
+              coalesceKey: typeof r.state.coalesceKey === "string" ? r.state.coalesceKey : null,
+              item: { ...r.state.remark, blockStateRef: { id: r.id, stateVersion: r.state_version } }
+            }))
+          );
+          if (stored.length > 0) dispatch(restageRemarks(conversationId, stored));
+        } catch (error) {
+          console.error("[remarks] restoring unsent chips failed:", error);
+        } finally {
+          restoring.delete(conversationId);
+        }
+      })();
+    }
+  };
+}
+export {
+  createDbRemarkDurability
+};

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

@@ -67,8 +67,8 @@ export declare const selectInstanceResources: (conversationId: string) => ((stat
     proposedDirectives: import("../../proposed-directives/proposedDirectivesSlice.js").ProposedDirectivesState;
     agentSettings: import("../../agent-settings/types.js").AgentSettingsState;
     conversationAttachments: import("../../../connectors/attachments.slice.js").AttachmentsSliceState;
-    modelRegistry: import("../../../model-registry/modelRegistrySlice.js").ModelRegistryState;
     chatHost: import("../../../../store/chat-host.slice.js").ChatHostState;
+    hostConversations: import("../host-conversations/host-conversations.slice.js").HostConversationsState;
 } & import("../../../../store/root-state.js").ChatHostReadSlices) => ManagedResource[]) & {
     clearCache: () => void;
     resultsCount: () => number;
@@ -148,8 +148,8 @@ export declare const selectReadyResources: (conversationId: string) => ((state:
     proposedDirectives: import("../../proposed-directives/proposedDirectivesSlice.js").ProposedDirectivesState;
     agentSettings: import("../../agent-settings/types.js").AgentSettingsState;
     conversationAttachments: import("../../../connectors/attachments.slice.js").AttachmentsSliceState;
-    modelRegistry: import("../../../model-registry/modelRegistrySlice.js").ModelRegistryState;
     chatHost: import("../../../../store/chat-host.slice.js").ChatHostState;
+    hostConversations: import("../host-conversations/host-conversations.slice.js").HostConversationsState;
 } & import("../../../../store/root-state.js").ChatHostReadSlices) => ManagedResource[]) & {
     clearCache: () => void;
     resultsCount: () => number;
@@ -216,8 +216,8 @@ export declare const selectPendingResources: (conversationId: string) => ((state
     proposedDirectives: import("../../proposed-directives/proposedDirectivesSlice.js").ProposedDirectivesState;
     agentSettings: import("../../agent-settings/types.js").AgentSettingsState;
     conversationAttachments: import("../../../connectors/attachments.slice.js").AttachmentsSliceState;
-    modelRegistry: import("../../../model-registry/modelRegistrySlice.js").ModelRegistryState;
     chatHost: import("../../../../store/chat-host.slice.js").ChatHostState;
+    hostConversations: import("../host-conversations/host-conversations.slice.js").HostConversationsState;
 } & import("../../../../store/root-state.js").ChatHostReadSlices) => ManagedResource[]) & {
     clearCache: () => void;
     resultsCount: () => number;
@@ -291,8 +291,8 @@ export declare const selectResourcePayloads: (conversationId: string) => ((state
     proposedDirectives: import("../../proposed-directives/proposedDirectivesSlice.js").ProposedDirectivesState;
     agentSettings: import("../../agent-settings/types.js").AgentSettingsState;
     conversationAttachments: import("../../../connectors/attachments.slice.js").AttachmentsSliceState;
-    modelRegistry: import("../../../model-registry/modelRegistrySlice.js").ModelRegistryState;
     chatHost: import("../../../../store/chat-host.slice.js").ChatHostState;
+    hostConversations: import("../host-conversations/host-conversations.slice.js").HostConversationsState;
 } & import("../../../../store/root-state.js").ChatHostReadSlices) => ({
     metadata?: {
         [key: string]: unknown;
@@ -1807,8 +1807,8 @@ export declare const selectResourceContextPayload: (conversationId: string) => (
     proposedDirectives: import("../../proposed-directives/proposedDirectivesSlice.js").ProposedDirectivesState;
     agentSettings: import("../../agent-settings/types.js").AgentSettingsState;
     conversationAttachments: import("../../../connectors/attachments.slice.js").AttachmentsSliceState;
-    modelRegistry: import("../../../model-registry/modelRegistrySlice.js").ModelRegistryState;
     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> | undefined) & {
     clearCache: () => void;
     resultsCount: () => number;
@@ -1877,8 +1877,8 @@ export declare const selectEditorResources: (conversationId: string) => ((state:
     proposedDirectives: import("../../proposed-directives/proposedDirectivesSlice.js").ProposedDirectivesState;
     agentSettings: import("../../agent-settings/types.js").AgentSettingsState;
     conversationAttachments: import("../../../connectors/attachments.slice.js").AttachmentsSliceState;
-    modelRegistry: import("../../../model-registry/modelRegistrySlice.js").ModelRegistryState;
     chatHost: import("../../../../store/chat-host.slice.js").ChatHostState;
+    hostConversations: import("../host-conversations/host-conversations.slice.js").HostConversationsState;
 } & import("../../../../store/root-state.js").ChatHostReadSlices) => ManagedResource[]) & {
     clearCache: () => void;
     resultsCount: () => number;
@@ -1946,8 +1946,8 @@ export declare const selectEditorResourceXml: (conversationId: string) => ((stat
     proposedDirectives: import("../../proposed-directives/proposedDirectivesSlice.js").ProposedDirectivesState;
     agentSettings: import("../../agent-settings/types.js").AgentSettingsState;
     conversationAttachments: import("../../../connectors/attachments.slice.js").AttachmentsSliceState;
-    modelRegistry: import("../../../model-registry/modelRegistrySlice.js").ModelRegistryState;
     chatHost: import("../../../../store/chat-host.slice.js").ChatHostState;
+    hostConversations: import("../host-conversations/host-conversations.slice.js").HostConversationsState;
 } & import("../../../../store/root-state.js").ChatHostReadSlices) => string) & {
     clearCache: () => void;
     resultsCount: () => number;
@@ -2002,8 +2002,8 @@ export declare const selectEditorResourceXml: (conversationId: string) => ((stat
         proposedDirectives: import("../../proposed-directives/proposedDirectivesSlice.js").ProposedDirectivesState;
         agentSettings: import("../../agent-settings/types.js").AgentSettingsState;
         conversationAttachments: import("../../../connectors/attachments.slice.js").AttachmentsSliceState;
-        modelRegistry: import("../../../model-registry/modelRegistrySlice.js").ModelRegistryState;
         chatHost: import("../../../../store/chat-host.slice.js").ChatHostState;
+        hostConversations: import("../host-conversations/host-conversations.slice.js").HostConversationsState;
     } & import("../../../../store/root-state.js").ChatHostReadSlices) => ManagedResource[]) & {
         clearCache: () => void;
         resultsCount: () => number;

package/dist/agents/redux/execution-system/instance-ui-state/instance-ui-state.selectors.d.ts

@@ -191,8 +191,8 @@ export declare const selectInstanceIdsByDisplayMode: (displayMode: ResultDisplay
     proposedDirectives: import("../../proposed-directives/proposedDirectivesSlice.js").ProposedDirectivesState;
     agentSettings: import("../../agent-settings/types.js").AgentSettingsState;
     conversationAttachments: import("../../../connectors/attachments.slice.js").AttachmentsSliceState;
-    modelRegistry: import("../../../model-registry/modelRegistrySlice.js").ModelRegistryState;
     chatHost: import("../../../../store/chat-host.slice.js").ChatHostState;
+    hostConversations: import("../host-conversations/host-conversations.slice.js").HostConversationsState;
 } & import("../../../../store/root-state.js").ChatHostReadSlices) => string[] | undefined) & {
     clearCache: () => void;
     resultsCount: () => number;
@@ -256,8 +256,8 @@ export declare const selectModalInstanceIds: ((state: {
     proposedDirectives: import("../../proposed-directives/proposedDirectivesSlice.js").ProposedDirectivesState;
     agentSettings: import("../../agent-settings/types.js").AgentSettingsState;
     conversationAttachments: import("../../../connectors/attachments.slice.js").AttachmentsSliceState;
-    modelRegistry: import("../../../model-registry/modelRegistrySlice.js").ModelRegistryState;
     chatHost: import("../../../../store/chat-host.slice.js").ChatHostState;
+    hostConversations: import("../host-conversations/host-conversations.slice.js").HostConversationsState;
 } & import("../../../../store/root-state.js").ChatHostReadSlices) => string[] | undefined) & {
     clearCache: () => void;
     resultsCount: () => number;
@@ -321,8 +321,8 @@ export declare const selectPersistentInstanceIds: ((state: {
     proposedDirectives: import("../../proposed-directives/proposedDirectivesSlice.js").ProposedDirectivesState;
     agentSettings: import("../../agent-settings/types.js").AgentSettingsState;
     conversationAttachments: import("../../../connectors/attachments.slice.js").AttachmentsSliceState;
-    modelRegistry: import("../../../model-registry/modelRegistrySlice.js").ModelRegistryState;
     chatHost: import("../../../../store/chat-host.slice.js").ChatHostState;
+    hostConversations: import("../host-conversations/host-conversations.slice.js").HostConversationsState;
 } & import("../../../../store/root-state.js").ChatHostReadSlices) => string[] | undefined) & {
     clearCache: () => void;
     resultsCount: () => number;
@@ -386,8 +386,8 @@ export declare const selectAllUIStateConversationIds: ((state: {
     proposedDirectives: import("../../proposed-directives/proposedDirectivesSlice.js").ProposedDirectivesState;
     agentSettings: import("../../agent-settings/types.js").AgentSettingsState;
     conversationAttachments: import("../../../connectors/attachments.slice.js").AttachmentsSliceState;
-    modelRegistry: import("../../../model-registry/modelRegistrySlice.js").ModelRegistryState;
     chatHost: import("../../../../store/chat-host.slice.js").ChatHostState;
+    hostConversations: import("../host-conversations/host-conversations.slice.js").HostConversationsState;
 } & import("../../../../store/root-state.js").ChatHostReadSlices) => string[]) & {
     clearCache: () => void;
     resultsCount: () => number;
@@ -456,8 +456,8 @@ export declare const selectUIStateInstancesByAgent: ((state: {
     proposedDirectives: import("../../proposed-directives/proposedDirectivesSlice.js").ProposedDirectivesState;
     agentSettings: import("../../agent-settings/types.js").AgentSettingsState;
     conversationAttachments: import("../../../connectors/attachments.slice.js").AttachmentsSliceState;
-    modelRegistry: import("../../../model-registry/modelRegistrySlice.js").ModelRegistryState;
     chatHost: import("../../../../store/chat-host.slice.js").ChatHostState;
+    hostConversations: import("../host-conversations/host-conversations.slice.js").HostConversationsState;
 } & import("../../../../store/root-state.js").ChatHostReadSlices) => InstanceAgentGroup[]) & {
     clearCache: () => void;
     resultsCount: () => number;

package/dist/agents/redux/execution-system/instance-user-input/composer-draft-store.js

@@ -1,9 +1,29 @@
+import { chatHostHasDatabase, getChatHost, isChatHostConfigured } from "../../../../host/configure.js";
 import { DRAFT_TTL_MS } from "@ai-matrx/kit/drafts";
 const PREFIX = "matrx.composer-draft.";
 const ALIAS_PREFIX = "matrx.composer-draft.surface.";
 const COMPOSER_DRAFT_MIN_CHARS = 2;
 let swept = false;
+function hostPrefsStorage() {
+  if (chatHostHasDatabase() || !isChatHostConfigured()) return null;
+  const prefs = getChatHost().prefs;
+  const keys = () => Object.keys(prefs.snapshot?.() ?? {});
+  return {
+    get length() {
+      return keys().length;
+    },
+    key: (index) => keys()[index] ?? null,
+    getItem: (key) => prefs.get(key),
+    setItem: (key, value) => prefs.set(key, value),
+    removeItem: (key) => prefs.remove(key),
+    clear: () => {
+      for (const key of keys()) if (key.startsWith(PREFIX)) prefs.remove(key);
+    }
+  };
+}
 function storage() {
+  const hosted = hostPrefsStorage();
+  if (hosted) return hosted;
   try {
     if (typeof window === "undefined") return null;
     const s = window.localStorage;

package/dist/agents/redux/execution-system/instance-user-input/useComposerDraftRestore.js

@@ -14,6 +14,7 @@ import {
   isDraftRestoreEnabled
 } from "./composer-draft.middleware.js";
 import { selectUserId } from "../../../../host/identity.js";
+import { chatHostHasDatabase } from "../../../../host/configure.js";
 import {
   selectUserInputEntryExists,
   selectUserInputText
@@ -48,7 +49,7 @@ function useComposerDraftRestore(conversationId, alias) {
     setRestoredValue(null);
     setStorageAvailable(isComposerDraftStorageAvailable());
     if (!enabled) return;
-    restoreComposerRemarks(conversationId);
+    if (chatHostHasDatabase()) restoreComposerRemarks(conversationId);
     const token = peekComposerDraft(conversationId, liveAlias, ownerId);
     if (!token) return;
     if (dispatch(applyComposerDraft(token)) === "restored") {