@pellux/goodvibes-tui 2.0.21 → 2.1.1

package/src/input/commands/workstream-attempts.ts

@@ -7,10 +7,10 @@
 // pickAttemptWinner, the same seam the fleet.attempts.* gateway verbs use).
 // This module drives that seam from the /workstream command:
 //   • list            , the held-merge groups awaiting a pick, with candidates.
-//   • diff <c>        , one candidate's worktree diff in the existing DiffPanel.
+//   • diff <c>        , one candidate's worktree diff in a Changes preview.
 //   • judge           , the OPTIONAL model proposal, clearly labelled a model
 //                        judgment (scoredBy 'model'), with its reasons; never a pick.
-//   • pick <c>        , behind a DiffPanel confirm; merges the winner and lets
+//   • pick <c>        , behind a question on its Changes preview; merges the winner and lets
 //                        the engine clean the losers, then renders the receipt.
 // ---------------------------------------------------------------------------
 
@@ -24,7 +24,6 @@ import { AttemptError } from '@pellux/goodvibes-sdk/platform/orchestration';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
 import type { CommandContext } from '../command-registry.ts';
 import type { WorkstreamCommandService } from '@pellux/goodvibes-sdk/platform/orchestration';
-import { requirePanelManager } from './runtime-services.ts';
 import { describeFailureReason, isTurnBudgetReason } from '../../core/turn-budget-outcome.ts';
 import { type AttemptGraphItem, renderDependentHoldLines } from './workstream-attempt-dependents.ts';
 
@@ -183,15 +182,9 @@ export async function handleAttemptsSubcommand(ctx: CommandContext, service: Wor
       ctx.print(`Attempt ${cand.attemptIndex + 1} has no viewable diff (${cand.state === 'failed' ? 'it failed' : 'its worktree was already cleaned'}).`);
       return true;
     }
-    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 the diff panel.'); return true; } }
-    pm.activateById('diff');
-    if (!pm.isVisible()) pm.show();
-    ctx.focusPanels?.();
-    (panel as InstanceType<typeof DiffPanel>).loadRawDiff(cand.diff.unifiedDiff);
-    ctx.print(`Showing attempt ${cand.attemptIndex + 1} ("${cand.title}") diff in the diff panel.`);
+    if (!ctx.previewChanges) { ctx.print('Showing a diff needs the Changes view, which is not available in this session.'); return true; }
+    void ctx.previewChanges({ title: `attempt ${cand.attemptIndex + 1}: ${cand.title}`, diff: cand.diff.unifiedDiff });
+    ctx.print(`Showing attempt ${cand.attemptIndex + 1} ("${cand.title}") in Changes.`);
     ctx.renderRequest();
     return true;
   }
