@pellux/goodvibes-tui 0.27.0 → 0.29.0

package/src/input/handler.ts

@@ -140,8 +140,33 @@ export class InputHandler implements InputHandlerLike {
   public commandMode = false;
   /** True when the process indicator bar has keyboard focus. */
   public indicatorFocused = false;
-  /** True when keyboard focus is on the active panel (arrow/enter go to panel, not prompt). */
-  public panelFocused = false;
+  /**
+   * Fallback focus store used only when the panel manager does not implement
+   * focus ownership (lightweight test stubs). Production always delegates to
+   * PanelManager, which is the single source of truth.
+   */
+  private _panelFocusedFallback = false;
+  /**
+   * True when keyboard focus is on the active panel (arrow/enter go to panel,
+   * not prompt). Ownership lives in PanelManager (focusTarget); this reads and
+   * writes through to it so handler focus can never disagree with what the
+   * panel workspace actually shows.
+   */
+  public get panelFocused(): boolean {
+    const pm = this.uiServices.shell.panelManager;
+    return typeof pm.getFocusTarget === 'function'
+      ? pm.getFocusTarget() === 'panel'
+      : this._panelFocusedFallback;
+  }
+  public set panelFocused(value: boolean) {
+    const pm = this.uiServices.shell.panelManager;
+    if (typeof pm.focusPanels === 'function' && typeof pm.focusPrompt === 'function') {
+      if (value) pm.focusPanels();
+      else pm.focusPrompt();
+    } else {
+      this._panelFocusedFallback = value;
+    }
+  }
 
   public tokenizer = new InputTokenizer();
   public pasteRegistry = new Map<string, string>();
@@ -468,6 +493,15 @@ export class InputHandler implements InputHandlerLike {
     };
 
     this.requestRender = bufferedRequestRender;
+    // Snapshot the overlay flags before the feed: command handlers executed
+    // synchronously during token processing (e.g. /shortcuts, /help via
+    // ui-openers) mutate these directly on the handler, and an unconditional
+    // write-back of the pre-feed snapshot would silently revert them in the
+    // same keystroke (the "/shortcuts never displays" defect).
+    const helpOverlayActiveBefore = this.helpOverlayActive;
+    const helpScrollOffsetBefore = this.helpScrollOffset;
+    const shortcutsOverlayActiveBefore = this.shortcutsOverlayActive;
+    const shortcutsScrollOffsetBefore = this.shortcutsScrollOffset;
     try {
       const context = this.feedContext;
       // Sync mutable scalars from handler into the reused context.
@@ -506,10 +540,13 @@ export class InputHandler implements InputHandlerLike {
       this.commandMode = context.commandMode;
       this.panelFocused = context.panelFocused;
       this.indicatorFocused = context.indicatorFocused;
-      this.helpOverlayActive = context.helpOverlayActive;
-      this.helpScrollOffset = context.helpScrollOffset;
-      this.shortcutsOverlayActive = context.shortcutsOverlayActive;
-      this.shortcutsScrollOffset = context.shortcutsScrollOffset;
+      // Overlay flags: only apply the pipeline's value when the pipeline
+      // itself changed it (e.g. Escape closing the overlay). Otherwise keep
+      // the live handler value, which a command handler may have just set.
+      if (context.helpOverlayActive !== helpOverlayActiveBefore) this.helpOverlayActive = context.helpOverlayActive;
+      if (context.helpScrollOffset !== helpScrollOffsetBefore) this.helpScrollOffset = context.helpScrollOffset;
+      if (context.shortcutsOverlayActive !== shortcutsOverlayActiveBefore) this.shortcutsOverlayActive = context.shortcutsOverlayActive;
+      if (context.shortcutsScrollOffset !== shortcutsScrollOffsetBefore) this.shortcutsScrollOffset = context.shortcutsScrollOffset;
       this.selectionCallback = context.selectionCallback;
       this.nextPasteId = context.nextPasteId;
       this.nextImageId = context.nextImageId;

package/src/input/keybindings.ts

@@ -38,6 +38,17 @@ export type KeyAction =
   | 'panel-close-all'
   | 'panel-tab-next'
   | 'panel-tab-prev'
+  | 'panel-tab-1'
+  | 'panel-tab-2'
+  | 'panel-tab-3'
+  | 'panel-tab-4'
+  | 'panel-tab-5'
+  | 'panel-tab-6'
+  | 'panel-tab-7'
+  | 'panel-tab-8'
+  | 'panel-tab-9'
+  | 'panel-ops'
+  | 'panel-focus-toggle'
   | 'history-search'
   | 'search'
   | 'block-copy'
@@ -51,7 +62,6 @@ export type KeyAction =
   | 'undo'
   | 'redo'
   | 'paste'
-  | 'replay-panel'
   | 'word-back'
   | 'word-forward'
   | 'kill-to-start'
@@ -69,6 +79,17 @@ export const ACTION_DESCRIPTIONS: Record<KeyAction, string> = {
   'panel-close-all':         'Close all open panels',
   'panel-tab-next':        'Next workspace panel tab',
   'panel-tab-prev':        'Previous workspace panel tab',
+  'panel-tab-1':           'Jump to workspace panel tab 1',
+  'panel-tab-2':           'Jump to workspace panel tab 2',
+  'panel-tab-3':           'Jump to workspace panel tab 3',
+  'panel-tab-4':           'Jump to workspace panel tab 4',
+  'panel-tab-5':           'Jump to workspace panel tab 5',
+  'panel-tab-6':           'Jump to workspace panel tab 6',
+  'panel-tab-7':           'Jump to workspace panel tab 7',
+  'panel-tab-8':           'Jump to workspace panel tab 8',
+  'panel-tab-9':           'Jump to workspace panel tab 9',
+  'panel-ops':             'Open the Ops Control panel',
+  'panel-focus-toggle':    'Switch keyboard focus between top and bottom pane',
   'history-search':        'Reverse input history search',
   'search':                'Toggle conversation search',
   'block-copy':            'Copy nearest block to clipboard',
@@ -82,7 +103,6 @@ export const ACTION_DESCRIPTIONS: Record<KeyAction, string> = {
   'undo':                  'Undo last prompt edit',
   'redo':                  'Redo last undone edit',
   'paste':                 'Paste from clipboard (image priority)',
-  'replay-panel':          'Open / close the Replay panel',
   'word-back':             'Move cursor to start of previous word (Alt+B)',
   'word-forward':          'Move cursor to end of next word (Alt+F)',
   'kill-to-start':         'Kill from cursor to start of line into kill ring (Ctrl+U)',
@@ -101,6 +121,27 @@ export const DEFAULT_KEYBINDINGS: Record<KeyAction, KeyCombo[]> = {
   'panel-close-all':         [{ key: 'x', ctrl: true, shift: true }],
   'panel-tab-next':        [{ key: ']', ctrl: true }],
   'panel-tab-prev':        [{ key: '[', ctrl: true }],
+  // Alt+1..9: jump directly to the Nth workspace panel tab (across both panes).
+  // The tokenizer delivers Alt as the token's `meta` modifier; comboMatches /
+  // lookup treat `meta` as an alias for `alt`, so these alt-combos route through
+  // the same rebindable path as every other action.
+  'panel-tab-1':           [{ key: '1', alt: true }],
+  'panel-tab-2':           [{ key: '2', alt: true }],
+  'panel-tab-3':           [{ key: '3', alt: true }],
+  'panel-tab-4':           [{ key: '4', alt: true }],
+  'panel-tab-5':           [{ key: '5', alt: true }],
+  'panel-tab-6':           [{ key: '6', alt: true }],
+  'panel-tab-7':           [{ key: '7', alt: true }],
+  'panel-tab-8':           [{ key: '8', alt: true }],
+  'panel-tab-9':           [{ key: '9', alt: true }],
+  // Ctrl+O: open the Ops Control panel (operator intervention console).
+  // Routed globally in handleGlobalShortcutToken: prefers commandContext.openOpsPanel()
+  // when the operator-control-plane feature flag wired it, else falls back to opening
+  // the always-registered 'ops-control' panel type directly via the panel manager.
+  'panel-ops':             [{ key: 'o', ctrl: true }],
+  // Ctrl+G: toggle keyboard focus between the top and bottom panes. Ctrl+G is
+  // otherwise unbound in the default table.
+  'panel-focus-toggle':    [{ key: 'g', ctrl: true }],
   'history-search':        [{ key: 'r', ctrl: true }],
   'search':                [{ key: 'f', ctrl: true }],
   'block-copy':            [{ key: 'y', ctrl: true }],
@@ -117,7 +158,6 @@ export const DEFAULT_KEYBINDINGS: Record<KeyAction, KeyCombo[]> = {
   'undo':                  [{ key: 'z', ctrl: true }],
   'redo':                  [{ key: 'z', ctrl: true, shift: true }],
   'paste':                 [{ key: 'v', ctrl: true }],
-  'replay-panel':          [{ key: 'r', ctrl: true, shift: true }],
   // Word navigation (Alt+B / Alt+F — emacs readline standard)
   'word-back':             [{ key: 'b', alt: true }],
   'word-forward':          [{ key: 'f', alt: true }],
@@ -240,9 +280,13 @@ export class KeybindingsManager {
    * lookup — O(1) keybinding lookup by token.
    * Returns the matching KeyAction, or null if no binding matches.
    */
-  lookup(token: { logicalName?: string; ctrl?: boolean; shift?: boolean; alt?: boolean }): KeyAction | null {
+  lookup(token: { logicalName?: string; ctrl?: boolean; shift?: boolean; alt?: boolean; meta?: boolean }): KeyAction | null {
     if (!token.logicalName) return null;
-    const key = `${token.logicalName}:${token.ctrl ? 1 : 0}:${token.shift ? 1 : 0}:${token.alt ? 1 : 0}`;
+    // The tokenizer delivers the Alt modifier as `meta`; the binding table stores
+    // it as `alt`. Treat the two as one modifier at the matching boundary so
+    // Alt-based combos (word-nav, kill-ring, panel-tab-1..9) resolve at runtime.
+    const alt = token.alt ?? token.meta;
+    const key = `${token.logicalName}:${token.ctrl ? 1 : 0}:${token.shift ? 1 : 0}:${alt ? 1 : 0}`;
     return this.lookupMap.get(key) ?? null;
   }
 
@@ -263,7 +307,7 @@ export class KeybindingsManager {
    */
   matches(
     action: KeyAction,
-    token: { logicalName?: string; ctrl?: boolean; shift?: boolean; alt?: boolean },
+    token: { logicalName?: string; ctrl?: boolean; shift?: boolean; alt?: boolean; meta?: boolean },
   ): boolean {
     const combos = this.bindings[action];
     if (!combos) return false;
@@ -272,12 +316,13 @@ export class KeybindingsManager {
 
   private comboMatches(
     combo: KeyCombo,
-    token: { logicalName?: string; ctrl?: boolean; shift?: boolean; alt?: boolean },
+    token: { logicalName?: string; ctrl?: boolean; shift?: boolean; alt?: boolean; meta?: boolean },
   ): boolean {
     if (token.logicalName !== combo.key) return false;
     if (!!combo.ctrl !== !!token.ctrl) return false;
     if (!!combo.shift !== !!token.shift) return false;
-    if (!!combo.alt !== !!token.alt) return false;
+    // Alt arrives as `meta` from the tokenizer; accept either as the Alt modifier.
+    if (!!combo.alt !== !!(token.alt ?? token.meta)) return false;
     return true;
   }
 

package/src/input/model-picker.ts

@@ -92,6 +92,8 @@ export class ModelPickerModal {
   public contextCapPendingModel: ModelDefinition | null = null;
   /** Current input string in contextCap mode. */
   public contextCapQuery = '';
+  /** Validation error from the last context cap commit (e.g. out-of-range value); null when no error. */
+  public contextCapError: string | null = null;
 
   // ── Search / filter ─────────────────────────────────────────────────────────────────────────────
   /** Current search query string (empty = no filter). */
@@ -215,6 +217,7 @@ export class ModelPickerModal {
     this.previousMode = 'model';
     this.contextCapPendingModel = model;
     this.contextCapQuery = '';
+    this.contextCapError = null;
     this.mode = 'contextCap';
   }
 
@@ -245,6 +248,7 @@ export class ModelPickerModal {
     this.query = '';
     this.categoryFilter = 'all';
     this.capabilityFilter = 'none';
+    this.availableOnly = true;
     const filtered = this.getFilteredModels();
     const idx = filtered.findIndex(m => m.id === currentModelId);
     this.selectedIndex = idx >= 0 ? idx : 0;
@@ -310,6 +314,7 @@ export class ModelPickerModal {
     this.pendingModel = null;
     this.contextCapPendingModel = null;
     this.contextCapQuery = '';
+    this.contextCapError = null;
     this.searchFocused = false;
     this.selectedIndex = 0;
     this.scrollOffset = 0;

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

@@ -6,6 +6,10 @@ 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');
@@ -24,7 +28,29 @@ function ensurePreviewPanel(panelManager: PanelManager): FilePreviewPanel | null
   return opened instanceof FilePreviewPanel ? opened : null;
 }
 
-function syncSymbolOutlineFromPreview(panelManager: PanelManager, previewPanel: FilePreviewPanel): void {
+// 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();
@@ -41,6 +67,16 @@ export function handlePanelIntegrationAction(
 ): boolean {
   if (!activePanel) return false;
 
+  // Prefer the panel's own integration hook when it provides one. Panels migrated
+  // onto the formal hook opt out of the instanceof routing below.
+  if (activePanel.handlePanelIntegrationAction) {
+    const consumed = activePanel.handlePanelIntegrationAction(key, {
+      panelManager,
+      executeCommand: commandContext?.executeCommand,
+    });
+    if (consumed) return true;
+  }
+
   if ((key === 'enter' || key === 'return' || key === 'right') && activePanel instanceof FileExplorerPanel) {
     const filePath = activePanel.getFocusedFilePath();
     if (!filePath) return false;
@@ -51,6 +87,44 @@ export function handlePanelIntegrationAction(
     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;
@@ -74,5 +148,47 @@ export function handlePanelIntegrationAction(
     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/main.ts

@@ -29,7 +29,6 @@ import { applyConversationOverlays } from './renderer/conversation-overlays.ts';
 import { buildPanelCompositeData } from './renderer/panel-composite.ts';
 import { logger } from '@pellux/goodvibes-sdk/platform/utils';
 import { registerBuiltinPanels } from './panels/builtin-panels.ts';
-import { renderPanelTabBar } from './renderer/panel-tab-bar.ts';
 import { bootstrapRuntime } from './runtime/bootstrap.ts';
 import type { BootstrapContext } from './runtime/bootstrap.ts';
 import type { HITLMode } from '@pellux/goodvibes-sdk/platform/state';
@@ -37,6 +36,7 @@ import {
   checkRecoveryFile,
   deleteRecoveryFile,
   loadRecoveryConversation,
+  readLastSessionPointer,
   writeRecoveryFile,
 } from '@/runtime/index.ts';
 import { handleBlockingShellInput, type PendingPermissionState } from './shell/blocking-input.ts';
@@ -59,7 +59,7 @@ import { formatUserFacingErrorLine } from './core/format-user-error.ts';
 import { wireStreamEventMetrics, type StreamMetrics, type WireStreamEventMetricsResult } from './core/stream-event-wiring.ts';
 import { wireTurnEventHandlers } from './core/turn-event-wiring.ts';
 import { buildContextStatusHint } from './renderer/context-status-hint.ts';
-import { evaluateSessionMaintenance } from './panels/session-maintenance.ts';
+import { evaluateSessionMaintenance } from '@/runtime/index.ts';
 
 const ALT_SCREEN_ENTER = '\x1b[?1049h'; const ALT_SCREEN_EXIT  = '\x1b[?1049l';
 const MOUSE_ENABLE     = '\x1b[?1000h\x1b[?1002h\x1b[?1006h'; const MOUSE_DISABLE    = '\x1b[?1006l\x1b[?1002l\x1b[?1000l';
@@ -429,6 +429,7 @@ async function main() {
     model: runtime.model,
     provider: runtime.provider,
     toolCount,
+    lastSessionId: readLastSessionPointer({ workingDirectory: workingDir, homeDirectory, surfaceRoot: 'tui' }) ?? undefined,
   };
 
   const render = () => {
@@ -491,6 +492,8 @@ async function main() {
       provider: runtime.provider,
       contextWindow,
       contextStatusHint,
+      // Compact footer posture on short terminals so the shell stays usable.
+      compact: height < 30,
       // behavior.autoCompactThreshold is stored as a percent integer (e.g. 80);
       // the meter expects a fraction [0..1]. Clamp to [0,1] to guard nonsense values.
       compactThreshold: Math.min(1, Math.max(0, (configManager.get('behavior.autoCompactThreshold') as number) / 100)),