@pellux/goodvibes-tui 2.0.21 → 2.1.0

package/src/input/changes-model.ts

@@ -0,0 +1,125 @@
+/**
+ * changes-model.ts, the Changes modal's data: a unified diff split into files
+ * and hunks, every line numbered on both sides.
+ *
+ * Built on the review model's hunk parser (views/diff-review-model.ts) so the
+ * hunks the Changes modal navigates are the very ReviewHunk values the review
+ * comment and hunk-revert seams take. Each file keeps its own header lines so
+ * one hunk can be turned back into a patch git will apply on its own (staging
+ * a hunk is `git apply --cached` of exactly that patch).
+ */
+
+import { parseReviewDiff, type ReviewHunk } from '../views/diff-review-model.ts';
+
+export type ChangeLineKind = 'add' | 'del' | 'ctx' | 'note';
+
+export interface ChangeLine {
+  readonly kind: ChangeLineKind;
+  /** The line without its leading '+', '-' or ' '. */
+  readonly text: string;
+  readonly oldNo: number | null;
+  readonly newNo: number | null;
+}
+
+export interface ChangeHunk {
+  readonly review: ReviewHunk;
+  readonly lines: readonly ChangeLine[];
+}
+
+export interface ChangeFile {
+  readonly path: string;
+  /** The file's diff header (diff --git, index, ---, +++ …), needed to apply one hunk alone. */
+  readonly headerLines: readonly string[];
+  readonly hunks: readonly ChangeHunk[];
+  readonly added: number;
+  readonly removed: number;
+  /** A binary file or a mode-only change: header only, nothing to show line by line. */
+  readonly headerOnly: boolean;
+  /**
+   * Why a file has no lines to show when it is not the usual binary or
+   * mode-only case (a large or empty untracked file). Read from a "# " line in
+   * the file's header, which changes-git.ts writes and git never does.
+   */
+  readonly note?: string;
+}
+
+function numberLines(hunk: ReviewHunk): ChangeLine[] {
+  const out: ChangeLine[] = [];
+  let oldNo = hunk.oldStart;
+  let newNo = hunk.newStart;
+  for (const raw of hunk.bodyLines) {
+    if (raw.startsWith('+')) out.push({ kind: 'add', text: raw.slice(1), oldNo: null, newNo: newNo++ });
+    else if (raw.startsWith('-')) out.push({ kind: 'del', text: raw.slice(1), oldNo: oldNo++, newNo: null });
+    else if (raw.startsWith('\\')) out.push({ kind: 'note', text: raw, oldNo: null, newNo: null });
+    else if (raw === '' ) continue; // the trailing split artifact of a chunk
+    else out.push({ kind: 'ctx', text: raw.slice(1), oldNo: oldNo++, newNo: newNo++ });
+  }
+  return out;
+}
+
+/** Header lines (everything before the first hunk) of each `diff --git` chunk, in order. */
+function chunkHeaders(raw: string): Array<{ lines: string[]; hasHunks: boolean }> {
+  const chunks = raw.split(/(?=^diff --git |^diff --cc |^diff --combined )/m).filter((chunk) => chunk.trim());
+  return chunks.map((chunk) => {
+    const lines = chunk.split('\n');
+    const first = lines.findIndex((line) => line.startsWith('@@'));
+    return { lines: (first < 0 ? lines : lines.slice(0, first)).filter((line) => line.length > 0), hasHunks: first >= 0 };
+  });
+}
+
+function pathFromHeader(header: readonly string[]): string {
+  for (const line of header) {
+    const m = /^diff --git "?a\/(.+?)"? "?b\/(.+?)"?$/.exec(line);
+    if (m) return m[2]!;
+  }
+  for (const line of header) {
+    const m = /^\+\+\+ (?:b\/)?(.+)$/.exec(line);
+    if (m && m[1] !== '/dev/null') return m[1]!;
+  }
+  return 'unknown';
+}
+
+/** Split a unified diff (one or many files) into files and numbered hunks. */
+export function parseChanges(raw: string): ChangeFile[] {
+  const headers = chunkHeaders(raw);
+  const reviewFiles = parseReviewDiff(raw);
+  const byIndex = new Map(reviewFiles.map((file) => [file.fileIndex, file]));
+  const files: ChangeFile[] = [];
+  headers.forEach((header, index) => {
+    const review = byIndex.get(index);
+    const hunks: ChangeHunk[] = (review?.hunks ?? []).map((hunk) => ({ review: hunk, lines: numberLines(hunk) }));
+    const noteLine = header.lines.find((line) => line.startsWith('# '));
+    files.push({
+      path: review?.filePath ?? pathFromHeader(header.lines),
+      headerLines: header.lines,
+      hunks,
+      added: hunks.reduce((n, h) => n + h.review.added, 0),
+      removed: hunks.reduce((n, h) => n + h.review.removed, 0),
+      headerOnly: hunks.length === 0,
+      ...(noteLine ? { note: noteLine.slice(2) } : {}),
+    });
+  });
+  return files;
+}
+
+/** One hunk as a complete patch (file header + hunk) that `git apply` accepts on its own. */
+export function hunkPatch(file: ChangeFile, hunk: ChangeHunk): string {
+  const header = file.headerLines.filter((line) => !line.startsWith('similarity') && !line.startsWith('rename'));
+  const hasFileLines = header.some((line) => line.startsWith('--- ')) && header.some((line) => line.startsWith('+++ '));
+  const fileLines = hasFileLines ? header : [...header, `--- a/${file.path}`, `+++ b/${file.path}`];
+  return [...fileLines, hunk.review.header, ...hunk.review.bodyLines.filter((line, i, all) => !(line === '' && i === all.length - 1))].join('\n') + '\n';
+}
+
+/** The language fence tag for a path (its extension), for syntax colors. */
+export function languageForPath(path: string): string {
+  const base = path.split('/').pop() ?? path;
+  if (base === 'Dockerfile') return 'dockerfile';
+  if (base === 'Makefile') return 'make';
+  const dot = base.lastIndexOf('.');
+  return dot > 0 ? base.slice(dot + 1).toLowerCase() : '';
+}
+
+/** Total +/- across files. */
+export function changeTotals(files: readonly ChangeFile[]): { added: number; removed: number } {
+  return files.reduce((acc, f) => ({ added: acc.added + f.added, removed: acc.removed + f.removed }), { added: 0, removed: 0 });
+}

