@pellux/goodvibes-tui 1.1.0 → 1.9.0

package/src/input/panel-integration-actions.ts

@@ -1,64 +1,16 @@
 import type { CommandContext } from './command-registry.ts';
-import { logger } from '@pellux/goodvibes-sdk/platform/utils';
 import type { Panel } from '../panels/types.ts';
 import type { PanelManager } from '../panels/panel-manager.ts';
-import { FileExplorerPanel } from '../panels/file-explorer-panel.ts';
-import { FilePreviewPanel } from '../panels/file-preview-panel.ts';
-import { SymbolOutlinePanel } from '../panels/symbol-outline-panel.ts';
-import { ApprovalPanel } from '../panels/approval-panel.ts';
-import { TasksPanel } from '../panels/tasks-panel.ts';
-import { OrchestrationPanel } from '../panels/orchestration-panel.ts';
-import { AgentInspectorPanel } from '../panels/agent-inspector-panel.ts';
-import { DiffPanel } from '../panels/diff-panel.ts';
-
-function ensurePreviewPanel(panelManager: PanelManager): FilePreviewPanel | null {
-  const existing = panelManager.getPanel('preview');
-  if (existing instanceof FilePreviewPanel) {
-    const pane = panelManager.getPaneOf('preview');
-    panelManager.activateById('preview');
-    if (pane) panelManager.focusPane(pane);
-    return existing;
-  }
-  const targetPane: 'top' | 'bottom' = panelManager.isBottomPaneVisible()
-    ? (panelManager.getFocusedPane() === 'top' ? 'bottom' : 'top')
-    : 'bottom';
-  const opened = panelManager.open('preview', targetPane);
-  panelManager.show();
-  panelManager.focusPane(targetPane);
-  return opened instanceof FilePreviewPanel ? opened : null;
-}
-
-// WO-133: shared by explorer's and preview's 'd' (diff) key — same
-// open/focus bridge as ensurePreviewPanel above.
-function ensureDiffPanel(panelManager: PanelManager): DiffPanel | null {
-  const existing = panelManager.getPanel('diff');
-  if (existing instanceof DiffPanel) {
-    const pane = panelManager.getPaneOf('diff');
-    panelManager.activateById('diff');
-    if (pane) panelManager.focusPane(pane);
-    return existing;
-  }
-  const targetPane: 'top' | 'bottom' = panelManager.isBottomPaneVisible()
-    ? (panelManager.getFocusedPane() === 'top' ? 'bottom' : 'top')
-    : 'bottom';
-  const opened = panelManager.open('diff', targetPane);
-  panelManager.show();
-  panelManager.focusPane(targetPane);
-  return opened instanceof DiffPanel ? opened : null;
-}
-
-// Exported so a future preview-reload action (e.g. an explicit "r" reload
-// key) can re-sync the outline against the same file without duplicating
-// this lookup — the panel-integration wiring for that key lands separately.
-export function syncSymbolOutlineFromPreview(panelManager: PanelManager, previewPanel: FilePreviewPanel): void {
-  const symbols = panelManager.getPanel('symbols');
-  const filePath = previewPanel.getCurrentFilePath();
-  const source = previewPanel.getSource();
-  if (symbols instanceof SymbolOutlinePanel && filePath && source !== null) {
-    symbols.loadFile(filePath, source);
-  }
-}
 
