@pellux/goodvibes-tui 0.28.0 → 1.0.0

package/src/core/conversation.ts

@@ -13,9 +13,9 @@ import {
   type BlockMeta as SdkBlockMeta,
 } from '@pellux/goodvibes-sdk/platform/core';
 import type { BlockMeta } from './conversation-types.ts';
+import { MessageLineCache } from './conversation-line-cache.ts';
 import {
   addConversationSplashScreen,
-  appendConversationMessages,
   conversationTextToLines,
   logConversationText,
   renderConversationAssistantMessage,
@@ -56,6 +56,13 @@ export class ConversationManager extends SdkConversationManager {
   private lastRenderedWidth = 0;
   /** When true the buffer needs to be rebuilt before the next display. */
   private dirty = true;
+  /**
+   * Per-message Line[] cache (WO-209). rebuildHistory() reuses cached lines for
+   * messages whose complete render inputs are unchanged, so appending one message
+   * to an N-message conversation no longer re-renders all N. A cache-served
+   * rebuild is byte-identical to a cold one (pure memoisation).
+   */
+  private lineCache = new MessageLineCache();
   /** Index of the first message not yet appended to the buffer. */
   private appendedUpTo = 0;
   /** Optional config manager for display settings. */
@@ -300,6 +307,7 @@ export class ConversationManager extends SdkConversationManager {
   public override resetAll(): void {
     super.resetAll();
     this.history.clear();
+    this.lineCache.clear();
     this.appendedUpTo = 0;
     this.lastRenderedWidth = 0;
     this.dirty = true;
@@ -322,6 +330,7 @@ export class ConversationManager extends SdkConversationManager {
   public override replaceMessagesForLLM(newMessages: ProviderMessage[]): void {
     super.replaceMessagesForLLM(newMessages);
     this.history.clear();
+    this.lineCache.clear();
     this.appendedUpTo = 0;
     this.lastRenderedWidth = 0;
     this.dirty = true;
@@ -360,6 +369,7 @@ export class ConversationManager extends SdkConversationManager {
   }): void {
     super.fromJSON(data);
     this.history.clear();
+    this.lineCache.clear();
     this.appendedUpTo = 0;
     this.lastRenderedWidth = 0;
     this.dirty = true;
@@ -374,6 +384,26 @@ export class ConversationManager extends SdkConversationManager {
     return this.history.getAllLines();
   }
 
+  /**
+   * clearLineCache - Drop every cached per-message Line[] and force a full cold
+   * re-render on the next display. The rendered output is unchanged (the cache is
+   * a pure memoisation); this only discards the reuse, e.g. to reclaim memory or
+   * to assert cache/cold equivalence in tests.
+   */
+  public clearLineCache(): void {
+    this.lineCache.clear();
+    this.dirty = true;
+  }
+
+  /**
+   * getLineCacheSize - Number of per-message Line[] entries currently retained.
+   * The cache mark-and-sweeps to the visible message set on every rebuild, so
+   * this is bounded by what is on screen — exposed for memory-hygiene assertions.
+   */
+  public getLineCacheSize(): number {
+    return this.lineCache.size;
+  }
+
   /**
    * rebuildHistory - Full rebuild. Called when width changes or on first render.
    * For incremental appends use flushHistory().
@@ -419,7 +449,11 @@ export class ConversationManager extends SdkConversationManager {
       return;
     }
 
-    this.appendMessages(visibleSnapshot, width, displayStart);
+    // The in-progress streaming placeholder (rendered EMPTY above via
+    // renderSnapshot) is left uncached: its content mutates in place per delta and
+    // the incremental streaming path (updateStreamingBlock) owns it.
+    const streamingPlaceholderAbsIdx = isStreaming ? snapshot.length - 1 : -1;
+    this.appendMessages(visibleSnapshot, width, displayStart, streamingPlaceholderAbsIdx);
     this.appendedUpTo = snapshot.length;
 
     if (isStreaming) {
@@ -491,8 +525,20 @@ export class ConversationManager extends SdkConversationManager {
    *   the renderer can resolve messageKindRegistry keys (which are absolute)
    *   from its slice-relative loop counter.
    */
-  private appendMessages(messages: Message[], width: number, msgIndexOffset = 0): void {
-    appendConversationMessages(this.renderingContext(), messages, width, this.messageLineRegistry, msgIndexOffset);
+  private appendMessages(
+    messages: Message[],
+    width: number,
+    msgIndexOffset = 0,
+    streamingPlaceholderAbsIdx = -1,
+  ): void {
+    this.lineCache.renderInto(
+      this.renderingContext(),
+      messages,
+      width,
+      this.messageLineRegistry,
+      msgIndexOffset,
+      streamingPlaceholderAbsIdx,
+    );
   }
 
   /** Find the nearest block to a given line index, optionally filtered by type. */

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

@@ -0,0 +1,49 @@
+import type { CommandRegistry } from '../command-registry.ts';
+import { CostTrackerPanel } from '../../panels/cost-tracker-panel.ts';
+import { openCommandPanel, requirePanelManager } from './runtime-services.ts';
+
+/**
+ * /cost budget <usd> — makes the CostTrackerPanel's budget alert real (WO-139).
+ * Opens the cost panel (creating it via the registered factory if not already
+ * open) and sets its budget threshold directly, so the meter+alert already
+ * built into CostTrackerPanel.render() (:266-290) actually fires. 0 disables
+ * the alert. Mirrors the /auth local rotate-password → panel-instance-call
+ * pattern (local-auth-runtime.ts) rather than only printing a signpost.
+ */
+export function registerCostRuntimeCommands(registry: CommandRegistry): void {
+  registry.register({
+    name: 'cost',
+    description: 'Inspect session/agent cost tracking and configure the budget alert threshold',
+    usage: '[panel|budget <usd>]',
+    handler(args, ctx) {
+      const sub = (args[0] ?? 'panel').toLowerCase();
+
+      if (sub === 'panel' || sub === 'open') {
+        openCommandPanel(ctx, 'cost');
+        return;
+      }
+
+      if (sub === 'budget') {
+        const raw = args[1];
+        const usd = raw !== undefined ? Number(raw) : NaN;
+        if (raw === undefined || !Number.isFinite(usd) || usd < 0) {
+          ctx.print('Usage: /cost budget <usd>  (0 disables the alert)');
+          return;
+        }
+        const panelManager = requirePanelManager(ctx);
+        const panel = panelManager.open('cost');
+        if (panel instanceof CostTrackerPanel) {
+          panel.setBudgetThreshold(usd);
+          ctx.print(usd > 0
+            ? `Cost budget alert set to $${usd.toFixed(2)}.`
+            : 'Cost budget alert disabled.');
+        } else {
+          ctx.print('Cost tracking is not available in this session.');
+        }
+        return;
+      }
+
+      ctx.print('Usage: /cost [panel|budget <usd>]');
+    },
+  });
+}

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

@@ -175,8 +175,12 @@ export function registerOperatorRuntimeCommands(registry: CommandRegistry): void
       const sub = args[0];
 
       if (sub === 'view' || sub === undefined) {
+        // Parity with the Ctrl+O keybind (handler-shortcuts.ts): prefer the
+        // flag-wired opener, else fall back to the always-registered panel,
+        // which renders its own honest not-configured state.
         if (ctx.openOpsPanel) ctx.openOpsPanel();
-        else ctx.print('Operator Control Plane panel is not available. Enable the operator-control-plane feature flag.');
+        else if (ctx.showPanel) ctx.showPanel('ops-control');
+        else ctx.print('Operator Control Plane panel is not available in this shell.');
         return;
       }
 

package/src/input/commands.ts

@@ -56,6 +56,7 @@ import { registerOnboardingRuntimeCommands } from './commands/onboarding-runtime
 import { registerTtsRuntimeCommands } from './commands/tts-runtime.ts';
 import { registerCloudflareRuntimeCommands } from './commands/cloudflare-runtime.ts';
 import { registerWorkPlanRuntimeCommands } from './commands/work-plan-runtime.ts';
+import { registerCostRuntimeCommands } from './commands/cost-runtime.ts';
 
 /**
  * registerBuiltinCommands - Register all built-in slash commands into the registry.
@@ -107,6 +108,7 @@ export function registerBuiltinCommands(registry: CommandRegistry): void {
   registerTtsRuntimeCommands(registry);
   registerCloudflareRuntimeCommands(registry);
   registerWorkPlanRuntimeCommands(registry);
+  registerCostRuntimeCommands(registry);
   registerLocalRuntimeCommands(registry);
   registerDiscoveryRuntimeCommands(registry);
   registerPlanningRuntimeCommands(registry);

package/src/input/handler-content-actions.ts

@@ -121,10 +121,15 @@ export function registerPaste(
     }
   }
 
-  const lines = content.split('\n');
-  if (lines.length <= 8) return { marker: content, nextPasteId: state.nextPasteId, nextImageId: state.nextImageId };
+  // Terminals transmit the line breaks inside a bracketed paste as \r (the
+  // byte Enter sends), and external clipboards can carry \r\n. Normalize to
+  // \n only here in the text branch — the image sniffing above must see the
+  // raw bytes (PNG's magic sequence itself contains \r\n).
+  const text = content.replace(/\r\n?/g, '\n');
+  const lines = text.split('\n');
+  if (lines.length <= 8) return { marker: text, nextPasteId: state.nextPasteId, nextImageId: state.nextImageId };
   const id = `p${state.nextPasteId++}`;
-  state.pasteRegistry.set(id, content);
+  state.pasteRegistry.set(id, text);
   return { marker: `[TEXT: ${id}, ${lines.length} lines]`, nextPasteId: state.nextPasteId, nextImageId: state.nextImageId };
 }
 

package/src/input/handler-feed-routes.ts

@@ -78,14 +78,14 @@ export function handlePanelFocusToken(state: PanelFocusRouteState, token: InputT
       return { handled: true, panelFocused };
     }
     const kb = state.keybindingsManager;
-    if (kb.matches('panel-tab-next', token)) {
-      state.cyclePanelTab('next');
-      return { handled: true, panelFocused };
-    }
-    if (kb.matches('panel-tab-prev', token)) {
-      state.cyclePanelTab('prev');
-      return { handled: true, panelFocused };
-    }
+    // NOTE: panel-tab-next/prev, panel-close, and panel-close-all are handled
+    // globally in handleGlobalShortcutToken, which runs earlier in the feed
+    // loop and consumes those tokens before they ever reach this focused-panel
+    // route. Their old copies lived here too and had drifted (this route never
+    // called pm.hide() on close-all); they were unreachable, so they are gone
+    // and close/close-all semantics now live in exactly one place. Only
+    // panel-focus-toggle stays here, because it is meaningful only while the
+    // panel workspace already owns focus (it swaps between the two panes).
     if (kb.matches('panel-focus-toggle', token)) {
       // Switch keyboard focus between the top and bottom panes (no-op when
       // there is no visible, non-empty bottom pane).
@@ -93,33 +93,10 @@ export function handlePanelFocusToken(state: PanelFocusRouteState, token: InputT
       state.requestRender();
       return { handled: true, panelFocused };
     }
-    // Alt+1..9 — jump directly to the Nth workspace tab (across both panes).
-    // The tokenizer maps the Alt modifier onto `meta`, so an Alt-held digit
-    // arrives as { logicalName: '1'..'9', meta: true }. Gating on the modifier
-    // keeps plain digits reaching the focused panel.
-    if (token.meta && !token.ctrl && /^[1-9]$/.test(token.logicalName ?? '')) {
-      const index = Number(token.logicalName) - 1;
-      state.panelManager.activateWorkspaceIndex(index);
-      state.requestRender();
-      return { handled: true, panelFocused };
-    }
-    if (kb.matches('panel-close-all', token)) {
-      const pm = state.panelManager;
-      for (const p of pm.getAllOpen()) pm.close(p.id);
-      panelFocused = false;
-      state.requestRender();
-      return { handled: true, panelFocused };
-    }
-    if (kb.matches('panel-close', token)) {
-      const pm = state.panelManager;
-      const active = pm.getActivePanel();
-      if (active) {
-        pm.close(active.id);
-      }
-      panelFocused = false;
-      state.requestRender();
-      return { handled: true, panelFocused };
-    }
+    // Alt+1..9 (panel-tab-1..9) is a global KeyAction consumed earlier by
+    // handleGlobalShortcutToken, so those meta+digit tokens never reach here.
+    // Any other ctrl/meta combo this route does not own falls through so the
+    // global handler (which ran first) or the prompt routes can act on it.
     if (token.ctrl || token.meta) {
       return { handled: false, panelFocused };
     }

package/src/input/handler-feed.ts

@@ -251,14 +251,10 @@ export function feedInputTokens(context: InputFeedContext, tokens: readonly Inpu
     }
 
     if (token.type === 'key') {
-      if (
-        context.panelFocused
-        && (!context.panelManager.isVisible()
-          || context.panelManager.getAllOpen().length === 0
-          || context.panelManager.getActivePanel() === null)
-      ) {
-        context.panelFocused = false;
-      }
+      // Focus can never disagree with workspace visibility: PanelManager owns
+      // focusTarget and self-heals it, and context.panelFocused was seeded from
+      // it at feed entry — so no manual "unfocus if panels vanished" patch is
+      // needed here anymore.
       const shortcutState = {
         panelFocused: context.panelFocused,
         prompt: context.prompt,

package/src/input/handler-shortcuts.ts

@@ -115,6 +115,21 @@ export function handleGlobalShortcutToken(
       state.requestRender();
       return true;
 
+    case 'panel-focus-toggle': {
+      // Global entry point for the focus-toggle key (Ctrl+G): from the prompt
+      // it grabs focus for the panel workspace. Once the workspace already has
+      // focus we let it fall through (return false) so handlePanelFocusToken
+      // can do the top/bottom pane swap — keeping that behavior in one place.
+      if (state.panelFocused) return false;
+      const pm = state.panelManager;
+      if (pm.isVisible() && pm.getAllOpen().length > 0) {
+        state.panelFocused = true;
+        state.requestRender();
+        return true;
+      }
+      return false;
+    }
+
     case 'panel-tab-next':
       state.cyclePanelTab('next');
       return true;
@@ -123,6 +138,42 @@ export function handleGlobalShortcutToken(
       state.cyclePanelTab('prev');
       return true;
 
+    case 'panel-tab-1':
+    case 'panel-tab-2':
+    case 'panel-tab-3':
+    case 'panel-tab-4':
+    case 'panel-tab-5':
+    case 'panel-tab-6':
+    case 'panel-tab-7':
+    case 'panel-tab-8':
+    case 'panel-tab-9': {
+      // Alt+1..9: jump directly to the Nth workspace tab. Routed globally (like
+      // panel-tab-next/prev) so the jump works whether focus is on the prompt or
+      // the workspace; gated on visibility, matching cyclePanelTab semantics.
+      const pm = state.panelManager;
+      if (pm.isVisible()) {
+        const index = Number(action.slice('panel-tab-'.length)) - 1;
+        pm.activateWorkspaceIndex(index);
+        state.requestRender();
+      }
+      return true;
+    }
+
+    case 'panel-ops': {
+      // Ctrl+O: open the Ops Control panel. Prefer the command-context callback
+      // (wired only when the operator-control-plane feature flag is on) so it
+      // reuses whatever show/open semantics bootstrap.ts set up; otherwise fall
+      // back to opening the always-registered 'ops-control' panel type directly
+      // — it renders an honest not-configured state when its deps are absent.
+      if (state.commandContext?.openOpsPanel) {
+        state.commandContext.openOpsPanel();
+      } else {
+        state.panelManager.open('ops-control');
+        state.requestRender();
+      }
+      return true;
+    }
+
     case 'history-search':
       state.historySearch.open(state.prompt);
       state.requestRender();

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/input-history.ts

@@ -351,15 +351,28 @@ export class InputHistory {
     return redactedText;
   }
 
+  /**
+   * Entries persisted before CR normalization was deployed (registerPaste now
+   * converts the \r line separators terminals send in bracketed pastes to \n)
+   * may still carry literal \r bytes; launder them on load so history recall
+   * cannot reintroduce \r into the composer.
+   */
+  private launderLineBreaks(text: string): string {
+    return text.replace(/\r\n?/g, '\n');
+  }
+
   private normalizeStoredEntry(entry: unknown): StoredInputHistoryEntry | null {
-    if (typeof entry === 'string') return entry;
+    if (typeof entry === 'string') return this.launderLineBreaks(entry);
     if (!entry || typeof entry !== 'object') return null;
     const record = entry as Record<string, unknown>;
     if (typeof record.text !== 'string') return null;
-    const text = record.text.trim();
+    const text = this.launderLineBreaks(record.text).trim();
     if (!text) return null;
-    if (typeof record.recallText === 'string' && record.recallText.trim() && record.recallText.trim() !== text) {
-      return { text, recallText: record.recallText.trim() };
+    const recallText = typeof record.recallText === 'string'
+      ? this.launderLineBreaks(record.recallText).trim()
+      : '';
+    if (recallText && recallText !== text) {
+      return { text, recallText };
     }
     return text;
   }

package/src/input/keybindings.ts

@@ -38,6 +38,16 @@ 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'
@@ -52,7 +62,6 @@ export type KeyAction =
   | 'undo'
   | 'redo'
   | 'paste'
-  | 'replay-panel'
   | 'word-back'
   | 'word-forward'
   | 'kill-to-start'
@@ -70,6 +79,16 @@ 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',
@@ -84,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)',
@@ -103,6 +121,24 @@ 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 }],
@@ -122,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 }],
@@ -245,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;
   }
 
@@ -268,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;
@@ -277,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;
   }