package/src/input/command-palette-types.ts

@@ -0,0 +1,41 @@
+/**
+ * command-palette-types.ts, the shapes the command palette and its renderer
+ * share (kept apart so the renderer never imports the modal it draws).
+ */
+
+export type PaletteGroup = 'Suggested' | 'Session' | 'Views' | 'Settings' | 'Commands';
+
+export interface PaletteEntry {
+  /** The command's primary name. */
+  readonly id: string;
+  /** Human title for the row. */
+  readonly title: string;
+  readonly description: string;
+  readonly category: string;
+  readonly group: Exclude<PaletteGroup, 'Suggested'>;
+  readonly aliases: readonly string[];
+  /** Extra search words (former view names and the like). */
+  readonly keywords: readonly string[];
+  readonly argsHint?: string;
+  /** True when the command has required arguments: Enter fills the composer. */
+  readonly needsArgs: boolean;
+  /** Right column; defaults to the slash command. */
+  readonly right?: string;
+}
+
+export type PaletteRunMode = 'run' | 'fill';
+
+export interface PaletteSection {
+  readonly group: PaletteGroup;
+  readonly entries: readonly PaletteEntry[];
+}
+
+/** What the palette renderer reads from the palette. */
+export interface PaletteView {
+  readonly query: string;
+  readonly entries: readonly PaletteEntry[];
+  sections(): PaletteSection[];
+  flat(): PaletteEntry[];
+  getSelected(): PaletteEntry | null;
+  describe(id: string): string | undefined;
+}