+// W6.1 (the purge): every instanceof-routed branch this file used to carry
+// (FileExplorerPanel/FilePreviewPanel/SymbolOutlinePanel — DELETE;
+// ApprovalPanel/TasksPanel/OrchestrationPanel/AgentInspectorPanel —
+// RETIRE-INTO-FLEET) targeted a panel class that no longer exists. Panels
+// migrated onto the formal `Panel.handlePanelIntegrationAction` hook (the
+// preferred seam — see the comment below) are unaffected; this function now
+// only provides that passthrough. See
+// .goodvibes/audit/2026-07-04-wave6-briefs.json (W6.1) for the disposition
+// map.
 export function handlePanelIntegrationAction(
   panelManager: PanelManager,
   activePanel: Panel | null,
@@ -77,118 +29,5 @@ export function handlePanelIntegrationAction(
     if (consumed) return true;
   }
 
-  if ((key === 'enter' || key === 'return' || key === 'right') && activePanel instanceof FileExplorerPanel) {
-    const filePath = activePanel.getFocusedFilePath();
-    if (!filePath) return false;
-    const previewPanel = ensurePreviewPanel(panelManager);
-    if (!previewPanel) return false;
-    previewPanel.openFile(filePath);
-    syncSymbolOutlineFromPreview(panelManager, previewPanel);
-    return true;
-  }
-
-  // WO-133: 'd' on the explorer diffs the currently focused file, and 'd' on
-  // the preview diffs whatever file is currently open — both against HEAD,
-  // both via the same DiffPanel.showFileDiffs entry point.
-  if (key === 'd' && activePanel instanceof FileExplorerPanel) {
-    const filePath = activePanel.getFocusedFilePath();
-    if (!filePath) return false;
-    const diffPanel = ensureDiffPanel(panelManager);
-    if (!diffPanel) return false;
-    void diffPanel.showFileDiffs([filePath], 'HEAD').catch((err) => {
-      logger.debug('explorer diff dispatch failed', { err });
-    });
-    return true;
-  }
-
-  if (key === 'd' && activePanel instanceof FilePreviewPanel) {
-    const filePath = activePanel.getCurrentFilePath();
-    if (!filePath) return false;
-    const diffPanel = ensureDiffPanel(panelManager);
-    if (!diffPanel) return false;
-    void diffPanel.showFileDiffs([filePath], 'HEAD').catch((err) => {
-      logger.debug('preview diff dispatch failed', { err });
-    });
-    return true;
-  }
-
-  // WO-133: 'r' on the preview reloads the open file from disk, then
-  // re-syncs the symbol outline against the refreshed content (WO-126's
-  // async tree-sitter loadFile via syncSymbolOutlineFromPreview above) once
-  // the reload actually settles.
-  if (key === 'r' && activePanel instanceof FilePreviewPanel) {
-    const reloaded = activePanel.consumePendingReload();
-    if (!reloaded) return false;
-    void reloaded.then(() => syncSymbolOutlineFromPreview(panelManager, activePanel)).catch((err) => {
-      logger.debug('preview reload dispatch failed', { err });
-    });
-    return true;
-  }
-
-  if ((key === 'enter' || key === 'return') && activePanel instanceof SymbolOutlinePanel) {
-    const location = activePanel.getSelectedLocation();
-    if (!location) return false;
-    const previewPanel = ensurePreviewPanel(panelManager);
-    if (!previewPanel) return false;
-    if (previewPanel.getCurrentFilePath() !== location.path) {
-      previewPanel.openFile(location.path);
-      syncSymbolOutlineFromPreview(panelManager, previewPanel);
-    }
-    previewPanel.goToLine(location.line);
-    return true;
-  }
-
-  if ((key === 'enter' || key === 'return') && activePanel instanceof ApprovalPanel) {
-    const command = activePanel.getSelectedCommand();
-    if (!command || !commandContext?.executeCommand) return false;
-    const parts = command.replace(/^\//, '').split(/\s+/).filter(Boolean);
-    const [name, ...args] = parts;
-    if (!name) return false;
-    void commandContext.executeCommand(name, args).catch((err) => { logger.debug('approval panel command dispatch failed', { err }); });
-    return true;
-  }
-
-  // WO-131: Enter on a Tasks row — agent-kind tasks jump straight to the Agent
-  // Inspector (which owns the deep per-agent timeline); everything else's
-  // advertised worktree follow-up is dispatched for real via ctx.executeCommand
-  // instead of being printed as a static "/worktree task <task-id>" signpost.
-  // w dispatches the task-family posture review the header line advertises.
-  if ((key === 'enter' || key === 'return' || key === 'w') && activePanel instanceof TasksPanel) {
-    const followUp = activePanel.consumePendingFollowUp();
-    if (!followUp) return false;
-    if (followUp.kind === 'agent-jump') {
-      const inspector = panelManager.open('inspector');
-      if (!(inspector instanceof AgentInspectorPanel)) return false;
-      inspector.inspectAgent(followUp.agentId);
-      return true;
-    }
-    if (!commandContext?.executeCommand) return false;
-    if (followUp.kind === 'teamwork-review') {
-      void commandContext.executeCommand('teamwork', ['review']).catch((err) => {
-        logger.debug('tasks panel teamwork review dispatch failed', { err });
-      });
-      return true;
-    }
-    void commandContext.executeCommand('worktree', ['task', followUp.taskId]).catch((err) => {
-      logger.debug('tasks panel worktree review dispatch failed', { err });
-    });
-    return true;
-  }
-
-  // WO-131: Enter on a node-focused Orchestration row jumps to the Agent
-  // Inspector (agent-backed nodes) or the Tasks panel (task-backed nodes).
-  if ((key === 'enter' || key === 'return') && activePanel instanceof OrchestrationPanel) {
-    const jump = activePanel.consumePendingNodeJump();
-    if (!jump) return false;
-    if (jump.kind === 'agent-jump') {
-      const inspector = panelManager.open('inspector');
-      if (!(inspector instanceof AgentInspectorPanel)) return false;
-      inspector.inspectAgent(jump.id);
-      return true;
-    }
-    panelManager.open('tasks');
-    return true;
-  }
-
   return false;
 }

package/src/input/panel-mouse-geometry.ts

@@ -0,0 +1,97 @@
+// ---------------------------------------------------------------------------
+// panel-mouse-geometry.ts
+//
+// Pure mouse-geometry helpers for the panel workspace, extracted from
+// handler-feed-routes.ts so that file stays under the 800-line architecture
+// cap once the UX-C focus verbs and the DEBT-5 paste-flood guard both live in
+// it. These map a terminal (row, col) onto the panel/pane/workspace-tab under
+// the cursor. No dependency on the feed-route state types, so no import cycle.
+// ---------------------------------------------------------------------------
+
+import type { PanelManager } from '../panels/panel-manager.ts';
+import { renderPanelWorkspaceBar } from '../renderer/panel-workspace-bar.ts';
+import type { TabHitRegion } from '../renderer/tab-strip.ts';
+
+/** Screen rectangle the panel workspace occupies, plus its vertical split. */
+export type PanelMouseLayout = {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+  hasBottomPane: boolean;
+  verticalSplitRatio: number;
+};
+
+function clampRatio(value: number): number {
+  return Math.max(0.2, Math.min(0.8, value));
+}
+
+export function getActivePanelInPane(panelManager: PanelManager, pane: 'top' | 'bottom') {
+  const target = pane === 'top' ? panelManager.getTopPane() : panelManager.getBottomPane();
+  return target.panels[target.activeIndex] ?? null;
+}
+
+export function getPanelUnderMouse(
+  panelManager: PanelManager,
+  layout: PanelMouseLayout | null,
+  row: number,
+  col: number,
+) {
+  if (
+    layout === null
+    || !panelManager.isVisible()
+    || panelManager.getAllOpen().length === 0
+    || col < layout.x
+    || col >= layout.x + layout.width
+    || row < layout.y
+    || row >= layout.y + layout.height
+  ) {
+    return null;
+  }
+
+  const panelRow = row - layout.y;
+  if (!layout.hasBottomPane) {
+    return getActivePanelInPane(panelManager, 'top');
+  }
+
+  // Single consolidated workspace bar (row 0) + h-separator; the rest splits
+  // between the two panes' content.
+  const panelAreaRows = Math.max(0, layout.height - 1);
+  const contentRows = Math.max(0, panelAreaRows - 1);
+  const topContentRows = contentRows <= 1
+    ? contentRows
+    : Math.max(1, Math.floor(contentRows * clampRatio(layout.verticalSplitRatio)));
+  // panelRow 0 = workspace bar; rows 1..topContentRows = top pane; rest = bottom.
+  return panelRow <= topContentRows
+    ? getActivePanelInPane(panelManager, 'top')
+    : getActivePanelInPane(panelManager, 'bottom');
+}
+
+/**
+ * If the mouse is over the consolidated workspace tab bar (the first panel
+ * row), return the index of the tab under the cursor, else null. Recomputes the
+ * tab hit regions by rendering the bar with a layout callback — cheap and keeps
+ * the click geometry in lockstep with what was drawn.
+ */
+export function workspaceTabAtMouse(
+  panelManager: PanelManager,
+  layout: PanelMouseLayout | null,
+  row: number,
+  col: number,
+): number | null {
+  if (
+    layout === null
+    || !panelManager.isVisible()
+    || panelManager.getAllOpen().length === 0
+    || row !== layout.y // workspace bar is the first panel row
+    || col < layout.x
+    || col >= layout.x + layout.width
+  ) {
+    return null;
+  }
+  let regions: readonly TabHitRegion[] = [];
+  renderPanelWorkspaceBar(panelManager.getWorkspaceTabs(), layout.width, true, (r) => { regions = r; });
+  const relCol = col - layout.x;
+  const hit = regions.find((rg) => relCol >= rg.startCol && relCol < rg.endCol);
+  return hit ? hit.index : null;
+}

package/src/input/panel-paste-flood-guard.ts

@@ -0,0 +1,86 @@
+// ---------------------------------------------------------------------------
+// panel-paste-flood-guard.ts — DEBT-5 item 5.
+//
+// A terminal WITHOUT bracketed paste delivers a pasted block as a burst of
+// discrete 1-char 'text' tokens (isPasteToken stays false for every one of
+// them, since that flag only fires for a single token whose value.length > 1
+// — see handler-feed-routes.ts's own Invariant B doc). Before this guard,
+// each such character became a real panel hotkey on a focused non-capturing
+// panel (K arms kill, etc.) once it reached handlePanelFocusToken's per-char
+// dispatch loop.
+//
+// This is a RATE guard: more than PANEL_PASTE_FLOOD_THRESHOLD qualifying
+// tokens within the trailing PANEL_PASTE_FLOOD_WINDOW_MS, evaluated with a
+// real sliding window (old timestamps age out of `timestamps` every call).
+// It is deliberately NOT the retired per-feed char-SUM burst heuristic this
+// same input layer already tore out once (see panel-focus-burst.test.ts's
+// header doc): that old guard summed one feed()'s character count with no
+// timing signal at all, so two ordinary nav keystrokes landing in a single
+// feed() — a real, common case, not an edge case — were misread as a burst
+// and focus was silently flipped to the composer. This guard:
+//   - never touches focus (panelFocused is untouched by trackPanelPasteFloodGuard
+//     and by its caller);
+//   - is keyed on WALL-CLOCK TIMING, not a per-feed token count, so it
+//     doesn't care how many tokens land in one feed() call, only how fast
+//     they arrive relative to each other;
+//   - is sticky once tripped (only a quiet gap — no qualifying token for a
+//     full window — clears it) so it doesn't flap dispatch on/off as the
+//     count oscillates near the threshold mid-flood.
+//
+// ~8 keys/120ms is far beyond sustained human typing (a fast typist peaks
+// well under that inter-key rate over any real span) but is exactly the
+// shape an unbracketed paste replay takes. It also keeps the pre-existing
+// Invariant B regression tests (2 keys in one feed(), no timing control at
+// all) far under threshold while catching a real flood within its first ~9
+// characters.
+// ---------------------------------------------------------------------------
+
+export const PANEL_PASTE_FLOOD_WINDOW_MS = 120;
+export const PANEL_PASTE_FLOOD_THRESHOLD = 8;
+
+/**
+ * Guard state — a single persistent instance lives on the caller's
+ * long-lived context (handler-feed.ts's InputFeedContext, mirroring how that
+ * object already owns `nextPasteId`/`mouseDownRow`/etc.) and is MUTATED IN
+ * PLACE by trackPanelPasteFloodGuard below, never replaced — so callers never
+ * need to thread a return value back into their own state (unlike
+ * `panelFocused`, which handlePanelFocusToken returns because it is NOT a
+ * mutable outparam).
+ */
+export interface PanelBurstGuardState {
+  timestamps: readonly number[];
+  suspended: boolean;
+  hintShown: boolean;
+}
+
+export interface PanelBurstGuardResult {
+  /** False while suspended — the caller must drop this token, not dispatch it. */
+  readonly dispatch: boolean;
+  /** True exactly once per burst: the call that just tripped suspension. */
+  readonly showHintNow: boolean;
+}
+
+/** Advance `guard` (mutated in place) by one qualifying token at time `now` (ms). */
+export function trackPanelPasteFloodGuard(guard: PanelBurstGuardState, now: number): PanelBurstGuardResult {
+  const lastAt = guard.timestamps.length > 0 ? guard.timestamps[guard.timestamps.length - 1]! : -Infinity;
+  const isQuietGap = now - lastAt > PANEL_PASTE_FLOOD_WINDOW_MS;
+  if (isQuietGap && guard.suspended) {
+    // A silence at least as long as the window means whatever burst was
+    // happening has ended — un-suspend so a LATER burst gets its own fresh
+    // count and its own one-shot hint.
+    guard.suspended = false;
+    guard.hintShown = false;
+  }
+  guard.timestamps = isQuietGap
+    ? [now]
+    : [...guard.timestamps.filter((t) => t > now - PANEL_PASTE_FLOOD_WINDOW_MS), now];
+  if (guard.timestamps.length > PANEL_PASTE_FLOOD_THRESHOLD) {
+    guard.suspended = true;
+  }
+  let showHintNow = false;
+  if (guard.suspended && !guard.hintShown) {
+    guard.hintShown = true;
+    showHintNow = true;
+  }
+  return { dispatch: !guard.suspended, showHintNow };
+}

package/src/input/selection-modal.ts

@@ -36,6 +36,14 @@ export class SelectionModal {
   public selectedIndex = 0;
   public allowSearch = true;
   public customActions: Map<string, SelectionAction> = new Map();
+  /**
+   * UX-C vocab unification: overrides the default per-primaryAction Enter
+   * verb ("Select"/"Toggle"/"Edit"/"Delete") shown in the footer hint. Used by
+   * callers whose items are really commands (e.g. /help) so the hint reads
+   * "[Enter] Run", matching the slash-command palette's own verb, instead of
+   * the generic "Select".
+   */
+  public primaryVerbLabel: string | undefined = undefined;
 
   /** Open the modal with items and title */
   open(
@@ -45,6 +53,7 @@ export class SelectionModal {
       preSelectId?: string;
       allowSearch?: boolean;
       customActions?: Map<string, SelectionAction>;
+      primaryVerbLabel?: string;
     }
   ): void {
     this.title = title;
@@ -53,6 +62,7 @@ export class SelectionModal {
     this.allowSearch = opts?.allowSearch ?? true;
     this.searchFocused = false;
     this.customActions = opts?.customActions ?? new Map();
+    this.primaryVerbLabel = opts?.primaryVerbLabel;
     this.active = true;
     this.filterItems();
 
@@ -74,6 +84,7 @@ export class SelectionModal {
     this.filteredItems = [];
     this.selectedIndex = 0;
     this.customActions = new Map();
+    this.primaryVerbLabel = undefined;
   }
 
   moveUp(): void {

package/src/input/session-picker-modal.ts

@@ -1,12 +1,28 @@
 /**
  * SessionPickerModal — state management for the /sessions picker modal.
  *
- * Lists sessions from SessionManager.list(), tracks selected index,
- * and handles load/delete actions.
+ * Lists LOCAL saved transcript files from SessionManager.list() (load/delete
+ * operate on these — a saved JSONL session is a different thing from a live
+ * control-plane session, see below), tracks selected index, and handles
+ * load/delete actions.
+ *
+ * W3-T2 (union-sessions surface): additionally surfaces the cross-surface
+ * session union from `sessionBroker` (a SessionReadFacade — normally
+ * `uiServices.sessions.sessionBroker`, the SessionUnionCache) so a user can
+ * SEE what sessions are live/closed across every surface sharing this
+ * daemon (TUI, webui, companion, automation), not just this process's own
+ * saved files. This is deliberately READ-ONLY: a SharedSessionRecord has no
+ * on-disk transcript this process can load()/delete() the way a local
+ * SessionInfo does, so cross-surface rows are visible + badged, not
+ * selectable for load/delete. `sessionBroker` is optional so every existing
+ * caller/test that only cares about local saved-session management keeps
+ * working unchanged.
  */
 
 import { unlinkSync } from 'node:fs';
 import type { SessionInfo, SessionManager } from '@pellux/goodvibes-sdk/platform/sessions';
+import type { SharedSessionRecord } from '@pellux/goodvibes-sdk/platform/control-plane';
+import type { CrossSurfaceView, SessionReadFacade } from '@pellux/goodvibes-sdk/platform/runtime/session-spine';
 import type { ConversationManager } from '../core/conversation';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
 
@@ -14,9 +30,22 @@ import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
 // SessionPickerModal
 // ---------------------------------------------------------------------------
 
+/** Honest default posture when no `sessionBroker` was wired: no cross-surface claim. */
+const DORMANT_CROSS_SURFACE_VIEW: CrossSurfaceView = {
+  mode: 'local',
+  online: false,
+  stale: false,
+  lastSyncAt: null,
+  offlineNote: null,
+};
+
 export class SessionPickerModal {
   public active = false;
   public sessions: SessionInfo[] = [];
+  /** Cross-surface session union (view-only) — see class doc. Empty until open(). */
+  public crossSurfaceSessions: readonly SharedSessionRecord[] = [];
+  /** Honest posture for crossSurfaceSessions: mode/online/stale/offlineNote. */
+  public crossSurfaceView: CrossSurfaceView = DORMANT_CROSS_SURFACE_VIEW;
   public selectedIndex = 0;
   public scrollOffset = 0;
   public visibleRows = 8;
@@ -25,13 +54,24 @@ export class SessionPickerModal {
   /** Last status message to show in the modal (e.g. error or success). */
   public statusMessage = '';
 
-  public constructor(private readonly sessionManager: SessionManager) {}
+  public constructor(
+    private readonly sessionManager: SessionManager,
+    private readonly sessionBroker?: SessionReadFacade,
+  ) {}
 
   /**
-   * Open the modal, loading sessions from SessionManager.
+   * Open the modal, loading local saved sessions from SessionManager and (when
+   * a sessionBroker was wired) the cross-surface session union, honestly.
    */
   open(): void {
     this.sessions = this.sessionManager.list();
+    if (this.sessionBroker) {
+      this.crossSurfaceSessions = this.sessionBroker.listSessions();
+      this.crossSurfaceView = this.sessionBroker.crossSurfaceView;
+    } else {
+      this.crossSurfaceSessions = [];
+      this.crossSurfaceView = DORMANT_CROSS_SURFACE_VIEW;
+    }
     this.selectedIndex = 0;
     this.scrollOffset = 0;
     this.statusMessage = '';