@pellux/goodvibes-tui 1.0.0 → 1.7.0

package/src/input/commands/websearch-runtime.ts

@@ -0,0 +1,101 @@
+import type { CommandRegistry } from '../command-registry.ts';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+
+interface ParsedSearchArgs {
+  readonly query: string;
+  readonly limit?: number;
+}
+
+function parseSearchArgs(args: string[]): ParsedSearchArgs {
+  const words: string[] = [];
+  let limit: number | undefined;
+  for (let i = 0; i < args.length; i++) {
+    const token = args[i]!;
+    if ((token === '--limit' || token === '-n') && i + 1 < args.length) {
+      const parsed = Number.parseInt(args[++i]!, 10);
+      if (Number.isFinite(parsed) && parsed > 0) limit = parsed;
+    } else {
+      words.push(token);
+    }
+  }
+  return { query: words.join(' ').trim(), ...(limit !== undefined ? { limit } : {}) };
+}
+
+/**
+ * registerWebSearchRuntimeCommands - `/search <query> [--limit <n>]`.
+ *
+ * Calls webSearchService.search() directly (skipping the agent-tool wrapper's
+ * JSON-stringify contract — same shape as /schedule's ctx.ops.automationManager
+ * pattern: read the service off the context, guard on undefined, print) and
+ * renders ranked results + the instant answer into the transcript with
+ * source labels. webSearchService is already constructed in services.ts and
+ * already agent-reachable; this is a second, direct-command consumer of the
+ * same instance (ctx.platform.webSearchService).
+ */
+export function registerWebSearchRuntimeCommands(registry: CommandRegistry): void {
+  registry.register({
+    name: 'search',
+    description: 'Search the web and render ranked results with source labels',
+    usage: '<query> [--limit <n>]',
+    argsHint: '<query> [--limit <n>]',
+    async handler(args, ctx) {
+      const service = ctx.platform.webSearchService;
+      if (!service) {
+        ctx.print('Web search is not available in this session.');
+        return;
+      }
+
+      const { query, limit } = parseSearchArgs(args);
+      if (!query) {
+        ctx.print('Usage: /search <query> [--limit <n>]');
+        return;
+      }
+
+      try {
+        const response = await service.search({
+          query,
+          ...(limit !== undefined ? { maxResults: limit } : {}),
+        });
+
+        const lines: string[] = [`Search: "${response.query}"  (source: ${response.providerLabel})`];
+
+        const instantAnswer = response.instantAnswer;
+        if (instantAnswer) {
+          const heading = instantAnswer.heading ?? instantAnswer.source ?? 'Instant answer';
+          const body = instantAnswer.answer ?? instantAnswer.abstract;
+          if (body) {
+            lines.push('', `${heading}: ${body}`);
+            if (instantAnswer.url) lines.push(`  ${instantAnswer.url}`);
+          }
+        }
+
+        if (response.results.length === 0) {
+          lines.push('', 'No results found.');
+        } else {
+          lines.push('');
+          for (const result of response.results) {
+            const title = result.title ?? result.displayUrl ?? result.url;
+            lines.push(`${result.rank}. ${title}`);
+            if (result.snippet) lines.push(`   ${result.snippet}`);
+            lines.push(`   ${result.url}`);
+          }
+        }
+
+        ctx.print(lines.join('\n'));
+      } catch (error) {
+        // Honest degradation: read the thrown error / the service's own status
+        // surface rather than inventing an env-var name. WebSearchService.search()
+        // throws (not a {success:false} result field) when no provider is
+        // registered or the provider itself fails.
+        let detail = summarizeError(error);
+        try {
+          const status = await service.getStatus();
+          if (!status.enabled) detail = `${detail} (${status.note})`;
+        } catch {
+          // getStatus() itself failing is not worth compounding into the error message.
+        }
+        ctx.print(`Search failed: ${detail}`);
+      }
+    },
+  });
+}

package/src/input/commands/work-plan-runtime.ts

@@ -1,7 +1,7 @@
 import type { CommandRegistry } from '../command-registry.ts';
 import type { WorkPlanItemStatus, WorkPlanStore } from '../../work-plans/work-plan-store.ts';
 import { WORK_PLAN_STATUSES } from '../../work-plans/work-plan-store.ts';