package/src/input/command-palette.ts

@@ -0,0 +1,272 @@
+/**
+ * command-palette.ts, the command palette (ctrl+p, also ctrl+k and /palette).
+ *
+ * One entry point for everything: every registered slash command, built live
+ * from the registry so it can never drift from the real command set. With no
+ * query the palette shows four curated groups (Suggested, Session, Views,
+ * Settings) and then every other command; typing filters across names,
+ * aliases, titles, descriptions, categories and search words (former view names
+ * such as "fleet", "cockpit", "tokens" and "git" find the modal that holds
+ * them now: Agents, Usage, Changes, Notifications). The slash
+ * command sits right-aligned on every row, so the palette also teaches it.
+ *
+ * Suggested learns from what you use (per process); until it has something
+ * to learn from it offers a sensible starting set.
+ *
+ * Enter runs the selected command; a command that needs arguments (and tab,
+ * for any command) fills the composer instead so the arguments can be typed.
+ */
+
+import type { InputToken } from '@pellux/goodvibes-sdk/platform/core';
+import type { SlashCommand } from './command-registry.ts';
+import type { SurfaceModal, SurfaceModalHost } from './surface-modal-host.ts';
+import type { SurfaceLayer } from '../renderer/surface-kit.ts';
+import { renderCommandPalette } from '../renderer/command-palette.ts';
+import { isTextBackspace } from './delete-key-policy.ts';
+import { AGENT_VIEW_NAMES, CHANGES_VIEW_NAMES, USAGE_VIEW_NAMES } from './views.ts';
+import type { PaletteEntry, PaletteGroup, PaletteRunMode, PaletteSection, PaletteView } from './command-palette-types.ts';
+export type { PaletteEntry, PaletteGroup, PaletteRunMode, PaletteSection } from './command-palette-types.ts';
+
+
+
+interface CuratedEntry {
+  readonly title: string;
+  readonly group: Exclude<PaletteGroup, 'Suggested' | 'Commands'>;
+  readonly keywords?: readonly string[];
+  readonly right?: string;
+}
+
+/**
+ * The curated groups, by command name. A name that is not registered in this
+ * build is skipped, so the table never shows a command that does not exist.
+ */
+const CURATED: ReadonlyArray<readonly [string, CuratedEntry]> = [
+  ['resume', { title: 'Resume a session', group: 'Session', keywords: ['open', 'load'] }],
+  ['session', { title: 'Sessions', group: 'Session', keywords: ['saved', 'hosted', 'history'] }],
+  ['clear', { title: 'Clear the conversation', group: 'Session', keywords: ['new', 'reset'] }],
+  ['compact', { title: 'Compact context', group: 'Session', keywords: ['summarize', 'tokens'] }],
+  ['fork', { title: 'Fork from here', group: 'Session', keywords: ['branch'] }],
+  ['bookmarks', { title: 'Bookmarks', group: 'Session' }],
+  ['replay', { title: 'Replay a session', group: 'Session' }],
+  ['agents', { title: 'Agents', group: 'Views', keywords: [...AGENT_VIEW_NAMES, 'hosted', 'acp', 'claude code', 'codex', 'opencode', 'steer', 'stop'] }],
+  ['usage', { title: 'Usage', group: 'Views', keywords: [...USAGE_VIEW_NAMES, 'budget', 'compact', 'price'] }],
+  ['changes', { title: 'Changes', group: 'Views', keywords: [...CHANGES_VIEW_NAMES, 'files', 'stage', 'commit', 'hunk'] }],
+  ['notifications', { title: 'Notifications', group: 'Views', keywords: ['notifications', 'alerts', 'messages', 'history', 'toasts'] }],
+  ['context', { title: 'Context inspector', group: 'Views', keywords: ['tokens', 'window'] }],
+  ['work-plan', { title: 'Work plan', group: 'Views', keywords: ['todo', 'plan'] }],
+  ['hosted', { title: 'Hosted sessions', group: 'Views', keywords: ['daemon'] }],
+  ['health', { title: 'Health', group: 'Views', keywords: ['doctor'] }],
+  ['settings', { title: 'Settings', group: 'Settings', keywords: ['preferences', 'options', 'theme'] }],
+  ['model', { title: 'Switch model', group: 'Settings', keywords: ['provider', 'llm'] }],
+  ['effort', { title: 'Reasoning effort', group: 'Settings', keywords: ['thinking'] }],
+  ['shortcuts', { title: 'Keyboard shortcuts', group: 'Settings', keywords: ['keys', 'help'], right: '?' }],
+  ['keybindings', { title: 'Keybindings', group: 'Settings', keywords: ['keys'] }],
+  ['mode', { title: 'Approval mode', group: 'Settings', keywords: ['permissions', 'hitl'] }],
+  ['profiles', { title: 'Profiles', group: 'Settings' }],
+  ['local-auth', { title: 'Local accounts', group: 'Settings', keywords: ['accounts', 'users', 'auth', 'password', 'local-auth'] }],
+  ['tts', { title: 'Voice and speech', group: 'Settings', keywords: ['voice'] }],
+];
+
+/** The Suggested group before there is any usage to learn from. */
+const DEFAULT_SUGGESTED = ['changes', 'model', 'compact'];
+const SUGGESTED_COUNT = 3;
+
+/** How often each command was run from the palette in this process. */
+const usage = new Map<string, number>();
+
+export function recordPaletteUse(id: string): void {
+  usage.set(id, (usage.get(id) ?? 0) + 1);
+}
+
+/** Test hook. */
+export function resetPaletteUsageForTests(): void {
+  usage.clear();
+}
+
+function hasRequiredArgs(command: SlashCommand): boolean {
+  const hint = command.argsHint ?? command.usage ?? '';
+  return /<[^>]+>/.test(hint.replace(/\[[^\]]*\]/g, ''));
+}
+
+/** Title for a command outside the curated table: its description's first clause. */
+function titleFromDescription(command: SlashCommand): string {
+  const text = command.description.trim();
+  if (!text) return `/${command.name}`;
+  const first = text.split(/(?<=[.;])\s/)[0]!.replace(/[.;]$/, '');
+  return first.length > 0 ? first : text;
+}
+
+/** Build the palette's entries from the registered commands. */
+export function buildPaletteEntries(commands: readonly SlashCommand[], categories: ReadonlyMap<string, string>): PaletteEntry[] {
+  const curated = new Map(CURATED);
+  const entries: PaletteEntry[] = [];
+  for (const command of commands) {
+    const c = curated.get(command.name);
+    entries.push({
+      id: command.name,
+      title: c?.title ?? titleFromDescription(command),
+      description: command.description,
+      category: categories.get(command.name) ?? 'Other',
+      group: c?.group ?? 'Commands',
+      aliases: command.aliases ?? [],
+      keywords: c?.keywords ?? [],
+      argsHint: command.argsHint ?? command.usage,
+      needsArgs: hasRequiredArgs(command),
+      right: c?.right,
+    });
+  }
+  // Curated entries in table order, the rest alphabetically by name.
+  const order = new Map(CURATED.map(([name], index) => [name, index]));
+  return entries.sort((a, b) => {
+    const oa = order.get(a.id);
+    const ob = order.get(b.id);
+    if (oa !== undefined && ob !== undefined) return oa - ob;
+    if (oa !== undefined) return -1;
+    if (ob !== undefined) return 1;
+    return a.id.localeCompare(b.id);
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Matching
+// ---------------------------------------------------------------------------
+
+function wordScore(entry: PaletteEntry, word: string): number {
+  const name = entry.id.toLowerCase();
+  const title = entry.title.toLowerCase();
+  if (name === word) return 100;
+  if (name.startsWith(word)) return 80;
+  if (entry.aliases.some((a) => a.toLowerCase() === word)) return 75;
+  if (entry.aliases.some((a) => a.toLowerCase().startsWith(word))) return 70;
+  if (title.split(/[\s/-]+/).some((w) => w.startsWith(word))) return 60;
+  if (entry.keywords.some((k) => k.toLowerCase().startsWith(word))) return 55;
+  if (name.includes(word) || title.includes(word)) return 40;
+  if (entry.keywords.some((k) => k.toLowerCase().includes(word))) return 35;
+  if (entry.description.toLowerCase().includes(word)) return 20;
+  if (entry.category.toLowerCase().includes(word)) return 10;
+  return 0;
+}
+
+/** Match score for a query (every word must match somewhere), or 0 for no match. */
+export function paletteScore(entry: PaletteEntry, query: string): number {
+  const words = query.trim().toLowerCase().replace(/^\//, '').split(/\s+/).filter(Boolean);
+  if (words.length === 0) return 1;
+  let total = 0;
+  for (const word of words) {
+    const s = wordScore(entry, word);
+    if (s === 0) return 0;
+    total += s;
+  }
+  return total;
+}
+
+
+// ---------------------------------------------------------------------------
+// The modal
+// ---------------------------------------------------------------------------
+
+export interface CommandPaletteOptions {
+  readonly entries: readonly PaletteEntry[];
+  /** Run or fill the composer with a command; the palette has already closed. */
+  readonly onRun: (entry: PaletteEntry, mode: PaletteRunMode) => void;
+  /** Optional live note for a row (e.g. the current model), shown muted after its title. */
+  readonly describe?: (id: string) => string | undefined;
+}
+
+export class CommandPalette implements SurfaceModal, PaletteView {
+  readonly name = 'command-palette';
+  query = '';
+  selectedIndex = 0;
+  private sectionsCache: { query: string; sections: PaletteSection[] } | null = null;
+
+  constructor(private readonly options: CommandPaletteOptions) {}
+
+  get entries(): readonly PaletteEntry[] {
+    return this.options.entries;
+  }
+
+  describe(id: string): string | undefined {
+    return this.options.describe?.(id);
+  }
+
+  /** The groups shown for the current query. */
+  sections(): PaletteSection[] {
+    if (this.sectionsCache?.query === this.query) return this.sectionsCache.sections;
+    const sections: PaletteSection[] = [];
+    if (this.query.trim().length === 0) {
+      const byId = new Map(this.entries.map((e) => [e.id, e]));
+      const learned = [...usage.entries()].sort((a, b) => b[1] - a[1]).map(([id]) => id);
+      const suggested: PaletteEntry[] = [];
+      for (const id of [...learned, ...DEFAULT_SUGGESTED]) {
+        const entry = byId.get(id);
+        if (entry && !suggested.includes(entry)) suggested.push(entry);
+        if (suggested.length >= SUGGESTED_COUNT) break;
+      }
+      if (suggested.length > 0) sections.push({ group: 'Suggested', entries: suggested });
+      for (const group of ['Session', 'Views', 'Settings', 'Commands'] as const) {
+        const entries = this.entries.filter((e) => e.group === group && !suggested.includes(e));
+        if (entries.length > 0) sections.push({ group, entries });
+      }
+    } else {
+      const ranked = this.entries
+        .map((entry, index) => ({ entry, index, score: paletteScore(entry, this.query) }))
+        .filter((r) => r.score > 0)
+        .sort((a, b) => b.score - a.score || a.index - b.index)
+        .map((r) => r.entry);
+      if (ranked.length > 0) sections.push({ group: 'Commands', entries: ranked });
+    }
+    this.sectionsCache = { query: this.query, sections };
+    return sections;
+  }
+
+  /** Entries in display order (what up and down walk). */
+  flat(): PaletteEntry[] {
+    return this.sections().flatMap((s) => s.entries);
+  }
+
+  getSelected(): PaletteEntry | null {
+    const flat = this.flat();
+    return flat[Math.max(0, Math.min(this.selectedIndex, flat.length - 1))] ?? null;
+  }
+
+  setQuery(query: string): void {
+    this.query = query;
+    this.selectedIndex = 0;
+  }
+
+  move(delta: number): void {
+    const count = this.flat().length;
+    if (count === 0) return;
+    this.selectedIndex = (this.selectedIndex + delta + count) % count;
+  }
+
+  handleToken(token: InputToken, host: SurfaceModalHost): void {
+    if (token.type === 'text') {
+      const text = [...token.value].filter((ch) => ch >= ' ' && ch !== '\x7f').join('');
+      if (text) this.setQuery(this.query + text);
+      return;
+    }
+    if (token.type !== 'key') return;
+    const key = token.logicalName ?? '';
+    if (token.ctrl && (key === 'p' || key === 'k')) {
+      host.close(this, 'escape');
+      return;
+    }
+    if (key === 'up') this.move(-1);
+    else if (key === 'down') this.move(1);
+    else if (key === 'pageup') this.move(-10);
+    else if (key === 'pagedown') this.move(10);
+    else if (isTextBackspace(key)) this.setQuery(this.query.slice(0, -1));
+    else if (key === 'enter' || key === 'tab') {
+      const entry = this.getSelected();
+      if (!entry) return;
+      host.close(this, 'done');
+      recordPaletteUse(entry.id);
+      this.options.onRun(entry, key === 'tab' || entry.needsArgs ? 'fill' : 'run');
+    }
+  }
+
+  render(screenWidth: number, screenHeight: number): SurfaceLayer {
+    return renderCommandPalette(this, screenWidth, screenHeight);
+  }
+}

package/src/input/command-registry.ts

@@ -9,7 +9,7 @@ import type { SelectionItem, SelectionResult, SelectionAction } from './selectio
 import type { FileUndoManager } from '@pellux/goodvibes-sdk/platform/state';
 import type { WorkspaceCheckpointManager } from '@pellux/goodvibes-sdk/platform/workspace';
 import type { GatewayMethodCatalog } from '@pellux/goodvibes-sdk/platform/control-plane';
-import type { PanelManager, PanelDeepLinkTarget } from '../panels/panel-manager.ts';
+import type { ViewTarget } from './views.ts';
 import type { KeybindingsManager } from './keybindings.ts';
 import type { OnboardingWizardMode } from './onboarding/onboarding-wizard.ts';
 import type { OpenOnboardingWizardOptions } from './handler-ui-state.ts';
@@ -119,7 +119,7 @@ export interface CommandUiActions {
   /** Set the daemon-held keep-awake toggle (power.keepAwake.set), acquiring/releasing the inhibitor live; returns the new state. */
   setKeepAwake?: (enabled: boolean) => Promise<import('../core/power-status.ts').PowerSurfaceState>;
   /** True while an LLM turn is actively streaming. Used to give Escape
-   *  cancel-turn precedence over a focused panel's own escape handling. */
+   *  cancel-turn precedence over a focused modal's own escape handling. */
   isGenerating?: () => boolean;
   completeModelSelection?: (selection: {
     model: { id: string; provider: string; displayName: string; registryKey: string };
@@ -180,13 +180,20 @@ export interface CommandShellUiOpeners {
   openSelection?: (
     title: string,
     items: SelectionItem[],
-    opts: { preSelectId?: string; allowSearch?: boolean; customActions?: Map<string, SelectionAction>; primaryVerbLabel?: string } | undefined,
+    opts: {
+      preSelectId?: string;
+      allowSearch?: boolean;
+      customActions?: Map<string, SelectionAction>;
+      primaryVerbLabel?: string;
+      /** Live preview: called whenever the highlighted row changes. */
+      onHighlight?: (item: SelectionItem | null) => void;
+    } | undefined,
     callback: (result: SelectionResult | null) => void,
   ) => void;
   openSettingsModal?: (target?: string) => void;
   /**
    * Open a MIGRATE-TO-MODAL surface by name (purge skeleton, B
-   * command runtimes call this instead of openCommandPanel once their panel
+   * command runtimes call this instead of an older view opener once their view
    * is converted to a ModalFactory config). Threaded from ui-openers.ts the
    * same way openSettingsModal is.
    */
@@ -195,13 +202,26 @@ export interface CommandShellUiOpeners {
   openProfilePicker?: () => void;
   openShortcutsOverlay?: () => void;
   getScrollTop?: () => number;
-  openPanelPicker?: () => void;
   /**
    * Open the fuzzy command palette, a searchable picker over every registered
    * slash command (generated live from the registry). Bound to Ctrl+K and the
    * /palette command. Selecting a command pre-fills it into the composer.
    */
   openCommandPalette?: () => void;
+  /**
+   * Ask a yes/no question in a small centered confirm dialog (a kit modal on
+   * top of whatever is open). Resolves true only when the confirming button
+   * is pressed; Esc and "no" resolve false.
+   */
+  confirm?: (options: import('./confirm-dialog.ts').ConfirmOptions) => Promise<boolean>;
+  /** Show a toast in the top right corner for five seconds (a colored ┃ on both sides). */
+  showToast?: (toast: import('../renderer/surface-kit-parts.ts').ToastSpec) => void;
+  /**
+   * The /status report: session, model, tools, notification mode, token
+   * totals and cost, context use, cross-surface posture and the safety
+   * states. Built by the shell from the same sources the footer reads.
+   */
+  describeStatus?: () => string;
   /**
    * Command name -> reference-category label, from the same single source of
    * truth as the generated command reference (categorizeBuiltinCommands),
@@ -212,40 +232,63 @@ export interface CommandShellUiOpeners {
    */
   getCommandCategories?: () => ReadonlyMap<string, string>;
   /**
-   * Open (and optionally focus) a panel. focus rule: the command path is
-   * "the user is mid-command-flow", opening a panel this way leaves keyboard
-   * focus in the composer by default. Pass `{ focus: true }` for a caller that
-   * genuinely wants to grab focus (chords use panelManager.focusPanels()
-   * directly instead of this method, so no current call site needs it, but
-   * the intent is explicit rather than implicit here). `target` is a
-   * fleet deep-link jump target forwarded to PanelManager.open.
+   * Open the modal that holds a view, by its current or old name ('agents',
+   * 'fleet', 'cockpit', 'tokens', 'git', 'providers', …; see views.ts).
+   * `target` selects a specific process in the Agents modal. Returns false
+   * when nothing holds that name.
+   */
+  openView?: (name: string, target?: ViewTarget) => boolean;
+  /** The Agents modal; `target` selects a process, `hosted` opens the attached hosted session. */
+  openAgents?: (options?: { readonly target?: ViewTarget; readonly hosted?: boolean }) => void;
+  /**
+   * Open an agent or a background process full screen (core/session-focus.ts).
+   * False when it is not known here (the caller keeps its own fallback).
+   */
+  openSessionView?: (target: { readonly kind: 'agent' | 'process'; readonly id: string }) => boolean;
+  /** The Usage modal (`tab: 'agents'` opens on the per-agent cost ledger). */
+  openUsage?: (options?: { readonly tab?: 'overview' | 'turns' | 'agents' }) => void;
+  /** The Changes modal over the repository (this session's files, not staged, staged or vs HEAD). */
+  openChanges?: (options?: { readonly source?: import('./changes-git.ts').ChangesSource }) => void;
+  /**
+   * Show a diff someone else produced (a rewind checkpoint, a workstream
+   * attempt, a fleet candidate) in a read-only Changes preview. With a
+   * question, resolves true only when its confirm button is pressed; closing
+   * the preview answers no. `note` is shown when there is no diff to draw.
    */
-  showPanel?: (panelId: string, pane?: 'top' | 'bottom', target?: PanelDeepLinkTarget, opts?: { focus?: boolean }) => void;
-  focusPanels?: () => void;
+  previewChanges?: (options: {
+    readonly title: string;
+    readonly diff?: string;
+    readonly note?: string;
+    readonly question?: import('./changes-modal.ts').ChangesQuestionSpec;
+  }) => Promise<boolean>;
+  /** The notification history. */
+  openNotifications?: () => void;
+  /** Open a file in $VISUAL / $EDITOR (at a line when the editor takes one). */
+  openFileInEditor?: (path: string, line?: number) => void;
   focusPrompt?: () => void;
-  openOpsPanel?: () => void;
-  openCockpitPanel?: () => void;
-  openOrchestrationPanel?: () => void;
-  openForensicsPanel?: () => void;
-  openIncidentPanel?: () => void;
-  openPolicyPanel?: () => void;
-  openHooksPanel?: () => void;
-  openCommunicationPanel?: () => void;
+  openOpsView?: () => void;
+  openCockpitView?: () => void;
+  openOrchestrationView?: () => void;
+  openForensicsView?: () => void;
+  openIncidentView?: () => void;
+  openPolicyView?: () => void;
+  openHooksView?: () => void;
+  openCommunicationView?: () => void;
   openMcpWorkspace?: () => void;
-  openSecurityPanel?: () => void;
-  openKnowledgePanel?: () => void;
-  openMemoryPanel?: () => void;
-  openRemotePanel?: () => void;
-  openSubscriptionPanel?: () => void;
+  openSecurityView?: () => void;
+  openKnowledgeView?: () => void;
+  openMemoryView?: () => void;
+  openRemoteView?: () => void;
+  openSubscriptionView?: () => void;
   /**
-   * Open the LocalAuthPanel in masked-password-entry mode for the given
-   * operation and username. The panel captures keystrokes into a private
-   * buffer; no plaintext password is ever stored in input history, transcript,
-   * logs, or recovery files.
+   * Open the local-auth password prompt (a kit modal) for the operation and
+   * user. Keystrokes land in a private buffer that is never drawn; no
+   * plaintext password reaches input history, the transcript, logs, or
+   * recovery files. An empty username for add-user asks for it first.
    */
   openLocalAuthMaskedEntry?: (
     kind: 'add-user' | 'rotate-password',
-    username: string,
+    username?: string,
   ) => void;
 }
 
@@ -310,7 +353,6 @@ export interface CommandWorkspaceUiServices {
   gatewayMethods?: GatewayMethodCatalog;
   workspaceTrustManager?: import('@pellux/goodvibes-sdk/platform/runtime/operations').WorkspaceTrustManager;
   workspaceRegistrationManager?: import('@pellux/goodvibes-sdk/platform/runtime/operations').WorkspaceRegistrationManager;
-  panelManager?: PanelManager;
   profileManager?: import('@pellux/goodvibes-sdk/platform/profiles').ProfileManager;
   bookmarkManager?: import('@pellux/goodvibes-sdk/platform/bookmarks').BookmarkManager;
   projectPlanningService?: import('@pellux/goodvibes-sdk/platform/knowledge').ProjectPlanningService;
@@ -350,7 +392,7 @@ export interface CommandOpsServices
 export interface CommandExtensionRegistryServices {
   readonly toolRegistry: ToolRegistry;
   readonly mcpRegistry: McpRegistry;
-  readonly evalRegistry?: import('../panels/eval-registry.ts').EvalRegistry;
+  readonly evalRegistry?: import('../views/eval-registry.ts').EvalRegistry;
 }
 
 export interface CommandExtensionServices
@@ -408,7 +450,7 @@ export interface CommandContext
  * unaffected, fuzzyMatch still searches every registered command exactly as
  * before; this only reorders the empty-query case. Curated for breadth across
  * the product's main workflows rather than raw usage frequency: help/config
- * (orientation), panel/model (workspace + provider), recall/codebase/search
+ * (orientation), panel (legacy view aliases)/model (workspace + provider), recall/codebase/search
  * (knowledge), workstream/checkpoint (control-plane), imagine (generation),
  * sessions (continuity), quit (exit).
  */