@pellux/goodvibes-tui 1.0.0 → 1.7.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,192 @@
+// ---------------------------------------------------------------------------
+// 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). This is Stage A only: no auto-injection into coding turns (Stage B,
+// out of scope — see the wo802/W5.3 design doc).
+// ---------------------------------------------------------------------------
+
+import type { CodeIndexStats, CodeContextResult } 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`;
+}
+
+function renderCodeIndexStatus(stats: CodeIndexStats, configManager: Pick<ConfigManager, 'get'>): 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)`,
+  );
+  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 (Wave-5 W5.3 Stage A)',
+    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));
+        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/diff-runtime.ts

@@ -1,8 +1,39 @@
 import { join } from 'path';
 import { logger } from '@pellux/goodvibes-sdk/platform/utils';
-import type { CommandRegistry } from '../command-registry.ts';
+import { GitService } from '@pellux/goodvibes-sdk/platform/git';
+import type { CommandContext, CommandRegistry } from '../command-registry.ts';
 import { requirePanelManager, requireSessionChangeTracker, requireShellPaths } from './runtime-services.ts';
 
+/**
+ * Run a git command that lists changed file names, capturing stderr instead
+ * of letting it fall through to the process's real stderr (which, for a
+ * spawned child with no stdio option, is inherited from the parent — i.e.
+ * written straight to the TUI's controlling terminal, corrupting the screen
+ * outside the renderer's front/back-buffer diffing). Mirrors the 'staged'
+ * subcommand's existing pattern below.
+ */
+async function runGitNameOnly(args: string[], cwd: string): Promise<{ files: string[]; errText: string; ok: boolean }> {
+  const proc = Bun.spawn(args, { stdout: 'pipe', stderr: 'pipe', cwd });
+  const [out, errRaw] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+  ]);
+  const exitCode = await proc.exited;
+  return {
+    files: out.trim().split('\n').filter(Boolean),
+    errText: errRaw.trim(),
+    ok: exitCode === 0,
+  };
+}
+
+/** Report a failed name-only fetch through the normal print channel and force
+ * a full repaint on the next frame as defense-in-depth, in case anything did
+ * reach the real tty. */
+function reportGitNameOnlyFailure(ctx: CommandContext, label: string, errText: string): void {
+  ctx.print(`${label} failed: ${errText || 'unknown error'}`);
+  ctx.requestFullRepaint?.();
+}
+
 async function enrichSemanticDiff(
   panel: InstanceType<typeof import('../../panels/diff-panel.ts').DiffPanel>,
   files: string[],
@@ -12,7 +43,7 @@ async function enrichSemanticDiff(
 ): Promise<void> {
   const { computeSemanticDiff, formatSemanticDiffSummary } = await import('../../renderer/semantic-diff.ts');
   const { relative: pathRelative } = await import('path');
-  const repoRootProc = Bun.spawn(['git', 'rev-parse', '--show-toplevel'], { stdout: 'pipe', cwd: workingDirectory });
+  const repoRootProc = Bun.spawn(['git', 'rev-parse', '--show-toplevel'], { stdout: 'pipe', stderr: 'pipe', cwd: workingDirectory });
   await repoRootProc.exited;
   const repoRoot = (await new Response(repoRootProc.stdout).text()).trim() || workingDirectory;
   await Promise.allSettled(
@@ -57,6 +88,14 @@ export function registerDiffRuntimeCommands(registry: CommandRegistry): void {
     async handler(args, ctx) {
       const shellPaths = requireShellPaths(ctx);
       const workingDirectory = shellPaths.workingDirectory;
+      // Gate before any git spawn happens (same defensive check /git already
+      // has) — every subcommand below shells out to git, and without this
+      // they each produced a differently-shaped error for the same
+      // not-a-git-repo condition.
+      if (!GitService.isGitRepo(workingDirectory)) {
+        ctx.print('Not a git repository here. Run /git to initialize one.');
+        return;
+      }
       const { DiffPanel } = await import('../../panels/diff-panel.ts');
 
       const pm = requirePanelManager(ctx);
@@ -81,13 +120,11 @@ export function registerDiffRuntimeCommands(registry: CommandRegistry): void {
           ctx.print('Loading working-tree diff...');
           await diffPanel.showGitDiff();
           ctx.print('Diff panel updated: working tree changes.');
-          const workingChangedFiles = await (async () => {
-            const proc = Bun.spawn(['git', 'diff', '--name-only'], { stdout: 'pipe', cwd: workingDirectory });
-            await proc.exited;
-            return (await new Response(proc.stdout).text()).trim().split('\n').filter(Boolean);
-          })();
-          if (workingChangedFiles.length > 0) {
-            enrichSemanticDiff(diffPanel, workingChangedFiles, 'HEAD', () => ctx.renderRequest(), workingDirectory).catch((err) => { logger.debug('semantic diff enrichment failed', { err }); });
+          const workingChanged = await runGitNameOnly(['git', 'diff', '--name-only'], workingDirectory);
+          if (!workingChanged.ok) {
+            reportGitNameOnlyFailure(ctx, 'git diff --name-only', workingChanged.errText);
+          } else if (workingChanged.files.length > 0) {
+            enrichSemanticDiff(diffPanel, workingChanged.files, 'HEAD', () => ctx.renderRequest(), workingDirectory).catch((err) => { logger.debug('semantic diff enrichment failed', { err }); });
           }
           break;
         }
@@ -106,13 +143,11 @@ export function registerDiffRuntimeCommands(registry: CommandRegistry): void {
           } else {
             diffPanel.loadRawDiff(raw);
             ctx.print('Diff panel updated: staged changes.');
-            const stagedChangedFiles = await (async () => {
-              const stagedProc = Bun.spawn(['git', 'diff', '--cached', '--name-only'], { stdout: 'pipe', cwd: workingDirectory });
-              await stagedProc.exited;
-              return (await new Response(stagedProc.stdout).text()).trim().split('\n').filter(Boolean);
-            })();
-            if (stagedChangedFiles.length > 0) {
-              enrichSemanticDiff(diffPanel, stagedChangedFiles, 'HEAD', () => ctx.renderRequest(), workingDirectory).catch((err) => { logger.debug('semantic diff enrichment failed', { err }); });
+            const stagedChanged = await runGitNameOnly(['git', 'diff', '--cached', '--name-only'], workingDirectory);
+            if (!stagedChanged.ok) {
+              reportGitNameOnlyFailure(ctx, 'git diff --cached --name-only', stagedChanged.errText);
+            } else if (stagedChanged.files.length > 0) {
+              enrichSemanticDiff(diffPanel, stagedChanged.files, 'HEAD', () => ctx.renderRequest(), workingDirectory).catch((err) => { logger.debug('semantic diff enrichment failed', { err }); });
             }
           }
           break;
@@ -121,13 +156,11 @@ export function registerDiffRuntimeCommands(registry: CommandRegistry): void {
           ctx.print('Loading diff vs HEAD...');
           await diffPanel.showGitDiff('HEAD');
           ctx.print('Diff panel updated: all changes vs HEAD.');
-          const headChangedFiles = await (async () => {
-            const proc = Bun.spawn(['/bin/sh', '-c', 'git diff HEAD --name-only'], { stdout: 'pipe', cwd: workingDirectory });
-            await proc.exited;
-            return (await new Response(proc.stdout).text()).trim().split('\n').filter(Boolean);
-          })();
-          if (headChangedFiles.length > 0) {
-            enrichSemanticDiff(diffPanel, headChangedFiles, 'HEAD', () => ctx.renderRequest(), workingDirectory).catch((err) => { logger.debug('semantic diff enrichment failed', { err }); });
+          const headChanged = await runGitNameOnly(['git', 'diff', 'HEAD', '--name-only'], workingDirectory);
+          if (!headChanged.ok) {
+            reportGitNameOnlyFailure(ctx, 'git diff HEAD --name-only', headChanged.errText);
+          } else if (headChanged.files.length > 0) {
+            enrichSemanticDiff(diffPanel, headChanged.files, 'HEAD', () => ctx.renderRequest(), workingDirectory).catch((err) => { logger.debug('semantic diff enrichment failed', { err }); });
           }
           break;
         }
@@ -143,13 +176,11 @@ export function registerDiffRuntimeCommands(registry: CommandRegistry): void {
             ctx.print('No session changes tracked yet. Showing diff vs HEAD...');
             await diffPanel.showGitDiff('HEAD');
             ctx.print('Diff panel updated: all changes vs HEAD.');
-            const fallbackFiles = await (async () => {
-              const proc = Bun.spawn(['/bin/sh', '-c', 'git diff HEAD --name-only'], { stdout: 'pipe', cwd: workingDirectory });
-              await proc.exited;
-              return (await new Response(proc.stdout).text()).trim().split('\n').filter(Boolean);
-            })();
-            if (fallbackFiles.length > 0) {
-              enrichSemanticDiff(diffPanel, fallbackFiles, 'HEAD', () => ctx.renderRequest(), workingDirectory).catch((err) => { logger.debug('semantic diff enrichment failed', { err }); });
+            const fallback = await runGitNameOnly(['git', 'diff', 'HEAD', '--name-only'], workingDirectory);
+            if (!fallback.ok) {
+              reportGitNameOnlyFailure(ctx, 'git diff HEAD --name-only', fallback.errText);
+            } else if (fallback.files.length > 0) {
+              enrichSemanticDiff(diffPanel, fallback.files, 'HEAD', () => ctx.renderRequest(), workingDirectory).catch((err) => { logger.debug('semantic diff enrichment failed', { err }); });
             }
           }
           break;

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

@@ -45,7 +45,7 @@ export function registerHealthRuntimeCommands(registry: CommandRegistry): void {
       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;
       }