-import { requirePanelManager } from './runtime-services.ts';
+import { openModalCommand } from './runtime-services.ts';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
 
 const STATUS_COMMANDS: Record<string, WorkPlanItemStatus> = {
@@ -25,14 +25,8 @@ function getStore(ctx: import('../command-registry.ts').CommandContext): WorkPla
 }
 
 function openPanel(ctx: import('../command-registry.ts').CommandContext): void {
-  if (ctx.showPanel) {
-    ctx.showPanel('work-plan');
-    return;
-  }
-  const panelManager = requirePanelManager(ctx);
-  panelManager.open('work-plan');
-  panelManager.show();
-  ctx.renderRequest();
+  // W6.1: work-plan migrated to the 'work-plan' modal — open it via the seam.
+  openModalCommand(ctx, 'work-plan-modal');
 }
 
 function formatList(store: WorkPlanStore): string {
@@ -81,7 +75,7 @@ export function registerWorkPlanRuntimeCommands(registry: CommandRegistry): void
     name: 'work-plan',
     aliases: ['wp', 'todo', 'workplan'],
     description: 'Track a persistent workspace-scoped work plan',
-    usage: '[panel|list|show|add <title> [--owner name] [--source label] [--notes text]|done <id>|start <id>|block <id>|fail <id>|cancel <id>|pending <id>|remove <id>|clear-done]',
+    usage: '[panel|list|show|export|add <title> [--owner name] [--source label] [--notes text]|edit <id> [<new title>] [--owner name] [--notes text]|done <id>|start <id>|block <id>|fail <id>|cancel <id>|pending <id>|remove <id>|clear-done]',
     argsHint: '[panel|add|list|done]',
     handler(args, ctx) {
       const store = getStore(ctx);
@@ -104,6 +98,14 @@ export function registerWorkPlanRuntimeCommands(registry: CommandRegistry): void
           ctx.print(store.toMarkdown());
           return;
         }
+        if (subcommand === 'export') {
+          // Thin wrapper over WorkPlanStore.exportMarkdown() — writes the plan's
+          // markdown alongside the JSON and reports the path. (W6 command-path
+          // parity: the work-plan modal's export action routes here.)
+          const { path } = store.exportMarkdown();
+          ctx.print(`Exported work plan markdown to ${path}`);
+          return;
+        }
         if (subcommand === 'add') {
           const parsed = parseAddArgs(args.slice(1));
           if (!parsed.title) {
@@ -120,6 +122,30 @@ export function registerWorkPlanRuntimeCommands(registry: CommandRegistry): void
           ctx.print(`Added work plan item ${item.id}.`);
           return;
         }
+        if (subcommand === 'edit' || subcommand === 'update') {
+          // Thin wrapper over WorkPlanStore.updateItem(idOrPrefix, patch).
+          // (W6 command-path parity: the work-plan modal's edit action routes
+          // here.) Only the flags the caller supplies are patched.
+          const id = args[1];
+          if (!id) {
+            ctx.print(`Usage: /work-plan ${subcommand} <id> [<new title>] [--owner name] [--source label] [--notes text]`);
+            return;
+          }
+          const parsed = parseAddArgs(args.slice(2));
+          const patch = {
+            ...(parsed.title ? { title: parsed.title } : {}),
+            ...(parsed.owner !== undefined ? { owner: parsed.owner } : {}),
+            ...(parsed.source !== undefined ? { source: parsed.source } : {}),
+            ...(parsed.notes !== undefined ? { notes: parsed.notes } : {}),
+          };
+          if (Object.keys(patch).length === 0) {
+            ctx.print(`Usage: /work-plan ${subcommand} <id> [<new title>] [--owner name] [--source label] [--notes text]`);
+            return;
+          }
+          const item = store.updateItem(id, patch);
+          ctx.print(`Updated work plan item ${item.id}: ${item.title}`);
+          return;
+        }
         if (subcommand === 'remove' || subcommand === 'delete' || subcommand === 'rm') {
           const id = args[1];
           if (!id) {

package/src/input/commands/workstream-runtime.ts

@@ -0,0 +1,338 @@
+// ---------------------------------------------------------------------------
+// workstream-runtime.ts — /workstream
+//
+// UX over the OrchestrationEngine (@pellux/goodvibes-sdk/platform/orchestration,
+// wo701/W4.1) via its command-facing facade wired onto RuntimeServices as
+// `workstreamCommands` (src/runtime/workstream-services.ts) and threaded
+// through CommandContext.session.workstreamEngine exactly like wrfcController
+// already is (bootstrap-command-context.ts).
+//
+// Render precedent: TRANSCRIPT + subcommand approve (like /plan approve,
+// planning-runtime.ts), NOT a panel — a multi-phase proposal is too rich for
+// a one-line confirm overlay, and Pillar-3 doctrine keeps work visible in the
+// transcript. create -> approve -> launch is a real three-step flow (edit and
+// cancel apply to the pending proposal too): the engine's own createWorkstream
+// immediately materializes a real, ticking-eligible Workstream with no
+// pre-creation "draft" concept, so approval happens on a TUI-held draft
+// (workstream-services.ts's WorkstreamDraft) before anything is created in
+// the engine at all — see that module's header doc for the full reality-wins
+// divergence from the wo703 design brief.
+// ---------------------------------------------------------------------------
+
+import { AdaptivePlanner } from '@pellux/goodvibes-sdk/platform/core';
+import type { PhaseKind, PhaseRole, WorkItemState, Workstream } from '@pellux/goodvibes-sdk/platform/orchestration';
+import type { WorkstreamCommandService, WorkstreamDraft } from '../../runtime/workstream-services.ts';
+import type { CommandContext, CommandRegistry } from '../command-registry.ts';
+
+// ---------------------------------------------------------------------------
+// Formatting helpers
+// ---------------------------------------------------------------------------
+
+function shortId(id: string): string {
+  return id.length > 12 ? id.slice(0, 12) : id;
+}
+
+/**
+ * The engine's ONLY two terminal work-item states (mirrors the SDK's own
+ * internal TERMINAL_ITEM_STATES in platform/runtime/fleet/adapters/
+ * orchestration.ts and engine.ts's kill() guard — neither is exported, so
+ * this is kept in lockstep by hand). Deriving "active" as NOT-terminal
+ * instead of enumerating the non-terminal states means a state this module
+ * doesn't know about yet (as 'blocked-budget' once was here) is still
+ * correctly treated as in-flight rather than silently falling through the
+ * cancel path.
+ */
+const TERMINAL_ITEM_STATES = new Set<WorkItemState>(['passed', 'failed']);
+
+function isActiveItemState(state: WorkItemState): boolean {
+  return !TERMINAL_ITEM_STATES.has(state);
+}
+
+/** Mirrors the engine's templateForPhase (phase-runner.ts): only 'review'/'gate' phases run the general template — everything else, INCLUDING 'custom', runs the engineer template regardless of phase.role's text. */
+function templateForPhaseKind(kind: PhaseKind): string {
+  return kind === 'review' || kind === 'gate' ? 'general' : 'engineer';
+}
+
+/**
+ * phase.role for a 'custom' phase is the free-text description passed to
+ * `/workstream insert-phase` — it is purely COSMETIC. Neither
+ * templateForPhase nor buildPhaseTask (phase-runner.ts, engine-side) ever
+ * reads it: a custom phase always runs the engineer template against the
+ * work item's own task text. Rendering it as `<kind> — <role>` like a real
+ * role would falsely imply the description drives what the phase does, so
+ * custom phases get an explicit "this is a description, not a role" label
+ * instead.
+ */
+function formatPhaseLabel(phase: { readonly kind: PhaseKind; readonly role: PhaseRole }): string {
+  if (phase.kind === 'custom') {
+    return `custom: "${phase.role}" (runs the ${templateForPhaseKind(phase.kind)} template)`;
+  }
+  return `${phase.kind} — ${phase.role}`;
+}
+
+function summarizeItemStates(ws: Workstream): string {
+  const counts = new Map<string, number>();
+  for (const item of ws.items) counts.set(item.state, (counts.get(item.state) ?? 0) + 1);
+  return Array.from(counts.entries()).map(([state, n]) => `${n} ${state}`).join(', ') || 'no items';
+}
+
+/** The engine's own PlanProposal is deliberately not rendered — see workstream-services.ts's buildSpec doc. This renders the REAL launchable spec instead, so the proposal and the launch are always the same plan. */
+function renderDraftProposal(draft: WorkstreamDraft): string {
+  const lines: string[] = [];
+  lines.push(`Workstream proposal ${draft.id} — "${draft.task}"`);
+  lines.push(
+    `Planner: strategy=${draft.gate.strategy} (${draft.gate.reasonCode}) — ${AdaptivePlanner.explainReasonCode(draft.gate.reasonCode)}`,
+  );
+  lines.push('Phases:');
+  draft.spec.phases.forEach((phase, i) => {
+    lines.push(`  ${i + 1}. ${formatPhaseLabel(phase)} (capacity ${phase.capacity})`);
+  });
+  lines.push('Work items:');
+  for (const item of draft.spec.items) {
+    lines.push(`  - ${item.title}`);
+  }
+  lines.push(
+    draft.approved
+      ? `Approved. Launch with: /workstream launch ${draft.id}`
+      : `Approve with: /workstream approve ${draft.id}`,
+  );
+  lines.push(`Edit the task: /workstream edit ${draft.id} <new task...>   Discard: /workstream cancel ${draft.id}`);
+  // Honest limitation (see workstream-services.ts's REALITY-WINS doc): the
+  // engine has no pre-creation draft concept, so this proposal is
+  // process-lifetime, in-memory state only — never journaled like a launched
+  // Workstream is. State that plainly, the same way an unsent chat draft
+  // would be, rather than letting a restart silently make it vanish.
+  lines.push('Note: not saved — lost if the TUI restarts before launch.');
+  return lines.join('\n');
+}
+
+function renderWorkstreamStatus(ws: Workstream): string {
+  const lines: string[] = [];
+  lines.push(`Workstream ${ws.id} — "${ws.title}"`);
+  lines.push('Phases:');
+  for (const phase of ws.phases) {
+    lines.push(`  [${phase.ordinal}] ${formatPhaseLabel(phase)} (capacity ${phase.capacity})`);
+  }
+  lines.push('Items:');
+  for (const item of ws.items) {
+    lines.push(`  ${shortId(item.id)}  [${item.state}]  ${item.title}  — phase: ${item.currentPhaseId ?? '—'}`);
+  }
+  return lines.join('\n');
+}
+
+function renderWorkstreamList(service: WorkstreamCommandService): string {
+  const drafts = service.listDrafts();
+  const live = service.engine.listWorkstreams();
+  if (drafts.length === 0 && live.length === 0) {
+    return 'No workstreams yet. Use /workstream create <task...> to propose one.';
+  }
+  const sections: string[] = [];
+  if (drafts.length > 0) {
+    const rows = drafts.map((d) => `  ${d.id}  ${d.approved ? '[approved]' : '[draft]  '}  "${d.task}"`);
+    sections.push([`Pending proposals (${drafts.length}, not yet launched):`, ...rows].join('\n'));
+  }
+  if (live.length > 0) {
+    const rows = live.map((ws) => `  ${shortId(ws.id)}  "${ws.title}"  (${ws.phases.length} phases, ${summarizeItemStates(ws)})`);
+    sections.push([`Workstreams (${live.length}):`, ...rows].join('\n'));
+  }
+  return sections.join('\n\n');
+}
+
+function resolveWorkstream(service: WorkstreamCommandService, ref: string): Workstream | undefined {
+  const exact = service.engine.getWorkstream(ref);
+  if (exact) return exact;
+  return service.engine.listWorkstreams().find((ws) => ws.id.startsWith(ref));
+}
+
+/**
+ * approve/edit/launch all fail this way when `id` doesn't resolve to a held
+ * draft. A bare "No pending proposal found" reads like a typo'd id even when
+ * the real cause is that drafts are process-lifetime, in-memory-only state
+ * (see renderDraftProposal's note and workstream-services.ts's REALITY-WINS
+ * doc) and a TUI restart wiped every one of them. Only hint at that when the
+ * service is holding zero drafts at all — with other drafts present, a typo
+ * or stale id is the more honest guess and the plain message stays.
+ */
+function draftNotFoundMessage(service: WorkstreamCommandService, id: string): string {
+  const base = `No pending proposal found: ${id}`;
+  if (service.listDrafts().length > 0) return base;
+  return `${base} (proposals aren't saved — a TUI restart since you created it would explain this; recreate it with /workstream create)`;
+}
+
+// ---------------------------------------------------------------------------
+// Command
+// ---------------------------------------------------------------------------
+
+export function registerWorkstreamRuntimeCommands(registry: CommandRegistry): void {
+  registry.register({
+    name: 'workstream',
+    description: 'Author and oversee multi-phase agent workstreams (orchestration engine)',
+    usage: 'create <task...> | list | status [id] | insert-phase <id> <description...> | approve <id> | edit <id> <task...> | launch <id> | cancel <id>',
+    argsHint: 'create <task> | list | status [id] | approve | edit | launch | cancel',
+    handler: async (args, ctx: CommandContext) => {
+      const service = ctx.session.workstreamEngine;
+      if (!service) {
+        ctx.print('Workstreams are not available in this session.');
+        return;
+      }
+
+      const sub = args[0];
+
+      if (!sub || sub === 'list') {
+        ctx.print(renderWorkstreamList(service));
+        return;
+      }
+
+      if (sub === 'create') {
+        const task = args.slice(1).join(' ').trim();
+        if (!task) {
+          ctx.print('Usage: /workstream create <task...>');
+          return;
+        }
+        const draft = service.proposeDraft(task);
+        ctx.print(renderDraftProposal(draft));
+        return;
+      }
+
+      if (sub === 'status') {
+        const ref = args[1];
+        const live = service.engine.listWorkstreams();
+        const target = ref ? resolveWorkstream(service, ref) : (live.length === 1 ? live[0] : undefined);
+        if (!target) {
+          if (!ref && live.length > 1) {
+            ctx.print(`Multiple workstreams running — specify one: ${live.map((ws) => shortId(ws.id)).join(', ')}`);
+            return;
+          }
+          ctx.print(ref ? `No workstream found: ${ref}` : 'No workstreams running. Use /workstream list to see pending proposals.');
+          return;
+        }
+        ctx.print(renderWorkstreamStatus(target));
+        return;
+      }
+
+      if (sub === 'insert-phase') {
+        const id = args[1];
+        const description = args.slice(2).join(' ').trim();
+        if (!id || !description) {
+          ctx.print('Usage: /workstream insert-phase <id> <description...>');
+          return;
+        }
+        const ws = resolveWorkstream(service, id);
+        if (!ws) {
+          ctx.print(`No workstream found: ${id}`);
+          return;
+        }
+        const lastOrdinal = ws.phases.reduce((max, phase) => Math.max(max, phase.ordinal), 0);
+        const templateGate = ws.phases.at(-1)?.gate ?? { scope: 'scoped' as const, gates: [] };
+        const inserted = service.engine.insertPhase(ws.id, lastOrdinal, {
+          role: description,
+          capacity: 1,
+          kind: 'custom',
+          gate: templateGate,
+        });
+        if (!inserted) {
+          ctx.print(`Could not insert phase — is "${id}" still an active workstream?`);
+          return;
+        }
+        ctx.print(`Inserted phase "${description}" into ${shortId(ws.id)} after ordinal ${lastOrdinal} (new ordinal ${inserted.ordinal}).`);
+        return;
+      }
+
+      if (sub === 'approve') {
+        const id = args[1];
+        if (!id) {
+          ctx.print('Usage: /workstream approve <id>');
+          return;
+        }
+        const draft = service.approveDraft(id);
+        if (!draft) {
+          ctx.print(draftNotFoundMessage(service, id));
+          return;
+        }
+        ctx.print(`Approved ${id}. Launch with: /workstream launch ${id}`);
+        return;
+      }
+
+      if (sub === 'edit') {
+        const id = args[1];
+        const task = args.slice(2).join(' ').trim();
+        if (!id || !task) {
+          ctx.print('Usage: /workstream edit <id> <new task...>');
+          return;
+        }
+        const draft = service.editDraft(id, task);
+        if (!draft) {
+          ctx.print(draftNotFoundMessage(service, id));
+          return;
+        }
+        ctx.print(renderDraftProposal(draft));
+        return;
+      }
+
+      if (sub === 'launch') {
+        const id = args[1];
+        if (!id) {
+          ctx.print('Usage: /workstream launch <id>');
+          return;
+        }
+        const draft = service.getDraft(id);
+        if (!draft) {
+          ctx.print(draftNotFoundMessage(service, id));
+          return;
+        }
+        if (!draft.approved) {
+          ctx.print(`Proposal ${id} is not approved yet. Run /workstream approve ${id} first.`);
+          return;
+        }
+        const result = service.launchDraft(id);
+        if (!result) {
+          ctx.print(`Could not launch ${id}.`);
+          return;
+        }
+        ctx.print(`Launched workstream ${result.workstreamId} — track it with /workstream status ${result.workstreamId} or the Fleet panel.`);
+        return;
+      }
+
+      if (sub === 'cancel') {
+        const id = args[1];
+        if (!id) {
+          ctx.print('Usage: /workstream cancel <id>');
+          return;
+        }
+        if (service.getDraft(id)) {
+          service.removeDraft(id);
+          ctx.print(`Discarded pending proposal ${id}.`);
+          return;
+        }
+        const ws = resolveWorkstream(service, id);
+        if (!ws) {
+          ctx.print(`No workstream or pending proposal found: ${id}`);
+          return;
+        }
+        const active = ws.items.filter((item) => isActiveItemState(item.state));
+        let killedCount = 0;
+        for (const item of active) {
+          if (service.engine.kill(item.id)) killedCount++;
+        }
+        ctx.print(
+          killedCount > 0
+            ? `Cancelled ${killedCount} of ${active.length} in-flight work item(s) in ${shortId(ws.id)}.`
+            : `${shortId(ws.id)} has no in-flight work items to cancel.`,
+        );
+        return;
+      }
+
+      ctx.print(
+        'Usage:\n'
+        + '  /workstream create <task...>\n'
+        + '  /workstream list\n'
+        + '  /workstream status [id]\n'
+        + '  /workstream insert-phase <id> <description...>\n'
+        + '  /workstream approve <id>\n'
+        + '  /workstream edit <id> <new task...>\n'
+        + '  /workstream launch <id>\n'
+        + '  /workstream cancel <id>',
+      );
+    },
+  });
+}

package/src/input/commands.ts

@@ -15,6 +15,7 @@ import { registerOperatorRuntimeCommands } from './commands/operator-runtime.ts'
 import { registerPluginRuntimeCommands } from './commands/plugin-runtime.ts';
 import { registerDiffRuntimeCommands } from './commands/diff-runtime.ts';
 import { registerGitRuntimeCommands } from './commands/git-runtime.ts';
+import { registerTestRuntimeCommands } from './commands/test-runtime.ts';
 import { registerNotifyRuntimeCommands } from './commands/notify-runtime.ts';
 import { registerReplayRuntimeCommands } from './commands/replay-runtime.ts';
 import { registerShareRuntimeCommands } from './commands/share-runtime.ts';
@@ -36,6 +37,9 @@ import { registerHooksRuntimeCommands } from './commands/hooks-runtime.ts';
 import { registerControlRoomRuntimeCommands } from './commands/control-room-runtime.ts';
 import { registerMcpRuntimeCommands } from './commands/mcp-runtime.ts';
 import { registerSessionContentCommands } from './commands/session-content.ts';
+import { registerCheckpointRuntimeCommands } from './commands/checkpoint-runtime.ts';
+import { registerWorkstreamRuntimeCommands } from './commands/workstream-runtime.ts';
+import { registerCodebaseRuntimeCommands } from './commands/codebase-runtime.ts';
 import { registerLocalRuntimeCommands } from './commands/local-runtime.ts';
 import { registerExperienceRuntimeCommands } from './commands/experience-runtime.ts';
 import { registerIncidentRuntimeCommands } from './commands/incident-runtime.ts';
@@ -57,6 +61,8 @@ import { registerTtsRuntimeCommands } from './commands/tts-runtime.ts';
 import { registerCloudflareRuntimeCommands } from './commands/cloudflare-runtime.ts';
 import { registerWorkPlanRuntimeCommands } from './commands/work-plan-runtime.ts';
 import { registerCostRuntimeCommands } from './commands/cost-runtime.ts';
+import { registerWebSearchRuntimeCommands } from './commands/websearch-runtime.ts';
+import { registerImageRuntimeCommands } from './commands/image-runtime.ts';
 
 /**
  * registerBuiltinCommands - Register all built-in slash commands into the registry.
@@ -69,6 +75,7 @@ export function registerBuiltinCommands(registry: CommandRegistry): void {
   registerPluginRuntimeCommands(registry);
   registerDiffRuntimeCommands(registry);
   registerGitRuntimeCommands(registry);
+  registerTestRuntimeCommands(registry);
   registerNotifyRuntimeCommands(registry);
   registerReplayRuntimeCommands(registry);
   registerShareRuntimeCommands(registry);
@@ -115,6 +122,11 @@ export function registerBuiltinCommands(registry: CommandRegistry): void {
   registerScheduleRuntimeCommands(registry);
   registerBranchRuntimeCommands(registry);
   registerSessionContentCommands(registry);
+  registerCheckpointRuntimeCommands(registry);
+  registerWorkstreamRuntimeCommands(registry);
+  registerCodebaseRuntimeCommands(registry);
+  registerWebSearchRuntimeCommands(registry);
+  registerImageRuntimeCommands(registry);
 
   // ── /policy ───────────────────────────────────────────────────────────────
   registry.register(policyCommand);