@pellux/goodvibes-agent 1.5.5 → 1.5.6

package/src/input/agent-workspace-knowledge-command-editor-submission.ts

@@ -1,96 +1,50 @@
-import type { AgentWorkspaceActionResult, AgentWorkspaceLocalEditor } from './agent-workspace-types.ts';
+import type { AgentWorkspaceLocalEditor } from './agent-workspace-types.ts';
 import type { AgentWorkspaceKnowledgeCommandEditorKind } from './agent-workspace-knowledge-command-editors.ts';
 import { isAgentWorkspaceKnowledgeCommandEditorKind } from './agent-workspace-knowledge-command-editors.ts';
 import { quoteSlashCommandArg } from './slash-command-parser.ts';
+import type { AgentWorkspaceCommandEditorSubmission, AgentWorkspaceCommandSubmissionHandler, AgentWorkspaceFieldReader } from './agent-workspace-command-editor-engine.ts';
+import { buildCommandEditorSubmissionFromTable, dispatchCommandEditorSubmission, editorMessageSubmission, isAffirmative, splitCommaList } from './agent-workspace-command-editor-engine.ts';
 
-type AgentWorkspaceFieldReader = (fieldId: string) => string;
-
-export type AgentWorkspaceKnowledgeCommandEditorSubmission =
-  | {
-    readonly kind: 'editor';
-    readonly editor: AgentWorkspaceLocalEditor;
-    readonly status: string;
-    readonly actionResult?: AgentWorkspaceActionResult;
-  }
-  | {
-    readonly kind: 'dispatch';
-    readonly command: string;
-    readonly status: string;
-    readonly actionResult: AgentWorkspaceActionResult;
-  };
+export type AgentWorkspaceKnowledgeCommandEditorSubmission = AgentWorkspaceCommandEditorSubmission;
 
 export function isAgentWorkspaceKnowledgeCommandSubmissionKind(kind: string): kind is AgentWorkspaceKnowledgeCommandEditorKind {
   return isAgentWorkspaceKnowledgeCommandEditorKind(kind as AgentWorkspaceKnowledgeCommandEditorKind);
 }
 
