@pellux/goodvibes-tui 2.0.21 → 2.1.1

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

@@ -1,7 +1,8 @@
 // ---------------------------------------------------------------------------
-// acp-runtime.ts, the scripted path for hosting third-party coding agents,
-// over the SAME verbs the Fleet panel's spawn affordance drives (acp.agents.list
-// / acp.sessions.create). `/agents list` shows what the daemon discovered
+// acp-runtime.ts, `/agents`. Bare `/agents` opens the Agents modal
+// (`--target <id>[:<kind>]` selects a process in it). The scripted path for
+// hosting third-party coding agents drives the SAME verbs the Agents modal's
+// n key does (acp.agents.list / acp.sessions.create). `/agents list` shows what the daemon discovered
 // (read-only, quiet when none); `/agents host <agentId> [dir]` spawns one as a
 // long-lived daemon session that shows up as an acp-agent fleet row. A working
 // directory defaults to the current one; a known workspace root can be named
@@ -14,17 +15,26 @@
 
 import type { CommandRegistry } from '../command-registry.ts';
 import { requireShellPaths } from './runtime-services.ts';
+import { takeTargetFlag } from '../views.ts';
 import { describeOperatorRpcError, getOperatorRpc } from './operator-rpc.ts';
 
 export function registerAcpRuntimeCommands(registry: CommandRegistry): void {
   registry.register({
     name: 'agents',
     aliases: ['acp'],
-    description: 'Host third-party coding agents (Claude Code, Codex, opencode) as fleet rows over ACP',
-    usage: 'list | host <agentId> [directory]',
-    argsHint: '[list|host]',
+    description: 'Open Agents (everything running: agents, chains, workflows, hosted sessions); list or host third-party coding agents over ACP',
+    usage: '[--target <id>[:<kind>]] | list | host <agentId> [directory]',
+    argsHint: '[list|host|--target <id>]',
     async handler(args, ctx) {
-      const sub = (args[0] ?? 'list').toLowerCase();
+      const rest = [...args];
+      const target = takeTargetFlag(rest);
+      if (rest.length === 0) {
+        // Bare /agents (or /agents --target <id>) opens the Agents modal.
+        if (ctx.openAgents) ctx.openAgents({ target });
+        else ctx.print('The Agents view is not available in this session; /agents list prints the hostable agents.');
+        return;
+      }
+      const sub = (rest[0] ?? 'list').toLowerCase();
       const rpc = getOperatorRpc(ctx);
       if (!rpc.available) { ctx.print(`[agents] ${rpc.reason}`); return; }
 
@@ -46,12 +56,12 @@ export function registerAcpRuntimeCommands(registry: CommandRegistry): void {
       }
 
       if (sub === 'host') {
-        const agentId = args[1];
+        const agentId = rest[1];
         if (!agentId) {
           ctx.print('Usage: /agents host <agentId> [directory]  (agentId from /agents list; directory defaults to the current one)');
           return;
         }
-        const cwd = args[2] ?? requireShellPaths(ctx).workingDirectory;
+        const cwd = rest[2] ?? requireShellPaths(ctx).workingDirectory;
         try {
           const { hosted, started } = await rpc.sdk.operator.invoke('acp.sessions.create', { agentId, cwd });
           if (hosted.error) {

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

@@ -147,7 +147,7 @@ export function registerChannelRuntimeCommands(registry: CommandRegistry): void
       const asJson = args.includes('--json');
 
       if (!sub || sub === 'open' || sub === 'panel') {
-        if (ctx.showPanel) ctx.showPanel('routes');
+        ctx.openView?.('routes');
         return;
       }
 
@@ -269,7 +269,7 @@ export function registerChannelRuntimeCommands(registry: CommandRegistry): void
 
       ctx.print(
         'Usage: /channel <subcommand>\n'
-        + '  (no args)  — open the Routes panel\n'
+        + '  (no args)  — open Agents (where routes live now)\n'
         + '  pair [surface] — guided channel pairing: list adapters, enter declared credentials, verify\n'
         + '  status     — channel overview: routes, sessions, tasks, pending approvals\n'
         + '  routes     — active route binding snapshot\n'

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

@@ -83,7 +83,7 @@ export function renderWatch(watch: CiWatchSubscription): string {
 export function registerCiRuntimeCommands(registry: CommandRegistry): void {
   registry.register({
     name: 'ci',
-    description: 'CI-watch: one-shot per-job status and standing watches over the operator panel',
+    description: 'CI-watch: one-shot per-job status and standing watches, surfaced in Agents',
     usage: 'status <repo-or-pr> | watch <repo-or-pr> <deliveryChannel> [--fix-session] | watches | unwatch <id>',
     argsHint: '[status|watch|watches|unwatch]',
     async handler(args, ctx) {

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

@@ -201,7 +201,7 @@ export function registerCodebaseRuntimeCommands(registry: CommandRegistry): void
           return;
         }
         store.scheduleBuild();
-        ctx.print('Build scheduled: track progress with /codebase status or the fleet panel (code-index node).');
+        ctx.print('Build scheduled: track progress with /codebase status or Agents (F2, the code-index row).');
         return;
       }
 

package/src/input/commands/config.ts

@@ -1,6 +1,6 @@
 import type { CommandContext, CommandRegistry } from '../command-registry.ts';
 import type { ConfigKey } from '@pellux/goodvibes-sdk/platform/config';
-import { setActiveThemeMode, type ThemeMode } from '../../renderer/theme.ts';
+import { setActiveThemeMode, setActiveThemeName, type ThemeMode } from '../../renderer/theme.ts';
 import {
   buildGoodVibesSecretKey,
   defaultSecretBackedScope,
@@ -45,9 +45,15 @@ export function registerConfigCommand(registry: CommandRegistry): void {
           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.theme') {
+            const applied = setActiveThemeName(after);
+            ctx.requestFullRepaint?.();
+            ctx.print(`Theme applied: ${applied}.`);
+          }
           if (key === 'display.themeMode') {
             if (after === 'dark' || after === 'light') {
               setActiveThemeMode(after as ThemeMode);
+              ctx.requestFullRepaint?.();
               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.');

package/src/input/commands/context-window.ts

@@ -6,11 +6,13 @@
  * control-plane config dir with provenance 'configured_cap'), so it survives
  * restarts, applies to any model (cloud or local), and is honored by every
  * consumer of the same home. Clearing returns the model to its automatic
- * window (catalog / provider API / family fallback).
+ * window (catalog / provider API / family fallback). The source line names
+ * where the window came from, with the SDK's describeContextWindowSource
+ * ('catalog: abacus', 'consensus of 4 providers', 'family default').
  */
 import type { CommandContext } from '../command-registry.ts';
 import type { ModelDefinition } from '@pellux/goodvibes-sdk/platform/providers';
-import { MAX_CONTEXT_WINDOW_OVERRIDE } from '@pellux/goodvibes-sdk/platform/providers';
+import { MAX_CONTEXT_WINDOW_OVERRIDE, describeContextWindowSource } from '@pellux/goodvibes-sdk/platform/providers';
 
 /**
  * Parse a user-supplied context window size. Accepts plain token counts
@@ -28,26 +30,28 @@ export function parseContextWindowSize(raw: string): number | null {
   return value;
 }
 
-function describeProvenance(model: ModelDefinition): string {
-  switch (model.contextWindowProvenance) {
-    case 'configured_cap': return 'custom override';
-    case 'observed_limit': return 'learned from a provider rejection';
-    case 'provider_api': return 'reported by the provider';
-    case 'fallback': return 'family default (no catalog entry)';
-    default: return 'model catalog';
-  }
-}
-
 /** Status text for the current model's window + override state. */
 export function buildContextWindowStatusText(
   model: ModelDefinition,
-  resolvedWindow: number,
+  /** The window a source states, or null when unknown. */
+  resolvedWindow: number | null,
   override: number | null,
   observed: number | null = null,
 ): string {
+  const resolvedText = resolvedWindow === null
+    ? model.contextWindowProvenance === 'accepted_floor'
+      ? `unknown (the provider accepted ${model.contextWindow.toLocaleString()} tokens, more than the stated window)`
+      : model.contextWindowOrigin?.kind === 'family_default'
+        ? `unknown (no catalog provider lists this model; the family default of ${model.contextWindow.toLocaleString()} tokens is a guess)`
+        : 'unknown (no catalog entry or provider report states it)'
+    : `${resolvedWindow.toLocaleString()} tokens`;
+  const sourceText = resolvedWindow === null && model.contextWindowProvenance === 'accepted_floor'
+    ? null
+    : describeContextWindowSource(model);
   const lines = [
     `Context window for ${model.displayName} (${model.registryKey}):`,
-    `  resolved: ${resolvedWindow.toLocaleString()} tokens (${describeProvenance(model)})`,
+    `  resolved: ${resolvedText}`,
+    ...(sourceText === null ? [] : [`  source:   ${sourceText}`]),
     `  override: ${override === null ? 'none (automatic)' : `${override.toLocaleString()} tokens`}`,
   ];
   if (observed !== null) {
@@ -71,23 +75,25 @@ export function handleContextWindowSubcommand(args: readonly string[], ctx: Comm
   if (arg === '') {
     output = buildContextWindowStatusText(
       model,
-      registry.getContextWindowForModel(model),
+      registry.getKnownContextWindowForModel(model),
       registry.getModelContextCap(model.registryKey),
       registry.getObservedContextWindow(model.registryKey),
     );
   } else if (arg === 'clear' || arg === 'auto' || arg === 'reset') {
     const existed = registry.clearModelContextCap(model.registryKey);
-    const resolved = registry.getContextWindowForModel(registry.getCurrentModel());
+    const known = registry.getKnownContextWindowForModel(registry.getCurrentModel());
+    const resolved = known === null ? 'unknown' : `${known.toLocaleString()} tokens`;
     output = existed
-      ? `Context window settings cleared for ${model.displayName} (custom override and any learned limit). Back to automatic: ${resolved.toLocaleString()} tokens.`
-      : `${model.displayName} has no custom context window or learned limit set (automatic: ${resolved.toLocaleString()} tokens).`;
+      ? `Context window settings cleared for ${model.displayName} (custom override and any learned limit). Back to automatic: ${resolved}.`
+      : `${model.displayName} has no custom context window or learned limit set (automatic: ${resolved}).`;
   } else {
     const size = parseContextWindowSize(arg);
     if (size === null) {
       output = `Invalid size '${args[0]}'. Use a token count between 1 and ${MAX_CONTEXT_WINDOW_OVERRIDE.toLocaleString()}, e.g. 120000, 200k, 1m, or 'clear'.`;
     } else {
+      const was = registry.getKnownContextWindowForModel(model);
       registry.setModelContextCap(model.registryKey, size);
-      output = `Context window for ${model.displayName} set to ${size.toLocaleString()} tokens (was ${registry.getContextWindowForModel(model).toLocaleString()}). Clear with /context window clear.`;
+      output = `Context window for ${model.displayName} set to ${size.toLocaleString()} tokens (was ${was === null ? 'unknown' : `${was.toLocaleString()} tokens`}). Clear with /context window clear.`;
     }
   }
 

package/src/input/commands/control-room-runtime.ts

@@ -9,13 +9,13 @@ export function registerControlRoomRuntimeCommands(registry: CommandRegistry): v
   registry.register({
     name: 'cockpit',
     aliases: [],
-    description: 'Open the unified operator cockpit',
+    description: 'Open Agents (the old operator cockpit)',
     handler(_args, ctx) {
-      if (ctx.openCockpitPanel) {
-        ctx.openCockpitPanel();
+      if (ctx.openCockpitView) {
+        ctx.openCockpitView();
         return;
       }
-      ctx.print('Cockpit panel is not available in this runtime.');
+      ctx.print('The Agents view is not available in this runtime.');
     },
   });
 
@@ -27,12 +27,12 @@ export function registerControlRoomRuntimeCommands(registry: CommandRegistry): v
     handler(args, ctx) {
       const graphs = [...requireReadModels(ctx).orchestration.getSnapshot().graphs];
       if (args.length === 0) {
-        if (ctx.openOrchestrationPanel) {
-          ctx.openOrchestrationPanel();
+        if (ctx.openOrchestrationView) {
+          ctx.openOrchestrationView();
           return;
         }
         if (graphs.length === 0) {
-          ctx.print('Orchestration panel is not available in this runtime.');
+          ctx.print('The Agents view is not available in this runtime.');
           return;
         }
       }
@@ -103,11 +103,11 @@ export function registerControlRoomRuntimeCommands(registry: CommandRegistry): v
     aliases: ['comms'],
     description: 'Inspect structured agent communication routes and recent activity',
     handler(_args, ctx) {
-      if (ctx.openCommunicationPanel) {
-        ctx.openCommunicationPanel();
+      if (ctx.openCommunicationView) {
+        ctx.openCommunicationView();
         return;
       }
-      ctx.print('Communication panel is not available in this runtime.');
+      ctx.print('The Agents view is not available in this runtime.');
     },
   });
 
@@ -118,11 +118,11 @@ export function registerControlRoomRuntimeCommands(registry: CommandRegistry): v
     usage: '[review | attack-paths | tokens]',
     handler(args, ctx) {
       if (args.length === 0) {
-        if (ctx.openSecurityPanel) {
-          ctx.openSecurityPanel();
+        if (ctx.openSecurityView) {
+          ctx.openSecurityView();
           return;
         }
-        ctx.print('Security panel is not available in this runtime.');
+        ctx.print('The Security view is not available in this runtime.');
         return;
       }
 
@@ -201,11 +201,11 @@ export function registerControlRoomRuntimeCommands(registry: CommandRegistry): v
     async handler(args, ctx) {
       const subcommand = (args[0] ?? 'open').toLowerCase();
       if (subcommand === 'open') {
-        if (ctx.openMemoryPanel) {
-          ctx.openMemoryPanel();
+        if (ctx.openMemoryView) {
+          ctx.openMemoryView();
           return;
         }
-        ctx.print('Memory panel is not available in this runtime.');
+        ctx.print('The Memory view is not available in this runtime.');
         return;
       }
       if (subcommand === 'queue') {
@@ -250,8 +250,8 @@ export function registerControlRoomRuntimeCommands(registry: CommandRegistry): v
         ctx.print(prompt ?? 'No reviewed project knowledge matched that task.');
         return;
       }
-      if (ctx.openMemoryPanel) {
-        ctx.openMemoryPanel();
+      if (ctx.openMemoryView) {
+        ctx.openMemoryView();
         return;
       }
       ctx.print(`Unknown project-memory subcommand: ${subcommand}`);

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

@@ -79,7 +79,6 @@ function buildComposerReview(ctx: CommandContext): string[] {
   const composer = deriveComposerState({
     text: '',
     commandMode: false,
-    panelFocused: false,
     pendingApproval: session.pendingApproval,
     hasAttachments: false,
     turnState: session.turnState,

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

@@ -1,6 +1,5 @@
 import type { CommandRegistry } from '../command-registry.ts';
-import { CostTrackerPanel } from '../../panels/cost-tracker-panel.ts';
-import { openCommandPanel, requirePanelManager } from './runtime-services.ts';
+import { BUDGET_ALERT_USD_CONFIG_KEY } from '@pellux/goodvibes-sdk/platform/providers';
 import { describeOperatorRpcError, getOperatorRpc } from './operator-rpc.ts';
 import {
   COST_ATTRIBUTION_OPTIONAL_DIMENSIONS,
@@ -11,23 +10,37 @@ import {
 } from './cost-attribution-format.ts';
 
 /**
- * /cost budget <usd>, makes the CostTrackerPanel's budget alert real.
- * Opens the cost panel (creating it via the registered factory if not already
- * open) and sets its budget threshold directly, so the meter+alert already
- * built into CostTrackerPanel.render() (:266-290) actually fires. 0 disables
- * the alert. Mirrors the /auth local rotate-password → panel-instance-call
- * pattern (local-auth-runtime.ts) rather than only printing a signpost.
+ * /usage and /cost. `/usage` (and `/cost` or `/cost panel`) opens the Usage
+ * modal. `/cost budget <usd>` sets the budget alert: it writes the
+ * behavior.budgetAlertUsd setting, the one the Usage modal's b key, the Usage
+ * modal's budget row and the background budget-breach notifier all read, so
+ * the alert is real wherever it shows. 0 turns it off.
  */
 export function registerCostRuntimeCommands(registry: CommandRegistry): void {
+  registry.register({
+    name: 'usage',
+    description: 'Context pressure, session tokens and cost, per-turn history, per-agent costs and the budget alert',
+    usage: '[turns|agents]',
+    handler(args, ctx) {
+      const tab = (args[0] ?? '').toLowerCase();
+      if (!ctx.openUsage) {
+        ctx.print('The Usage view is not available in this session.');
+        return;
+      }
+      ctx.openUsage({ tab: tab === 'turns' || tab === 'agents' ? tab : undefined });
+    },
+  });
+
   registry.register({
     name: 'cost',
-    description: 'Inspect session/agent cost tracking, windowed cost attribution, and the budget alert threshold',
+    description: 'Open Usage, set the session budget alert, or show windowed cost attribution',
     usage: '[panel|budget <usd>|attribution [24h|7d] [--json]]',
     async handler(args, ctx) {
       const sub = (args[0] ?? 'panel').toLowerCase();
 
       if (sub === 'panel' || sub === 'open') {
-        openCommandPanel(ctx, 'cost');
+        if (ctx.openUsage) ctx.openUsage();
+        else ctx.print('The Usage view is not available in this session.');
         return;
       }
 
@@ -38,16 +51,12 @@ export function registerCostRuntimeCommands(registry: CommandRegistry): void {
           ctx.print('Usage: /cost budget <usd>  (0 disables the alert)');
           return;
         }
-        const panelManager = requirePanelManager(ctx);
-        const panel = panelManager.open('cost');
-        if (panel instanceof CostTrackerPanel) {
-          panel.setBudgetThreshold(usd);
-          ctx.print(usd > 0
-            ? `Cost budget alert set to $${usd.toFixed(2)}.`
-            : 'Cost budget alert disabled.');
-        } else {
-          ctx.print('Cost tracking is not available in this session.');
-        }
+        const config = ctx.platform.configManager;
+        config.set(BUDGET_ALERT_USD_CONFIG_KEY as Parameters<typeof config.set>[0], usd as never);
+        ctx.print(usd > 0
+          ? `Cost budget alert set to $${usd.toFixed(2)}.`
+          : 'Cost budget alert disabled.');
+        ctx.renderRequest();
         return;
       }
 

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

@@ -1,193 +1,47 @@
-import { join } from 'path';
-import { logger } from '@pellux/goodvibes-sdk/platform/utils';
-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,
-  };
+import type { ChangesSource } from '../changes-git.ts';
+
+/** `session` (default), `working` (not staged), `staged`, or `head` (everything vs HEAD). */
+function sourceFor(arg: string | undefined): ChangesSource {
+  const sub = (arg ?? 'session').toLowerCase();
+  if (sub === 'working' || sub === 'unstaged') return 'working';
+  if (sub === 'staged' || sub === 'cached') return 'staged';
+  if (sub === 'head' || sub === 'all') return 'head';
+  return 'session';
 }
 
-/** 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[],
-  ref: string,
-  renderFn: () => void,
-  workingDirectory: string,
-): 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', stderr: 'pipe', cwd: workingDirectory });
-  await repoRootProc.exited;
-  const repoRoot = (await new Response(repoRootProc.stdout).text()).trim() || workingDirectory;
-  await Promise.allSettled(
-    files.map(async (filePath) => {
-      try {
-        const absPath = filePath.startsWith('/') ? filePath : join(workingDirectory, filePath);
-        const repoRelPath = filePath.startsWith('/') ? pathRelative(repoRoot, filePath) : filePath;
-        const [beforeResult, afterResult] = await Promise.allSettled([
-          (async () => {
-            const proc = Bun.spawn(
-              ['git', 'show', `${ref}:${repoRelPath}`],
-              { stdout: 'pipe', stderr: 'pipe', cwd: repoRoot },
-            );
-            const [text, exitCode] = await Promise.all([new Response(proc.stdout).text(), proc.exited]);
-            if (exitCode !== 0) throw new Error(`git show failed for ${repoRelPath}`);
-            return text;
-          })(),
-          Bun.file(absPath).text(),
-        ]);
-        if (beforeResult.status !== 'fulfilled' || afterResult.status !== 'fulfilled') return;
-        const semanticDiff = await computeSemanticDiff(filePath, beforeResult.value, afterResult.value);
-        if (!semanticDiff) return;
-        const summary = formatSemanticDiffSummary(semanticDiff);
-        if (summary) {
-          panel.setSemanticSummary(filePath, summary);
-          renderFn();
-        }
-      } catch {
-        // best-effort only
-      }
-    }),
-  );
+function openChanges(ctx: CommandContext, args: string[]): void {
+  if (!ctx.openChanges) {
+    ctx.print('The Changes view is not available in this session.');
+    return;
+  }
+  ctx.openChanges({ source: sourceFor(args[0]) });
 }
 
+/**
+ * `/changes` and `/diff`: the Changes modal over this repository. With no
+ * argument it shows the files this session edited against HEAD (everything vs
+ * HEAD when none are tracked yet); `working`, `staged` and `head` pick the
+ * other views, which v also cycles inside the modal.
+ */
 export function registerDiffRuntimeCommands(registry: CommandRegistry): void {
+  registry.register({
+    name: 'changes',
+    description: 'Changed files with a tinted diff and semantic summary: stage hunks, comment for the model, mark reviewed',
+    usage: '[session|working|staged|head]',
+    argsHint: '[session|working|staged|head]',
+    handler(args, ctx) {
+      openChanges(ctx, args);
+    },
+  });
   registry.register({
     name: 'diff',
     aliases: ['d'],
-    description: 'Show unified diff of session file changes. Uses git diff HEAD if in a git repo',
-    usage: '[session|head|working|staged|<git-ref>]',
-    argsHint: '[session|head|working|staged|<ref>]',
-    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);
-      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();
-      ctx.focusPanels?.();
-
-      const diffPanel = panel as InstanceType<typeof DiffPanel>;
-      const sub = (args[0] ?? 'session').toLowerCase();
-
-      switch (sub) {
-        case 'working': {
-          ctx.print('Loading working-tree diff...');
-          await diffPanel.showGitDiff();
-          ctx.print('Diff panel updated: working tree changes.');
-          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;
-        }
-        case 'staged': {
-          ctx.print('Loading staged diff...');
-          const proc = Bun.spawn(['/bin/sh', '-c', 'git diff --cached'], { stdout: 'pipe', stderr: 'pipe', cwd: workingDirectory });
-          const [raw, errText] = await Promise.all([new Response(proc.stdout).text(), new Response(proc.stderr).text()]);
-          const exitCode = await proc.exited;
-          if (exitCode !== 0) {
-            ctx.print(`git diff --cached failed: ${errText.trim() || 'unknown error'}`);
-            return;
-          }
-          if (!raw.trim()) {
-            ctx.print('No staged changes.');
-            diffPanel.showDiff('(no staged changes)', '@@ -0,0 +0,0 @@\n No staged changes.');
-          } else {
-            diffPanel.loadRawDiff(raw);
-            ctx.print('Diff panel updated: staged changes.');
-            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;
-        }
-        case 'head': {
-          ctx.print('Loading diff vs HEAD...');
-          await diffPanel.showGitDiff('HEAD');
-          ctx.print('Diff panel updated: all changes vs HEAD.');
-          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;
-        }
-        case 'session':
-        default: {
-          const sessionFiles = requireSessionChangeTracker(ctx).getChangedFiles();
-          if (sessionFiles.length > 0) {
-            ctx.print(`Loading session diff (${sessionFiles.length} file${sessionFiles.length === 1 ? '' : 's'} changed this session)...`);
-            await diffPanel.showFileDiffs(sessionFiles, 'HEAD');
-            ctx.print(`Diff panel updated: ${sessionFiles.length} session file${sessionFiles.length === 1 ? '' : 's'}.`);
-            enrichSemanticDiff(diffPanel, sessionFiles, 'HEAD', () => ctx.renderRequest(), workingDirectory).catch((err) => { logger.debug('semantic diff enrichment failed', { err }); });
-          } else {
-            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 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;
-        }
-      }
-
-      ctx.renderRequest();
+    description: 'Show the diff of this session\'s file changes (or working, staged, or everything vs HEAD) in Changes',
+    usage: '[session|head|working|staged]',
+    argsHint: '[session|head|working|staged]',
+    handler(args, ctx) {
+      openChanges(ctx, args);
     },
   });
 }

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-registry.ts';
+import type { EvalRegistry } from '../../views/eval-registry.ts';
 import { formatSuiteResult, formatGateResult } from '@/runtime/index.ts';
 import { requireShellPaths } from './runtime-services.ts';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';