@pellux/goodvibes-tui 1.1.0 → 1.9.0

package/src/input/handler-command-route.ts

@@ -1,4 +1,5 @@
 import { loadSkillByTrigger } from '@pellux/goodvibes-sdk/platform/tools';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
 import type { CommandContext, CommandRegistry } from './command-registry.ts';
 import type { AutocompleteEngine } from './autocomplete.ts';
 import type { InputToken } from '@pellux/goodvibes-sdk/platform/core';
@@ -92,25 +93,34 @@ export function handleCommandModeToken(state: CommandModeRouteState, token: Inpu
       const commandPromise = state.commandRegistry.get(name)
         ? state.commandRegistry.execute(name, args, ctx)
         : (ctx.executeCommand?.(name, args) ?? Promise.resolve(false));
-      commandPromise.then((handled) => {
-        if (handled) {
-          state.requestRender();
-        } else {
-          const shellPaths = state.commandContext?.workspace.shellPaths;
-          const skillContent = shellPaths
-            ? loadSkillByTrigger('/' + name, {
-                workingDirectory: shellPaths.workingDirectory,
-                homeDirectory: shellPaths.homeDirectory,
-              })
-            : null;
-          if (skillContent) {
-            state.commandContext?.submitInput?.(skillContent);
-          } else {
-            state.conversationManager?.log(`Unknown command: /${name}. Type /help for available commands.`, { fg: '#ef4444' });
+      commandPromise
+        .then((handled) => {
+          if (handled) {
             state.requestRender();
+          } else {
+            const shellPaths = state.commandContext?.workspace.shellPaths;
+            const skillContent = shellPaths
+              ? loadSkillByTrigger('/' + name, {
+                  workingDirectory: shellPaths.workingDirectory,
+                  homeDirectory: shellPaths.homeDirectory,
+                })
+              : null;
+            if (skillContent) {
+              state.commandContext?.submitInput?.(skillContent);
+            } else {
+              state.conversationManager?.log(`Unknown command: /${name}. Type /help for available commands.`, { fg: '#ef4444' });
+              state.requestRender();
+            }
           }
-        }
-      });
+        })
+        .catch((err: unknown) => {
+          // Defense in depth for EVERY command, not just the ones that
+          // already guard their own internals: a handler that throws or
+          // awaits a rejected promise must never become a silent unhandled
+          // rejection — it renders the same way an unknown command does.
+          state.conversationManager?.log(`Command /${name} failed: ${summarizeError(err)}`, { fg: '#ef4444' });
+          state.requestRender();
+        });
     } else {
       closeCommandMode();
     }
@@ -133,9 +143,16 @@ function withPanelFocusSync(context: CommandContext, state: CommandModeRouteStat
         }
       : undefined,
     showPanel: context.showPanel
-      ? (panelId, pane) => {
-          context.showPanel?.(panelId, pane);
-          state.panelFocused = true;
+      ? (panelId, pane, target, opts) => {
+          context.showPanel?.(panelId, pane, target, opts);
+          // UX-C: showPanel no longer transfers focus by default — the command
+          // path leaves the composer focused (ui-openers.ts's showPanel only
+          // calls focusPanels() when opts.focus is set). Only flip the local
+          // panelFocused mirror when the caller explicitly asked for focus;
+          // otherwise leave it exactly as it was (the composer, since you can
+          // only type a command from there in the first place). `target` is the
+          // DEBT-5 deep-link jump target, forwarded verbatim.
+          if (opts?.focus) state.panelFocused = true;
         }
       : undefined,
     focusPanels: context.focusPanels

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

@@ -421,7 +421,7 @@ export function handleCtrlC(
   saveUndoState: () => void,
   setPrompt: (value: string) => void,
   setCursorPos: (value: number) => void,
-  cancelGeneration: (() => void) | undefined,
+  cancelGeneration: (() => boolean | void) | undefined,
   exitApp: () => void,
   requestRender: () => void,
   lastCtrlCTime: number,
@@ -436,7 +436,22 @@ export function handleCtrlC(
     setCursorPos(0);
     return;
   }
-  cancelGeneration?.();
+  // Stopping in-flight speech / aborting the turn must never prevent the quit
+  // double-press window from advancing. A throw from the async TTS-stop path
+  // (e.g. killing the audio subprocess) would otherwise swallow this press and
+  // strand the user unable to quit while TTS is speaking. Decouple the two: the
+  // press below is recorded no matter how speech-stop fares. (UX-B item 6b.)
+  let stoppedSpeech = false;
+  try {
+    stoppedSpeech = cancelGeneration?.() === true;
+  } catch {
+    // Non-fatal to the exit chord; the quit-window bookkeeping still runs.
+  }
+  // A press that silenced LIVE speech is consumed by that job (batch replay
+  // D5) — symmetric with the prompt-clearing press above. The quit chord
+  // ("Ctrl+C x2") starts from a quiet state; turn-aborts still count toward
+  // the double-press.
+  if (stoppedSpeech) return;
   const now = Date.now();
   // Clear any hide-timer pending from a prior press before deciding this
   // one's outcome, whichever branch below runs. Without this, a hide-timer

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

@@ -13,11 +13,13 @@ import {
 } from './handler-prompt-buffer.ts';
 import { cleanupMarkerRegistry, expandPrompt, findMarkerAtPos, registerPaste } from './handler-content-actions.ts';
 import type { PanelManager } from '../panels/panel-manager.ts';
-import { renderPanelWorkspaceBar } from '../renderer/panel-workspace-bar.ts';
-import type { TabHitRegion } from '../renderer/tab-strip.ts';
+import { getPanelUnderMouse, workspaceTabAtMouse } from './panel-mouse-geometry.ts';
+import type { PanelMouseLayout } from './panel-mouse-geometry.ts';
+export type { PanelMouseLayout };
 import type { KeybindingsManager } from './keybindings.ts';
 import type { KillRing } from './kill-ring.ts';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+import { trackPanelPasteFloodGuard, type PanelBurstGuardState } from './panel-paste-flood-guard.ts';
 
 export type PanelFocusRouteState = {
   panelManager: PanelManager;
@@ -31,14 +33,29 @@ export type PanelFocusRouteState = {
   cyclePanelTab: (direction: 'next' | 'prev') => void;
   onPanelInputConsumed?: (activePanel: import('../panels/types.ts').Panel | null, key: string) => void;
   /**
-   * True when the tokens produced by the current feed() call carry more than
-   * one printable character total (a bracketed paste, or several 1-char text
-   * tokens from a fast-typed burst in one stdin chunk). A burst can never be
-   * a deliberate single-key panel hotkey, so it must not be exploded into
-   * per-char activePanel.handleInput(ch) calls — see the text-token branch
+   * True when THIS token is a paste: a single 'text' token whose value holds
+   * more than one character. The SDK tokenizer emits a bracketed paste
+   * (\x1b[?2004h, enabled in main.ts init) as exactly one such token; discrete
+   * keystrokes — even several batched into one feed() by render-tick latency —
+   * arrive as separate 1-char tokens. See the text-token branch below.
+   */
+  isPasteToken: boolean;
+  /**
+   * One-shot hint emitted when a paste is dropped because the focused panel has
+   * no text capture (Invariant A: focus must not silently flip to the composer).
+   */
+  onPasteDropped?: (panelName: string) => void;
+  /** Wall-clock time (ms) for this token; `burstGuard` is DEBT-5 item 5's flood-guard state, mutated in place across tokens (see panel-paste-flood-guard.ts). */
+  now: number;
+  burstGuard: PanelBurstGuardState;
+  /**
+   * True while a turn is actively streaming; gates Escape's cancel-first
+   * precedence (I6.1) ahead of the panel's own two-stage escape contract
    * below.
    */
-  isPrintableBurst: boolean;
+  isTurnActive: () => boolean;
+  /** Cancel the active turn. Wired to commandContext.cancelGeneration. */
+  cancelGeneration: () => void;
 };
 
 export function handlePanelFocusToken(state: PanelFocusRouteState, token: InputToken): {
@@ -75,6 +92,18 @@ export function handlePanelFocusToken(state: PanelFocusRouteState, token: InputT
     // (e.g. dismiss a confirm dialog or clear search). Only unfocus if the
     // panel returns false (unconsumed) or there is no active panel.
     if (token.logicalName === 'escape') {
+      // I6.1/replay R5: while streaming, a focused panel must not swallow the
+      // only way to cancel — Escape's first job is always cancel-turn; the
+      // panel's own two-stage consume-or-unfocus contract only runs once no
+      // turn is active, so a *second* Escape falls through to it normally
+      // (panelFocused stays unchanged here). Calls cancelGeneration()
+      // directly rather than the shared handleEscape() (handler-modal-stack.ts),
+      // whose fallthrough order doesn't guarantee reaching it first.
+      if (state.isTurnActive()) {
+        state.cancelGeneration();
+        state.requestRender();
+        return { handled: true, panelFocused };
+      }
       const activePanel = state.panelManager.getActive();
       const panelConsumedEscape = activePanel?.handleInput?.('escape') ?? false;
       if (panelConsumedEscape) {
@@ -88,13 +117,10 @@ export function handlePanelFocusToken(state: PanelFocusRouteState, token: InputT
     }
     const kb = state.keybindingsManager;
     // 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).
+    // globally in handleGlobalShortcutToken (runs earlier in the feed loop) —
+    // their old, drifted copies here were unreachable and are gone. Only
+    // panel-focus-toggle stays, since it's meaningful only once 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).
@@ -122,19 +148,32 @@ export function handlePanelFocusToken(state: PanelFocusRouteState, token: InputT
 
   if (token.type === 'text' && token.value) {
     const activePanel = state.panelManager.getActive();
-    // A burst (paste or several fast-typed chars in one stdin chunk) is never
-    // a deliberate single-key panel hotkey. Eating it silently as per-char
-    // hotkeys leaves the user with no echo and no error, looking exactly
-    // like dead keystrokes. Unless the active panel has its own text-capture
-    // buffer open (a `/`-search or draft-answer field that deliberately
-    // wants every character, burst or not — see isCapturingTextBurst), unfocus
-    // the panel and let the token fall through to the prompt route instead,
-    // same as it would from an unfocused panel.
-    if (state.isPrintableBurst && !activePanel?.isCapturingTextBurst?.()) {
+    // UX-C: '/' is an explicit transfer verb back to the composer (a capturing panel, isCapturingTextBurst, keeps '/' for itself).
+    if (token.value === '/' && !activePanel?.isCapturingTextBurst?.()) {
       panelFocused = false;
-      state.requestRender();
       return { handled: false, panelFocused };
     }
+    // Invariant A/B (W6.2): a paste (isPasteToken, one multi-char token) into
+    // a capturing panel forwards verbatim below; elsewhere it is DROPPED with
+    // a one-shot hint (never exploded into hotkeys, never a silent focus
+    // flip — focus moves only on an explicit verb). Discrete keystrokes fall
+    // through to the per-char dispatch below.
+    if (state.isPasteToken && !activePanel?.isCapturingTextBurst?.()) {
+      state.onPasteDropped?.(activePanel?.name ?? 'the panel');
+      state.requestRender();
+      return { handled: true, panelFocused };
+    }
+
+    // DEBT-5 item 5 — paste flood guard (rate-based; see panel-paste-flood-guard.ts).
+    if (!state.isPasteToken && !activePanel?.isCapturingTextBurst?.()) {
+      const guard = trackPanelPasteFloodGuard(state.burstGuard, state.now);
+      if (!guard.dispatch) {
+        if (guard.showHintNow) state.onPasteDropped?.(activePanel?.name ?? 'the panel');
+        state.requestRender();
+        return { handled: true, panelFocused };
+      }
+    }
+
     if (activePanel?.handleInput) {
       for (const ch of token.value) {
         activePanel.handleInput(ch);
@@ -150,7 +189,8 @@ export function handlePanelFocusToken(state: PanelFocusRouteState, token: InputT
 export type IndicatorFocusRouteState = {
   indicatorFocused: boolean;
   modalOpened: (name: string) => void;
-  processModal: { open: () => void };
+  /** W2.2: the footer process indicator's [Enter] opens the Fleet panel (F2 also opens the Fleet panel; the retired process modal was removed in W6.2). */
+  openFleetPanel: () => void;
   requestRender: () => void;
 };
 
@@ -171,8 +211,8 @@ export function handleIndicatorFocusToken(state: IndicatorFocusRouteState, token
     }
     if (token.logicalName === 'enter') {
       indicatorFocused = false;
-      state.modalOpened('process');
-      state.processModal.open();
+      // W2.2: opens the Fleet panel (see openFleetPanel's own doc, line ~352).
+      state.openFleetPanel();
       state.requestRender();
       return { handled: true, indicatorFocused };
     }
@@ -297,7 +337,8 @@ export type KeyRouteState = {
   commandRegistry?: CommandRegistry | null;
   autocomplete: AutocompleteEngine | null;
   blockActionsMenu: { open: (block: BlockMeta) => void };
-  processModal: { open: () => void };
+  /** W6.2 e: F2 opens+focuses the Fleet panel (which subsumes the retired process modal). */
+  openFleetPanel: () => void;
   modalOpened: (name: string) => void;
   saveUndoState: () => void;
   /** Break the undo coalescing group (call on cursor moves). */
@@ -568,10 +609,12 @@ export function handlePromptKeyToken(state: KeyRouteState, token: InputToken): {
     return { handled: true, prompt, cursorPos, inputScrollTop, commandMode, indicatorFocused };
   }
 
+  // UX-C: F2 is now handled globally with toggle semantics (handler-shortcuts.ts)
+  // BEFORE it ever reaches this route; this branch is dead in the real
+  // pipeline but stays for panel-entry-points-reachable.test.ts's direct test.
   if (token.logicalName === 'f2') {
     indicatorFocused = false;
-    state.modalOpened('process');
-    state.processModal.open();
+    state.openFleetPanel();
     return { handled: true, prompt, cursorPos, inputScrollTop, commandMode, indicatorFocused };
   }
 
@@ -594,89 +637,6 @@ export type MouseRouteState = {
   handleCopy: () => void;
 };
 
-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));
-}
-
-function getActivePanelInPane(panelManager: PanelManager, pane: 'top' | 'bottom') {
-  const target = pane === 'top' ? panelManager.getTopPane() : panelManager.getBottomPane();
-  return target.panels[target.activeIndex] ?? null;
-}
-
-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.
- */
-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;
-}
-
 function scrollPanelUnderMouse(
   state: MouseRouteState,
   token: Extract<InputToken, { type: 'mouse' }>,

package/src/input/handler-feed.ts

@@ -9,15 +9,13 @@ import type { SelectionResult } from './selection-modal.ts';
 import { SearchManager } from './search.ts';
 import type { InputHistory, HistorySearch } from './input-history.ts';
 import type { BlockMeta, ConversationManager } from '../core/conversation';
-import { ProcessModal } from '../renderer/process-modal.ts';
-import { LiveTailModal } from '../renderer/live-tail-modal.ts';
 import { BlockActionsMenu } from '../renderer/block-actions.ts';
-import { AgentDetailModal } from '../renderer/agent-detail-modal.ts';
 import { ContextInspectorModal } from '../renderer/context-inspector.ts';
 import { BookmarkModal } from './bookmark-modal.ts';
 import { SettingsModal } from './settings-modal.ts';
 import type { McpWorkspace } from './mcp-workspace.ts';
 import { SessionPickerModal } from './session-picker-modal.ts';
+import type { ConfigModal } from './config-modal.ts';
 import { ProfilePickerModal } from './profile-picker-modal.ts';
 import type { OnboardingWizardController } from './onboarding/onboarding-wizard.ts';
 import type { OnboardingWizardAction } from './onboarding/onboarding-wizard.ts';
@@ -34,6 +32,7 @@ import {
   handlePromptTextToken,
   type PanelMouseLayout,
 } from './handler-feed-routes.ts';
+import type { PanelBurstGuardState } from './panel-paste-flood-guard.ts';
 import type { WrappedPromptInfo } from './handler-prompt-buffer.ts';
 import { handleModalTokenRoutes } from './handler-modal-token-routes.ts';
 import { handleCommandModeToken } from './handler-command-route.ts';
@@ -45,6 +44,7 @@ import type { PanelManager } from '../panels/panel-manager.ts';
 import type { KeybindingsManager } from './keybindings.ts';
 import type { ModelPickerTarget } from './model-picker.ts';
 import type { KillRing } from './kill-ring.ts';
+import type { FocusTracker } from '../core/focus-tracker.ts';
 
 /**
  * InputFeedContext — The single long-lived context object passed to feedInputTokens
@@ -72,8 +72,8 @@ import type { KillRing } from './kill-ring.ts';
  *   - `pasteRegistry`, `imageRegistry` — owned Maps, never replaced
  *   - `selectionModal`, `bookmarkModal`, `settingsModal`, `sessionPickerModal`,
  *     `profilePickerModal` — modal objects constructed once in InputHandler constructor
- *   - `filePicker`, `modelPicker`, `onboardingWizard`, `processModal`, `liveTailModal`,
- *     `agentDetailModal`, `contextInspectorModal`, `blockActionsMenu`, `searchManager`, `historySearch` —
+ *   - `filePicker`, `modelPicker`, `onboardingWizard`,
+ *     `contextInspectorModal`, `blockActionsMenu`, `searchManager`, `historySearch` —
  *     service objects constructed once
  *   - `panelManager`, `keybindingsManager` — from uiServices, stable for app lifetime
  *   - `modalStack` — reference to the handler's shared array (mutated in place)
@@ -111,6 +111,7 @@ export interface InputFeedContext {
   readonly mcpWorkspace: McpWorkspace;
   readonly sessionPickerModal: SessionPickerModal;
   readonly profilePickerModal: ProfilePickerModal;
+  readonly configModal: ConfigModal;
   readonly historySearch: HistorySearch;
   commandRegistry: CommandRegistry | null;
   commandContext: CommandContext | undefined;
@@ -118,9 +119,6 @@ export interface InputFeedContext {
   readonly filePicker: FilePickerModal;
   readonly modelPicker: ModelPickerModal;
   readonly onboardingWizard: OnboardingWizardController;
-  readonly processModal: ProcessModal;
-  readonly liveTailModal: LiveTailModal;
-  readonly agentDetailModal: AgentDetailModal;
   readonly contextInspectorModal: ContextInspectorModal;
   readonly blockActionsMenu: BlockActionsMenu;
   readonly searchManager: SearchManager;
@@ -131,6 +129,10 @@ export interface InputFeedContext {
   inputHistory: InputHistory | null;
   conversationManager: ConversationManager | null;
   readonly killRing: KillRing;
+  /** Terminal focus tracker (W2.3) — updated here from 'focus' tokens, read by the unfocused-alert notifiers in core/. */
+  readonly focusTracker: FocusTracker;
+  /** DEBT-5 item 5 — the paste-flood guard's persistent state, mutated in place across tokens by handlePanelFocusToken (see panel-paste-flood-guard.ts). Never reallocated. */
+  readonly panelBurstGuard: PanelBurstGuardState;
   readonly getHistory: () => InfiniteBuffer;
   readonly getViewportHeight: () => number;
   readonly getScrollTop: () => number;
@@ -180,17 +182,39 @@ export function feedInputTokens(context: InputFeedContext, tokens: readonly Inpu
   const lineCount = history.getLineCount();
   const keybindings = context.keybindingsManager;
 
-  // A single stdin chunk can tokenize into several 'text' tokens (fast-typed
-  // burst) or one 'text' token with a multi-char value (bracketed paste).
-  // Computed once per feed() call, not per token, so per-token cost stays
-  // the same O(1) check it always was.
-  let totalPrintableChars = 0;
-  for (const t of tokens) {
-    if (t.type === 'text') totalPrintableChars += t.value.length;
-  }
-  const isPrintableBurst = totalPrintableChars > 1;
+  // Shared opener for the Fleet panel: makes it visible AND transfers keyboard
+  // focus to it. panelManager.open() only makes the panel active — focus is a
+  // separate axis (see PanelManager.focusPanels()/getFocusTarget()); without the
+  // focusPanels() call, j/k/i/K land silently in the composer until Tab. Used by
+  // the footer indicator's [Enter] and by F2 (W6.2 e: F2 and the footer
+  // indicator both subsume the retired process modal). Mirrors the Ctrl+P
+  // panel-picker launcher (ui-openers.ts openPanelPicker).
+  const openFleetPanel = (): void => {
+    context.panelManager.open('fleet');
+    context.panelManager.focusPanels();
+    context.panelFocused = true;
+  };
 
+  // Paste-ness is a per-TOKEN property, computed at the handlePanelFocusToken
+  // call below — never a per-feed character sum. The SDK tokenizer emits a
+  // bracketed paste (\x1b[?2004h, enabled in main.ts terminal init) as ONE
+  // 'text' token holding the whole payload, while discrete keystrokes — even
+  // several batched into one feed() by render-tick latency — arrive as
+  // separate 1-char 'text' tokens. The old per-feed sum misread two quick nav
+  // keystrokes (e.g. j then k in one drain) as a "burst" and yanked focus.
+  // DEBT-5 item 5's flood guard reuses that same per-token model but adds
+  // real timing: one `now` per feed() call (not per token) is intentional —
+  // a genuine flood delivers many tokens in one drain, and they should all
+  // measure as arriving "at once", not spread across meaningless sub-ms noise.
+  const now = Date.now();
   for (const token of tokens) {
+    // Focus-reporting tokens (CSI ?1004h, W2.3) never reach the composer or any
+    // modal route — consumed here, first, unconditionally. No render needed.
+    if (token.type === 'focus') {
+      context.focusTracker.setFocused(token.action === 'in');
+      continue;
+    }
+
     if (token.type === 'key' && context.keybindingsManager.matches('clear-cancel', token)) {
       context.handleCtrlC();
       continue;
@@ -210,6 +234,7 @@ export function feedInputTokens(context: InputFeedContext, tokens: readonly Inpu
       mcpWorkspace: context.mcpWorkspace,
       sessionPickerModal: context.sessionPickerModal,
       profilePickerModal: context.profilePickerModal,
+      configModal: context.configModal,
       onboardingWizard: context.onboardingWizard,
       helpOverlayActive: context.helpOverlayActive,
       helpScrollOffset: context.helpScrollOffset,
@@ -224,9 +249,6 @@ export function feedInputTokens(context: InputFeedContext, tokens: readonly Inpu
       getViewportHeight: context.getViewportHeight,
       requestRender: context.requestRender,
       handleEscape: context.handleEscape,
-      liveTailModal: context.liveTailModal,
-      processModal: context.processModal,
-      agentDetailModal: context.agentDetailModal,
       contextInspectorModal: context.contextInspectorModal,
       modalOpened: context.modalOpened,
       filePicker: context.filePicker,
@@ -265,6 +287,12 @@ export function feedInputTokens(context: InputFeedContext, tokens: readonly Inpu
       // 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.
+      // Snapshot these four BEFORE dispatch so the write-back below can tell
+      // a pipeline-driven change (see comment there) from a stale copy.
+      const promptBefore = context.prompt;
+      const cursorPosBefore = context.cursorPos;
+      const commandModeBefore = context.commandMode;
+      const panelFocusedBefore = context.panelFocused;
       const shortcutState = {
         panelFocused: context.panelFocused,
         prompt: context.prompt,
@@ -298,10 +326,22 @@ export function feedInputTokens(context: InputFeedContext, tokens: readonly Inpu
         killRing: context.killRing,
       };
       if (handleGlobalShortcutToken(shortcutState, token, viewportHeight)) {
-        context.prompt = shortcutState.prompt;
-        context.cursorPos = shortcutState.cursorPos;
-        context.commandMode = shortcutState.commandMode;
-        context.panelFocused = shortcutState.panelFocused;
+        // Some branches (handleEscape, handleCtrlC, handleUndo, handleRedo,
+        // handlePaste) mutate handler state directly and immediately sync it
+        // into this same `context` via syncFeedContextMutableFields — e.g.
+        // Escape closing the slash-command palette clears context.prompt and
+        // context.commandMode on the live handler mid-call. `shortcutState`
+        // above is a snapshot taken BEFORE that call, so applying it
+        // unconditionally would stomp the live update right back to its
+        // stale pre-action value (undoing the very close it just performed,
+        // and even re-arming the palette below). This is the same class of
+        // bug as the overlay-flag write-back guard in handler.ts's feed().
+        // Only apply the snapshot for a field the dispatched action did NOT
+        // already update out from under us.
+        context.prompt = context.prompt === promptBefore ? shortcutState.prompt : context.prompt;
+        context.cursorPos = context.cursorPos === cursorPosBefore ? shortcutState.cursorPos : context.cursorPos;
+        context.commandMode = context.commandMode === commandModeBefore ? shortcutState.commandMode : context.commandMode;
+        context.panelFocused = context.panelFocused === panelFocusedBefore ? shortcutState.panelFocused : context.panelFocused;
         if (context.commandMode) {
           if (!context.prompt.startsWith('/')) {
             context.commandMode = false;
@@ -330,7 +370,19 @@ export function feedInputTokens(context: InputFeedContext, tokens: readonly Inpu
       panelManager: context.panelManager,
       keybindingsManager: context.keybindingsManager,
       onPanelInputConsumed: context.onPanelInputConsumed,
-      isPrintableBurst,
+      now,
+      burstGuard: context.panelBurstGuard,
+      // Per-token paste classification (Invariant B): a paste is a single
+      // 'text' token whose value holds more than one character.
+      isPasteToken: token.type === 'text' && token.value.length > 1,
+      // One-shot honesty hint when a paste is dropped into a non-capturing
+      // focused panel (Invariant A: focus never silently flips to the composer).
+      onPasteDropped: (panelName: string) =>
+        context.commandContext?.print(
+          `paste ignored — focus is on ${panelName}; Tab returns to composer`,
+        ),
+      isTurnActive: () => context.commandContext?.isGenerating?.() ?? false,
+      cancelGeneration: () => context.commandContext?.cancelGeneration?.(),
     }, token);
     context.panelFocused = panelRoute.panelFocused;
     if (panelRoute.handled) {
@@ -340,7 +392,7 @@ export function feedInputTokens(context: InputFeedContext, tokens: readonly Inpu
     const indicatorRoute = handleIndicatorFocusToken({
       indicatorFocused: context.indicatorFocused,
       modalOpened: context.modalOpened,
-      processModal: context.processModal,
+      openFleetPanel,
       requestRender: context.requestRender,
     }, token);
     context.indicatorFocused = indicatorRoute.indicatorFocused;
@@ -422,7 +474,7 @@ export function feedInputTokens(context: InputFeedContext, tokens: readonly Inpu
         commandRegistry: context.commandRegistry,
         autocomplete: context.autocomplete,
         blockActionsMenu: { open: (block: BlockMeta) => context.blockActionsMenu.open(block) },
-        processModal: context.processModal,
+        openFleetPanel,
         modalOpened: context.modalOpened,
         saveUndoState: context.saveUndoState,
         breakUndoCoalesce: context.breakUndoCoalesce,

package/src/input/handler-interactions.ts

@@ -225,14 +225,12 @@ export function handleEscapeForHandler(handler: InputHandler): void {
       helpOverlayActive: handler.helpOverlayActive,
       shortcutsOverlayActive: handler.shortcutsOverlayActive,
       bookmarkModal: handler.bookmarkModal,
-      agentDetailModal: handler.agentDetailModal,
-      liveTailModal: handler.liveTailModal,
       settingsModal: handler.settingsModal,
       mcpWorkspace: handler.mcpWorkspace,
       sessionPickerModal: handler.sessionPickerModal,
       profilePickerModal: handler.profilePickerModal,
+      configModal: handler.configModal,
       contextInspectorModal: handler.contextInspectorModal,
-      processModal: handler.processModal,
       modelPicker: handler.modelPicker,
       filePicker: handler.filePicker,
       blockActionsMenu: handler.blockActionsMenu,