@@ -204,42 +197,26 @@ export async function handleAttemptsSubcommand(ctx: CommandContext, service: Wor
     if ('error' in cand) { ctx.print(cand.error); return true; }
     if (cand.state !== 'held-merge') { ctx.print(`Attempt ${cand.attemptIndex + 1} failed: only a held (pick-ready) candidate can win.`); return true; }
 
-    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 the diff panel to confirm.'); return true; } }
-    pm.activateById('diff');
-    if (!pm.isVisible()) pm.show();
-    ctx.focusPanels?.();
-    const diffPanel = panel as InstanceType<typeof DiffPanel>;
-    if (cand.diff?.unifiedDiff.trim()) diffPanel.loadRawDiff(cand.diff.unifiedDiff);
-    else diffPanel.showDiff(cand.title, '@@ pick @@\n (no diff to preview for this candidate)');
-
-    diffPanel.confirmOverlay.arm({
-      id: `${group.groupId}:${cand.itemId}`,
-      label: `Pick attempt ${cand.attemptIndex + 1} ("${cand.title}"): merge it, clean the ${group.candidates.length - 1} other worktree(s)`,
-      verb: 'Pick',
-      onConfirm: async () => {
-        try {
-          const result = await service.engine.pickAttemptWinner(group.groupId, cand.itemId);
-          pm.close('diff');
-          ctx.focusPrompt?.();
-          ctx.print(renderPickReceipt(result));
-        } catch (err) {
-          pm.close('diff');
-          ctx.focusPrompt?.();
-          ctx.print(err instanceof AttemptError ? `Pick refused: ${err.message}` : `Pick failed: ${summarizeError(err)}`);
-        }
-        ctx.renderRequest();
-      },
-      onCancel: () => {
-        pm.close('diff');
-        ctx.focusPrompt?.();
-        ctx.print('Pick cancelled: nothing merged, no worktree cleaned.');
-        ctx.renderRequest();
-      },
+    if (!ctx.previewChanges) { ctx.print('Confirming a pick needs the Changes view, which is not available in this session.'); return true; }
+    ctx.print(`Confirm the pick in Changes: Enter or y merges attempt ${cand.attemptIndex + 1} and cleans the losers, n or Esc cancels.`);
+    ctx.renderRequest();
+    const confirmed = await ctx.previewChanges({
+      title: `attempt ${cand.attemptIndex + 1}: ${cand.title}`,
+      diff: cand.diff?.unifiedDiff.trim() ? cand.diff.unifiedDiff : undefined,
+      note: cand.diff?.unifiedDiff.trim() ? undefined : 'This candidate has no diff to preview.',
+      question: { text: `Pick attempt ${cand.attemptIndex + 1} ("${cand.title}")? It merges, and the ${group.candidates.length - 1} other worktree(s) are cleaned.`, confirmLabel: 'Pick', tone: 'warning' },
     });
-    ctx.print(`Confirm the pick in the diff panel: Enter/y to merge attempt ${cand.attemptIndex + 1} and clean the losers, n/Esc to cancel.`);
+    if (!confirmed) {
+      ctx.print('Pick cancelled: nothing merged, no worktree cleaned.');
+      ctx.renderRequest();
+      return true;
+    }
+    try {
+      const result = await service.engine.pickAttemptWinner(group.groupId, cand.itemId);
+      ctx.print(renderPickReceipt(result));
+    } catch (err) {
+      ctx.print(err instanceof AttemptError ? `Pick refused: ${err.message}` : `Pick failed: ${summarizeError(err)}`);
+    }
     ctx.renderRequest();
     return true;
   }

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

@@ -8,7 +8,7 @@
 // already is (bootstrap-command-context.ts).
 //
 // Render precedent: TRANSCRIPT + subcommand approve (like /plan approve,
-// planning-runtime.ts), NOT a panel, a multi-phase proposal is too rich for
+// planning-runtime.ts), NOT a modal, a multi-phase proposal is too rich for
 // a one-line confirm overlay, and Pillar-3 doctrine keeps work visible in the
 // transcript. create -> approve -> launch is a real three-step flow (edit and
 // cancel apply to the pending proposal too). The transcript IS the plan-review
@@ -126,7 +126,7 @@ async function launchApprovedDraft(ctx: CommandContext, service: WorkstreamComma
     ctx.print(`Could not launch ${id}.`);
     return;
   }
-  ctx.print(`Launched workstream ${result.workstreamId}: track it with /workstream status ${result.workstreamId} or the Fleet panel.`);
+  ctx.print(`Launched workstream ${result.workstreamId}: track it with /workstream status ${result.workstreamId} or in Agents (F2).`);
 }
 
 /**

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

@@ -1,7 +1,7 @@
 import { getPersistedWorktreeMeta, reviewWorktreeAttachments, summarizeWorktreeOwnership } from '@/runtime/index.ts';
 import type { ManagedWorktreeMeta } from '@/runtime/index.ts';
 import type { CommandRegistry } from '../command-registry.ts';
-import { openCommandPanel, requireShellPaths } from './runtime-services.ts';
+import { openCommandView, requireShellPaths } from './runtime-services.ts';
 import { describeOperatorRpcError, getOperatorRpc } from './operator-rpc.ts';
 
 /** Compact per-row setup-state tag for /worktree review, absent when setup has never run; failure stands out. */
@@ -43,7 +43,7 @@ export function registerWorktreeRuntimeCommands(registry: CommandRegistry): void
         return;
       }
       if (sub === 'panel' || sub === 'open') {
-        openCommandPanel(ctx, 'worktrees');
+        openCommandView(ctx, 'worktrees');
         return;
       }
       if (sub === 'inspect') {
@@ -149,7 +149,7 @@ export function registerWorktreeRuntimeCommands(registry: CommandRegistry): void
         // Discard is a real destructive act, not a metadata flip: route it
         // through the worktrees.discard operator verb (preservation commit,
         // git worktree removal, honest receipt), the SAME behavior as the
-        // Fleet panel's D key. Typing the verb with an explicit path is the
+        // Agents modal's D key. Typing the verb with an explicit path is the
         // confirmation.
         const path = args[1];
         if (!path) {

package/src/input/commands.ts

@@ -57,6 +57,7 @@ import { registerServicesRuntimeCommands } from './commands/services-runtime.ts'
 import { registerTasksRuntimeCommands } from './commands/tasks-runtime.ts';
 import { registerLocalProviderRuntimeCommands } from './commands/local-provider-runtime.ts';
 import { registerHealthRuntimeCommands } from './commands/health-runtime.ts';
+import { registerStatusRuntimeCommands } from './commands/status-runtime.ts';
 import { registerClusterRuntimeCommands } from './commands/cluster-runtime.ts';
 import { registerSettingsSyncRuntimeCommands } from './commands/settings-sync-runtime.ts';
 import { registerWorktreeRuntimeCommands } from './commands/worktree-runtime.ts';
@@ -145,10 +146,11 @@ export const BUILTIN_COMMAND_GROUPS: readonly BuiltinCommandGroup[] = [
   { category: 'Tasks', register: registerTasksRuntimeCommands },
   { category: 'Local Providers', register: registerLocalProviderRuntimeCommands },
   { category: 'Health', register: registerHealthRuntimeCommands },
+  { category: 'Health', register: registerStatusRuntimeCommands },
   { category: 'Cluster', register: registerClusterRuntimeCommands },
   { category: 'Settings Sync', register: registerSettingsSyncRuntimeCommands },
   { category: 'Worktrees', register: registerWorktreeRuntimeCommands },
-  { category: 'Fleet', register: registerAcpRuntimeCommands },
+  { category: 'Agents', register: registerAcpRuntimeCommands },
   { category: 'Provider Accounts', register: registerProviderAccountsRuntimeCommands },
   { category: 'Local Auth', register: registerLocalAuthRuntimeCommands },
   { category: 'Intelligence', register: registerIntelligenceRuntimeCommands },

package/src/input/composer-editor.ts

@@ -136,3 +136,47 @@ export function makeComposerEditorOpener(deps: ComposerEditorOpenerDeps): () =>
     },
   });
 }