-function isAffirmative(value: string): boolean {
-  return /^(y|yes|true)$/i.test(value.trim());
-}
-
-function splitCommaList(value: string): readonly string[] {
-  return value.split(',').map((entry) => entry.trim()).filter(Boolean);
-}
-
-function unconfirmed(editor: AgentWorkspaceLocalEditor, message: string): AgentWorkspaceKnowledgeCommandEditorSubmission {
-  return {
-    kind: 'editor',
-    editor: { ...editor, message },
-    status: message,
-  };
-}
-
-function dispatch(command: string, title: string, detail: string, safety: AgentWorkspaceActionResult['safety']): AgentWorkspaceKnowledgeCommandEditorSubmission {
-  return {
-    kind: 'dispatch',
-    command,
-    status: `${title}.`,
-    actionResult: { kind: 'dispatched', title, detail, command, safety },
-  };
-}
-
-export function buildAgentWorkspaceKnowledgeCommandEditorSubmission(
-  editor: AgentWorkspaceLocalEditor,
-  readField: AgentWorkspaceFieldReader,
-): AgentWorkspaceKnowledgeCommandEditorSubmission {
-  if (editor.kind === 'knowledge-get') {
-    return dispatch(
-      `/knowledge get ${quoteSlashCommandArg(readField('id'))}`,
-      'Opening Agent Knowledge item',
-      'The workspace handed a read-only Agent Knowledge item command to the shell-owned command router.',
-      'read-only',
-    );
-  }
-  if (editor.kind === 'knowledge-map') {
+const KNOWLEDGE_COMMAND_SUBMISSION_HANDLERS: Readonly<Record<AgentWorkspaceKnowledgeCommandEditorKind, AgentWorkspaceCommandSubmissionHandler>> = {
+  'knowledge-get': (_editor, readField) => dispatchCommandEditorSubmission(
+    `/knowledge get ${quoteSlashCommandArg(readField('id'))}`,
+    'Opening Agent Knowledge item',
+    'The workspace handed a read-only Agent Knowledge item command to the shell-owned command router.',
+    'read-only',
+  ),
+  'knowledge-map': (_editor, readField) => {
     const query = readField('query');
     const limit = readField('limit');
     const parts = ['/knowledge', 'map'];
     if (query.length > 0) parts.push(quoteSlashCommandArg(query));
     if (limit.length > 0) parts.push('--limit', quoteSlashCommandArg(limit));
-    return dispatch(
+    return dispatchCommandEditorSubmission(
       parts.join(' '),
       'Opening Agent Knowledge map',
       'The workspace handed a read-only Agent Knowledge map command to the shell-owned command router.',
       'read-only',
     );
-  }
-  if (editor.kind === 'knowledge-connector-show') {
-    return dispatch(
-      `/knowledge connectors ${quoteSlashCommandArg(readField('connectorId'))}`,
-      'Opening Agent Knowledge connector',
-      'The workspace handed a read-only Agent Knowledge connector detail command to the shell-owned command router.',
-      'read-only',
-    );
-  }
-  if (editor.kind === 'knowledge-connector-doctor') {
-    return dispatch(
-      `/knowledge connectors doctor ${quoteSlashCommandArg(readField('connectorId'))}`,
-      'Opening Agent Knowledge connector doctor',
-      'The workspace handed a read-only Agent Knowledge connector doctor command to the shell-owned command router.',
-      'read-only',
-    );
-  }
-  if (editor.kind === 'knowledge-review-issue') {
-    if (!isAffirmative(readField('confirm'))) return unconfirmed(editor, 'Agent Knowledge issue review not confirmed. Type yes, then press Enter.');
+  },
+  'knowledge-connector-show': (_editor, readField) => dispatchCommandEditorSubmission(
+    `/knowledge connectors ${quoteSlashCommandArg(readField('connectorId'))}`,
+    'Opening Agent Knowledge connector',
+    'The workspace handed a read-only Agent Knowledge connector detail command to the shell-owned command router.',
+    'read-only',
+  ),
+  'knowledge-connector-doctor': (_editor, readField) => dispatchCommandEditorSubmission(
+    `/knowledge connectors doctor ${quoteSlashCommandArg(readField('connectorId'))}`,
+    'Opening Agent Knowledge connector doctor',
+    'The workspace handed a read-only Agent Knowledge connector doctor command to the shell-owned command router.',
+    'read-only',
+  ),
+  'knowledge-review-issue': (editor, readField) => {
+    if (!isAffirmative(readField('confirm'))) return editorMessageSubmission(editor, 'Agent Knowledge issue review not confirmed. Type yes, then press Enter.');
     const parts = [
       '/knowledge',
       'review-issue',
@@ -102,31 +56,48 @@ export function buildAgentWorkspaceKnowledgeCommandEditorSubmission(
     if (reviewer.length > 0) parts.push('--reviewer', quoteSlashCommandArg(reviewer));
     if (value.length > 0) parts.push('--value', quoteSlashCommandArg(value));
     parts.push('--yes');
-    return dispatch(
+    return dispatchCommandEditorSubmission(
       parts.join(' '),
       'Opening Agent Knowledge issue review',
       'The workspace handed a confirmed Agent Knowledge issue review command to the shell-owned command router.',
       'safe',
     );
-  }
-  if (editor.kind === 'knowledge-consolidate') {
-    if (!isAffirmative(readField('confirm'))) return unconfirmed(editor, 'Agent Knowledge consolidation not confirmed. Type yes, then press Enter.');
-    return dispatch(
+  },
+  'knowledge-consolidate': (editor, readField) => {
+    if (!isAffirmative(readField('confirm'))) return editorMessageSubmission(editor, 'Agent Knowledge consolidation not confirmed. Type yes, then press Enter.');
+    return dispatchCommandEditorSubmission(
       `/knowledge consolidate ${quoteSlashCommandArg(readField('mode'))} --yes`,
       'Opening Agent Knowledge consolidation',
       'The workspace handed a confirmed Agent Knowledge consolidation command to the shell-owned command router.',
       'safe',
     );
-  }
+  },
+  'knowledge-explain': (editor, readField) => knowledgeExplainOrPacket(editor, readField),
+  'knowledge-packet': (editor, readField) => knowledgeExplainOrPacket(editor, readField),
+};
+
+function knowledgeExplainOrPacket(editor: AgentWorkspaceLocalEditor, readField: AgentWorkspaceFieldReader): AgentWorkspaceCommandEditorSubmission {
   const subcommand = editor.kind === 'knowledge-explain' ? 'explain' : 'packet';
   const parts = ['/knowledge', subcommand, quoteSlashCommandArg(readField('task'))];
   for (const scope of splitCommaList(readField('scopes'))) {
     parts.push('--scope', quoteSlashCommandArg(scope));
   }
-  return dispatch(
+  return dispatchCommandEditorSubmission(
     parts.join(' '),
     subcommand === 'explain' ? 'Opening Agent Knowledge explanation' : 'Opening Agent Knowledge prompt packet',
     'The workspace handed a read-only Agent Knowledge context command to the shell-owned command router.',
     'read-only',
   );
 }
+
+export function buildAgentWorkspaceKnowledgeCommandEditorSubmission(
+  editor: AgentWorkspaceLocalEditor,
+  readField: AgentWorkspaceFieldReader,
+): AgentWorkspaceCommandEditorSubmission {
+  return buildCommandEditorSubmissionFromTable(
+    editor.kind as AgentWorkspaceKnowledgeCommandEditorKind,
+    editor,
+    readField,
+    KNOWLEDGE_COMMAND_SUBMISSION_HANDLERS,
+  );
+}

package/src/input/agent-workspace-knowledge-command-editors.ts

@@ -1,4 +1,6 @@
 import type { AgentWorkspaceEditorKind, AgentWorkspaceLocalEditor } from './agent-workspace-types.ts';
+import type { AgentWorkspaceEditorSpec, AgentWorkspaceEditorSpecEntry } from './agent-workspace-command-editor-engine.ts';
+import { createAgentWorkspaceEditorFromTable } from './agent-workspace-command-editor-engine.ts';
 
 export type AgentWorkspaceKnowledgeCommandEditorKind = Extract<
   AgentWorkspaceEditorKind,
@@ -23,79 +25,24 @@ export function isAgentWorkspaceKnowledgeCommandEditorKind(kind: AgentWorkspaceE
     || kind === 'knowledge-explain';
 }
 
-export function createAgentWorkspaceKnowledgeCommandEditor(kind: AgentWorkspaceKnowledgeCommandEditorKind): AgentWorkspaceLocalEditor {
-  if (kind === 'knowledge-get') {
-    return {
-      kind,
-      mode: 'create',
-      title: 'Show Agent Knowledge Item',
-      selectedFieldIndex: 0,
-      message: 'Show one source, node, or issue from the isolated Agent Knowledge segment.',
-      fields: [
-        { id: 'id', label: 'Item id', value: '', required: true, multiline: false, hint: 'Agent Knowledge source, node, or issue id.' },
-      ],
-    };
-  }
-  if (kind === 'knowledge-map') {
-    return {
-      kind,
-      mode: 'create',
-      title: 'Map Agent Knowledge',
-      selectedFieldIndex: 0,
-      message: 'Summarize the isolated Agent Knowledge graph map. Leave query blank for a bounded full map summary.',
-      fields: [
-        { id: 'query', label: 'Query', value: '', required: false, multiline: false, hint: 'Optional map filter query.' },
-        { id: 'limit', label: 'Limit', value: '50', required: false, multiline: false, hint: 'Maximum map records to summarize.' },
-      ],
-    };
-  }
-  if (kind === 'knowledge-connector-show' || kind === 'knowledge-connector-doctor') {
-    const doctor = kind === 'knowledge-connector-doctor';
-    return {
-      kind,
-      mode: 'create',
-      title: doctor ? 'Doctor Agent Knowledge Connector' : 'Show Agent Knowledge Connector',
-      selectedFieldIndex: 0,
-      message: doctor
-        ? 'Run a read-only readiness doctor for one Agent Knowledge connector.'
-        : 'Show one Agent Knowledge connector from the isolated Agent Knowledge connector registry.',
-      fields: [
-        { id: 'connectorId', label: 'Connector id', value: '', required: true, multiline: false, hint: 'Connector id from the Agent Knowledge connector inventory.' },
-      ],
-    };
-  }
-  if (kind === 'knowledge-review-issue') {
-    return {
-      kind,
-      mode: 'update',
-      title: 'Review Agent Knowledge Issue',
-      selectedFieldIndex: 0,
-      message: 'Accept, reject, resolve, reopen, edit, or forget one Agent Knowledge issue. Type yes on the final field to confirm.',
-      fields: [
-        { id: 'issueId', label: 'Issue id', value: '', required: true, multiline: false, hint: 'Issue id from the review queue.' },
-        { id: 'action', label: 'Action', value: 'resolve', required: true, multiline: false, hint: 'accept, reject, resolve, reopen, edit, or forget.' },
-        { id: 'reviewer', label: 'Reviewer', value: 'agent', required: false, multiline: false, hint: 'Reviewer label. Blank defaults to agent.' },
-        { id: 'value', label: 'Value JSON', value: '', required: false, multiline: true, hint: 'Optional JSON object for edit actions. Ctrl-J inserts a new line.' },
-        { id: 'confirm', label: 'Confirm', value: '', required: true, multiline: false, hint: 'Type yes to run /knowledge review-issue with --yes.' },
-      ],
-    };
-  }
-  if (kind === 'knowledge-consolidate') {
-    return {
-      kind,
-      mode: 'update',
-      title: 'Consolidate Agent Knowledge',
-      selectedFieldIndex: 0,
-      message: 'Run isolated Agent Knowledge consolidation. Type yes on the final field to confirm.',
-      fields: [
-        { id: 'mode', label: 'Mode', value: 'light', required: true, multiline: false, hint: 'light or deep.' },
-        { id: 'confirm', label: 'Confirm', value: '', required: true, multiline: false, hint: 'Type yes to run /knowledge consolidate with --yes.' },
-      ],
-    };
-  }
+function knowledgeConnectorSpec(kind: AgentWorkspaceKnowledgeCommandEditorKind): AgentWorkspaceEditorSpec {
+  const doctor = kind === 'knowledge-connector-doctor';
+  return {
+    mode: 'create',
+    title: doctor ? 'Doctor Agent Knowledge Connector' : 'Show Agent Knowledge Connector',
+    selectedFieldIndex: 0,
+    message: doctor
+      ? 'Run a read-only readiness doctor for one Agent Knowledge connector.'
+      : 'Show one Agent Knowledge connector from the isolated Agent Knowledge connector registry.',
+    fields: [
+      { id: 'connectorId', label: 'Connector id', value: '', required: true, multiline: false, hint: 'Connector id from the Agent Knowledge connector inventory.' },
+    ],
+  };
+}
+
+function knowledgeExplainOrPacketSpec(kind: AgentWorkspaceKnowledgeCommandEditorKind): AgentWorkspaceEditorSpec {
   const explain = kind === 'knowledge-explain';
   return {
-    kind,
     mode: 'create',
     title: explain ? 'Explain Memory Selection' : 'Build Prompt Packet',
     selectedFieldIndex: 0,
@@ -108,3 +55,56 @@ export function createAgentWorkspaceKnowledgeCommandEditor(kind: AgentWorkspaceK
     ],
   };
 }
+
+const KNOWLEDGE_COMMAND_EDITOR_SPECS: Readonly<Record<AgentWorkspaceKnowledgeCommandEditorKind, AgentWorkspaceEditorSpecEntry<AgentWorkspaceKnowledgeCommandEditorKind>>> = {
+  'knowledge-get': {
+    mode: 'create',
+    title: 'Show Agent Knowledge Item',
+    selectedFieldIndex: 0,
+    message: 'Show one source, node, or issue from the isolated Agent Knowledge segment.',
+    fields: [
+      { id: 'id', label: 'Item id', value: '', required: true, multiline: false, hint: 'Agent Knowledge source, node, or issue id.' },
+    ],
+  },
+  'knowledge-map': {
+    mode: 'create',
+    title: 'Map Agent Knowledge',
+    selectedFieldIndex: 0,
+    message: 'Summarize the isolated Agent Knowledge graph map. Leave query blank for a bounded full map summary.',
+    fields: [
+      { id: 'query', label: 'Query', value: '', required: false, multiline: false, hint: 'Optional map filter query.' },
+      { id: 'limit', label: 'Limit', value: '50', required: false, multiline: false, hint: 'Maximum map records to summarize.' },
+    ],
+  },
+  'knowledge-connector-show': knowledgeConnectorSpec,
+  'knowledge-connector-doctor': knowledgeConnectorSpec,
+  'knowledge-review-issue': {
+    mode: 'update',
+    title: 'Review Agent Knowledge Issue',
+    selectedFieldIndex: 0,
+    message: 'Accept, reject, resolve, reopen, edit, or forget one Agent Knowledge issue. Type yes on the final field to confirm.',
+    fields: [
+      { id: 'issueId', label: 'Issue id', value: '', required: true, multiline: false, hint: 'Issue id from the review queue.' },
+      { id: 'action', label: 'Action', value: 'resolve', required: true, multiline: false, hint: 'accept, reject, resolve, reopen, edit, or forget.' },
+      { id: 'reviewer', label: 'Reviewer', value: 'agent', required: false, multiline: false, hint: 'Reviewer label. Blank defaults to agent.' },
+      { id: 'value', label: 'Value JSON', value: '', required: false, multiline: true, hint: 'Optional JSON object for edit actions. Ctrl-J inserts a new line.' },
+      { id: 'confirm', label: 'Confirm', value: '', required: true, multiline: false, hint: 'Type yes to run /knowledge review-issue with --yes.' },
+    ],
+  },
+  'knowledge-consolidate': {
+    mode: 'update',
+    title: 'Consolidate Agent Knowledge',
+    selectedFieldIndex: 0,
+    message: 'Run isolated Agent Knowledge consolidation. Type yes on the final field to confirm.',
+    fields: [
+      { id: 'mode', label: 'Mode', value: 'light', required: true, multiline: false, hint: 'light or deep.' },
+      { id: 'confirm', label: 'Confirm', value: '', required: true, multiline: false, hint: 'Type yes to run /knowledge consolidate with --yes.' },
+    ],
+  },
+  'knowledge-explain': knowledgeExplainOrPacketSpec,
+  'knowledge-packet': knowledgeExplainOrPacketSpec,
+};
+
+export function createAgentWorkspaceKnowledgeCommandEditor(kind: AgentWorkspaceKnowledgeCommandEditorKind): AgentWorkspaceLocalEditor {
+  return createAgentWorkspaceEditorFromTable(kind, KNOWLEDGE_COMMAND_EDITOR_SPECS);
+}

package/src/input/agent-workspace-library-command-editor-submission.ts

@@ -1,23 +1,11 @@
-import type { AgentWorkspaceActionResult, AgentWorkspaceEditorKind, AgentWorkspaceLocalEditor } from './agent-workspace-types.ts';
+import type { AgentWorkspaceEditorKind, AgentWorkspaceLocalEditor } from './agent-workspace-types.ts';
 import type { AgentWorkspaceLibraryCommandEditorKind } from './agent-workspace-library-command-editors.ts';
 import { isAgentWorkspaceLibraryCommandEditorKind } from './agent-workspace-library-command-editors.ts';
 import { quoteSlashCommandArg } from './slash-command-parser.ts';
+import type { AgentWorkspaceCommandEditorSubmission, AgentWorkspaceFieldReader } from './agent-workspace-command-editor-engine.ts';
+import { dispatchCommandEditorSubmission } from './agent-workspace-command-editor-engine.ts';
 
-type AgentWorkspaceFieldReader = (fieldId: string) => string;
-
-export type AgentWorkspaceLibraryCommandEditorSubmission =
-  | {
-    readonly kind: 'editor';
-    readonly editor: AgentWorkspaceLocalEditor;
-    readonly status: string;
-    readonly actionResult?: AgentWorkspaceActionResult;
-  }
-  | {
-    readonly kind: 'dispatch';
-    readonly command: string;
-    readonly status: string;
-    readonly actionResult: AgentWorkspaceActionResult;
-  };
+export type AgentWorkspaceLibraryCommandEditorSubmission = AgentWorkspaceCommandEditorSubmission;
 
 export function isAgentWorkspaceLibraryCommandSubmissionKind(kind: AgentWorkspaceEditorKind): kind is AgentWorkspaceLibraryCommandEditorKind {
   return isAgentWorkspaceLibraryCommandEditorKind(kind);
@@ -26,7 +14,7 @@ export function isAgentWorkspaceLibraryCommandSubmissionKind(kind: AgentWorkspac
 export function buildAgentWorkspaceLibraryCommandEditorSubmission(
   editor: AgentWorkspaceLocalEditor,
   readField: AgentWorkspaceFieldReader,
-): AgentWorkspaceLibraryCommandEditorSubmission {
+): AgentWorkspaceCommandEditorSubmission {
   const target = editor.kind.startsWith('persona') ? 'persona' : editor.kind.startsWith('skill') ? 'skill' : 'routine';
   const root = target === 'persona' ? '/personas' : target === 'skill' ? '/skills' : '/routines';
   const search = editor.kind.endsWith('search');
@@ -35,16 +23,10 @@ export function buildAgentWorkspaceLibraryCommandEditorSubmission(
     : `${root} show ${quoteSlashCommandArg(readField('id'))}`;
   const label = target === 'persona' ? 'persona' : target === 'skill' ? 'skill' : 'routine';
   const title = search ? `Opening ${label} search` : `Opening ${label} detail`;
-  return {
-    kind: 'dispatch',
+  return dispatchCommandEditorSubmission(
     command,
-    status: `${title}.`,
-    actionResult: {
-      kind: 'dispatched',
-      title,
-      detail: `The workspace handed read-only local ${label} ${search ? 'search' : 'detail inspection'} to the shell-owned command router.`,
-      command,
-      safety: 'read-only',
-    },
-  };
+    title,
+    `The workspace handed read-only local ${label} ${search ? 'search' : 'detail inspection'} to the shell-owned command router.`,
+    'read-only',
+  );
 }

package/src/input/agent-workspace-library-command-editors.ts

@@ -1,4 +1,6 @@
 import type { AgentWorkspaceEditorKind, AgentWorkspaceLocalEditor } from './agent-workspace-types.ts';
+import type { AgentWorkspaceEditorSpec } from './agent-workspace-command-editor-engine.ts';
+import { createAgentWorkspaceEditorFromTable } from './agent-workspace-command-editor-engine.ts';
 
 export type AgentWorkspaceLibraryCommandEditorKind = Extract<
   AgentWorkspaceEditorKind,
@@ -14,12 +16,11 @@ export function isAgentWorkspaceLibraryCommandEditorKind(kind: AgentWorkspaceEdi
     || kind === 'routine-show';
 }
 
-export function createAgentWorkspaceLibraryCommandEditor(kind: AgentWorkspaceLibraryCommandEditorKind): AgentWorkspaceLocalEditor {
+function librarySpec(kind: AgentWorkspaceLibraryCommandEditorKind): AgentWorkspaceEditorSpec {
   const target = kind.startsWith('persona') ? 'persona' : kind.startsWith('skill') ? 'skill' : 'routine';
   const search = kind.endsWith('search');
   const label = target === 'persona' ? 'Persona' : target === 'skill' ? 'Skill' : 'Routine';
   return {
-    kind,
     mode: 'create',
     title: search ? `Search ${label}s` : `Show ${label}`,
     selectedFieldIndex: 0,
@@ -33,3 +34,16 @@ export function createAgentWorkspaceLibraryCommandEditor(kind: AgentWorkspaceLib
     ],
   };
 }
+
+const LIBRARY_COMMAND_EDITOR_SPECS: Readonly<Record<AgentWorkspaceLibraryCommandEditorKind, typeof librarySpec>> = {
+  'persona-search': librarySpec,
+  'persona-show': librarySpec,
+  'skill-search': librarySpec,
+  'skill-show': librarySpec,
+  'routine-search': librarySpec,
+  'routine-show': librarySpec,
+};
+
+export function createAgentWorkspaceLibraryCommandEditor(kind: AgentWorkspaceLibraryCommandEditorKind): AgentWorkspaceLocalEditor {
+  return createAgentWorkspaceEditorFromTable(kind, LIBRARY_COMMAND_EDITOR_SPECS);
+}

package/src/input/agent-workspace-live-counters.ts

@@ -0,0 +1,55 @@
+import type { CommandContext } from './command-registry.ts';
+import { readLiveAgentMemoryCounters, readLiveAgentRoutineCounters } from './agent-workspace-snapshot.ts';
+import type { AgentWorkspaceRuntimeSnapshot } from './agent-workspace-types.ts';
+
+export interface SyncAgentWorkspaceLiveCountersOptions {
+  readonly context: CommandContext | null;
+  readonly runtimeSnapshot: AgentWorkspaceRuntimeSnapshot | null;
+  readonly setRuntimeSnapshot: (snapshot: AgentWorkspaceRuntimeSnapshot) => void;
+  readonly clampSelection: () => void;
+}
+
+/**
+ * Quiet, render-path refresh of the two counters the W4-A6 dogfood finding
+ * named as stale: the memory count and the routine counts (incl. each
+ * routine's live start count). Call this once per repaint, before rendering,
+ * so an external disk mutation (another shell deleting a memory, a CLI
+ * `routines start` bumping a start count) shows up on the NEXT paint instead
+ * of requiring the user to trigger a workspace action first.
+ *
+ * Unlike AgentWorkspace.refreshRuntimeSnapshot(), this never touches status
+ * or lastActionResult -- it must be safe to call on every passive repaint,
+ * including ones triggered by unrelated key presses. It also intentionally
+ * does NOT rebuild the entire runtime snapshot (~20 registry/config reads):
+ * that full rebuild stays reserved for real action completions elsewhere on
+ * AgentWorkspace. Re-deriving just these two counters keeps the render-path
+ * cost proportional to "did the memory/routine store change", not to the
+ * whole workspace's surface area.
+ *
+ * On a read failure the previous counters are kept (never overwritten with a
+ * fabricated 0) and runtimeSnapshot.liveCountersStale is set so the render
+ * path can label them honestly as refreshing rather than asserting a number
+ * the disk might already contradict.
+ */
+export function syncAgentWorkspaceLiveCounters(options: SyncAgentWorkspaceLiveCountersOptions): void {
+  const { context, runtimeSnapshot, setRuntimeSnapshot, clampSelection } = options;
+  if (!context || !runtimeSnapshot) return;
+  try {
+    const memory = readLiveAgentMemoryCounters(context);
+    const routines = readLiveAgentRoutineCounters(context);
+    setRuntimeSnapshot({
+      ...runtimeSnapshot,
+      localMemoryCount: memory.count,
+      localMemoryReviewQueueCount: memory.reviewQueueCount,
+      localMemoryPromptActiveCount: memory.promptActiveCount,
+      localMemories: memory.items,
+      localRoutineCount: routines.count,
+      enabledRoutineCount: routines.enabled,
+      localRoutines: routines.items,
+      liveCountersStale: false,
+    });
+  } catch {
+    setRuntimeSnapshot({ ...runtimeSnapshot, liveCountersStale: true });
+  }
+  clampSelection();
+}

package/src/input/agent-workspace-mcp-command-editor-submission.ts

@@ -1,95 +1,73 @@
-import type { AgentWorkspaceActionResult, AgentWorkspaceEditorKind, AgentWorkspaceLocalEditor } from './agent-workspace-types.ts';
+import type { AgentWorkspaceEditorKind, AgentWorkspaceLocalEditor } from './agent-workspace-types.ts';
 import { quoteSlashCommandArg, tokenizeSlashCommand } from './slash-command-parser.ts';
+import type { AgentWorkspaceMcpCommandEditorKind } from './agent-workspace-mcp-command-editors.ts';
+import { isAgentWorkspaceMcpCommandEditorKind } from './agent-workspace-mcp-command-editors.ts';
+import type { AgentWorkspaceCommandEditorSubmission, AgentWorkspaceCommandSubmissionHandler, AgentWorkspaceFieldReader } from './agent-workspace-command-editor-engine.ts';
+import { buildCommandEditorSubmissionFromTable, dispatchCommandEditorSubmission, editorMessageSubmission, isAffirmative, splitCommaList } from './agent-workspace-command-editor-engine.ts';
 
-type AgentWorkspaceFieldReader = (fieldId: string) => string;
-
-export type AgentWorkspaceMcpCommandEditorKind = Extract<AgentWorkspaceEditorKind, 'mcp-server' | 'mcp-tools-server' | 'mcp-repair'>;
-
-export type AgentWorkspaceMcpCommandEditorSubmission =
-  | {
-    readonly kind: 'editor';
-    readonly editor: AgentWorkspaceLocalEditor;
-    readonly status: string;
-    readonly actionResult?: AgentWorkspaceActionResult;
-  }
-  | {
-    readonly kind: 'dispatch';
-    readonly command: string;
-    readonly status: string;
-    readonly actionResult: AgentWorkspaceActionResult;
-  };
+export type { AgentWorkspaceMcpCommandEditorKind } from './agent-workspace-mcp-command-editors.ts';
+export type AgentWorkspaceMcpCommandEditorSubmission = AgentWorkspaceCommandEditorSubmission;
 
 export function isAgentWorkspaceMcpCommandSubmissionKind(kind: AgentWorkspaceEditorKind): kind is AgentWorkspaceMcpCommandEditorKind {
-  return kind === 'mcp-server' || kind === 'mcp-tools-server' || kind === 'mcp-repair';
+  return isAgentWorkspaceMcpCommandEditorKind(kind);
 }
 
-function isAffirmative(value: string): boolean {
-  return /^(y|yes|true)$/i.test(value.trim());
-}
+const MCP_COMMAND_SUBMISSION_HANDLERS: Readonly<Record<AgentWorkspaceMcpCommandEditorKind, AgentWorkspaceCommandSubmissionHandler>> = {
+  'mcp-tools-server': (editor, readField) => mcpToolsOrRepair(editor, readField),
+  'mcp-repair': (editor, readField) => mcpToolsOrRepair(editor, readField),
+  'mcp-server': (editor, readField) => {
+    if (!isAffirmative(readField('confirm'))) {
+      return editorMessageSubmission(editor, 'MCP server add/update not confirmed. Type yes, then press Enter.', 'MCP server add/update not confirmed.');
+    }
+    const parts = [
+      '/mcp',
+      'add',
+      quoteSlashCommandArg(readField('name')),
+      quoteSlashCommandArg(readField('command')),
+      ...tokenizeSlashCommand(readField('args')).map(quoteSlashCommandArg),
+    ];
+    const scope = readField('scope');
+    const role = readField('role');
+    const trust = readField('trust');
+    if (scope.length > 0) parts.push('--scope', quoteSlashCommandArg(scope));
+    if (role.length > 0) parts.push('--role', quoteSlashCommandArg(role));
+    if (trust.length > 0) parts.push('--trust', quoteSlashCommandArg(trust));
+    for (const env of splitCommaList(readField('env'))) parts.push('--env', quoteSlashCommandArg(env));
+    for (const path of splitCommaList(readField('paths'))) parts.push('--path', quoteSlashCommandArg(path));
+    for (const host of splitCommaList(readField('hosts'))) parts.push('--host', quoteSlashCommandArg(host));
+    parts.push('--yes');
+    return dispatchCommandEditorSubmission(
+      parts.join(' '),
+      'Opening MCP server add/update',
+      'The workspace handed a confirmed MCP server add/update command to the shell-owned command router.',
+      'safe',
+    );
+  },
+};
 
-function splitCommaList(value: string): readonly string[] {
-  return value.split(',').map((entry) => entry.trim()).filter(Boolean);
+function mcpToolsOrRepair(editor: AgentWorkspaceLocalEditor, readField: AgentWorkspaceFieldReader): AgentWorkspaceCommandEditorSubmission {
+  const server = quoteSlashCommandArg(readField('server'));
+  const tools = editor.kind === 'mcp-tools-server';
+  const command = tools ? `/mcp tools ${server}` : `/mcp repair ${server}`;
+  const title = tools ? 'Opening MCP server tools' : 'Opening MCP repair guidance';
+  return dispatchCommandEditorSubmission(
+    command,
+    title,
+    tools
+      ? 'The workspace handed read-only MCP server tool inspection to the shell-owned command router.'
+      : 'The workspace handed read-only MCP repair guidance to the shell-owned command router.',
+    'read-only',
+  );
 }
 
 export function buildAgentWorkspaceMcpCommandEditorSubmission(
   editor: AgentWorkspaceLocalEditor,
   readField: AgentWorkspaceFieldReader,
-): AgentWorkspaceMcpCommandEditorSubmission {
-  if (editor.kind === 'mcp-tools-server' || editor.kind === 'mcp-repair') {
-    const server = quoteSlashCommandArg(readField('server'));
-    const tools = editor.kind === 'mcp-tools-server';
-    const command = tools ? `/mcp tools ${server}` : `/mcp repair ${server}`;
-    const title = tools ? 'Opening MCP server tools' : 'Opening MCP repair guidance';
-    return {
-      kind: 'dispatch',
-      command,
-      status: `${title}.`,
-      actionResult: {
-        kind: 'dispatched',
-        title,
-        detail: tools
-          ? 'The workspace handed read-only MCP server tool inspection to the shell-owned command router.'
-          : 'The workspace handed read-only MCP repair guidance to the shell-owned command router.',
-        command,
-        safety: 'read-only',
-      },
-    };
-  }
-  if (!isAffirmative(readField('confirm'))) {
-    return {
-      kind: 'editor',
-      editor: { ...editor, message: 'MCP server add/update not confirmed. Type yes, then press Enter.' },
-      status: 'MCP server add/update not confirmed.',
-    };
-  }
-  const parts = [
-    '/mcp',
-    'add',
-    quoteSlashCommandArg(readField('name')),
-    quoteSlashCommandArg(readField('command')),
-    ...tokenizeSlashCommand(readField('args')).map(quoteSlashCommandArg),
-  ];
-  const scope = readField('scope');
-  const role = readField('role');
-  const trust = readField('trust');
-  if (scope.length > 0) parts.push('--scope', quoteSlashCommandArg(scope));
-  if (role.length > 0) parts.push('--role', quoteSlashCommandArg(role));
-  if (trust.length > 0) parts.push('--trust', quoteSlashCommandArg(trust));
-  for (const env of splitCommaList(readField('env'))) parts.push('--env', quoteSlashCommandArg(env));
-  for (const path of splitCommaList(readField('paths'))) parts.push('--path', quoteSlashCommandArg(path));
-  for (const host of splitCommaList(readField('hosts'))) parts.push('--host', quoteSlashCommandArg(host));
-  parts.push('--yes');
-  const command = parts.join(' ');
-  return {
-    kind: 'dispatch',
-    command,
-    status: 'Opening MCP server add/update.',
-    actionResult: {
-      kind: 'dispatched',
-      title: 'Opening MCP server add/update',
-      detail: 'The workspace handed a confirmed MCP server add/update command to the shell-owned command router.',
-      command,
-      safety: 'safe',
-    },
-  };
+): AgentWorkspaceCommandEditorSubmission {
+  return buildCommandEditorSubmissionFromTable(
+    editor.kind as AgentWorkspaceMcpCommandEditorKind,
+    editor,
+    readField,
+    MCP_COMMAND_SUBMISSION_HANDLERS,
+  );
 }