@pellux/goodvibes-tui 1.1.0 → 1.9.0

package/src/panels/diff-panel.ts

@@ -8,9 +8,8 @@ import { truncateDisplay, getDisplayWidth } from '../utils/terminal-width.ts';
 import { GitService } from '@pellux/goodvibes-sdk/platform/git';
 import { BasePanel } from './base-panel.ts';
 import { UI_TONES, DIFF_TONES } from '../renderer/ui-primitives.ts';
-import { FilePreviewPanel } from './file-preview-panel.ts';
-import type { PanelIntegrationContext } from './types.ts';
 import { logger } from '@pellux/goodvibes-sdk/platform/utils';
+import { PanelConfirmOverlay } from './panel-confirm-overlay.ts';
 import {
   buildBodyText,
   buildEmptyState,
@@ -262,14 +261,12 @@ export class DiffPanel extends BasePanel {
   private selectedFile = 0;
   private scrollOffset = 0;
 
-  /** Set by the 'o' key; consumed by handlePanelIntegrationAction on the next dispatch. */
-  private pendingOpenPreview = false;
-
   /** One-line confirmation for the 'w'/'h'/'s' self-load hotkeys — otherwise a
    * reload that produces identical content is visually indistinguishable
    * from the keypress doing nothing at all. */
   private hotkeyStatus: string | null = null;
 
+  public readonly confirmOverlay = new PanelConfirmOverlay(() => this.markDirty()); // armed by a command handler (e.g. /rewind); see panel-confirm-overlay.ts
   constructor(
     workingDirectory: string,
     private readonly requestRender: () => void = () => {},
@@ -502,6 +499,7 @@ export class DiffPanel extends BasePanel {
   }
 
   handleInput(key: string): boolean {
+    if (this.confirmOverlay.handleInput(key)) return true; // confirm takes priority (git-panel.ts:284-303 precedent)
     switch (key) {
       case 'up':    this.scrollUp();   return true;
       case 'down':  this.scrollDown(); return true;
@@ -519,48 +517,17 @@ export class DiffPanel extends BasePanel {
       case 'w': this.runHotkeyReload('working tree', () => this.showGitDiff());       return true;
       case 'h': this.runHotkeyReload('HEAD',         () => this.showGitDiff('HEAD')); return true;
       case 's': this.runHotkeyReload('staged',       () => this.showStagedDiff());    return true;
-      case 'o': {
-        if (!this.currentEntry()) return false;
-        this.pendingOpenPreview = true;
-        return true;
-      }
       default: return false;
     }
   }
 
-  /**
-   * Cross-panel integration hook — 'o' opens the currently selected file in
-   * the preview panel via the same open/focus bridge FileExplorerPanel uses
-   * (src/input/panel-integration-actions.ts), without this panel needing to
-   * know about PanelManager pane/focus mechanics beyond what ctx exposes.
-   */
-  handlePanelIntegrationAction(_key: string, ctx: PanelIntegrationContext): boolean {
-    if (!this.pendingOpenPreview) return false;
-    this.pendingOpenPreview = false;
-    const entry = this.currentEntry();
-    if (!entry) return false;
-
-    const pm = ctx.panelManager;
-    let previewPanel = pm.getPanel('preview');
-    if (previewPanel instanceof FilePreviewPanel) {
-      const pane = pm.getPaneOf('preview');
-      pm.activateById('preview');
-      if (pane) pm.focusPane(pane);
-    } else {
-      const targetPane: 'top' | 'bottom' = pm.isBottomPaneVisible()
-        ? (pm.getFocusedPane() === 'top' ? 'bottom' : 'top')
-        : 'bottom';
-      const opened = pm.open('preview', targetPane);
-      pm.show();
-      pm.focusPane(targetPane);
-      previewPanel = opened instanceof FilePreviewPanel ? opened : null;
-    }
-    if (previewPanel instanceof FilePreviewPanel) {
-      previewPanel.openFile(entry.filePath);
-      return true;
-    }
-    return false;
-  }
+  // W6.1 (the purge): 'o' used to open the currently selected file in the
+  // preview panel via a staged pendingOpenPreview flag + a
+  // handlePanelIntegrationAction cross-panel hook (the same bridge
+  // FileExplorerPanel used). 'preview' is DELETE-disposition with no
+  // successor surface (no file-picker-overlay preview to repoint to
+  // either — verified), so the key and the hook were removed rather than
+  // repointed; diff no longer has an 'o' action.
 
   private scrollUp(): void {
     if (this.scrollOffset > 0) {
@@ -618,6 +585,8 @@ export class DiffPanel extends BasePanel {
     return this.trackedRender(() => {
     if (height <= 0 || width <= 0) return [];
 
+    const confirmLines = this.confirmOverlay.renderLines(width);
+    if (confirmLines) return buildPanelWorkspace(width, height, { title: 'Diff Workspace', palette: COLOR, sections: [{ title: 'Confirmation', lines: confirmLines }] });
     if (this.entries.length === 0) {
       return buildPanelWorkspace(width, height, {
         title: 'Diff Workspace',

package/src/panels/eval-registry.ts

@@ -0,0 +1,60 @@
+/**
+ * EvalRegistry — holds the latest evaluation harness run state.
+ *
+ * W6.1 (the purge): extracted out of eval-panel.ts. 'eval' was
+ * DELETE-disposition (no surviving human surface — the evaluation harness
+ * is driven and reviewed via the `/eval` CLI command, input/commands/eval.ts)
+ * but this registry is still a live consumer of `/eval run` output, so it
+ * survives as a standalone read-model rather than being deleted with the
+ * view. See .goodvibes/audit/2026-07-04-wave6-briefs.json (W6.1).
+ */
+
+import type { EvalSuiteResult, EvalGateResult } from '@/runtime/index.ts';
+
+export class EvalRegistry {
+  private _suiteResults: EvalSuiteResult[] = [];
+  private _gateResults: EvalGateResult[] = [];
+  private _running = false;
+  private _lastRunAt: number | null = null;
+  private readonly _subscribers = new Set<() => void>();
+
+  push(result: EvalSuiteResult): void {
+    const idx = this._suiteResults.findIndex((r) => r.suite === result.suite);
+    if (idx >= 0) {
+      this._suiteResults[idx] = result;
+    } else {
+      this._suiteResults.push(result);
+    }
+    this._lastRunAt = Date.now();
+    this._notify();
+  }
+
+  pushGate(gate: EvalGateResult): void {
+    const idx = this._gateResults.findIndex((g) => g.suite === gate.suite);
+    if (idx >= 0) {
+      this._gateResults[idx] = gate;
+    } else {
+      this._gateResults.push(gate);
+    }
+    this._notify();
+  }
+
+  setRunning(running: boolean): void {
+    this._running = running;
+    this._notify();
+  }
+
+  isRunning(): boolean { return this._running; }
+  getLastRunAt(): number | null { return this._lastRunAt; }
+  getSuiteResults(): EvalSuiteResult[] { return this._suiteResults; }
+  getGateResults(): EvalGateResult[] { return this._gateResults; }
+
+  subscribe(cb: () => void): () => void {
+    this._subscribers.add(cb);
+    return () => this._subscribers.delete(cb);
+  }
+
+  private _notify(): void {
+    for (const cb of this._subscribers) cb();
+  }
+}

package/src/panels/fleet-deep-link.ts

@@ -0,0 +1,31 @@
+// ---------------------------------------------------------------------------
+// fleet-deep-link.ts — DEBT-5 item 4.
+//
+// PanelManager.open('fleet', pane, target) hands FleetPanel a
+// PanelDeepLinkTarget (a process id + optional ProcessKind) so a cross-panel
+// jump (the work-plan modal's 'i'/'w' agent/WRFC-chain jumps, the docs
+// modal's tools-tab Enter) can select + reveal a SPECIFIC node instead of
+// just opening Fleet generically. Extracted from fleet-panel.ts (already at
+// the 800-line architecture cap) so the panel stays a thin caller.
+//
+// `kind`, when given, must also match: ProcessNode ids are unique per the
+// SDK's own contract, so this is a cheap extra honesty check, not the
+// primary lookup key. Reveal is "free" once selectedIndex is set —
+// ScrollableListPanel's render-time scroll-window resolution keeps the
+// selected row visible, so FleetPanel.receiveDeepLink does not need its own
+// scroll math.
+//
+// A target that isn't found (pruned, killed, never existed, or a domain —
+// like the docs Tools tab's static tool definitions — that has no
+// corresponding fleet node at all) resolves to -1; the caller degrades
+// honestly (FleetPanel.setError('node no longer present.')) rather than
+// silently landing on an unrelated row.
+// ---------------------------------------------------------------------------
+
+import type { PanelDeepLinkTarget } from './types.ts';
+import type { FleetTreeRow } from './fleet-read-model.ts';
+
+/** The row index matching `target`'s id (+ kind, if given), or -1. Pure — no I/O, no mutation. */
+export function resolveFleetDeepLinkIndex(rows: readonly FleetTreeRow[], target: PanelDeepLinkTarget): number {
+  return rows.findIndex((row) => row.node.id === target.id && (!target.kind || row.node.kind === target.kind));
+}

package/src/panels/fleet-panel-format.ts

@@ -0,0 +1,62 @@
+// ---------------------------------------------------------------------------
+// fleet-panel-format.ts
+//
+// Pure column-layout + cell-formatting helpers for FleetPanel's tree rows.
+// Extracted from fleet-panel.ts (S3b hygiene) to hold that file under the
+// 800-line architecture cap; these are stateless functions the panel's
+// renderItem/renderDetail call, with no `this` dependency.
+// ---------------------------------------------------------------------------
+
+import type { ProcessCostState, ProcessUsage } from '@pellux/goodvibes-sdk/platform/runtime/fleet';
+import { formatAgentCost } from './agent-inspector-shared.ts';
+import { DEFAULT_PANEL_PALETTE, type ColumnSpec, type PanelPalette } from './polish.ts';
+import { fleetUsageTokens, hasFleetCost, type FleetStateTone } from './fleet-read-model.ts';
+
+// Column widths for the tree row layout. `label` absorbs whatever width is
+// left over after the fixed columns + gaps; on hostile (narrow) widths the
+// trailing columns simply clip (buildAlignedRow/buildSelectablePanelLine stop
+// writing once a cell would overflow the row) rather than throwing or
+// wrapping — the tree stays readable, just denser.
+const KIND_W = 8;
+const ELAPSED_W = 7;
+const TOKENS_W = 7;
+const COST_W = 8;
+const ACTIVITY_W = 20;
+const GAP = 1;
+const FIXED_W = 1 /* glyph */ + KIND_W + ELAPSED_W + TOKENS_W + COST_W + ACTIVITY_W + GAP * 6;
+
+export function planColumns(width: number): ColumnSpec[] {
+  const labelWidth = Math.max(10, width - FIXED_W);
+  return [
+    { width: 1 },
+    { width: KIND_W },
+    { width: labelWidth },
+    { width: ELAPSED_W, align: 'right' },
+    { width: TOKENS_W, align: 'right' },
+    { width: COST_W, align: 'right' },
+    { width: ACTIVITY_W },
+  ];
+}
+
+export function toneColor(tone: FleetStateTone, palette: PanelPalette): string {
+  switch (tone) {
+    case 'active': return palette.info ?? DEFAULT_PANEL_PALETTE.info;
+    case 'success': return palette.good ?? DEFAULT_PANEL_PALETTE.good;
+    case 'failure': return palette.bad ?? DEFAULT_PANEL_PALETTE.bad;
+    case 'warn': return palette.warn ?? DEFAULT_PANEL_PALETTE.warn;
+    case 'muted': return palette.dim;
+  }
+}
+
+export function formatFleetTokens(usage: ProcessUsage | undefined): string {
+  const total = fleetUsageTokens(usage);
+  if (total === null) return 'n/a';
+  return total >= 1000 ? `${(total / 1000).toFixed(1)}k` : String(total);
+}
+
+/** Honest cost display: never a fabricated $0.00 — 'unpriced' when costState says so. */
+export function formatFleetCost(costUsd: number | null | undefined, costState: ProcessCostState): string {
+  if (!hasFleetCost(costUsd, costState)) return 'unpriced';
+  const formatted = formatAgentCost(costUsd as number);
+  return costState === 'estimated' ? `~${formatted}` : formatted;
+}

package/src/panels/fleet-panel-worktree-detail.ts

@@ -0,0 +1,48 @@
+// ---------------------------------------------------------------------------
+// fleet-panel-worktree-detail.ts
+//
+// NET-NEW helper (not moved code — it was authored here because fleet-panel.ts
+// sits at the architecture check's 800-line cap, scripts/check-architecture.ts):
+// a single pure helper for the Fleet panel's per-work-item detail view, so a
+// new panel feature doesn't have to fight that cap inline.
+// ---------------------------------------------------------------------------
+
+import type { WorkItem } from '@pellux/goodvibes-sdk/platform/orchestration';
+
+/**
+ * Per-item worktree-isolation detail text for the Fleet panel's expanded
+ * node detail (fleet-panel.ts renderDetail), or null for a shared-isolation
+ * item (or any node that isn't a work item). Inferred from the item's OWN
+ * fields (worktreePath/worktreeBranch/mergeState) rather than a
+ * workstream-level flag — adaptWorkItem's ProcessNode.raw carries
+ * `{ item, workstreamId }`, not the full Workstream, and these fields are
+ * set ONLY when the owning workstream's isolation is 'worktree'
+ * (engine.ts/worktree-isolation.ts, SDK), so they are a reliable
+ * self-contained signal with no fleet-adapter change needed.
+ */
+export function formatWorkItemIsolationDetail(item: WorkItem): string | null {
+  const isolated = item.worktreePath !== undefined || item.worktreeBranch !== undefined || item.mergeState !== undefined;
+  if (!isolated) return null;
+  switch (item.mergeState) {
+    case 'merged':
+      // Papercut sweep item 3: worktree-isolation items whose integration had
+      // no changes to merge (mergeState 'merged', mergeHash undefined — a
+      // documented cosmetic case, not an error) used to read as a bare/awkward
+      // "merged (nothing to merge)". "merged (no changes)" says the same thing
+      // in the same shape as the other merge-state phrases below.
+      return item.mergeHash ? `worktree — merged ${item.mergeHash.slice(0, 12)}` : 'worktree — merged (no changes)';
+    case 'conflict':
+      return 'worktree — merge-conflict (kept for inspection)';
+    case 'pending':
+      return 'worktree — merge pending';
+    case 'n-a':
+    default:
+      return item.worktreeKept ? 'worktree — kept' : 'worktree — not yet integrated';
+  }
+}
+
+/** `node.raw` for a 'work-item' ProcessNode is `{ item, workstreamId }` (unknown to the panel's own types) — this narrows without fleet-panel.ts needing its own WorkItem import at the call site. Non-work-item nodes (raw is undefined/some other shape) fall through to null. */
+export function formatWorkItemIsolationDetailFromRaw(raw: unknown): string | null {
+  const item = (raw as { item?: WorkItem } | undefined)?.item;
+  return item ? formatWorkItemIsolationDetail(item) : null;
+}