@ai-matrx/chat 0.7.18 → 0.7.20

package/dist/agents/components/inputs/smart-input/composer/ComposerSplash.js

@@ -11,6 +11,9 @@ import { isMandateKey } from "@ai-matrx/agents/mandates";
 import { useAppSelector } from "../../../../../store/hooks.js";
 import { selectActiveUserName } from "../../../../../host/identity.js";
 import { useMandateSet } from "../../../../../mandates/useMandateSet.js";
+import { resolveMandate } from "../../../../../mandates/service.js";
+import { toast } from "../../../../../host/notify.js";
+import { useIdleReady } from "@ai-matrx/kit/idle-scheduler";
 import { useSessionKnob } from "../../../../../host/prefs-react.js";
 import { cn } from "@ai-matrx/design-system";
 import { COMPOSER_KNOBS } from "./composer-mode-cookie.js";
@@ -73,9 +76,23 @@ function ComposerQuickActions({
   const organizationId = useAppSelector(selectOrganizationId);
   const actions = parseQuickActions(knob);
   const quickActionKeys = actions.map((a) => a.mandateKey);
+  const idle = useIdleReady();
   const mandates = useMandateSet(quickActionKeys, {
-    enabled: Boolean(organizationId)
+    enabled: Boolean(organizationId) && idle
   });
+  const [launching, setLaunching] = useState(null);
+  const launch = (action) => {
+    const known = mandates[action.mandateKey]?.mandate?.agentId;
+    if (known) {
+      onLaunchAgent(known);
+      return;
+    }
+    setLaunching(action.mandateKey);
+    resolveMandate(action.mandateKey).then((mandate) => onLaunchAgent(mandate.agentId)).catch((error) => {
+      console.error(`[composer] quick action ${action.mandateKey} could not resolve:`, error);
+      toast.error(`"${action.label}" is not available yet`);
+    }).finally(() => setLaunching(null));
+  };
   const scrollerRef = useRef(null);
   const [canScroll, setCanScroll] = useState(false);
   useEffect(() => {
@@ -105,9 +122,8 @@ function ComposerQuickActions({
           className: "flex min-w-0 flex-nowrap gap-2 overflow-x-auto px-1 [scrollbar-width:none] [&::-webkit-scrollbar]:hidden",
           children: actions.map((action) => {
             const state = mandates[action.mandateKey];
-            const agentId = state?.mandate?.agentId ?? null;
             const unavailable = Boolean(state && !state.loading && state.error);
-            return /* @__PURE__ */ jsx(Button, { variant: "outline", disabled: !agentId, title: unavailable ? `"${action.label}" is not available yet \u2014 its agent has not been assigned (${action.mandateKey}).` : void 0, onClick: () => agentId && onLaunchAgent(agentId), className: "shrink-0", children: action.label }, `${action.mandateKey}:${action.label}`);
+            return /* @__PURE__ */ jsx(Button, { variant: "outline", disabled: unavailable || launching === action.mandateKey, title: unavailable ? `"${action.label}" is not available yet \u2014 its agent has not been assigned (${action.mandateKey}).` : void 0, onClick: () => launch(action), className: "shrink-0", children: action.label }, `${action.mandateKey}:${action.label}`);
           })
         }
       ),

package/dist/agents/components/inputs/smart-input/composer/useComposerAgent.d.ts

@@ -18,9 +18,30 @@ export interface ComposerAgentInfo {
     /** The Matrx Chat agent (`chat.cx_default`) — shown as "Custom Agent". */
     customAgentId: string | null;
     isCustom: boolean;
-    preset: ComposerPreset | null;
-    presets: ComposerPreset[];
 }
 /** The model this conversation will run on: its override, else the agent's own. */
 export declare function useEffectiveModelId(conversationId: string): string | null;
-export declare function useComposerAgent(conversationId: string): ComposerAgentInfo;
+/**
+ * The pill's CLOSED state (2026-10-09: /chat/new loads nearly instantly) — read
+ * from what the run already loaded (the run tier names the agent) plus ONE
+ * model's record and classes. Nothing here reads a list: the agent catalogue,
+ * the model options, every model's classes and the chat presets load when a
+ * person opens the menu (`useComposerPresets`).
+ *
+ * `engaged` = the menu is (or was) open. The `chat.cx_default` job ("Custom
+ * Agent") is asked then, or once the page is idle — whichever comes first — so
+ * the closed label can say "Custom Agent" without the ask holding up paint.
+ */
+export declare function useComposerAgent(conversationId: string, options?: {
+    engaged?: boolean;
+}): ComposerAgentInfo;
+/**
+ * Chat mode's presets (`chat-agent` tagged agents, each with its model) — the
+ * agent catalogue and the model options, read when the menu that lists them
+ * MOUNTS (it mounts only while open). Both reads are shared and deduped with
+ * every other picker on the page.
+ */
+export declare function useComposerPresets(agentId: string | null): {
+    preset: ComposerPreset | null;
+    presets: ComposerPreset[];
+};

package/dist/agents/components/inputs/smart-input/composer/useComposerAgent.js

@@ -2,19 +2,16 @@
 import { useEffect } from "react";
 import { MANDATE_KEYS } from "@ai-matrx/agents/mandates";
 import { useAgentCatalogRows } from "@ai-matrx/agents/catalog/react";
-import { useAppDispatch, useAppSelector } from "../../../../../store/hooks.js";
+import { useAppSelector } from "../../../../../store/hooks.js";
 import { useMandate } from "../../../../../mandates/useMandate.js";
 import { selectAgentIdFromInstance } from "../../../../redux/execution-system/conversations/conversations.selectors.js";
 import {
   selectAgentModelId
 } from "../../../../redux/agent-definition/selectors.js";
 import { selectInstanceOverrideState } from "../../../../redux/execution-system/instance-model-overrides/instance-model-overrides.selectors.js";
-import {
-  selectModelLabelById,
-  selectModelLabelWithClass
-} from "@ai-matrx/agents/models";
-import { useModelOptions } from "../../../../identity/model-catalog.js";
-import { useModelClassLabels, useModelRecords } from "../../../../identity/model-catalog.js";
+import { selectModelLabelById } from "@ai-matrx/agents/models";
+import { useModelLabelForOneModel, useModelOptions, useModelRecords } from "../../../../identity/model-catalog.js";
+import { useIdleReady } from "@ai-matrx/kit/idle-scheduler";
 import { useEffectiveClassPin } from "../../../../redux/execution-system/instance-model-overrides/useEffectiveClassPin.js";
 import { ensureAgentCatalog, useAgentName } from "../../../../identity/agent-identity.js";
 const CHAT_AGENT_TAG = "chat-agent";
@@ -36,34 +33,23 @@ function useEffectiveModelId(conversationId) {
   const overrideModel = overrideState?.overrides?.model ?? null;
   return (typeof overrideModel === "string" ? overrideModel : null) ?? (typeof baseModel === "string" ? baseModel : null) ?? agentModelId ?? null;
 }
-function useComposerAgent(conversationId) {
-  const dispatch = useAppDispatch();
-  useModelOptions();
-  useEffect(() => {
-    void ensureAgentCatalog();
-  }, [dispatch]);
+function useComposerAgent(conversationId, options) {
   const agentId = useAppSelector(selectAgentIdFromInstance(conversationId)) ?? null;
   const agentName = useAgentName(agentId) ?? null;
   const effectiveModelId = useEffectiveModelId(conversationId);
-  useModelClassLabels();
   const classPins = useEffectiveClassPin(conversationId);
   const effectivePin = classPins.effectivePin ?? null;
   const agentOwnPin = classPins.basePin ?? null;
-  const effectiveModelLabel = useModelRecords((state) => selectModelLabelWithClass(state, effectiveModelId, effectivePin)) ?? null;
+  const effectiveModelLabel = useModelLabelForOneModel(effectiveModelId, effectivePin) ?? null;
   const agentOwnModelId = useAgentOwnModelId(conversationId);
-  const agentModelLabel = useModelRecords((state) => selectModelLabelWithClass(state, agentOwnModelId, agentOwnPin)) ?? null;
-  const { mandate: customMandate } = useMandate(MANDATE_KEYS.chat__cx_default, { optional: true });
+  const agentModelLabel = useModelLabelForOneModel(agentOwnModelId, agentOwnPin) ?? null;
+  const conversationMandateKey = useAppSelector(
+    (state) => state.conversations.byConversationId[conversationId]?.mandateKey ?? null
+  );
+  const idle = useIdleReady();
+  const askCustom = Boolean(options?.engaged) || idle;
+  const { mandate: customMandate } = useMandate(askCustom ? MANDATE_KEYS.chat__cx_default : "", { optional: true });
   const customAgentId = customMandate?.agentId ?? null;
-  const rows = useAgentCatalogRows();
-  const presetRows = rows.filter(isPresetRow);
-  const modelLabels = useModelRecords(
-    (state) => presetRows.map((row) => selectModelLabelById(state, row.modelId) ?? null).join("\0")
-  ).split("\0");
-  const presets = presetRows.map((row, index) => ({
-    id: row.id,
-    name: row.name ?? "Untitled agent",
-    modelLabel: modelLabels[index] || null
-  }));
   return {
     agentId,
     agentName,
@@ -74,13 +60,29 @@ function useComposerAgent(conversationId) {
     ),
     agentModelLabel,
     customAgentId,
-    isCustom: Boolean(agentId && customAgentId && agentId === customAgentId),
-    preset: presets.find((p) => p.id === agentId) ?? null,
-    presets
+    isCustom: conversationMandateKey === MANDATE_KEYS.chat__cx_default || Boolean(agentId && customAgentId && agentId === customAgentId)
   };
 }
+function useComposerPresets(agentId) {
+  useModelOptions();
+  useEffect(() => {
+    void ensureAgentCatalog();
+  }, []);
+  const rows = useAgentCatalogRows();
+  const presetRows = rows.filter(isPresetRow);
+  const modelLabels = useModelRecords(
+    (state) => presetRows.map((row) => selectModelLabelById(state, row.modelId) ?? null).join("\0")
+  ).split("\0");
+  const presets = presetRows.map((row, index) => ({
+    id: row.id,
+    name: row.name ?? "Untitled agent",
+    modelLabel: modelLabels[index] || null
+  }));
+  return { preset: presets.find((p) => p.id === agentId) ?? null, presets };
+}
 export {
   CHAT_AGENT_TAG,
   useComposerAgent,
+  useComposerPresets,
   useEffectiveModelId
 };

package/dist/agents/components/inputs/smart-input/use-compute-target-actions.d.ts

@@ -14,6 +14,26 @@ export declare function pickComputeLensTargets(targets: ComputeTarget[], boundRo
     totalCount: number;
 };
 export declare function useSandboxBindingBlocked(conversationId: string): boolean;
+/**
+ * The bound box ONLY — named from the conversation's record, with no targets
+ * list. For a surface that shows what this chat runs on at rest (the Cloud
+ * chip, the bound-box button): the list of every computer and sandbox
+ * (`GET /api/compute-targets`) is read when a picker OPENS — the panels that
+ * offer a choice call `useComputeTargetActions` themselves, and they mount on
+ * open (owner, 2026-10-09: nothing non-essential at startup). The view's
+ * `state` stays `"checking"` here: liveness comes with the list.
+ */
+export declare function useComputeBinding(conversationId: string): {
+    boundView: import("../../../../compute/targets.js").BoundTargetView | null;
+    sandboxBlocked: boolean;
+    hasBinding: boolean;
+};
+/**
+ * Everything a compute PICKER needs: the bound box, every target this person
+ * can use, and the bind. Reads the targets list — call it only from a surface
+ * the person opened (a popover / menu panel) or one that shows a bound box's
+ * liveness; an at-rest chip uses `useComputeBinding`.
+ */
 export declare function useComputeTargetActions(conversationId: string): {
     loading: boolean;
     sandboxBlocked: boolean;

package/dist/agents/components/inputs/smart-input/use-compute-target-actions.js

@@ -43,6 +43,16 @@ function useSandboxBindingBlocked(conversationId) {
   const chatIncognito = useAppSelector(selectChatIncognitoActive);
   return isEphemeral || chatIncognito && sourceFeature === "chat-route";
 }
+function useComputeBinding(conversationId) {
+  const binding = useVerifiedSandboxBinding(conversationId);
+  const sandboxBlocked = useSandboxBindingBlocked(conversationId);
+  const boundView = resolveBoundTargetView({
+    ref: binding.ref,
+    status: binding.status,
+    targets: null
+  });
+  return { boundView, sandboxBlocked, hasBinding: !!binding.ref };
+}
 function useComputeTargetActions(conversationId) {
   const dispatch = useAppDispatch();
   const { data, loading, refetch } = useComputeTargets();
@@ -125,6 +135,7 @@ export {
   computeTargetIconColor,
   computeTargetKindLabel,
   pickComputeLensTargets,
+  useComputeBinding,
   useComputeTargetActions,
   useSandboxBindingBlocked
 };

package/dist/agents/hooks/useConversationMaterialized.js

@@ -4,6 +4,7 @@ import { useAppSelector } from "../../store/hooks.js";
 import { selectPrimaryRequest } from "../redux/execution-system/active-requests/active-requests.selectors.js";
 import { waitForConversationPersisted } from "../redux/execution-system/conversations/conversation-persistence.js";
 import { selectUserId } from "../../host/identity.js";
+import { selectIsDraftConversation } from "../redux/execution-system/conversations/conversations.selectors.js";
 const materializedIds = /* @__PURE__ */ new Set();
 function materializedKey(userId, conversationId) {
   return `${userId}:${conversationId}`;
@@ -21,12 +22,48 @@ function markMaterialized(userId, conversationId) {
   materializedIds.add(key);
   for (const listener of cacheListeners) listener();
 }
+const probesInFlight = /* @__PURE__ */ new Map();
+function joinProbe(conversationId, key, poll) {
+  const probeKey = `${key}:${poll ? "poll" : "once"}`;
+  let probe = probesInFlight.get(probeKey);
+  if (!probe) {
+    const controller = new AbortController();
+    const promise = waitForConversationPersisted(conversationId, {
+      signal: controller.signal,
+      // Existing/reloaded conversations need one cheap proof read. A live
+      // stream keeps waiting because its first atomic commit is still pending.
+      timeoutMs: poll ? void 0 : 0
+    }).finally(() => {
+      if (probesInFlight.get(probeKey)?.promise === promise) {
+        probesInFlight.delete(probeKey);
+      }
+    });
+    probe = { promise, controller, waiters: 0 };
+    probesInFlight.set(probeKey, probe);
+  }
+  const joined = probe;
+  joined.waiters += 1;
+  let left = false;
+  return {
+    promise: joined.promise,
+    leave: () => {
+      if (left) return;
+      left = true;
+      joined.waiters -= 1;
+      if (joined.waiters <= 0) {
+        joined.controller.abort();
+        if (probesInFlight.get(probeKey) === joined) probesInFlight.delete(probeKey);
+      }
+    }
+  };
+}
 function useConversationMaterialized(conversationId) {
   const userId = useAppSelector(selectUserId);
   const status = useAppSelector(
     (state) => conversationId ? selectPrimaryRequest(conversationId)(state)?.status : void 0
   );
   const shouldPoll = status === "streaming" || status === "awaiting-tools" || status === "complete";
+  const isDraft = useAppSelector(selectIsDraftConversation(conversationId));
   const confirmedByCache = useSyncExternalStore(
     subscribeToCache,
     () => userId && conversationId ? materializedIds.has(materializedKey(userId, conversationId)) : false,
@@ -34,19 +71,15 @@ function useConversationMaterialized(conversationId) {
   );
   useEffect(() => {
     if (!userId || !conversationId) return;
+    if (isDraft && !shouldPoll) return;
     const key = materializedKey(userId, conversationId);
     if (materializedIds.has(key)) return;
-    const controller = new AbortController();
-    void waitForConversationPersisted(conversationId, {
-      signal: controller.signal,
-      // Existing/reloaded conversations need one cheap proof read. A live
-      // stream keeps waiting because its first atomic commit is still pending.
-      timeoutMs: shouldPoll ? void 0 : 0
-    }).then((persisted) => {
+    const probe = joinProbe(conversationId, key, shouldPoll);
+    void probe.promise.then((persisted) => {
       if (persisted) markMaterialized(userId, conversationId);
     });
-    return () => controller.abort();
-  }, [conversationId, shouldPoll, userId]);
+    return probe.leave;
+  }, [conversationId, isDraft, shouldPoll, userId]);
   return confirmedByCache;
 }
 export {

package/dist/agents/hooks/useCreatorOwnershipSync.js

@@ -1,5 +1,6 @@
 "use client";
 import { useEffect } from "react";
+import { whenPageIdle } from "@ai-matrx/kit/idle-scheduler";
 import { useAppDispatch, useAppSelector } from "../../store/hooks.js";
 import { setIsCreator } from "../../host/prefs.js";
 import { adminSeatOpen } from "../../host/admin-seat.js";
@@ -11,9 +12,12 @@ function useCreatorOwnershipSync(agentId) {
     (state) => agentId ? selectAgentIsOwner(state, agentId) : null
   );
   useEffect(() => {
-    if (agentId && isOwnerFlag === null) {
-      void dispatch(fetchAgentAccessLevel(agentId));
-    }
+    if (!agentId || isOwnerFlag !== null) return void 0;
+    const controller = new AbortController();
+    void whenPageIdle(controller.signal).then((idle) => {
+      if (idle) void dispatch(fetchAgentAccessLevel(agentId));
+    });
+    return () => controller.abort();
   }, [dispatch, agentId, isOwnerFlag]);
   const adminSeat = useAppSelector((state) => adminSeatOpen(state));
   const isOwner = !!agentId && (isOwnerFlag === true || adminSeat);

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

@@ -18,11 +18,18 @@ export declare function useWorkingDocumentContextSync(conversationId: string, ki
 export declare function useScratchpadContextSync(conversationId: string): void;
 /**
  * Always-on per-conversation bridge: restore the conversation's persisted
- * WORKING document + attached scratchpads, resolve the user's global ACTIVE
- * scratchpad, then keep the conversation's document context entries current.
- * Mount this once where a conversation is always present (the Smart Input), so
- * the agent receives the current documents regardless of which editor (if any)
- * is open.
+ * WORKING document + attached scratchpads, then keep the conversation's
+ * document context entries current. Mount this once where a conversation is
+ * always present (the Smart Input), so the agent receives the current
+ * documents regardless of which editor (if any) is open.
+ *
+ * Nothing is read at mount that cannot change what is sent (owner, 2026-10-09:
+ * the page loads near-instantly):
+ *   • a DRAFT (minted here, not yet sent) has no edges to restore — the
+ *     restore runs the moment the first send makes the conversation real;
+ *   • the user's global ACTIVE scratchpad is read only when this conversation
+ *     sends it (its scratch gate is on) or a scratchpad surface opens (those
+ *     surfaces hydrate it themselves).
  */
 export declare function useConversationDocumentsBridge(conversationId: string): void;
 export interface UseWorkingDocumentResult {

package/dist/agents/hooks/useWorkingDocument.js

@@ -69,7 +69,10 @@ import {
   getCxWorkingDocumentById,
   updateCxWorkingDocumentTitle
 } from "../redux/execution-system/instance-working-document/cx-working-document.service.js";
-import { selectIsCacheOnly } from "../redux/execution-system/conversations/conversations.selectors.js";
+import {
+  selectIsCacheOnly,
+  selectIsDraftConversation
+} from "../redux/execution-system/conversations/conversations.selectors.js";
 import {
   useOpenScratchpadPanel,
   useOpenWorkingDocumentPanel
@@ -332,8 +335,9 @@ function useScratchpadContextSync(conversationId) {
 function useConversationDocumentsBridge(conversationId) {
   const dispatch = useAppDispatch();
   const userId = useAppSelector(selectUserId);
+  const isDraft = useAppSelector(selectIsDraftConversation(conversationId));
   useEffect(() => {
-    if (!userId) return;
+    if (!userId || isDraft) return;
     const ownsHydration = acquireDocumentBridge(conversationId);
     if (!ownsHydration) {
       return () => releaseDocumentBridge(conversationId);
@@ -344,14 +348,22 @@ function useConversationDocumentsBridge(conversationId) {
         "Couldn't restore this conversation's working document \u2014 the agent won't see it until you reopen the conversation."
       );
     });
-    void dispatch(hydrateActiveScratchpadThunk()).unwrap().then(
-      () => dispatch(hydrateAttachedScratchpadsThunk({ conversationId })).unwrap()
-    ).catch((err) => {
+    void dispatch(hydrateAttachedScratchpadsThunk({ conversationId })).unwrap().catch((err) => {
       console.error("[scratchpad] bridge hydrate failed", err);
       toast.error("Couldn't restore your scratchpad for this conversation.");
     });
     return () => releaseDocumentBridge(conversationId);
-  }, [dispatch, conversationId, userId]);
+  }, [dispatch, conversationId, userId, isDraft]);
+  const scratchGateOn = useAppSelector(
+    selectWorkingDocEnabled(conversationId, "scratch")
+  );
+  useEffect(() => {
+    if (!userId || !scratchGateOn) return;
+    void dispatch(hydrateActiveScratchpadThunk()).unwrap().catch((err) => {
+      console.error("[scratchpad] bridge hydrate failed", err);
+      toast.error("Couldn't load your scratchpad \u2014 the agent won't see it this turn.");
+    });
+  }, [dispatch, userId, scratchGateOn]);
   useWorkingDocumentContextSync(conversationId, "working");
   useScratchpadContextSync(conversationId);
 }

package/dist/agents/identity/agent-identity.d.ts

@@ -12,6 +12,10 @@
  *   useAgentView(id)                     — the record, completed from the catalog row (derived, no copy)
  *   readAgentName / readAgentDescription / readAgentView(state, id)   — thunks, callbacks
  *   ensureAgentCatalog() / isAgentCatalogStale()                         — load the list
+ *
+ * The name/description hooks read the catalogue only when the record has not read
+ * the field and is not reading it (`catalogNeededFor`): the list loads when a
+ * picker opens, never to print one name.
  */
 import type { AgentSummary } from "@ai-matrx/agents/catalog";
 import type { ChatRootState } from "../../store/root-state.js";
@@ -32,7 +36,9 @@ export interface AgentIdentity {
  * One agent's catalog row, loading the catalog (then a server search) when it is missing — chat's
  * own binding of the store (the same contract as `@ai-matrx/agents/catalog/react` `useAgentSummary`).
  */
-export declare function useAgentSummaryRow(agentId: string | null | undefined): AgentSummary | undefined;
+export declare function useAgentSummaryRow(agentId: string | null | undefined, options?: {
+    load?: boolean;
+}): AgentSummary | undefined;
 type MaybeRecord = AgentDefinitionRecord | undefined;
 /**
  * The agent's record completed from its catalog row: every field the record has READ wins; the

package/dist/agents/identity/agent-identity.js

@@ -39,7 +39,8 @@ function isAgentCatalogStale() {
   }
 }
 const noopSubscribe = () => () => void 0;
-function useAgentSummaryRow(agentId) {
+function useAgentSummaryRow(agentId, options) {
+  const load = options?.load ?? true;
   const catalog = useCatalog();
   const row = useSyncExternalStore(
     catalog ? catalog.subscribe : noopSubscribe,
@@ -48,7 +49,7 @@ function useAgentSummaryRow(agentId) {
   );
   const present = row !== void 0;
   useEffect(() => {
-    if (!catalog || !agentId || present) return;
+    if (!catalog || !agentId || present || !load) return;
     let cancelled = false;
     void catalog.ensureLoaded().then(() => {
       if (cancelled || catalog.getState().byId[agentId]) return;
@@ -57,9 +58,13 @@ function useAgentSummaryRow(agentId) {
     return () => {
       cancelled = true;
     };
-  }, [catalog, agentId, present]);
+  }, [catalog, agentId, present, load]);
   return row;
 }
+function catalogNeededFor(record, fields) {
+  if (record?._loading) return false;
+  return !fields.every((field) => loaded(record, field));
+}
 function loaded(record, field) {
   return !!record?._loadedFields && hasField(record._loadedFields, field);
 }
@@ -110,18 +115,18 @@ function readAgentView(state, agentId) {
   return agentViewOf(recordOf(state, agentId), catalogRow(agentId));
 }
 function useAgentName(agentId) {
-  const row = useAgentSummaryRow(agentId);
   const record = useAppSelector((s) => recordOf(s, agentId));
+  const row = useAgentSummaryRow(agentId, { load: catalogNeededFor(record, ["name"]) });
   return nameOf(record, row);
 }
 function useAgentDescription(agentId) {
-  const row = useAgentSummaryRow(agentId);
   const record = useAppSelector((s) => recordOf(s, agentId));
+  const row = useAgentSummaryRow(agentId, { load: catalogNeededFor(record, ["description"]) });
   return descriptionOf(record, row);
 }
 function useAgentIdentity(agentId) {
-  const summary = useAgentSummaryRow(agentId);
   const record = useAppSelector((s) => recordOf(s, agentId));
+  const summary = useAgentSummaryRow(agentId, { load: catalogNeededFor(record, ["name", "description"]) });
   return { name: nameOf(record, summary), description: descriptionOf(record, summary), summary };
 }
 function readAgentName(state, agentId) {

package/dist/agents/identity/model-catalog.d.ts

@@ -44,3 +44,10 @@ export declare function useModelOptions(): {
 };
 /** One model's FULL record (controls included), or undefined until it has loaded. */
 export declare function useModelFull(modelId: string | null | undefined): ModelRecord | undefined;
+/**
+ * The label a CLOSED control shows for the model a conversation runs on —
+ * "Qwen3.8 27B · Matrx Lightning" — from ONE model's reads: its record (the same
+ * deduped read `useModelFull` makes) and its own classes. Never the options
+ * list or every model's classes; those load when a picker opens.
+ */
+export declare function useModelLabelForOneModel(modelId: string | null | undefined, offeringId: string | null | undefined): string | undefined;

package/dist/agents/identity/model-catalog.js

@@ -110,11 +110,25 @@ function useModelFull(modelId) {
   const isFull = useModelRecords((s) => selectModelFullyLoaded(s, modelId));
   useEffect(() => {
     if (!chatHostHasDatabase()) return;
-    void getModelRecords().loadOptions();
     if (modelId && !isFull) void getModelRecords().loadModel(modelId);
   }, [modelId, isFull]);
   return isFull ? record : void 0;
 }
+function useModelLabelForOneModel(modelId, offeringId) {
+  const label = useModelRecords((s) => selectModelLabelWithClass(s, modelId, offeringId));
+  const known = useModelRecords((s) => Boolean(selectModelLabelById(s, modelId)));
+  useEffect(() => {
+    if (!modelId || !chatHostHasDatabase()) return;
+    const records = getModelRecords();
+    if (!known) {
+      void records.loadModel(modelId).then(() => {
+        if (!selectModelLabelById(records.getState(), modelId)) void records.loadIdentity(modelId);
+      });
+    }
+    void records.loadModelClasses(modelId);
+  }, [modelId, known]);
+  return label;
+}
 export {
   getModelCatalog,
   getModelRecords,
@@ -123,6 +137,7 @@ export {
   useModelClassLabels,
   useModelFull,
   useModelLabel,
+  useModelLabelForOneModel,
   useModelLabelWithClass,
   useModelOptions,
   useModelRecord,

package/dist/agents/redux/conversation-history/slice.d.ts

@@ -16,6 +16,8 @@ export declare const configureScope: import("@reduxjs/toolkit").ActionCreatorWit
     includeOriginClasses?: string[];
     grouping?: HistoryGrouping;
     pageSize?: number;
+    /** Slim row read (`ConversationHistoryScopeState.nameRowsOnly`). */
+    nameRowsOnly?: boolean;
     /** When true, drops items/offset so a fresh fetch repopulates. */
     reset?: boolean;
 }, "conversationHistory/configureScope">, setScopeAgentIds: import("@reduxjs/toolkit").ActionCreatorWithPayload<{

package/dist/agents/redux/conversation-history/slice.js

@@ -58,6 +58,7 @@ const slice = createSlice({
         includeOriginClasses,
         grouping,
         pageSize,
+        nameRowsOnly,
         reset
       } = action.payload;
       const scope = ensureScope(state, scopeId);
@@ -79,6 +80,7 @@ const slice = createSlice({
       }
       if (grouping !== void 0) scope.grouping = grouping;
       if (pageSize !== void 0) scope.pageSize = pageSize;
+      if (nameRowsOnly !== void 0) scope.nameRowsOnly = nameRowsOnly;
       if (reset) invalidateScopeWindow(scope);
     },
     /**

package/dist/agents/redux/conversation-history/thunks.d.ts

@@ -34,6 +34,8 @@ export interface FetchConversationHistoryArgs {
     includeEmptySource?: boolean;
     /** Overrides the scope's stored pageSize for this fetch. */
     pageSize?: number;
+    /** Overrides the scope's stored `nameRowsOnly` (slim row read). */
+    nameRowsOnly?: boolean;
     /**
      * When true (default), replaces existing items with the freshly-fetched
      * first page. When false, appends a new page using the scope's `offset`.

package/dist/agents/redux/conversation-history/thunks.js

@@ -2,6 +2,7 @@ import { createAsyncThunk } from "@reduxjs/toolkit";
 import { supabase } from "../../../host/db.js";
 import { applyFavoritesFromUes } from "../conversation-list/conversation-list.thunks.js";
 import {
+  CONVERSATION_NAME_ROW_COLUMNS,
   CONVERSATION_ROW_COLUMNS,
   mapConversationDbRow
 } from "../conversation-list/conversation-rows.js";
@@ -31,7 +32,7 @@ const fetchConversationHistory = createAsyncThunk(
     const replace = args.replace ?? true;
     const state = getState();
     const existing = state.conversationHistory.scopes[args.scopeId];
-    if (!existing || args.agentIds !== void 0 || args.excludeSourceFeatures !== void 0 || args.includeSourceFeatures !== void 0 || args.includeSourceApps !== void 0 || args.includeEmptySource !== void 0 || args.pageSize !== void 0) {
+    if (!existing || args.agentIds !== void 0 || args.excludeSourceFeatures !== void 0 || args.includeSourceFeatures !== void 0 || args.includeSourceApps !== void 0 || args.includeEmptySource !== void 0 || args.pageSize !== void 0 || args.nameRowsOnly !== void 0) {
       dispatch(
         configureScope({
           scopeId: args.scopeId,
@@ -40,7 +41,8 @@ const fetchConversationHistory = createAsyncThunk(
           includeSourceFeatures: args.includeSourceFeatures ?? existing?.includeSourceFeatures ?? [],
           includeSourceApps: args.includeSourceApps ?? existing?.includeSourceApps ?? [],
           includeEmptySource: args.includeEmptySource ?? existing?.includeEmptySource ?? false,
-          pageSize: args.pageSize ?? existing?.pageSize ?? defaultScopeState.pageSize
+          pageSize: args.pageSize ?? existing?.pageSize ?? defaultScopeState.pageSize,
+          nameRowsOnly: args.nameRowsOnly ?? existing?.nameRowsOnly ?? defaultScopeState.nameRowsOnly
         })
       );
     }
@@ -66,7 +68,8 @@ const fetchConversationHistory = createAsyncThunk(
       );
       return { scopeId: args.scopeId, items: [], hasMore: false, nextOffset: 0, replace };
     }
-    let query = supabase.schema("chat").from("conversation").select(CONVERSATION_ROW_COLUMNS).is("deleted_at", null).eq("is_ephemeral", false).order("updated_at", { ascending: false }).range(offset, offset + pageSize - 1);
+    const columns = scope.nameRowsOnly ? CONVERSATION_NAME_ROW_COLUMNS : CONVERSATION_ROW_COLUMNS;
+    let query = supabase.schema("chat").from("conversation").select(columns).is("deleted_at", null).eq("is_ephemeral", false).order("updated_at", { ascending: false }).range(offset, offset + pageSize - 1);
     if (viewerId && !(agentIds.length > 0 && adminSeatOpen(getState()))) {
       query = query.eq("created_by", viewerId);
     }

package/dist/agents/redux/conversation-history/types.d.ts

@@ -97,6 +97,12 @@ export interface ConversationHistoryScopeState {
     grouping: HistoryGrouping;
     /** Page size for range-based pagination. */
     pageSize: number;
+    /**
+     * Read only what a history ROW shows (`CONVERSATION_NAME_ROW_COLUMNS`: name,
+     * time, provenance for its menu) — the /chat sidebar's slim read. Rows from
+     * it carry no description / message count / model.
+     */
+    nameRowsOnly: boolean;
     /** How many items we've fetched so far (the next `range` offset). */
     offset: number;
     /** Items in display order (already sorted by `updated_at` desc). */

package/dist/agents/redux/conversation-history/types.js

@@ -13,6 +13,7 @@ const defaultScopeState = {
   searchTerm: "",
   grouping: "date",
   pageSize: 30,
+  nameRowsOnly: false,
   offset: 0,
   items: [],
   hasMore: false,