@pellux/goodvibes-tui 1.1.0 → 1.9.0

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

@@ -0,0 +1,280 @@
+// ---------------------------------------------------------------------------
+// checkpoint-runtime.ts — /checkpoints, /checkpoint, /rewind
+//
+// UX over WorkspaceCheckpointManager (@pellux/goodvibes-sdk/platform/workspace),
+// the whole-workspace, git-backed rewind engine wired onto RuntimeServices as
+// `workspaceCheckpointManager` (src/runtime/services.ts) and threaded through
+// CommandContext.workspace exactly like FileUndoManager already is.
+//
+// Architecture note (why the confirm step lives in DiffPanel, not here):
+// SlashCommand.handler(args, ctx) is a single-shot call — there is no "await
+// next keypress" primitive in the command layer. So `/rewind <id>` can only
+// resolve the target, load the preview, open+focus the diff panel, and arm
+// its confirm overlay (DiffPanel.confirmOverlay, a PanelConfirmOverlay —
+// see panel-confirm-overlay.ts); the actual y/n/Enter/Esc handling happens
+// in DiffPanel.handleInput() via the project's canonical ConfirmState<T>
+// contract (confirm-state.ts), which every other destructive-action confirm
+// in this codebase already uses (see git-panel.ts).
+// ---------------------------------------------------------------------------
+
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+import type { WorkspaceCheckpoint, WorkspaceCheckpointManager } from '@pellux/goodvibes-sdk/platform/workspace';
+import type { CommandContext, CommandRegistry } from '../command-registry.ts';
+import { requirePanelManager } from './runtime-services.ts';
+
+// ---------------------------------------------------------------------------
+// Formatting helpers
+// ---------------------------------------------------------------------------
+
+/** Drop the redundant 'wcp_' prefix and cap length for compact listing. Full ids (and any unambiguous prefix of one) are still accepted by /rewind. */
+function shortId(id: string): string {
+  const stripped = id.startsWith('wcp_') ? id.slice(4) : id;
+  return stripped.length > 12 ? stripped.slice(0, 12) : stripped;
+}
+
+function formatAge(createdAtMs: number, nowMs: number = Date.now()): string {
+  const deltaMs = Math.max(0, nowMs - createdAtMs);
+  const seconds = Math.floor(deltaMs / 1000);
+  if (seconds < 60) return `${seconds}s ago`;
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return `${minutes}m ago`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  return `${days}d ago`;
+}
+
+function formatBytes(bytes: number): string {
+  if (bytes < 1024) return `${bytes}B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}
+
+function plural(n: number, word: string): string {
+  return `${n} ${word}${n === 1 ? '' : 's'}`;
+}
+
+// ---------------------------------------------------------------------------
+// Checkpoint resolution — shared by /rewind
+// ---------------------------------------------------------------------------
+
+type ResolveResult =
+  | { checkpoint: WorkspaceCheckpoint }
+  | { error: string };
+
+/**
+ * Resolve a user-supplied checkpoint reference ('last' or an id / id prefix,
+ * as shown by /checkpoints) against the live checkpoint list. Resolution
+ * happens entirely against list() results — never against
+ * WorkspaceCheckpointManager's own requireCheckpoint() — so an unknown ref is
+ * caught here, before anything touches the diff panel or arms a confirm.
+ *
+ * mgr.list() is guarded here (not left to the caller) so every caller gets a
+ * plain ResolveResult and can never be handed a rejected promise: if the
+ * manager's list() call fails (including a cached init() failure — see
+ * services.ts — which makes every WorkspaceCheckpointManager method reject
+ * forever), that surfaces as an honest `{ error }` instead of an unhandled
+ * rejection.
+ */
+async function resolveCheckpointTarget(
+  mgr: WorkspaceCheckpointManager,
+  ref: string,
+): Promise<ResolveResult> {
+  let all: WorkspaceCheckpoint[];
+  try {
+    all = await mgr.list();
+  } catch (err) {
+    return { error: `Failed to list checkpoints: ${summarizeError(err)}` };
+  }
+  if (ref === 'last') {
+    const checkpoint = all[0];
+    if (!checkpoint) {
+      return { error: 'No checkpoints to rewind to. Use /checkpoint <label> to create one.' };
+    }
+    return { checkpoint };
+  }
+  const exact = all.find((c) => c.id === ref);
+  if (exact) return { checkpoint: exact };
+
+  const prefixMatches = all.filter((c) => c.id.startsWith(ref) || shortId(c.id).startsWith(ref));
+  if (prefixMatches.length === 1) return { checkpoint: prefixMatches[0]! };
+  if (prefixMatches.length > 1) {
+    return {
+      error: `Checkpoint id "${ref}" is ambiguous — matches ${prefixMatches.length} checkpoints. Use a longer prefix or run /checkpoints for full ids.`,
+    };
+  }
+  return { error: `Unknown checkpoint id: "${ref}". Run /checkpoints to see available checkpoints.` };
+}
+
+// ---------------------------------------------------------------------------
+// Commands
+// ---------------------------------------------------------------------------
+
+export function registerCheckpointRuntimeCommands(registry: CommandRegistry): void {
+  registry.register({
+    name: 'checkpoints',
+    aliases: ['ckpts'],
+    description: 'List workspace checkpoints, newest first',
+    handler: async (_args, ctx: CommandContext) => {
+      const mgr = ctx.workspace.workspaceCheckpointManager;
+      if (!mgr) {
+        ctx.print('Checkpoints are not available in this session.');
+        return;
+      }
+      let checkpoints: WorkspaceCheckpoint[];
+      try {
+        checkpoints = await mgr.list();
+      } catch (err) {
+        ctx.print(`Failed to list checkpoints: ${summarizeError(err)}`);
+        return;
+      }
+      if (checkpoints.length === 0) {
+        ctx.print('No checkpoints yet. /checkpoint <label> creates one manually; turns and agent runs snapshot automatically.');
+        return;
+      }
+      ctx.print(`Checkpoints (${checkpoints.length}, newest first):`);
+      for (const cp of checkpoints) {
+        ctx.print(`  ${shortId(cp.id).padEnd(12)} ${cp.kind.padEnd(9)} ${cp.label}  ${formatAge(cp.createdAt)}  ~${formatBytes(cp.sizeBytes)} new`);
+      }
+      // Files-changed counts are deliberately NOT shown per-row here: getting
+      // them would cost one diff spawn per checkpoint (O(checkpoints)), which
+      // stops being cheap once there are more than a handful. /rewind <id>
+      // loads exactly one diff, so the exact file list is available there.
+      ctx.print('Use /rewind <id|last> to preview the exact file changes and restore a checkpoint.');
+    },
+  });
+
+  registry.register({
+    name: 'checkpoint',
+    description: 'Create a manual workspace checkpoint (forensic retention)',
+    usage: '[label]',
+    argsHint: '[label]',
+    handler: async (args, ctx: CommandContext) => {
+      const mgr = ctx.workspace.workspaceCheckpointManager;
+      if (!mgr) {
+        ctx.print('Checkpoints are not available in this session.');
+        return;
+      }
+      const label = args.join(' ').trim() || undefined;
+      try {
+        const checkpoint = await mgr.create({ kind: 'manual', label, retentionClass: 'forensic' });
+        if (!checkpoint) {
+          ctx.print('No changes since the last checkpoint — nothing to save.');
+          return;
+        }
+        ctx.print(`Checkpoint created: ${shortId(checkpoint.id)} "${checkpoint.label}" (forensic retention).`);
+      } catch (err) {
+        ctx.print(`Checkpoint failed: ${summarizeError(err)}`);
+      }
+    },
+  });
+
+  registry.register({
+    name: 'rewind',
+    description: 'Preview and restore a workspace checkpoint (files only — conversation history is unchanged)',
+    usage: '<id|last>',
+    argsHint: '<id|last>',
+    handler: async (args, ctx: CommandContext) => {
+      const mgr = ctx.workspace.workspaceCheckpointManager;
+      if (!mgr) {
+        ctx.print('Checkpoints are not available in this session.');
+        return;
+      }
+      const ref = args[0];
+      if (!ref) {
+        ctx.print('Usage: /rewind <id|last>. Run /checkpoints to see available checkpoints.');
+        return;
+      }
+
+      const resolved = await resolveCheckpointTarget(mgr, ref);
+      if ('error' in resolved) {
+        ctx.print(resolved.error);
+        return;
+      }
+      const { checkpoint } = resolved;
+
+      let diff: Awaited<ReturnType<WorkspaceCheckpointManager['diff']>>;
+      try {
+        diff = await mgr.diff(checkpoint.id);
+      } catch (err) {
+        ctx.print(`Could not load checkpoint preview: ${summarizeError(err)}`);
+        return;
+      }
+
+      const { DiffPanel } = await import('../../panels/diff-panel.ts');
+      const pm = requirePanelManager(ctx);
+      let panel = pm.getAllOpen().find((p) => p.id === 'diff');
+      if (!panel) {
+        try {
+          panel = pm.open('diff');
+        } catch {
+          ctx.print('Could not open diff panel.');
+          return;
+        }
+      }
+      pm.activateById('diff');
+      if (!pm.isVisible()) pm.show();
+      // Must focus the panel — otherwise the user is left typing at the
+      // prompt while the panel silently shows a pending confirm they never
+      // see (the single most likely UX bug in this feature).
+      ctx.focusPanels?.();
+
+      const diffPanel = panel as InstanceType<typeof DiffPanel>;
+      if (diff.unifiedDiff.trim()) {
+        diffPanel.loadRawDiff(diff.unifiedDiff);
+      } else {
+        diffPanel.showDiff('(no changes)', '@@ -0,0 +0,0 @@\n Working tree already matches this checkpoint.');
+      }
+
+      diffPanel.confirmOverlay.arm({
+        id: checkpoint.id,
+        // renderConfirmLines (panels/confirm-state.ts) builds the on-screen
+        // prompt as `${verb} "${label}"?` itself — it supplies both the verb
+        // and the surrounding quotes. A label that already contained "Restore
+        // "..."" duplicated both, rendering as `Restore "Restore
+        // "baseline-pin"…`. label here must be just the descriptive subject,
+        // with no verb and no quotes of its own (same convention GitPanel
+        // already follows for its own confirms — see git-panel.ts:352,370).
+        label: `${checkpoint.label} (${plural(diff.files.length, 'file')} differ) — files only, conversation history is unchanged`,
+        verb: 'Restore',
+        onConfirm: async () => {
+          try {
+            const result = await mgr.restore(checkpoint.id, { safetyCheckpoint: true });
+            ctx.print(
+              `Rewind complete: restored ${plural(result.restoredFiles.length, 'file')}, removed ${plural(result.removedFiles.length, 'file')}. ` +
+              `Safety checkpoint: ${result.safetyCheckpointId ? shortId(result.safetyCheckpointId) : '(none — working tree already matched)'}.`,
+            );
+            // Conversation is NOT rewound: addSystemMessage (not ctx.print)
+            // persists this note into real turn/session history so it is
+            // indexed by getTranscriptEventIndex() and session save/load,
+            // while staying a distinct message kind from user/assistant turns.
+            ctx.session.conversationManager.addSystemMessage(
+              `[Rewind] Restored checkpoint "${checkpoint.label}" (${plural(result.restoredFiles.length, 'file')} restored, ${plural(result.removedFiles.length, 'file')} removed). ` +
+              'Files were rewound — conversation history is unchanged. Use /undo to remove turns separately.',
+            );
+            // Auto-close the preview: once the restore has actually happened,
+            // the diff panel showing the (now-stale) pre-restore preview has
+            // nothing left to confirm and no obvious way to dismiss it
+            // otherwise (same pm.close(id) + focusPrompt() pattern as
+            // /panel close — see operator-panel-runtime.ts).
+            pm.close('diff');
+            ctx.focusPrompt?.();
+            ctx.renderRequest();
+          } catch (err) {
+            ctx.print(`Rewind failed: ${summarizeError(err)}`);
+          }
+        },
+        onCancel: () => {
+          ctx.print('Rewind cancelled — no files changed.');
+          // Same auto-close as the confirm path above — a denied restore also
+          // leaves nothing actionable in the preview panel.
+          pm.close('diff');
+          ctx.focusPrompt?.();
+          ctx.renderRequest();
+        },
+      });
+      ctx.print(`Previewing checkpoint ${shortId(checkpoint.id)} "${checkpoint.label}". Confirm in the diff panel: Enter/y to restore, n/Esc to cancel.`);
+      ctx.renderRequest();
+    },
+  });
+}

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

