@pellux/goodvibes-tui 1.1.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/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;
       }
 

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

@@ -0,0 +1,112 @@
+import type { CommandRegistry } from '../command-registry.ts';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+
+/**
+ * registerImageRuntimeCommands - `/imagine <prompt>`.
+ *
+ * Named 'imagine', not 'image' — `/image <path> [prompt]` already exists
+ * (local-runtime.ts) and does something entirely different (attach a local
+ * image file to the next message). Re-verified against the current registry
+ * before wiring this in: the brief that scoped this command was written
+ * before checking for the collision.
+ *
+ * First production caller of MediaProviderRegistry.generate() — the SDK
+ * plumbing existed with zero non-test call sites before this command.
+ * findProvider('generate') returns whichever generation-capable provider is
+ * configured; when none are, the command prints the registry's own
+ * per-provider status (id/state/detail) verbatim — those detail strings
+ * already name the exact env var per builtin provider
+ * (builtin-generation-providers.ts's buildStatus()), so this command never
+ * has to (and never should) guess or hardcode an env-var name itself.
+ */
+export function registerImageRuntimeCommands(registry: CommandRegistry): void {
+  registry.register({
+    name: 'imagine',
+    description: 'Generate an image from a prompt via a configured media provider',
+    usage: '<prompt>',
+    argsHint: '<prompt>',
+    async handler(args, ctx) {
+      const mediaProviders = ctx.platform.mediaProviders;
+      const artifactStore = ctx.platform.artifactStore;
+      if (!mediaProviders || !artifactStore) {
+        ctx.print('Image generation is not available in this session.');
+        return;
+      }
+
+      const prompt = args.join(' ').trim();
+      if (!prompt) {
+        ctx.print('Usage: /imagine <prompt>');
+        return;
+      }
+
+      const provider = mediaProviders.findProvider('generate');
+      if (!provider?.generate) {
+        const statuses = await mediaProviders.status();
+        const generationStatuses = statuses.filter((status) => status.capabilities.includes('generate'));
+        const lines = ['No image-generation provider is configured.', ''];
+        if (generationStatuses.length === 0) {
+          lines.push('No media-generation providers are registered in this build.');
+        } else {
+          for (const status of generationStatuses) {
+            lines.push(`  ${status.id} (${status.label}): ${status.state}${status.detail ? ` — ${status.detail}` : ''}`);
+          }
+        }
+        ctx.print(lines.join('\n'));
+        return;
+      }
+
+      try {
+        const result = await provider.generate({
+          prompt,
+          outputMimeType: 'image/png',
+          metadata: { source: 'tui-image-command' },
+        });
+
+        if (result.artifacts.length === 0) {
+          ctx.print(`${provider.label} returned no artifacts for this prompt.`);
+          return;
+        }
+
+        const lines = [`Generated ${result.artifacts.length} artifact(s) via ${provider.label} (${result.providerId}).`];
+        for (const artifact of result.artifacts) {
+          if (!artifact.mimeType.startsWith('image/')) {
+            lines.push(`  Note: ${provider.label} produced ${artifact.mimeType}, not an image — no image-capable provider is configured in this build.`);
+          }
+          if (artifact.dataBase64) {
+            const descriptor = await artifactStore.create({
+              dataBase64: artifact.dataBase64,
+              mimeType: artifact.mimeType,
+              filename: artifact.filename ?? 'generated-image',
+              metadata: { ...artifact.metadata, generatedBy: result.providerId },
+            });
+            lines.push(`  artifact: ${descriptor.id} (${descriptor.mimeType}, ${descriptor.sizeBytes} bytes)`);
+          } else if (artifact.uri) {
+            // Design note: this is the first production caller of generate(), and
+            // returned artifacts may be provider-hosted remote URLs rather than
+            // inline bytes. There is no existing precedent for whether to eagerly
+            // download remote-only output into ArtifactStore, and doing so
+            // unconditionally would turn a text command into an unbounded
+            // background fetch of arbitrary provider-hosted content. Conservative
+            // default: store a small JSON pointer record (not the media bytes) so
+            // the generation is still discoverable via the artifact store, and
+            // render the URL directly so the result stays immediately usable.
+            const descriptor = await artifactStore.create({
+              text: JSON.stringify({ remoteUrl: artifact.uri, mimeType: artifact.mimeType, providerId: result.providerId }, null, 2),
+              mimeType: 'application/json',
+              filename: `${artifact.filename ?? 'generated-image'}.reference.json`,
+              sourceUri: artifact.uri,
+              metadata: { ...artifact.metadata, generatedBy: result.providerId, remote: true },
+            });
+            lines.push(`  artifact: ${descriptor.id} (remote reference — not downloaded)`);
+            lines.push(`  url: ${artifact.uri}`);
+          } else {
+            lines.push('  artifact: (no retrievable content returned)');
+          }
+        }
+        ctx.print(lines.join('\n'));
+      } catch (error) {
+        ctx.print(`Image generation failed: ${summarizeError(error)}`);
+      }
+    },
+  });
+}

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