+
+/** Editors known to take `+<line> <file>` to open at a line. */
+const LINE_ARG_EDITORS = new Set(['vi', 'vim', 'nvim', 'nano', 'emacs', 'micro', 'kak', 'hx', 'helix', 'ne', 'joe', 'mg']);
+
+export interface FileEditorOpenerDeps {
+  readonly stdin: { setRawMode(on: boolean): unknown };
+  readonly stdout: { write(seq: string): unknown };
+  readonly writeGuard: (fn: () => void) => void;
+  readonly repaint: () => void;
+  readonly cwd: string;
+  readonly env: NodeJS.ProcessEnv;
+  readonly notify: (message: string) => void;
+  readonly spawn?: EditorSpawn;
+}
+
+/**
+ * Build `openFileInEditor`: suspend the TUI, run $VISUAL / $EDITOR on a file
+ * (at a line when the editor is known to take `+<line>`), then restore and
+ * repaint. The Changes modal's `o` uses this.
+ */
+export function makeFileEditorOpener(deps: FileEditorOpenerDeps): (path: string, line?: number) => void {
+  return (path, line) => {
+    const editor = resolveEditorCommand(deps.env);
+    if (!editor) {
+      deps.notify('[Editor] Set $EDITOR or $VISUAL to open files in an external editor.');
+      return;
+    }
+    const base = editor.cmd.split('/').pop() ?? editor.cmd;
+    const lineArgs = line !== undefined && line > 0 && LINE_ARG_EDITORS.has(base) ? [`+${line}`] : [];
+    const spawn = deps.spawn ?? defaultSpawn;
+    try { deps.stdin.setRawMode(false); } catch { /* stdin may not be a TTY */ }
+    deps.writeGuard(() => deps.stdout.write(LEAVE_TUI));
+    let result: EditorSpawnResult;
+    try {
+      result = spawn(editor.cmd, [...editor.args, ...lineArgs, path], { cwd: deps.cwd, env: deps.env });
+    } finally {
+      deps.writeGuard(() => deps.stdout.write(ENTER_TUI));
+      try { deps.stdin.setRawMode(true); } catch { /* stdin may not be a TTY */ }
+      deps.repaint();
+    }
+    if (result.error) deps.notify(`[Editor] Failed to launch ${editor.cmd}: ${result.error.message}`);
+    else if (result.status !== 0 && result.status !== null) deps.notify(`[Editor] ${editor.cmd} exited with code ${result.status}.`);
+  };
+}

