@ai-matrx/chat 0.3.5 → 0.3.9

package/dist/compute/targets.d.ts

@@ -116,15 +116,13 @@ export interface ChatComputeTargetsSource {
         error: string | null;
         fetchInstances: (opts?: {
             limit?: number;
-            [option: string]: unknown;
         }) => Promise<unknown>;
         createInstance: (request: {
             organization_id: string;
             template?: string;
-            tier?: string;
+            tier: "ec2" | "hosted";
             ttl_seconds?: number;
             labels?: Record<string, string>;
-            [field: string]: unknown;
         }) => Promise<{
             instance: SandboxInstance | null;
             error: string | null;
@@ -190,15 +188,13 @@ export declare const useSandboxInstances: () => {
     error: string | null;
     fetchInstances: (opts?: {
         limit?: number;
-        [option: string]: unknown;
     }) => Promise<unknown>;
     createInstance: (request: {
         organization_id: string;
         template?: string;
-        tier?: string;
+        tier: "ec2" | "hosted";
         ttl_seconds?: number;
         labels?: Record<string, string>;
-        [field: string]: unknown;
     }) => Promise<{
         instance: SandboxInstance | null;
         error: string | null;

package/dist/context/sources/scopes.d.ts

@@ -17,6 +17,7 @@
  * have no honest default and throw, naming themselves.
  */
 import type { ComponentType } from "react";
+import type { AssociationSourceEdge, AssociationTargetEdge } from "@ai-matrx/associations";
 import type { ChatDatabase, Json } from "../../host/db-types.js";
 import { type AnyComponent, type AnyFn } from "../../host/registered-source.js";
 export type ContextItemRow = ChatDatabase["context"]["Tables"]["context_items"]["Row"];
@@ -61,7 +62,6 @@ export interface ScopeTreeOrganization {
     projects?: Array<{
         id: string;
         name: string;
-        [field: string]: unknown;
     }>;
 }
 export interface ContextItemValue {
@@ -175,10 +175,10 @@ export interface AssociationEdgeRow {
 }
 export interface ChatAssociationsService {
     listForTargets(targetType: string, targetIds: string[], ...rest: any[]): Promise<ScopesRpcResult<{
-        edges: AssociationEdgeRow[];
+        edges: AssociationTargetEdge[];
     }>>;
     listForSources(sourceType: string, sourceIds: string[], ...rest: any[]): Promise<ScopesRpcResult<{
-        edges: AssociationEdgeRow[];
+        edges: AssociationSourceEdge[];
     }>>;
     add(input: any): Promise<ScopesRpcResult<any>>;
     remove(input: any): Promise<ScopesRpcResult<any>>;

package/dist/host/ui-slots.js

@@ -410,7 +410,7 @@ const loadCodeEditHistoryThunk = slotFn("loadCodeEditHistoryThunk");
 const applySkillStreamEvent = slotFn("applySkillStreamEvent");
 const isSkillStreamEvent = slotFn("isSkillStreamEvent", () => false);
 const materializeMessageArtifacts = slotFn("materializeMessageArtifacts");
-const reconcileMessagesArtifacts = slotFn("reconcileMessagesArtifacts", () => void 0);
+const reconcileMessagesArtifacts = slotFn("reconcileMessagesArtifacts", async () => void 0);
 const noteBrowserActivity = slotFn("noteBrowserActivity");
 const selectCloudBrowserRunLive = slotFn("selectCloudBrowserRunLive");
 const adoptCloudBrowserRunFromStream = slotFn("adoptCloudBrowserRunFromStream");

package/dist/host/window-openers.d.ts

@@ -27,7 +27,7 @@ export interface OpenAgentIdWindowOptions {
     agentId?: string | null;
 }
 export type OpenAgentAdminFindUsagesWindowOptions = OpenAgentIdWindowOptions;
-export type OpenAgentCreateAppWindowOptions = OpenAgentIdWindowOptions;
+export type OpenAgentCreateAppWindowOptions = Record<string, never>;
 export type OpenAgentDataStorageWindowOptions = OpenAgentIdWindowOptions;
 export type OpenAgentFindUsagesWindowOptions = OpenAgentIdWindowOptions;
 export type OpenAgentInterfaceVariationsWindowOptions = OpenAgentIdWindowOptions;
@@ -222,7 +222,7 @@ export interface EditorPrimaryAction {
     label: string;
     variant?: "default" | "secondary" | "outline" | "destructive" | "ghost" | "link";
 }
-export interface OpenFullScreenMarkdownEditorOptions {
+interface OpenFullScreenMarkdownEditorOptionsBase {
     instanceId?: string;
     content?: string;
     mode?: unknown;
@@ -236,14 +236,29 @@ export interface OpenFullScreenMarkdownEditorOptions {
     showSaveButton?: boolean;
     showCopyButton?: boolean;
     primaryActions?: EditorPrimaryAction[];
-    onSave?: (content: string) => void | Promise<void>;
-    onAction?: (action: string, content: string) => void | Promise<void>;
+}
+type OpenFullScreenMarkdownEditorHandlers = {
+    onSave: (content: string) => Promise<void>;
+    onAction?: never;
     onEvent?: (event: {
         type: "save";
         content: string;
         action?: string;
     }) => void | Promise<void>;
-}
+} | {
+    onSave?: never;
+    onAction: (action: string, content: string) => Promise<void>;
+    onEvent?: (event: {
+        type: "save";
+        content: string;
+        action?: string;
+    }) => void | Promise<void>;
+} | {
+    onSave?: undefined;
+    onAction?: undefined;
+    onEvent?: undefined;
+};
+export type OpenFullScreenMarkdownEditorOptions = OpenFullScreenMarkdownEditorOptionsBase & OpenFullScreenMarkdownEditorHandlers;
 export interface ChatFullScreenEditorHandle {
     instanceId: string;
     callbackGroupId: string | null;
@@ -361,3 +376,4 @@ export declare function useOpenTopicalMapWindow(): (opts: OpenTopicalMapWindowOp
 export declare function useOpenScratchpadPanel(): (opts?: OpenScratchpadPanelOptions) => ChatWindowHandle;
 export declare function useOpenWorkingDocumentPanel(): (opts: OpenWorkingDocumentPanelOptions) => ChatWindowHandle;
 export declare function useOpenWorkingDocumentWindow(): (opts: OpenWorkingDocumentWindowOptions) => ChatInstanceWindowHandle;
+export {};

package/dist/surfaces/lib/ui-surfaces-agent-writes.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Pure parsers for the UI Surfaces registry's agent write targets
+ * (`create_surfaces` / `update_surfaces` / `delete_surfaces` on
+ * `matrx-admin/ui-surfaces`). Each reads the agent's WHOLE list, reports every
+ * problem at once, and returns plans the page saves through its own service
+ * functions. No I/O here — unit-tested in `__tests__/ui-surfaces-agent-writes.test.ts`.
+ */
+export declare const DEFAULT_PARENT = "matrx-default/default";
+export declare const DEFAULT_SORT_ORDER = 150;
+/** What a parser needs to know about one existing surface. */
+export interface ExistingSurface {
+    name: string;
+    has_manifest: boolean;
+}
+export interface SurfaceWriteContext {
+    existing: readonly ExistingSurface[];
+    clientNames: readonly string[];
+}
+export interface CreateSurfacePlan {
+    name: string;
+    client_name: string;
+    label: string | null;
+    description: string;
+    parent_surface_name: string | null;
+    sort_order: number;
+    is_active: boolean;
+    executor_name: string | null;
+    url_pattern: string | null;
+}
+export interface UpdateSurfacePatch {
+    description?: string | null;
+    parent_surface_name?: string | null;
+    sort_order?: number;
+    is_active?: boolean;
+    executor_name?: string | null;
+    url_pattern?: string | null;
+}
+export interface UpdateSurfacePlan {
+    name: string;
+    patch: UpdateSurfacePatch;
+    changed: string[];
+}
+export declare function parseCreateSurfacesValue(value: unknown, ctx: SurfaceWriteContext): CreateSurfacePlan[];
+export declare function parseUpdateSurfacesValue(value: unknown, ctx: SurfaceWriteContext): UpdateSurfacePlan[];
+export declare function parseDeleteSurfacesValue(value: unknown, ctx: SurfaceWriteContext): ExistingSurface[];
+/** Fields the New surface dialog holds — the `new_surface_draft` target. */
+export interface NewSurfaceDraftFields {
+    client?: string;
+    local?: string;
+    /** A surface name, or null for a root surface. */
+    parent_surface_name?: string | null;
+    /** A tier label: Pages | Specialized | Overlays | Editor variants | Debug. */
+    tier?: string;
+    description?: string;
+}
+export declare const NEW_SURFACE_TIERS: readonly ["Pages", "Specialized", "Overlays", "Editor variants", "Debug"];
+/**
+ * Read the `new_surface_draft` value: an OBJECT with any of { name, parent_surface_name,
+ * tier, description }. Every problem is reported at once; nothing is saved.
+ */
+export declare function parseNewSurfaceDraftValue(value: unknown, ctx: SurfaceWriteContext): NewSurfaceDraftFields;

package/dist/surfaces/lib/ui-surfaces-agent-writes.js

@@ -0,0 +1,305 @@
+import {
+  collectProblems,
+  ListLevelProblem,
+  ProblemList,
+  readCollectionList,
+  repeatsProblem
+} from "../runtime/collection-write-targets.js";
+const DEFAULT_PARENT = "matrx-default/default";
+const DEFAULT_SORT_ORDER = 150;
+const LOCAL_RE = /^[a-z0-9][a-z0-9-/]*$/;
+const UPDATE_FIELDS = [
+  "description",
+  "parent_surface_name",
+  "sort_order",
+  "is_active",
+  "executor_name",
+  "url_pattern"
+];
+const MANIFEST_OWNED = /* @__PURE__ */ new Set([
+  "description",
+  "parent_surface_name",
+  "is_active",
+  "url_pattern"
+]);
+function asObject(raw) {
+  if (raw === null || typeof raw !== "object" || Array.isArray(raw))
+    throw new Error("must be an object.");
+  return raw;
+}
+function optionalText(obj, key, problems, nullable) {
+  if (!(key in obj)) return void 0;
+  const v = obj[key];
+  if (v === null && nullable) return null;
+  if (typeof v !== "string") {
+    problems.add(`${key} must be a string${nullable ? " or null" : ""}.`);
+    return void 0;
+  }
+  return v.trim();
+}
+function readSortOrder(obj, problems) {
+  if (!("sort_order" in obj)) return void 0;
+  const v = obj.sort_order;
+  if (typeof v !== "number" || !Number.isInteger(v) || v < 100) {
+    problems.add(
+      "sort_order must be a whole number of at least 100 (0-99 is reserved)."
+    );
+    return void 0;
+  }
+  return v;
+}
+function readParent(obj, names, problems, self) {
+  const parent = optionalText(obj, "parent_surface_name", problems, true);
+  if (typeof parent === "string") {
+    if (!parent) return null;
+    if (parent === self) {
+      problems.add("a surface cannot be its own parent.");
+      return void 0;
+    }
+    if (!names.has(parent)) {
+      problems.add(`parent_surface_name "${parent}" is not a surface in the registry.`);
+      return void 0;
+    }
+  }
+  return parent;
+}
+function nameOfRaw(raw) {
+  if (typeof raw === "string") return raw;
+  if (raw && typeof raw === "object" && typeof raw.name === "string")
+    return raw.name;
+  return void 0;
+}
+function parseCreateSurfacesValue(value, ctx) {
+  const target = "create_surfaces";
+  const list = readCollectionList(target, "surfaces", value);
+  const names = new Set(ctx.existing.map((s) => s.name));
+  const clients = new Set(ctx.clientNames);
+  return collectProblems(
+    target,
+    list,
+    (raw) => {
+      const obj = asObject(raw);
+      const problems = new ProblemList(target);
+      const name = typeof obj.name === "string" ? obj.name.trim() : "";
+      let client = "";
+      if (!name) problems.add('name is required ("<client>/<local>").');
+      else {
+        const slash = name.indexOf("/");
+        client = slash > 0 ? name.slice(0, slash) : "";
+        const local = slash > 0 ? name.slice(slash + 1) : "";
+        if (!client || !local)
+          problems.add(`name "${name}" must be "<client>/<local>".`);
+        else {
+          if (!clients.has(client))
+            problems.add(
+              `client "${client}" is not a UI client (one of: ${[...clients].join(", ")}).`
+            );
+          if (!LOCAL_RE.test(local))
+            problems.add(
+              `the local part "${local}" may use only lowercase letters, digits, hyphens and slashes.`
+            );
+        }
+      }
+      const label = optionalText(obj, "label", problems, true);
+      const description = optionalText(obj, "description", problems, true);
+      const parent = readParent(obj, names, problems);
+      const sort = readSortOrder(obj, problems);
+      const executor = optionalText(obj, "executor_name", problems, true);
+      const url = optionalText(obj, "url_pattern", problems, true);
+      let isActive = true;
+      if ("is_active" in obj) {
+        if (typeof obj.is_active !== "boolean")
+          problems.add("is_active must be true or false.");
+        else isActive = obj.is_active;
+      }
+      problems.throwIfAny();
+      return {
+        name,
+        client_name: client,
+        label: label || null,
+        description: description ?? "",
+        parent_surface_name: parent === void 0 ? DEFAULT_PARENT : parent,
+        sort_order: sort ?? DEFAULT_SORT_ORDER,
+        is_active: isActive,
+        executor_name: executor || null,
+        url_pattern: url || null
+      };
+    },
+    {
+      nameOf: nameOfRaw,
+      listChecks: (items) => [
+        repeatsProblem(target, items.map((i) => i.name), "name"),
+        ...items.filter((i) => i.name && names.has(i.name)).map(
+          (i) => `${target}[${i.index}] "${i.name}" already exists in the registry \u2014 use update_surfaces to change it.`
+        )
+      ]
+    }
+  );
+}
+function parseUpdateSurfacesValue(value, ctx) {
+  const target = "update_surfaces";
+  const list = readCollectionList(target, "surfaces", value);
+  const byName = new Map(ctx.existing.map((s) => [s.name, s]));
+  const names = new Set(byName.keys());
+  return collectProblems(
+    target,
+    list,
+    (raw) => {
+      const obj = asObject(raw);
+      const name = typeof obj.name === "string" ? obj.name.trim() : "";
+      if (!name) throw new Error("name is required (from surfaces).");
+      const current = byName.get(name);
+      if (!current)
+        throw new ListLevelProblem(
+          `${target}: "${name}" is not a surface in the registry.`
+        );
+      const problems = new ProblemList(target);
+      const unknown = Object.keys(obj).filter(
+        (k) => k !== "name" && !UPDATE_FIELDS.includes(k)
+      );
+      if (unknown.length)
+        problems.add(
+          `cannot change ${unknown.join(", ")} here (changeable: ${UPDATE_FIELDS.join(", ")}).`
+        );
+      if (current.has_manifest) {
+        const owned = Object.keys(obj).filter((k) => MANIFEST_OWNED.has(k));
+        if (owned.length)
+          problems.add(
+            `"${name}" has a code manifest, which owns ${owned.join(", ")} \u2014 Sync manifests would overwrite the change. Change the manifest in code; here only sort_order and executor_name may change.`
+          );
+      }
+      const patch = {};
+      const description = optionalText(obj, "description", problems, true);
+      if (description !== void 0) patch.description = description || null;
+      const parent = readParent(obj, names, problems, name);
+      if (parent !== void 0) patch.parent_surface_name = parent;
+      const sort = readSortOrder(obj, problems);
+      if (sort !== void 0) patch.sort_order = sort;
+      if ("is_active" in obj) {
+        if (typeof obj.is_active !== "boolean")
+          problems.add("is_active must be true or false.");
+        else patch.is_active = obj.is_active;
+      }
+      const executor = optionalText(obj, "executor_name", problems, true);
+      if (executor !== void 0) patch.executor_name = executor || null;
+      const url = optionalText(obj, "url_pattern", problems, true);
+      if (url !== void 0) patch.url_pattern = url || null;
+      problems.throwIfAny();
+      const changed = Object.keys(patch);
+      if (changed.length === 0) throw new Error("sends no field to change.");
+      return { name, patch, changed };
+    },
+    {
+      nameOf: nameOfRaw,
+      listChecks: (items) => [
+        repeatsProblem(target, items.map((i) => i.name), "surface")
+      ]
+    }
+  );
+}
+function parseDeleteSurfacesValue(value, ctx) {
+  const target = "delete_surfaces";
+  const list = readCollectionList(target, "surfaces", value);
+  const byName = new Map(ctx.existing.map((s) => [s.name, s]));
+  return collectProblems(
+    target,
+    list,
+    (raw) => {
+      const name = nameOfRaw(raw)?.trim();
+      if (!name) throw new Error('must be a surface name or { "name": "\u2026" }.');
+      const current = byName.get(name);
+      if (!current)
+        throw new ListLevelProblem(
+          `${target}: "${name}" is not a surface in the registry.`
+        );
+      if (current.has_manifest)
+        throw new Error(
+          `"${name}" has a code manifest, so code owns it: remove the manifest in code, or deactivate it instead.`
+        );
+      return current;
+    },
+    {
+      nameOf: nameOfRaw,
+      listChecks: (items) => [
+        repeatsProblem(target, items.map((i) => i.name), "surface")
+      ]
+    }
+  );
+}
+const NEW_SURFACE_TIERS = [
+  "Pages",
+  "Specialized",
+  "Overlays",
+  "Editor variants",
+  "Debug"
+];
+function parseNewSurfaceDraftValue(value, ctx) {
+  const target = "new_surface_draft";
+  const problems = new ProblemList(target);
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    problems.add(
+      "new_surface_draft expects a JSON OBJECT like { name, parent_surface_name, tier, description }."
+    );
+    problems.throwIfAny();
+  }
+  const obj = value;
+  const allowed = ["name", "parent_surface_name", "tier", "description"];
+  const unknown = Object.keys(obj).filter((k) => !allowed.includes(k));
+  if (unknown.length)
+    problems.add(
+      `the dialog has no ${unknown.join(", ")} field (fields: ${allowed.join(", ")}).`
+    );
+  const out = {};
+  if ("name" in obj) {
+    const name = typeof obj.name === "string" ? obj.name.trim() : "";
+    const slash = name.indexOf("/");
+    const client = slash > 0 ? name.slice(0, slash) : "";
+    const local = slash > 0 ? name.slice(slash + 1) : "";
+    if (!client || !local) problems.add(`name must be "<client>/<local>".`);
+    else {
+      if (!ctx.clientNames.includes(client))
+        problems.add(
+          `client "${client}" is not a UI client (one of: ${ctx.clientNames.join(", ")}).`
+        );
+      if (!LOCAL_RE.test(local))
+        problems.add(
+          `the local part "${local}" may use only lowercase letters, digits, hyphens and slashes.`
+        );
+      if (ctx.existing.some((s) => s.name === name))
+        problems.add(`"${name}" already exists in the registry.`);
+      out.client = client;
+      out.local = local;
+    }
+  }
+  if ("parent_surface_name" in obj) {
+    const parent = readParent(
+      obj,
+      new Set(ctx.existing.map((s) => s.name)),
+      problems
+    );
+    if (parent !== void 0) out.parent_surface_name = parent;
+  }
+  if ("tier" in obj) {
+    if (typeof obj.tier !== "string" || !NEW_SURFACE_TIERS.includes(obj.tier))
+      problems.add(`tier must be one of: ${NEW_SURFACE_TIERS.join(", ")}.`);
+    else out.tier = obj.tier;
+  }
+  if ("description" in obj) {
+    if (typeof obj.description !== "string")
+      problems.add("description must be a string.");
+    else out.description = obj.description;
+  }
+  problems.throwIfAny();
+  if (Object.keys(out).length === 0)
+    throw new Error("new_surface_draft sends no field to fill. Nothing was changed.");
+  return out;
+}
+export {
+  DEFAULT_PARENT,
+  DEFAULT_SORT_ORDER,
+  NEW_SURFACE_TIERS,
+  parseCreateSurfacesValue,
+  parseDeleteSurfacesValue,
+  parseNewSurfaceDraftValue,
+  parseUpdateSurfacesValue
+};

package/dist/surfaces/lib/ui-surfaces-scope.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Pure scope builder for the UI Surfaces registry page
+ * (`matrx-admin/ui-surfaces`, `/administration/ui/surfaces`).
+ *
+ * Called by `SurfacesContainer` with state the page already rendered — it
+ * never fetches (the runtime polls it every 400 ms). Not loaded yet → the
+ * registry keys are omitted; a failed load reports only `load_state`.
+ */
+import type { SurfaceScopePayload } from "../types.js";
+import { type UiSurfaceScopeEntry, type UiSurfacesFilterScope, type UiSurfacesRegistryCounts } from "../manifests/admin-ui-surfaces.manifest.js";
+import { type SurfaceWithStats } from "../services/surfaces.service.js";
+import type { SurfacesFilterState } from "../host-surface-types.js";
+import type { NewSurfaceDraftScope } from "../host-surface-types.js";
+/** How many rows `surface_list` carries up front (~4,000 chars). */
+export declare const SURFACE_LIST_MAX_ROWS = 40;
+export type UiSurfacesDialog = "new_surface" | "new_client" | "candidates" | "sync_manifests" | "drift_report";
+export interface UiSurfacesScopeInput {
+    loading: boolean;
+    error: string | null;
+    /** Every row loaded (empty until the first successful load). */
+    surfaces: readonly SurfaceWithStats[];
+    /** The rows after the page's own filters, in the page's order. */
+    visible: readonly SurfaceWithStats[];
+    clientNames: readonly string[];
+    manifestedNames: ReadonlySet<string>;
+    filters: SurfacesFilterState;
+    readinessCounts: UiSurfacesRegistryCounts["readiness"];
+    candidatesAvailable: number;
+    /** The drift report's total (countDriftIssues); null until it loads. */
+    driftIssues: number | null;
+    peekedName: string | null;
+    openDialog: UiSurfacesDialog | null;
+    /** The New surface dialog's live values; null while it is closed. */
+    newSurfaceDraft: NewSurfaceDraftScope | null;
+}
+export declare function filtersToScope(f: SurfacesFilterState): UiSurfacesFilterScope;
+export declare function toSurfaceScopeEntry(row: SurfaceWithStats, manifestedNames: ReadonlySet<string>): UiSurfaceScopeEntry;
+/** The condensed on-screen list as one XML bundle. */
+export declare function buildSurfaceListBundle(visible: readonly SurfaceWithStats[], manifestedNames: ReadonlySet<string>, filters: UiSurfacesFilterScope): string;
+export declare function buildUiSurfacesScope(input: UiSurfacesScopeInput): SurfaceScopePayload;

package/dist/surfaces/lib/ui-surfaces-scope.js

@@ -0,0 +1,116 @@
+import { getManifest } from "../runtime/registry.js";
+import {
+  createAdminUiSurfacesScope
+} from "../manifests/admin-ui-surfaces.manifest.js";
+import {
+  readinessBucketOf,
+  tierFor
+} from "../services/surfaces.service.js";
+import { surfaceCheckState } from "../utils/surface-check-ledger.js";
+import { xmlElement, xmlList } from "../runtime/context-bundle.js";
+const SURFACE_LIST_MAX_ROWS = 40;
+function filtersToScope(f) {
+  return {
+    client: f.client === "__all__" ? "all" : f.client,
+    status: f.status,
+    check_age: f.checked,
+    manifest: f.manifest,
+    parent: f.parent === "__all__" ? "all" : f.parent === "__none__" ? "none" : f.parent,
+    readiness: f.readiness
+  };
+}
+function toSurfaceScopeEntry(row, manifestedNames) {
+  return {
+    name: row.name,
+    label: row.label ?? null,
+    client_name: row.client_name,
+    executor_name: row.executor_name ?? null,
+    parent_surface_name: row.parent_surface_name ?? null,
+    sort_order: row.sort_order,
+    tier: tierFor(row.sort_order).label,
+    is_active: row.is_active !== false,
+    readiness: readinessBucketOf(row),
+    readiness_note: row.readiness_note ?? null,
+    has_manifest: manifestedNames.has(row.name),
+    value_count: row.surfaceValueCount,
+    declared_value_count: getManifest(row.name)?.values.length ?? null,
+    agent_count: row.agentCount,
+    tool_count: row.toolCount,
+    check_state: surfaceCheckState(row),
+    last_checked_at: row.last_checked_at ?? null,
+    last_checked_by: row.last_checked_by ?? null,
+    url_pattern: row.url_pattern ?? null,
+    description: row.description ?? null
+  };
+}
+function buildSurfaceListBundle(visible, manifestedNames, filters) {
+  const active = Object.fromEntries(
+    Object.entries(filters).filter(([, v]) => v !== "all")
+  );
+  return xmlList(
+    "surfaces",
+    visible,
+    (row) => xmlElement("s", {
+      name: row.name,
+      label: row.label,
+      client: row.client_name,
+      parent: row.parent_surface_name,
+      tier: `${tierFor(row.sort_order).label} ${row.sort_order}`,
+      readiness: readinessBucketOf(row),
+      values: row.surfaceValueCount,
+      declared: getManifest(row.name)?.values.length,
+      agents: row.agentCount,
+      tools: row.toolCount,
+      checked: surfaceCheckState(row),
+      active: row.is_active !== false,
+      manifest: manifestedNames.has(row.name)
+    }),
+    { maxRows: SURFACE_LIST_MAX_ROWS, attrs: active }
+  ) || '<surfaces total="0"/>';
+}
+function buildUiSurfacesScope(input) {
+  const filters = filtersToScope(input.filters);
+  const extras = {
+    ...input.peekedName ? { peeked_surface: input.peekedName } : {},
+    ...input.openDialog ? { open_dialog: input.openDialog } : {},
+    ...input.newSurfaceDraft ? { new_surface_draft: input.newSurfaceDraft } : {}
+  };
+  if (input.error) {
+    return createAdminUiSurfacesScope({
+      load_state: `error: ${input.error}`,
+      filters,
+      ...extras
+    });
+  }
+  if (input.loading && input.surfaces.length === 0) {
+    return createAdminUiSurfacesScope({ load_state: "loading", filters, ...extras });
+  }
+  const surfaces = input.surfaces.map(
+    (s) => toSurfaceScopeEntry(s, input.manifestedNames)
+  );
+  return createAdminUiSurfacesScope({
+    load_state: "ready",
+    filters,
+    surface_list: buildSurfaceListBundle(input.visible, input.manifestedNames, filters),
+    surfaces,
+    registry_counts: {
+      total: surfaces.length,
+      active: surfaces.filter((s) => s.is_active).length,
+      manifests: input.manifestedNames.size,
+      unused: surfaces.filter((s) => s.agent_count === 0 && s.tool_count === 0).length,
+      visible: input.visible.length,
+      readiness: input.readinessCounts,
+      candidates_available: input.candidatesAvailable,
+      ...input.driftIssues !== null ? { drift_issues: input.driftIssues } : {}
+    },
+    client_names: [...input.clientNames],
+    ...extras
+  });
+}
+export {
+  SURFACE_LIST_MAX_ROWS,
+  buildSurfaceListBundle,
+  buildUiSurfacesScope,
+  filtersToScope,
+  toSurfaceScopeEntry
+};

package/dist/tool-call-visualization/effects/toolStateEffects.d.ts

@@ -27,7 +27,7 @@
  * that dispatches the feature's refetch thunk(s). Known not-yet-covered
  * writers (no canonical Redux refetch today, or their state is hook-local):
  * picklist (session-cached `usePickListDetail`), dictionary, workbook,
- * dataset/usertable, document. The working document is already reconciled by
+ * dataset, document. The working document is already reconciled by
  * its own `context_changed` re-read; the scratchpad is agent-readonly.
  */
 import type { ChatRootState } from "../../store/root-state.js";

package/dist/tool-call-visualization/registry/registry.js

@@ -1066,7 +1066,6 @@ const APP_FEATURE_TOOL_NAMES = /* @__PURE__ */ new Set([
   "user_todos",
   "document",
   "dataset",
-  "usertable_create",
   "knowledge_search",
   "document_search",
   "knowledge_browse",
@@ -1202,7 +1201,6 @@ const TOOL_GLYPHS = {
   update_plan: { icon: ListTodo, accent: "primary" },
   document: { icon: FileText, accent: "slate" },
   dataset: { icon: Table2, accent: "cyan" },
-  usertable_create: { icon: Table2, accent: "cyan" },
   workbook: { icon: Sheet, accent: "green" },
   dictionary: { icon: BookText, accent: "amber" },
   note: { icon: NotebookPen, accent: "amber" },