@@ -55,7 +55,17 @@ export function registerIntelligenceRuntimeCommands(registry: CommandRegistry):
     async handler(args, ctx) {
       const sub = (args[0] ?? 'review').toLowerCase();
       if (sub === 'panel' || sub === 'open') {
-        openCommandPanel(ctx, 'intelligence');
+        // W6.1 (the purge): 'intelligence'/IntelligencePanel was
+        // DELETE-disposition (no surviving human surface — its read model
+        // stays and still backs every subcommand below). There is no alias
+        // to resolve through, so this prints an honest notice and opens
+        // Fleet instead of throwing "Unknown panel".
+        ctx.print('Intelligence panel retired — use /intelligence review|diagnostics|symbols|outline|definition|references|hover|repair for the live data. Opening Fleet.');
+        try {
+          openCommandPanel(ctx, 'fleet');
+        } catch {
+          // Panel registry may be unavailable in lightweight command-only contexts.
+        }
         return;
       }
 

package/src/input/commands/local-auth-runtime.ts

@@ -10,7 +10,10 @@ export function handleLocalAuthCommand(args: string[], ctx: CommandContext): voi
   const sub = (args[0] ?? 'review').toLowerCase();
   const auth = requireLocalUserAuthManager(ctx);
   if (sub === 'panel' || sub === 'open') {
-    openCommandPanel(ctx, 'local-auth');
+    // W6.1: browse view moved to local-auth-modal. The LocalAuthPanel itself is
+    // kept (masked password-entry host) but is no longer the /local-auth panel
+    // destination — masked entry is reached via add-user/rotate-password below.
+    ctx.openModal?.('local-auth-modal');
     return;
   }
 

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

@@ -70,8 +70,14 @@ export function registerLocalRuntimeCommands(registry: CommandRegistry): void {
     handler(args, ctx) {
       const sub = (args[0] ?? '').toLowerCase();
       if (sub === 'panel' || sub === 'review') {
+        // W6.1 (the purge): 'tools'/ToolInspectorPanel was DELETE-disposition
+        // (no surviving human surface — tool results render inline in the
+        // transcript, plus a per-node tool list in Fleet). There is no alias
+        // to resolve through, so this prints an honest notice and opens
+        // Fleet instead of the retired inspector.
+        ctx.print('Tools panel retired — tool activity now renders inline in the transcript and per-agent in the Fleet panel. Opening Fleet.');
         try {
-          openCommandPanel(ctx, 'tools');
+          openCommandPanel(ctx, 'fleet');
         } catch {
           // Panel registry may be unavailable in lightweight command-only contexts.
         }
@@ -79,9 +85,9 @@ export function registerLocalRuntimeCommands(registry: CommandRegistry): void {
           ctx.print([
             'Tool Surface Review',
             '  Native file tools stay compact by default.',
-            '  Read/write/edit/notebook capabilities are available through the native tool stack, with detail routed to the tools panel and approval surfaces instead of transcript bloat.',
+            '  Read/write/edit/notebook capabilities are available through the native tool stack, with detail routed inline and to approval surfaces instead of transcript bloat.',
             '  Shell and native tool approvals classify work into read, mutation, destructive, dependency, config, notebook, network, remote, and lifecycle risk families.',
-            '  Use /tools panel to inspect risk class, output-policy actions, spill posture, compact summaries, and approval posture for recent calls.',
+            '  Use /tools panel to jump to the Fleet panel for live per-agent tool activity.',
             '  Use /approval review shell or /approval review file when you need the action-specific why-prompted posture.',
           ].join('\n'));
         }