@ai-matrx/chat 0.7.20 → 0.7.21

package/CHANGELOG.md

@@ -1,11 +1,38 @@
 # @ai-matrx/chat
 
+## 0.7.21
+### Unreleased
+
+### /chat/new: the live residuals of the startup-read work
+
+- **A minted id is a draft before its record exists.** `generateConversationId` remembers the ids this tab
+  minted (`wasMintedInThisTab`); `selectIsDraftConversation` answers true for one Redux does not hold yet.
+  The composer mounts — and its children's effects run — before the launch thunk creates the record, so
+  plan/tasks/todos, document + scratchpad links and the materialized probe fired for every new draft.
+- **One agent's name is one row.** `useAgentName` / `useAgentDescription` / `useAgentIdentity` ask
+  `fetchAgentRunTier(agentId)` when the record has not read the field; the whole catalogue is read only
+  when that fails. `fetchAgentRunTier` joins a run-tier read already in flight instead of forcing a second.
+- **One mandate verdict per question.** The resolution GET is shared across the optional and required
+  lanes and with `resolveMandateHolder` (cached like resolutions; dropped on invalidation and org switch).
+  New `useMandateHolderSet(keys, { enabled })` — the verdict only; the composer's quick-action row uses it
+  instead of `useMandateSet`, so its jobs no longer read each definition + treatment row.
+- **The greeting paints its final word.** `ComposerGreeting` ships an inline script that writes the local
+  time-of-day word before first paint; hydration renders the same word (no Largest Contentful Paint swap).
+- The composer rail loads the saved context rules once the page is idle, not at mount.
+- **Consumer action:** none.
+
 ## 0.7.20
 
 Automatic changed-only republish (docs/metadata drift since the last tag — see
 `git diff npm/chat/v0.7.19..npm/chat/v0.7.20 -- apps/shared/chat`).
 No source changes intended and no consumer action required.
 