package/src/input/concealed-input.ts

@@ -2,7 +2,7 @@
  * Composer concealed-input mode.
  *
  * Generalizes the masking that previously lived only on the two purpose-built
- * auth surfaces (local-auth panel, onboarding wizard) into the MAIN composer,
+ * auth surfaces (local-auth modal, onboarding wizard) into the MAIN composer,
  * so any password-like prompt can request concealed entry: the typed text is
  * masked in the composer AND never reaches input history or the transcript
  * plaintext. The plaintext is delivered exactly once, to the requester's

package/src/input/config-modal-types.ts

@@ -1,4 +1,10 @@
-import type { ModalSectionStyle } from '../renderer/modal-factory.ts';
+/** A row's text style in a config modal (foreground, background, weight). */
+export interface ModalSectionStyle {
+  fg?: string;
+  bg?: string;
+  bold?: boolean;
+  dim?: boolean;
+}
 
 /**
  * Config-modal host, the shared seam every MIGRATE-TO-MODAL surface
@@ -37,6 +43,12 @@ export interface ConfigModalRow {
    * up/down navigation and never receives an action. Defaults to selectable.
    */
   readonly selectable?: boolean;
+  /**
+   * A group header (a section title such as "Next steps"): drawn as a kit
+   * group header (✦ lowercase accent) with a blank row above it. Always
+   * non-selectable and never filtered out.
+   */
+  readonly header?: boolean;
 }
 
 /** One tab (section) of a surface. Tabs are switched with left/right or Tab. */
@@ -79,8 +91,8 @@ export interface ConfigModalActionContext {
   /** Print a line to the conversation transcript. */
   readonly print: (message: string) => void;
   /**
-   * Execute a slash command, the same seam panels used via
-   * `PanelIntegrationContext.executeCommand`. This is how a migrated action
+   * Execute a slash command, the seam a migrated action
+   * uses to reach its existing command. This is how a migrated action
    * preserves parity: the mutation still runs through its existing, tested
    * command (e.g. `/settings-sync resolve`, `/local-auth delete-user`).
    */
@@ -124,10 +136,10 @@ export interface ConfigModalAction {
   /**
    * Trigger key: a single printable char ('r', 'd') or a named key ('enter').
    * Must not collide with the host-reserved nav keys (up/down/left/right/tab/
-   * j/k/escape/'/'), those are consumed by the host before actions are
-   * consulted. '/' arms the host's type-to-filter (item 1); while
-   * filtering, EVERY printable key (not just j/k) is captured by the query
-   * instead of firing an action, see handleConfigModalToken.
+   * escape), those are consumed by the host before actions are consulted.
+   * The search row is always live: a printable key that matches an action
+   * fires the action only while the query is empty; otherwise it is typed
+   * into the query, see handleConfigModalToken.
    */
   readonly key: string;
   /** Action id passed to `onAction`. */
@@ -151,7 +163,7 @@ export interface ConfigModalAction {
 /**
  * A named config-modal surface. Pure seam, the host knows nothing about the
  * surface's data. Built once (closing over its read-models) and registered on
- * PanelManager via `registerModalSurface`; opened by name from a panel-id
+ * the panel manager via `registerModalSurface`; opened by name from a view-id
  * redirect hit or `ctx.openModal(name)`.
  */
 export interface ConfigModalSurface {