@@ -0,0 +1,232 @@
+// ---------------------------------------------------------------------------
+// codebase-runtime.ts — /codebase
+//
+// Explicit-query + transparency surface over the repo source-tree code index
+// (CodeIndexStore, @pellux/goodvibes-sdk/platform/state, landed on SDK main
+// as wo802/W5.3 Stage A) via the TUI's own wiring in
+// src/runtime/code-index-services.ts, threaded through
+// CommandContext.session.codeIndexStore exactly like wrfcController/
+// workstreamEngine already are (bootstrap-command-context.ts).
+//
+// Mirrors /recall's transparency idiom (recall-query.ts's handleRecallVector:
+// status/rebuild) and /workstream's registerXRuntimeCommands function-export
+// shape: build (schedules the index build — visible as a fleet 'code-index'
+// node while it runs), status (counts, skips, degradation state, last
+// build), search <query> (explicit retrieval, results labeled
+// 'lexical'|'semantic' honestly — never implied as more precise than they
+// are). Stage B (now landed) adds passive auto-injection into coding turns and
+// tool-site incremental reindex; `status` surfaces both honestly (the
+// auto-injection flag+setting gate, and the last reindex activity).
+// ---------------------------------------------------------------------------
+
+import type { CodeIndexStats, CodeContextResult, CodeIndexReindexActivity } from '@pellux/goodvibes-sdk/platform/state';
+import type { ConfigManager } from '@pellux/goodvibes-sdk/platform/config';
+import { isCodeIndexAutoStartEnabled, CODE_INDEX_MAX_FILES, CODE_INDEX_MAX_FILE_BYTES, CODE_INDEX_MAX_TOTAL_BYTES } from '../../runtime/code-index-services.ts';
+import type { CommandContext, CommandRegistry } from '../command-registry.ts';
+
+// ---------------------------------------------------------------------------
+// Formatting helpers
+// ---------------------------------------------------------------------------
+
+function formatBytes(bytes: number): string {
+  if (bytes >= 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+  if (bytes >= 1024) return `${Math.round(bytes / 1024)}KB`;
+  return `${bytes}B`;
+}
+
+/**
+ * Honest one-line auto-injection state (Stage B): both the (default-off)
+ * `agent-passive-code-injection` feature flag AND storage.codeIndexEnabled must
+ * be on for passive code injection to run — state which is off, and why.
+ */
+function renderAutoInjectionState(flagEnabled: boolean, settingEnabled: boolean): string {
+  if (flagEnabled && settingEnabled) {
+    return '  auto-injection: on (code hits may be injected into coding turns within the shared knowledge budget)';
+  }
+  const reasons: string[] = [];
+  if (!flagEnabled) reasons.push('agent-passive-code-injection flag off (default off) — enable in the settings modal flags section');
+  if (!settingEnabled) reasons.push('storage.codeIndexEnabled off — /config to change');
+  return `  auto-injection: off (${reasons.join('; ')})`;
+}
+
+/** Honest last-reindex activity line (Stage B tool-site incremental reindex). */
+function renderReindexActivity(activity: CodeIndexReindexActivity | null, now: number): string {
+  if (!activity) return '  last reindex: none this session (writes/edits reindex touched files once the index is built)';
+  const agoSec = Math.max(0, Math.round((now - activity.at) / 1000));
+  const detail = activity.status === 'error'
+    ? `error: ${activity.error ?? 'unknown'}`
+    : activity.status === 'skipped'
+      ? `skipped (${activity.mode ?? 'empty'})`
+      : `indexed (${activity.mode ?? 'symbols'})`;
+  return `  last reindex: ${activity.path} — ${detail}, ${agoSec}s ago`;
+}
+
+interface CodeIndexStatusExtras {
+  readonly flagEnabled: boolean;
+  readonly reindexActivity: CodeIndexReindexActivity | null;
+  readonly now?: number;
+}
+
+function renderCodeIndexStatus(stats: CodeIndexStats, configManager: Pick<ConfigManager, 'get'>, extras: CodeIndexStatusExtras): string {
+  const lines: string[] = [];
+  lines.push(`Code index — backend: ${stats.backend}, available: ${stats.available ? 'yes' : 'no'}`);
+  lines.push(`  path: ${stats.path}`);
+  lines.push(`  indexed: ${stats.indexedFiles} file(s), ${stats.indexedChunks} chunk(s), ${stats.dimensions} dims`);
+  lines.push(`  embedding provider: ${stats.embeddingProviderLabel} (${stats.embeddingProviderId})`);
+  lines.push(
+    stats.semanticRetrievalAvailable
+      ? '  search results labeled: semantic'
+      : '  search results labeled: lexical (hashed fallback — low precision)',
+  );
+  const autoStart = isCodeIndexAutoStartEnabled(configManager);
+  lines.push(
+    `  auto-build on startup: ${autoStart ? 'on' : 'off'} (storage.codeIndexEnabled, default off — /config to change)`,
+  );
+  // Stage B surfacing: passive code auto-injection state (flag + setting) and the last tool-site reindex.
+  lines.push(renderAutoInjectionState(extras.flagEnabled, autoStart));
+  lines.push(renderReindexActivity(extras.reindexActivity, extras.now ?? Date.now()));
+  lines.push(
+    `  bounds: max ${CODE_INDEX_MAX_FILES} files (maxFiles), ${formatBytes(CODE_INDEX_MAX_FILE_BYTES)} per file (maxFileBytes),`
+    + ` ${formatBytes(CODE_INDEX_MAX_TOTAL_BYTES)} total per build (maxTotalBytes)`,
+  );
+  // Provider-space honesty (SDK finding): vectors embedded under a different
+  // provider than the current default disable the vector search path until a
+  // rebuild re-embeds — say so, in the store's own words.
+  if (stats.embeddingProviderMismatch) {
+    lines.push(`  provider mismatch: ${stats.embeddingProviderMismatch} (vector search disabled — lexical fallback only)`);
+  }
+
+  if (stats.building) {
+    lines.push('  build: in progress');
+  } else if (stats.lastBuild) {
+    const b = stats.lastBuild;
+    lines.push(
+      `  last build: ${b.filesIndexed} indexed, ${b.filesUnchanged} unchanged, ${b.filesRemoved} removed,`
+      + ` ${b.chunksIndexed} chunk(s) embedded (${b.chunksUnchanged} unchanged), ${b.durationMs}ms`,
+    );
+    const skip = b.skip;
+    const skipParts: string[] = [];
+    if (skip.tooLarge) skipParts.push(`${skip.tooLarge} too large`);
+    if (skip.overFileCap) skipParts.push(`${skip.overFileCap} over file cap (maxFiles)`);
+    if (skip.overTotalBytes) skipParts.push(`${skip.overTotalBytes} over total byte budget (maxTotalBytes)`);
+    if (skip.binary) skipParts.push(`${skip.binary} binary`);
+    if (skip.ignoredByGitignore) skipParts.push(`${skip.ignoredByGitignore} gitignored`);
+    if (skip.readErrors) skipParts.push(`${skip.readErrors} read error(s)`);
+    if (skip.chunkedByWindow) skipParts.push(`${skip.chunkedByWindow} windowed (no tree-sitter symbols)`);
+    lines.push(skipParts.length > 0 ? `  skipped: ${skipParts.join(', ')}` : '  skipped: none');
+  } else {
+    lines.push('  last build: never — run /codebase build');
+  }
+
+  if (stats.error) lines.push(`  error: ${stats.error}`);
+
+  const degradation = stats.semanticRetrievalAvailable ? null : describeDegradationFallback(stats);
+  if (degradation) lines.push(`  ${degradation}`);
+
+  return lines.join('\n');
+}
+
+/** Reuses the exact wording CodeIndexStore.describeDegradation() would return for a hashed-only provider, without requiring a live call the status renderer doesn't otherwise need. */
+function describeDegradationFallback(stats: CodeIndexStats): string | null {
+  if (stats.semanticRetrievalAvailable) return null;
+  return 'code auto-retrieval disabled: no semantic embedding provider configured';
+}
+
+function renderSearchResults(results: readonly CodeContextResult[]): string {
+  return results
+    .map((result) => {
+      const c = result.chunk;
+      const pct = Math.round(result.similarity * 100);
+      const symbol = c.symbol ? ` ${c.symbol}` : '';
+      return `  ${c.path}:${c.startLine}-${c.endLine}  [${result.label}]  sim ${pct}%  ${c.kind}${symbol}`;
+    })
+    .join('\n');
+}
+
+function parseLimitArg(args: readonly string[]): { readonly limit: number | undefined; readonly queryTokens: string[] } {
+  const limitIdx = args.indexOf('--limit');
+  let limit: number | undefined;
+  if (limitIdx !== -1 && args[limitIdx + 1]) {
+    const parsed = parseInt(args[limitIdx + 1]!, 10);
+    if (!Number.isNaN(parsed)) limit = parsed;
+  }
+  const queryTokens = args.filter((token, index) => {
+    if (token === '--limit') return false;
+    if (limitIdx !== -1 && index === limitIdx + 1) return false;
+    return true;
+  });
+  return { limit, queryTokens };
+}
+
+const USAGE = 'Usage:\n'
+  + '  /codebase build\n'
+  + '  /codebase status\n'
+  + '  /codebase search <query...> [--limit n]';
+
+// ---------------------------------------------------------------------------
+// Command
+// ---------------------------------------------------------------------------
+
+export function registerCodebaseRuntimeCommands(registry: CommandRegistry): void {
+  registry.register({
+    name: 'codebase',
+    description: 'Repo source-tree code index — build, inspect, and search',
+    usage: 'build | status | search <query...> [--limit n]',
+    argsHint: 'build | status | search <query>',
+    handler(args: string[], ctx: CommandContext) {
+      const store = ctx.session.codeIndexStore;
+      if (!store) {
+        ctx.print('The code index is not available in this session.');
+        return;
+      }
+
+      const sub = args[0];
+
+      if (!sub || sub === 'status') {
+        ctx.print(renderCodeIndexStatus(store.stats(), ctx.platform.configManager, {
+          flagEnabled: ctx.session.isPassiveCodeInjectionFlagEnabled?.() ?? false,
+          reindexActivity: ctx.session.codeIndexReindexScheduler?.lastActivity() ?? null,
+        }));
+        return;
+      }
+
+      if (sub === 'build' || sub === 'reindex') {
+        if (store.isBuilding()) {
+          const progress = store.buildProgress();
+          ctx.print(
+            progress
+              ? `A build is already in progress (${progress.scanned}/${progress.total} files scanned).`
+              : 'A build is already in progress.',
+          );
+          return;
+        }
+        store.scheduleBuild();
+        ctx.print('Build scheduled — track progress with /codebase status or the fleet panel (code-index node).');
+        return;
+      }
+
+      if (sub === 'search') {
+        const { limit, queryTokens } = parseLimitArg(args.slice(1));
+        const query = queryTokens.join(' ').trim();
+        if (!query) {
+          ctx.print('Usage: /codebase search <query...> [--limit n]');
+          return;
+        }
+        const results = store.search(query, limit !== undefined ? { limit } : undefined);
+        if (results.length === 0) {
+          const stats = store.stats();
+          ctx.print(
+            stats.indexedChunks === 0
+              ? 'No results — the code index is empty. Run /codebase build first.'
+              : 'No matching chunks found.',
+          );
+          return;
+        }
+        ctx.print(`${results.length} result(s):\n${renderSearchResults(results)}`);
+        return;
+      }
+
+      ctx.print(USAGE);
+    },
+  });
+}

package/src/input/commands/config.ts

@@ -1,13 +1,45 @@
 import type { CommandRegistry } from '../command-registry.ts';
+import type { ConfigKey } from '@pellux/goodvibes-sdk/platform/config';
+import { setActiveThemeMode, type ThemeMode } from '../../renderer/theme.ts';
 
 export function registerConfigCommand(registry: CommandRegistry): void {
   registry.register({
     name: 'config',
     aliases: ['cfg'],
-    description: 'Open the fullscreen configuration workspace',
-    usage: '[category|key]',
-    argsHint: '[category|key]',
+    description: 'Open the fullscreen configuration workspace, or set a key directly',
+    usage: '[category|key] | set <key> <value>',
+    argsHint: '[category|key] | set <key> <value>',
     handler(args, ctx) {
+      // Batch replay D2: `/config set <key> <value>` used to fall through to
+      // the workspace with the assignment silently ignored — the dishonest-
+      // fallthrough class. `set` is now a real verb.
+      if (args[0] === 'set') {
+        const key = args[1];
+        const value = args.slice(2).join(' ');
+        if (!key || value === '') {
+          ctx.print('Usage: /config set <key> <value> — e.g. /config set display.themeMode light');
+          return;
+        }
+        try {
+          const before = ctx.platform.configManager.get(key as ConfigKey);
+          ctx.platform.configManager.setDynamic(key as ConfigKey, coerceConfigValue(value));
+          const after = ctx.platform.configManager.get(key as ConfigKey);
+          ctx.print(`Set ${key}: ${JSON.stringify(before)} → ${JSON.stringify(after)}`);
+          // Forced theme modes apply immediately (matches the settings-modal
+          // path); 'auto' re-probes on the next launch (stated honestly).
+          if (key === 'display.themeMode') {
+            if (after === 'dark' || after === 'light') {
+              setActiveThemeMode(after as ThemeMode);
+              ctx.print('Theme applied. Note: transcript, modal, and header/footer/thinking chrome all flip; only the background colour follows your terminal.');
+            } else {
+              ctx.print('Theme mode "auto" probes the terminal background on the next launch.');
+            }
+          }
+        } catch (e) {
+          ctx.print(`Could not set ${key}: ${e instanceof Error ? e.message : String(e)}`);
+        }
+        return;
+      }
       if (ctx.openSettingsModal) {
         ctx.openSettingsModal(args[0]);
         return;
@@ -16,3 +48,11 @@ export function registerConfigCommand(registry: CommandRegistry): void {
     },
   });
 }
+
+/** Coerce CLI text to the JSON-ish scalar the config schema expects. */
+function coerceConfigValue(raw: string): unknown {
+  if (raw === 'true') return true;
+  if (raw === 'false') return false;
+  if (raw !== '' && Number.isFinite(Number(raw))) return Number(raw);
+  return raw;
+}

package/src/input/commands/eval.ts

@@ -14,7 +14,7 @@ import { EvalRunner } from '@/runtime/index.ts';
 import { BUILTIN_SUITES } from '@/runtime/index.ts';
 import { formatScorecard } from '@/runtime/index.ts';
 import { loadBaseline, captureBaseline, formatBaselineComparison, writeBaseline } from '@/runtime/index.ts';
-import type { EvalRegistry } from '../../panels/eval-panel.ts';
+import type { EvalRegistry } from '../../panels/eval-registry.ts';
 import { formatSuiteResult, formatGateResult } from '@/runtime/index.ts';
 import { requireShellPaths } from './runtime-services.ts';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';

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

@@ -39,13 +39,13 @@ export function registerHealthRuntimeCommands(registry: CommandRegistry): void {
     name: 'health',
     aliases: ['doctor'],
     description: 'Health workspace for startup posture, service readiness, sandbox posture, and provider health',
-    usage: '[open|review|setup|services|sandbox|provider|accounts|auth|settings|intelligence|remote|mcp|continuity|worktrees|maintenance|term|repair [domain]]',
+    usage: '[report|review|open|setup|services|sandbox|provider|accounts|auth|settings|intelligence|remote|mcp|continuity|worktrees|maintenance|term|repair [domain]] — bare and report stay a cross-domain transcript report (see also /health provider for the providers modal)',
     async handler(args, ctx) {
       const sub = (args[0] ?? 'review').toLowerCase();
       const readModels = requireReadModels(ctx);
 
       if (sub === 'open' || sub === 'panel' || sub === 'provider') {
-        openCommandPanel(ctx, 'provider-health');
+        ctx.openModal?.('providers-modal'); // W6.1: provider-health panel -> config modal
         return;
       }
 
@@ -424,6 +424,14 @@ export function registerHealthRuntimeCommands(registry: CommandRegistry): void {
 
       ctx.print([
         'Health Review',
+        // DEBT-5 item 3: /health stays a cross-domain transcript report (it
+        // genuinely spans settings/accounts/auth/sandbox/etc — no single
+        // modal owns this data), but the providers domain DOES have one, so
+        // point at it honestly. "/provider" (no domain) is a DIFFERENT
+        // command (switch/manage custom providers) — the real front door to
+        // the providers modal is /health provider (see sub === 'provider'
+        // above), so that is what this hint names.
+        '  see also: the providers modal — /health provider',
         `  session: ${snapshot.sessionId}`,
         `  setup issues: ${snapshot.issues.length}`,
         `  service issues: ${snapshot.serviceIssues.length}`,