+## 0.7.19
+
+Automatic changed-only republish (docs/metadata drift since the last tag — see
+`git diff npm/chat/v0.7.18..npm/chat/v0.7.19 -- apps/shared/chat`).
+No source changes intended and no consumer action required.
+
 ## 0.7.18
 
 Automatic changed-only republish (docs/metadata drift since the last tag — see

package/dist/agents/components/inputs/smart-input/ConversationContextRail.js

@@ -13,6 +13,7 @@ import {
 import { useAppDispatch, useAppSelector } from "../../../../store/hooks.js";
 import { ensureSurfaceFeatureLoaded } from "../../../../surfaces/redux/userStateSlice.js";
 import { CONTEXT_RULES_FEATURE } from "@ai-matrx/agents/context";
+import { whenPageIdle } from "@ai-matrx/kit/idle-scheduler";
 import { cn } from "@ai-matrx/design-system";
 import { useIsMobile } from "@ai-matrx/kit/media-query";
 import {
@@ -124,7 +125,11 @@ function ConversationContextRailBody({
   useConversationFollowsPage(conversationId);
   const contextChipShown = useConversationContextChipShown(conversationId) && withValueGroupChip;
   useEffect(() => {
-    void dispatch(ensureSurfaceFeatureLoaded(CONTEXT_RULES_FEATURE));
+    const idle = new AbortController();
+    void whenPageIdle(idle.signal).then((ready) => {
+      if (ready) void dispatch(ensureSurfaceFeatureLoaded(CONTEXT_RULES_FEATURE));
+    });
+    return () => idle.abort();
   }, [dispatch]);
   const workingDocEnabled = useAppSelector(
     selectWorkingDocEnabled(conversationId, "working")

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

@@ -6,7 +6,7 @@
  * The list is DATA: the `agents.chat_composer.quick_actions` knob (system
  * default, overridable per organization and per person). Each entry names a
  * label and the agent JOB (mandate) it opens; the job resolves through the
- * mandate ladder (`useMandateSet`), exactly like today's /chat/new chips. An
+ * mandate ladder (`useMandateHolderSet`: the verdict only, never a launch read). An
  * entry whose job cannot resolve renders disabled with the reason — never a
  * silent fallback.
  */

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

@@ -10,7 +10,7 @@ import { ChevronRight } from "lucide-react";
 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 { useMandateHolderSet } from "../../../../../mandates/useMandateHolderSet.js";
 import { resolveMandate } from "../../../../../mandates/service.js";
 import { toast } from "../../../../../host/notify.js";
 import { useIdleReady } from "@ai-matrx/kit/idle-scheduler";
@@ -27,6 +27,7 @@ function timeOfDayGreeting(hour) {
 }
 const noSubscription = () => () => {
 };
+const GREETING_SCRIPT = `(function(s){var h=s&&s.previousElementSibling;var e=h&&h.querySelector('[data-matrx-greeting]');if(e)e.textContent=(${timeOfDayGreeting.toString()})(new Date().getHours())})(document.currentScript)`;
 function ComposerGreeting({ className }) {
   const userName = useAppSelector(selectActiveUserName);
   const firstName = (userName ?? "").trim().split(/\s+/)[0] || "";
@@ -44,9 +45,10 @@ function ComposerGreeting({ className }) {
       }
     ),
     /* @__PURE__ */ jsxs("h1", { className: "font-serif text-[clamp(2rem,1.6rem+1.8vw,2.875rem)] font-normal tracking-tight text-foreground", children: [
-      greeting ?? "Hello",
+      /* @__PURE__ */ jsx("span", { "data-matrx-greeting": "", suppressHydrationWarning: true, children: greeting ?? "Hello" }),
       firstName ? `, ${firstName}` : ""
-    ] })
+    ] }),
+    /* @__PURE__ */ jsx("script", { dangerouslySetInnerHTML: { __html: GREETING_SCRIPT } })
   ] });
 }
 function parseQuickActions(value) {
@@ -77,12 +79,12 @@ function ComposerQuickActions({
   const actions = parseQuickActions(knob);
   const quickActionKeys = actions.map((a) => a.mandateKey);
   const idle = useIdleReady();
-  const mandates = useMandateSet(quickActionKeys, {
+  const mandates = useMandateHolderSet(quickActionKeys, {
     enabled: Boolean(organizationId) && idle
   });
   const [launching, setLaunching] = useState(null);
   const launch = (action) => {
-    const known = mandates[action.mandateKey]?.mandate?.agentId;
+    const known = mandates[action.mandateKey]?.agentId;
     if (known) {
       onLaunchAgent(known);
       return;

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

@@ -1,8 +1,9 @@
 "use client";
 import { getChatHost } from "../../host/configure.js";
 const getAgentCatalog = () => getChatHost().catalog();
-import { useAppSelector } from "../../store/hooks.js";
-import { useEffect, useMemo, useSyncExternalStore } from "react";
+import { useAppDispatch, useAppSelector } from "../../store/hooks.js";
+import { useEffect, useMemo, useState, useSyncExternalStore } from "react";
+import { fetchAgentRunTier } from "../redux/agent-definition/thunks.js";
 import { hasField } from "@ai-matrx/agents/field-flags";
 import { selectAgentById } from "../redux/agent-definition/selectors.js";
 import { makeEmptyRecord } from "../redux/agent-definition/slice.js";
@@ -114,21 +115,40 @@ function useAgentView(agentId) {
 function readAgentView(state, agentId) {
   return agentViewOf(recordOf(state, agentId), catalogRow(agentId));
 }
+function useIdentityRow(agentId, record, fields) {
+  const dispatch = useAppDispatch();
+  const needed = Boolean(agentId) && catalogNeededFor(record, fields);
+  const [runTierFailedFor, setRunTierFailedFor] = useState(null);
+  useEffect(() => {
+    if (!agentId || !needed) return void 0;
+    let cancelled = false;
+    dispatch(fetchAgentRunTier(agentId)).unwrap().catch(() => {
+      if (!cancelled) setRunTierFailedFor(agentId);
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [dispatch, agentId, needed]);
+  return useAgentSummaryRow(agentId, { load: needed && runTierFailedFor === agentId });
+}
 function useAgentName(agentId) {
   const record = useAppSelector((s) => recordOf(s, agentId));
-  const row = useAgentSummaryRow(agentId, { load: catalogNeededFor(record, ["name"]) });
+  const row = useIdentityRow(agentId, record, NAME);
   return nameOf(record, row);
 }
 function useAgentDescription(agentId) {
   const record = useAppSelector((s) => recordOf(s, agentId));
-  const row = useAgentSummaryRow(agentId, { load: catalogNeededFor(record, ["description"]) });
+  const row = useIdentityRow(agentId, record, DESCRIPTION);
   return descriptionOf(record, row);
 }
 function useAgentIdentity(agentId) {
   const record = useAppSelector((s) => recordOf(s, agentId));
-  const summary = useAgentSummaryRow(agentId, { load: catalogNeededFor(record, ["name", "description"]) });
+  const summary = useIdentityRow(agentId, record, NAME_AND_DESCRIPTION);
   return { name: nameOf(record, summary), description: descriptionOf(record, summary), summary };
 }
+const NAME = ["name"];
+const DESCRIPTION = ["description"];
+const NAME_AND_DESCRIPTION = ["name", "description"];
 function readAgentName(state, agentId) {
   return nameOf(recordOf(state, agentId), catalogRow(agentId));
 }

package/dist/agents/redux/agent-definition/thunks.js

@@ -140,7 +140,9 @@ const fetchAgentRunTier = createAsyncThunk(
     if (await isSignedOutVisitor()) throw new NotAuthenticatedError();
     dispatch(setAgentLoading({ id: agentId, loading: true }));
     try {
-      await getRunTierStore().loadRunTier(agentId, { force: true });
+      const store = getRunTierStore();
+      const inFlight = store.getState().runTier[agentId]?.status === "loading";
+      await store.loadRunTier(agentId, { force: !inFlight });
     } catch (e) {
       dispatch(setAgentLoading({ id: agentId, loading: false }));
       const failure = runTierFailure(agentId, e);

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

@@ -270,10 +270,15 @@ export declare const selectIsCacheOnly: (conversationId: string) => (state: Chat
  * Is this a DRAFT — a conversation minted in this tab that has no server row
  * yet (`cacheOnly`, until the first send's confirmation or a DB hydrate flips
  * it)? Reads keyed by a draft's id can only answer "nothing": gate them on
- * this and they run the moment the first send makes it real. A conversation
- * Redux does not hold is NOT a draft (it was opened from elsewhere, so it has a
- * row) — unlike `selectIsCacheOnly`, which answers true for an unknown id
- * because it gates WRITES.
+ * this and they run the moment the first send makes it real.
+ *
+ * A conversation Redux holds answers from its record. One Redux does NOT hold
+ * is a draft only if this tab minted its id (`wasMintedInThisTab`) — the
+ * window between the launcher minting the id and the launch thunk creating the
+ * record, in which /chat/new's composer has already mounted and run its
+ * effects. Any other unknown id was opened from elsewhere, so it has a row —
+ * unlike `selectIsCacheOnly`, which answers true for every unknown id because
+ * it gates WRITES.
  */
 export declare const selectIsDraftConversation: (conversationId: string | null | undefined) => (state: ChatRootState) => boolean;
 export declare const selectConversationTitle: (conversationId: string) => (state: ChatRootState) => string | null;

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

@@ -1,4 +1,5 @@
 import { createSelector } from "@reduxjs/toolkit";
+import { wasMintedInThisTab } from "../utils/ids.js";
 const EMPTY_INSTANCES = [];
 const EMPTY_CONVERSATION_IDS_BY_AGENT = {};
 const selectInstance = (conversationId) => (state) => state.conversations.byConversationId[conversationId];
@@ -44,8 +45,12 @@ const selectRunningInstances = createSelector(
 );
 const selectAgentIdFromInstance = (conversationId) => (state) => state.conversations.byConversationId[conversationId]?.agentId;
 const selectIsCacheOnly = (conversationId) => (state) => state.conversations.byConversationId[conversationId]?.cacheOnly ?? true;
-const selectIsDraftConversation = (conversationId) => (state) => !!conversationId && // A store without the conversations slice holds no drafts.
-state.conversations?.byConversationId[conversationId]?.cacheOnly === true;
+const selectIsDraftConversation = (conversationId) => (state) => {
+  if (!conversationId) return false;
+  const record = state.conversations?.byConversationId[conversationId];
+  if (record) return record.cacheOnly === true;
+  return wasMintedInThisTab(conversationId);
+};
 const selectConversationTitle = (conversationId) => (state) => state.conversations.byConversationId[conversationId]?.title ?? null;
 const selectConversationDescription = (conversationId) => (state) => state.conversations.byConversationId[conversationId]?.description ?? null;
 const selectConversationKeywords = (conversationId) => (state) => state.conversations.byConversationId[conversationId]?.keywords ?? null;

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

@@ -6,6 +6,8 @@
  * as-is and used as the authoritative conversation key.
  */
 export declare const generateConversationId: () => string;
+/** True for an id `generateConversationId` minted in this tab. */
+export declare const wasMintedInThisTab: (conversationId: string) => boolean;
 /** @deprecated Use generateConversationId() */
 export declare const generateInstanceId: typeof generateConversationId;
 export declare const generateResourceId: () => string;

package/dist/agents/redux/execution-system/utils/ids.js

@@ -1,4 +1,10 @@
-const generateConversationId = () => crypto.randomUUID();
+const mintedInThisTab = /* @__PURE__ */ new Set();
+const generateConversationId = () => {
+  const id = crypto.randomUUID();
+  mintedInThisTab.add(id);
+  return id;
+};
+const wasMintedInThisTab = (conversationId) => mintedInThisTab.has(conversationId);
 const generateInstanceId = generateConversationId;
 const generateResourceId = () => `res_${crypto.randomUUID()}`;
 const generateRequestId = () => `req_${crypto.randomUUID()}`;
@@ -8,5 +14,6 @@ export {
   generateInstanceId,
   generateRequestId,
   generateResourceId,
-  generateScopeId
+  generateScopeId,
+  wasMintedInThisTab
 };

package/dist/mandates/service.js

@@ -96,7 +96,12 @@ function dropMandateCacheForOrgSwitch() {
     cache.delete(key);
     dropped = true;
   }
+  for (const key of verdictCache.keys()) {
+    if (current !== null && key.split(":")[1] === current) continue;
+    verdictCache.delete(key);
+  }
   resolutionsInFlight.clear();
+  verdictsInFlight.clear();
   cacheGeneration += 1;
   if (!dropped) return;
   for (const listener of invalidationListeners) listener(void 0);
@@ -111,13 +116,18 @@ function invalidateMandateCache(mandateKey) {
   invalidateMandateCatalogueCache();
   cacheGeneration += 1;
   resolutionsInFlight.clear();
+  verdictsInFlight.clear();
   if (mandateKey) {
     for (const key of cache.keys()) {
       if (key.endsWith(`:${mandateKey}`)) cache.delete(key);
     }
+    for (const key of verdictCache.keys()) {
+      if (key.endsWith(`:${mandateKey}`)) verdictCache.delete(key);
+    }
     pinCache.delete(mandateKey);
   } else {
     cache.clear();
+    verdictCache.clear();
     pinCache.clear();
   }
   for (const listener of invalidationListeners) listener(mandateKey);
@@ -172,7 +182,7 @@ async function selectedOrganizationFor(mandateKey) {
 }
 async function fetchResolutionVerdict(mandateKey, options) {
   const question = await resolutionQuestion(mandateKey, options);
-  const verdict = await askResolutionDoor(mandateKey, options, question.organizationId);
+  const verdict = await askVerdict(mandateKey, options, question);
   if (verdict === null) return null;
   return { kind: "verdict", verdict, ...question };
 }
@@ -189,7 +199,7 @@ async function resolutionQuestion(mandateKey, options) {
   const organizationId = options.organizationId ?? await selectedOrganizationFor(mandateKey);
   return { organizationId, cacheKey: mandateCacheKey(userId, organizationId, mandateKey), guest: false };
 }
-async function askResolutionDoor(mandateKey, options, organizationId) {
+async function askResolutionDoor(mandateKey, captureErrors, organizationId) {
   let verdict;
   try {
     const { data } = await apiGet(
@@ -210,43 +220,78 @@ async function askResolutionDoor(mandateKey, options, organizationId) {
         // answering 404 is the documented result, not a system error, so it must
         // not enter the global Error Inspector. Anything that is not a 404 is
         // re-thrown below and captured by the consumer that asked.
-        captureErrors: !options.optional
+        captureErrors
       }
     );
     verdict = data;
   } catch (error) {
-    if (error instanceof BackendApiError && error.status === 404) {
-      if (options.optional) return null;
-      throw recordUnavailable({
-        entity: "mandate",
-        reason: "unknown",
-        recordId: mandateKey,
-        relation: "mandate.definition"
-      });
-    }
+    if (error instanceof BackendApiError && error.status === 404) return null;
     throw error;
   }
   return verdict;
 }
+function mandateMissing(mandateKey) {
+  return recordUnavailable({
+    entity: "mandate",
+    reason: "unknown",
+    recordId: mandateKey,
+    relation: "mandate.definition"
+  });
+}
+async function askVerdict(mandateKey, options, question) {
+  const answer = await sharedVerdict(mandateKey, options, question);
+  if (answer === MISSING) {
+    if (options.optional) return null;
+    throw mandateMissing(mandateKey);
+  }
+  return answer;
+}
+const MISSING = "missing";
+const verdictCache = /* @__PURE__ */ new Map();
+const verdictsInFlight = /* @__PURE__ */ new Map();
+function sharedVerdict(mandateKey, options, question) {
+  const key = question.cacheKey;
+  const cached = verdictCache.get(key);
+  if (cached && Date.now() - cached.at < CACHE_TTL_MS) return Promise.resolve(cached.value);
+  const pending = verdictsInFlight.get(key);
+  if (pending) return pending;
+  const generation = cacheGeneration;
+  const run = askResolutionDoor(mandateKey, !options.optional, question.organizationId).then((verdict) => {
+    const value = verdict ?? MISSING;
+    if (generation === cacheGeneration) verdictCache.set(key, { at: Date.now(), value });
+    return value;
+  }).finally(() => {
+    if (verdictsInFlight.get(key) === run) verdictsInFlight.delete(key);
+  });
+  verdictsInFlight.set(key, run);
+  return run;
+}
 async function resolveMandate(mandateKey, options = {}) {
   const question = await resolutionQuestion(mandateKey, options);
   const cached = cache.get(question.cacheKey);
   if (cached && Date.now() - cached.at < CACHE_TTL_MS) return cached.value;
-  const flightKey = `${question.cacheKey}|${options.optional ? "optional" : "required"}`;
-  const pending = resolutionsInFlight.get(flightKey);
-  if (pending) return pending;
-  const run = resolveFromDoor(mandateKey, options, question).finally(() => {
-    if (resolutionsInFlight.get(flightKey) === run) resolutionsInFlight.delete(flightKey);
-  });
-  resolutionsInFlight.set(flightKey, run);
-  return run;
+  const flightKey = question.cacheKey;
+  let run = resolutionsInFlight.get(flightKey);
+  if (!run) {
+    const started = resolveFromDoor(mandateKey, options, question).finally(() => {
+      if (resolutionsInFlight.get(flightKey) === started) resolutionsInFlight.delete(flightKey);
+    });
+    resolutionsInFlight.set(flightKey, started);
+    run = started;
+  }
+  const answer = await run;
+  if (answer === MISSING) {
+    if (options.optional) return null;
+    throw mandateMissing(mandateKey);
+  }
+  return answer;
 }
 const resolutionsInFlight = /* @__PURE__ */ new Map();
 async function resolveFromDoor(mandateKey, options, question) {
   const supabase = createClient();
   const generation = cacheGeneration;
-  const verdict = await askResolutionDoor(mandateKey, options, question.organizationId);
-  if (verdict === null) return null;
+  const verdict = await sharedVerdict(mandateKey, options, question);
+  if (verdict === MISSING) return MISSING;
   const { organizationId, cacheKey, guest } = question;
   const holder = assertRunnableVerdict(mandateKey, verdict);
   const provenance = verdict.provenance;
@@ -283,15 +328,7 @@ async function resolveFromDoor(mandateKey, options, question) {
   }
   const { data: mandate, error } = await mandateDefinitions(supabase).select("*").eq("mandate_key", mandateKey).is("deleted_at", null).maybeSingle();
   if (error) throw error;
-  if (!mandate) {
-    if (options.optional) return null;
-    throw recordUnavailable({
-      entity: "mandate",
-      reason: "unknown",
-      recordId: mandateKey,
-      relation: "mandate.definition"
-    });
-  }
+  if (!mandate) return MISSING;
   let presentation = null;
   {
     const { data: treatment, error: treatmentError } = await mandateTreatments(

package/dist/mandates/useMandateHolderSet.d.ts

@@ -0,0 +1,9 @@
+import type { AnyMandateKey } from "@ai-matrx/agents/mandates";
+export interface MandateHolderState {
+    agentId: string | null;
+    loading: boolean;
+    error: string | null;
+}
+export declare function useMandateHolderSet(keys: readonly AnyMandateKey[], options?: {
+    enabled?: boolean;
+}): Readonly<Record<string, MandateHolderState>>;

package/dist/mandates/useMandateHolderSet.js

@@ -0,0 +1,52 @@
+"use client";
+import { useEffect, useState } from "react";
+import { extractErrorMessage } from "@ai-matrx/data/net";
+import { onMandateCacheInvalidated, resolveMandateHolder } from "./service.js";
+import { useAppSelector } from "../store/hooks.js";
+import { selectOrganizationId } from "../host/org.js";
+const SEPARATOR = "\0";
+function useMandateHolderSet(keys, options = {}) {
+  const enabled = options.enabled ?? true;
+  const organizationId = useAppSelector(selectOrganizationId) ?? null;
+  const keyList = enabled ? keys.join(SEPARATOR) : "";
+  const question = keyList ? `${keyList}|${organizationId ?? ""}` : "";
+  const [state, setState] = useState(
+    () => ({ question: "", epoch: 0, set: {} })
+  );
+  if (state.question !== question) setState({ question, epoch: 0, set: {} });
+  useEffect(() => {
+    if (!keyList) return void 0;
+    const listed = keyList.split(SEPARATOR);
+    return onMandateCacheInvalidated((key) => {
+      if (key === void 0 || listed.includes(key)) setState((prev) => ({ ...prev, epoch: prev.epoch + 1 }));
+    });
+  }, [keyList]);
+  const epoch = state.epoch;
+  useEffect(() => {
+    if (!keyList) return void 0;
+    const listed = keyList.split(SEPARATOR);
+    let cancelled = false;
+    void Promise.allSettled(listed.map((key) => resolveMandateHolder(key))).then((results) => {
+      if (cancelled) return;
+      const next = {};
+      results.forEach((result, i) => {
+        const key = listed[i];
+        if (result.status === "fulfilled" && result.value?.holderType === "agent") {
+          next[key] = { agentId: result.value.holderId, loading: false, error: null };
+          return;
+        }
+        const message = result.status === "rejected" ? extractErrorMessage(result.reason) : `${key} is held by a workflow, not an agent`;
+        console.error(`[mandates] ${key} has no agent to open:`, message);
+        next[key] = { agentId: null, loading: false, error: message };
+      });
+      setState((prev) => prev.question === question ? { ...prev, set: next } : prev);
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [keyList, question, epoch]);
+  return state.set;
+}
+export {
+  useMandateHolderSet
+};

package/package.json

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