@pellux/goodvibes-tui 1.1.0 → 1.7.0

package/src/input/config-modal.ts

@@ -0,0 +1,377 @@
+import type {
+  ConfigModalAction,
+  ConfigModalActionContext,
+  ConfigModalRow,
+  ConfigModalSurface,
+  ConfigModalTab,
+  ConfigModalView,
+} from './config-modal-types.ts';
+import type { ModalSectionStyle } from '../renderer/modal-factory.ts';
+
+export type {
+  ConfigModalAction,
+  ConfigModalActionContext,
+  ConfigModalRow,
+  ConfigModalSurface,
+  ConfigModalTab,
+  ConfigModalView,
+} from './config-modal-types.ts';
+
+/** A tab as the renderer sees it (structure frozen, label live). */
+export interface ConfigModalRenderTab {
+  readonly id: string;
+  readonly label: string;
+  readonly active: boolean;
+}
+
+/** A row as the renderer sees it: frozen identity, live label/value overlay. */
+export interface ConfigModalRenderRow {
+  readonly id: string;
+  readonly label: string;
+  readonly style?: ModalSectionStyle;
+  readonly selected: boolean;
+  readonly selectable: boolean;
+  /** True when this frozen row has no live counterpart this tick (value went
+   *  stale — kept in place, dimmed, until the next interaction boundary). */
+  readonly stale: boolean;
+}
+
+/** Everything renderConfigModal needs — computed by overlaying live values onto
+ *  the frozen structure so layout stays stable between key presses. */
+export interface ConfigModalRenderModel {
+  readonly title: string;
+  readonly tabs: readonly ConfigModalRenderTab[];
+  readonly header: readonly string[];
+  readonly rows: readonly ConfigModalRenderRow[];
+  readonly emptyText?: string;
+  readonly degraded?: string;
+  readonly status?: string;
+  readonly hints: readonly string[];
+  readonly scroll: { readonly offset: number; readonly total: number; readonly visible: number };
+}
+
+const DEFAULT_VISIBLE_ROWS = 10;
+
+/**
+ * ConfigModal — the single, generic, named config-modal host. One instance
+ * lives on the InputHandler (like `settingsModal`); it renders whatever
+ * `ConfigModalSurface` is currently open. Key routing is a single
+ * `handleConfigModalToken` path (handler-modal-routes.ts) — no parallel input
+ * system. See config-modal-types.ts for the surface contract and the liveness
+ * doctrine this class enforces.
+ */
+export class ConfigModal {
+  public active = false;
+
+  private surface: ConfigModalSurface | null = null;
+  private requestRender: () => void = () => {};
+
+  /** Active tab / selected row tracked by STABLE id (survives value refresh). */
+  private activeTabId = '';
+  private selectedRowId = '';
+
+  /** Transient status line (action result, error, or confirm prompt). */
+  private statusMessage = '';
+  /** Pending destructive confirm: the action key awaiting a second press. */
+  private pendingConfirmKey: string | null = null;
+
+  /**
+   * Structure captured at the last interaction boundary (open / key press).
+   * Renders overlay live values onto THIS so rows never reflow mid-interaction.
+   */
+  private frozenView: ConfigModalView | null = null;
+
+  private scrollOffset = 0;
+  private visibleRows = DEFAULT_VISIBLE_ROWS;
+
+  // ── Lifecycle ──────────────────────────────────────────────────────────────
+
+  open(surface: ConfigModalSurface, requestRender: () => void = () => {}): void {
+    // Re-opening a different surface closes the previous one cleanly.
+    if (this.surface && this.surface !== surface) this.surface.onClose?.();
+    this.surface = surface;
+    this.requestRender = requestRender;
+    this.active = true;
+    this.statusMessage = '';
+    this.pendingConfirmKey = null;
+    this.scrollOffset = 0;
+    const view = surface.buildView();
+    this.frozenView = view;
+    this.activeTabId = view.tabs[0]?.id ?? '';
+    this.selectedRowId = this._firstSelectableId(this._frozenTab());
+    surface.onOpen?.(requestRender);
+  }
+
+  close(): void {
+    if (!this.active) return;
+    this.surface?.onClose?.();
+    this.active = false;
+    this.surface = null;
+    this.frozenView = null;
+    this.statusMessage = '';
+    this.pendingConfirmKey = null;
+  }
+
+  /** Re-activate the current surface after a nested modal closes (Esc stack). */
+  reopen(): void {
+    if (!this.surface) return;
+    this.active = true;
+    this.syncStructure();
+    this.surface.onOpen?.(this.requestRender);
+  }
+
+  getSurfaceName(): string | null {
+    return this.surface?.name ?? null;
+  }
+
+  setViewportRows(rows: number): void {
+    this.visibleRows = Math.max(3, rows);
+    this._clampScroll();
+  }
+
+  // ── Interaction boundary ────────────────────────────────────────────────────
+
+  /**
+   * Re-capture the structure from the current live view. Called on every key
+   * press (never during a pure render tick) — this is what makes structural
+   * changes appear only at an interaction boundary. Selection + active tab are
+   * preserved by id and clamped if their target vanished.
+   */
+  syncStructure(): void {
+    if (!this.surface) return;
+    const view = this.surface.buildView();
+    this.frozenView = view;
+    if (!view.tabs.some((t) => t.id === this.activeTabId)) {
+      this.activeTabId = view.tabs[0]?.id ?? '';
+    }
+    const tab = this._frozenTab();
+    if (!this._selectableIds(tab).includes(this.selectedRowId)) {
+      this.selectedRowId = this._firstSelectableId(tab);
+    }
+    this._clampScroll();
+  }
+
+  // ── Navigation (each is an interaction boundary) ────────────────────────────
+
+  moveDown(): void {
+    this._clearConfirm();
+    this.syncStructure();
+    const ids = this._selectableIds(this._frozenTab());
+    if (ids.length === 0) return;
+    const i = ids.indexOf(this.selectedRowId);
+    this.selectedRowId = ids[(i + 1) % ids.length]!;
+    this._clampScroll();
+  }
+
+  moveUp(): void {
+    this._clearConfirm();
+    this.syncStructure();
+    const ids = this._selectableIds(this._frozenTab());
+    if (ids.length === 0) return;
+    const i = ids.indexOf(this.selectedRowId);
+    this.selectedRowId = ids[(i - 1 + ids.length) % ids.length]!;
+    this._clampScroll();
+  }
+
+  nextTab(): void {
+    this._switchTab(1);
+  }
+
+  prevTab(): void {
+    this._switchTab(-1);
+  }
+
+  private _switchTab(dir: 1 | -1): void {
+    this._clearConfirm();
+    this.syncStructure();
+    const tabs = this.frozenView?.tabs ?? [];
+    if (tabs.length <= 1) return;
+    const i = tabs.findIndex((t) => t.id === this.activeTabId);
+    const next = tabs[(i + dir + tabs.length) % tabs.length]!;
+    this.activeTabId = next.id;
+    this.selectedRowId = this._firstSelectableId(next);
+    this.scrollOffset = 0;
+    this.statusMessage = '';
+  }
+
+  // ── Actions ─────────────────────────────────────────────────────────────────
+
+  /** The action bound to `key` on the active tab/row, if enabled. */
+  resolveAction(key: string): ConfigModalAction | null {
+    const actions = this.surface?.actions ?? [];
+    const row = this.getSelectedRow();
+    for (const action of actions) {
+      if (action.key !== key) continue;
+      if (action.enabledFor && !action.enabledFor(row, this.activeTabId)) return null;
+      return action;
+    }
+    return null;
+  }
+
+  /**
+   * Attempt to fire the action bound to `key`. Returns true if a key was an
+   * action (consumed). Handles the two-press confirm for destructive actions.
+   * This is an interaction boundary (syncs structure first).
+   */
+  fireAction(key: string, ctx: Omit<ConfigModalActionContext, 'row' | 'tabId' | 'setStatus' | 'close' | 'requestRender'>): boolean {
+    this.syncStructure();
+    const action = this.resolveAction(key);
+    if (!action) return false;
+    if (action.confirm && this.pendingConfirmKey !== key) {
+      this.pendingConfirmKey = key;
+      this.statusMessage = `Press ${key} again to ${action.label}.`;
+      return true;
+    }
+    this._clearConfirm();
+    const fullCtx: ConfigModalActionContext = {
+      row: this.getSelectedRow(),
+      tabId: this.activeTabId,
+      print: ctx.print,
+      executeCommand: ctx.executeCommand,
+      openModal: ctx.openModal,
+      requestRender: this.requestRender,
+      setStatus: (m: string) => { this.statusMessage = m; },
+      close: () => this.close(),
+    };
+    this.surface?.onAction?.(action.id, fullCtx);
+    return true;
+  }
+
+  /** Clear a pending confirm when the user navigates or presses an unrelated key. */
+  clearConfirmOnMiss(): void {
+    this._clearConfirm();
+  }
+
+  // ── Read accessors (for the renderer + tests) ───────────────────────────────
+
+  getSelectedRow(): ConfigModalRow | null {
+    const tab = this._liveTab(this.activeTabId) ?? this._frozenTab();
+    return tab?.rows.find((r) => r.id === this.selectedRowId) ?? null;
+  }
+
+  getActiveTabId(): string {
+    return this.activeTabId;
+  }
+
+  getSelectedRowId(): string {
+    return this.selectedRowId;
+  }
+
+  getStatusMessage(): string {
+    return this.statusMessage;
+  }
+
+  /**
+   * Compute the render model: frozen structure + live value overlay. Pure —
+   * does NOT sync structure, so calling it repeatedly with only value mutations
+   * yields byte-identical layout (the liveness contract).
+   */
+  getRenderModel(): ConfigModalRenderModel {
+    const live = this.surface?.buildView() ?? null;
+    const frozen = this.frozenView;
+    if (!frozen) {
+      return { title: '', tabs: [], header: [], rows: [], hints: [], scroll: { offset: 0, total: 0, visible: this.visibleRows } };
+    }
+
+    const tabs: ConfigModalRenderTab[] = frozen.tabs.map((ft) => {
+      const lt = live?.tabs.find((t) => t.id === ft.id);
+      return { id: ft.id, label: lt?.label ?? ft.label, active: ft.id === this.activeTabId };
+    });
+
+    const frozenTab = frozen.tabs.find((t) => t.id === this.activeTabId) ?? frozen.tabs[0];
+    const liveTab = live?.tabs.find((t) => t.id === this.activeTabId);
+
+    // Header: all-or-nothing live overlay. Same line count → use live values;
+    // a count change is a structural change, deferred (keep frozen header).
+    const frozenHeader = frozenTab?.header ?? [];
+    const liveHeader = liveTab?.header ?? [];
+    const header = liveHeader.length === frozenHeader.length ? liveHeader : frozenHeader;
+
+    // Rows: iterate the frozen id order; overlay the live row (value refresh) by
+    // id, or keep the frozen row marked stale when its live counterpart is gone.
+    const frozenRows = frozenTab?.rows ?? [];
+    const allRows: ConfigModalRenderRow[] = frozenRows.map((fr) => {
+      const lr = liveTab?.rows.find((r) => r.id === fr.id);
+      const src = lr ?? fr;
+      return {
+        id: fr.id,
+        label: src.label,
+        style: src.style,
+        selected: fr.id === this.selectedRowId,
+        selectable: fr.selectable !== false,
+        stale: lr === undefined,
+      };
+    });
+
+    const visible = this.visibleRows;
+    const windowed = allRows.slice(this.scrollOffset, this.scrollOffset + visible);
+
+    const hints = [
+      ...(frozen.hints ?? []),
+      ...(frozenTab?.hints ?? []),
+      ...this._actionHints(),
+      'Esc close',
+    ];
+
+    return {
+      title: live?.title ?? frozen.title,
+      tabs,
+      header,
+      rows: windowed,
+      emptyText: frozenRows.length === 0 ? (frozenTab?.emptyText ?? 'Nothing to show.') : undefined,
+      degraded: live?.degraded ?? frozen.degraded,
+      status: this.statusMessage || undefined,
+      hints,
+      scroll: { offset: this.scrollOffset, total: allRows.length, visible },
+    };
+  }
+
+  // ── internals ────────────────────────────────────────────────────────────────
+
+  private _actionHints(): string[] {
+    const actions = this.surface?.actions ?? [];
+    const row = this.getSelectedRow();
+    const out: string[] = [];
+    for (const a of actions) {
+      if (a.enabledFor && !a.enabledFor(row, this.activeTabId)) continue;
+      out.push(`${a.key} ${a.label}`);
+    }
+    return out;
+  }
+
+  private _clearConfirm(): void {
+    if (this.pendingConfirmKey !== null) {
+      this.pendingConfirmKey = null;
+      this.statusMessage = '';
+    }
+  }
+
+  private _frozenTab(): ConfigModalTab | undefined {
+    return this.frozenView?.tabs.find((t) => t.id === this.activeTabId) ?? this.frozenView?.tabs[0];
+  }
+
+  private _liveTab(id: string): ConfigModalTab | undefined {
+    return this.surface?.buildView().tabs.find((t) => t.id === id);
+  }
+
+  private _selectableIds(tab: ConfigModalTab | undefined): string[] {
+    return (tab?.rows ?? []).filter((r) => r.selectable !== false).map((r) => r.id);
+  }
+
+  private _firstSelectableId(tab: ConfigModalTab | undefined): string {
+    return this._selectableIds(tab)[0] ?? '';
+  }
+
+  private _clampScroll(): void {
+    const tab = this._frozenTab();
+    const rows = tab?.rows ?? [];
+    const idx = rows.findIndex((r) => r.id === this.selectedRowId);
+    const visible = Math.max(3, this.visibleRows);
+    if (idx >= 0) {
+      if (idx < this.scrollOffset) this.scrollOffset = idx;
+      else if (idx >= this.scrollOffset + visible) this.scrollOffset = idx - visible + 1;
+    }
+    const maxOffset = Math.max(0, rows.length - visible);
+    this.scrollOffset = Math.max(0, Math.min(this.scrollOffset, maxOffset));
+  }
+}

package/src/input/feed-context-factory.ts

@@ -22,15 +22,13 @@ import type { SelectionResult } from './selection-modal.ts';
 import type { SearchManager } from './search.ts';
 import type { InputHistory, HistorySearch } from './input-history.ts';
 import type { ConversationManager } from '../core/conversation';
-import type { ProcessModal } from '../renderer/process-modal.ts';
-import type { LiveTailModal } from '../renderer/live-tail-modal.ts';
 import type { BlockActionsMenu } from '../renderer/block-actions.ts';
-import type { AgentDetailModal } from '../renderer/agent-detail-modal.ts';
 import type { ContextInspectorModal } from '../renderer/context-inspector.ts';
 import type { BookmarkModal } from './bookmark-modal.ts';
 import type { SettingsModal } from './settings-modal.ts';
 import type { McpWorkspace } from './mcp-workspace.ts';
 import type { SessionPickerModal } from './session-picker-modal.ts';
+import type { ConfigModal } from './config-modal.ts';
 import type { ProfilePickerModal } from './profile-picker-modal.ts';
 import type { OnboardingWizardController } from './onboarding/onboarding-wizard.ts';
 import type { WrappedPromptInfo } from './handler-prompt-buffer.ts';
@@ -40,6 +38,7 @@ import type { KeybindingsManager } from './keybindings.ts';
 import type { ModelPickerTarget } from './model-picker.ts';
 import type { KillRing } from './kill-ring.ts';
 import type { PanelMouseLayout } from './handler-feed-routes.ts';
+import type { FocusTracker } from '../core/focus-tracker.ts';
 
 /**
  * Initial mutable scalar values for InputFeedContext.
@@ -82,8 +81,7 @@ export interface FeedContextMutableInit {
  *   - `pasteRegistry`, `imageRegistry` — owned Maps, never replaced
  *   - `selectionModal`, `bookmarkModal`, `settingsModal`, `sessionPickerModal`,
  *     `profilePickerModal` — modal objects constructed once
- *   - `filePicker`, `modelPicker`, `processModal`, `liveTailModal`,
- *     `agentDetailModal`, `contextInspectorModal`, `blockActionsMenu`,
+ *   - `filePicker`, `modelPicker`, `contextInspectorModal`, `blockActionsMenu`,
  *     `searchManager`, `historySearch`, `onboardingWizard` — service objects constructed once
  *   - `panelManager`, `keybindingsManager` — from uiServices, stable
  *   - `modalStack` — reference to the handler's shared array
@@ -91,6 +89,8 @@ export interface FeedContextMutableInit {
  *   - `commandRegistry`, `commandContext`, `autocomplete`, `inputHistory`,
  *     `conversationManager` — wired after construction; synced at feed() entry only
  *     (not per-action) since no in-feed action changes them
+ *   - `focusTracker` (W2.3) — shared instance from uiServices.platform, mutated
+ *     directly by feedInputTokens() on 'focus' tokens; never reallocated
  *
  * **Rationale:** per-feed mutation on a single object avoids per-keystroke GC pressure
  * from ~80-field object allocation. Stable references are service handles that never
@@ -107,6 +107,7 @@ export interface FeedContextStableRefs {
   mcpWorkspace: McpWorkspace;
   sessionPickerModal: SessionPickerModal;
   profilePickerModal: ProfilePickerModal;
+  configModal: ConfigModal;
   historySearch: HistorySearch;
   commandRegistry: CommandRegistry | null;
   commandContext: CommandContext | undefined;
@@ -114,9 +115,6 @@ export interface FeedContextStableRefs {
   filePicker: FilePickerModal;
   modelPicker: ModelPickerModal;
   onboardingWizard: OnboardingWizardController;
-  processModal: ProcessModal;
-  liveTailModal: LiveTailModal;
-  agentDetailModal: AgentDetailModal;
   contextInspectorModal: ContextInspectorModal;
   blockActionsMenu: BlockActionsMenu;
   searchManager: SearchManager;
@@ -126,6 +124,7 @@ export interface FeedContextStableRefs {
   panelManager: PanelManager;
   keybindingsManager: KeybindingsManager;
   killRing: KillRing;
+  focusTracker: FocusTracker;
   getHistory: () => InfiniteBuffer;
   getViewportHeight: () => number;
   getScrollTop: () => number;

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();
     }

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

@@ -31,14 +31,26 @@ 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;
+  /**
+   * 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 +87,25 @@ 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: while a turn is streaming, a focused panel must not be able to
+      // swallow the only way to cancel it (replay R5) — Escape's first job is
+      // always cancel-turn. The panel's own two-stage consume-or-unfocus
+      // contract below only runs once no turn is active, so a *second*
+      // Escape (now with the turn already cancelled) falls through to it
+      // normally. panelFocused is left unchanged here (panel stays open and
+      // focused) — the panel close moves to that second Escape, or to
+      // Ctrl+X (panel-close, keybindings.ts), which is handled earlier in
+      // handleGlobalShortcutToken and is unaffected by this branch. This
+      // deliberately calls cancelGeneration() directly instead of routing
+      // through the shared handleEscape() (handler-modal-stack.ts) — that
+      // function's fallthrough order (modal-pop -> active-modal-close ->
+      // clear-nonempty-prompt -> cancelGeneration) is not guaranteed to reach
+      // cancelGeneration first in every state combination.
+      if (state.isTurnActive()) {
+        state.cancelGeneration();
+        state.requestRender();
+        return { handled: true, panelFocused };
+      }
       const activePanel = state.panelManager.getActive();
       const panelConsumedEscape = activePanel?.handleInput?.('escape') ?? false;
       if (panelConsumedEscape) {
@@ -122,18 +153,19 @@ 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?.()) {
-      panelFocused = false;
+    // Invariant A/B (W6.2). A paste (isPasteToken: one multi-char text token)
+    // into a focused text-capturing panel (a `/`-search or steer-draft field —
+    // isCapturingTextBurst) is forwarded verbatim below; into any other focused
+    // panel it is DROPPED with a one-shot hint — never exploded into per-char
+    // hotkeys, and never a silent focus flip to the composer (what the old
+    // per-feed char-sum burst guard did, which also misfired on two quick nav
+    // keys in one feed). Focus moves only on an explicit transfer verb, so
+    // panelFocused is left unchanged. Discrete 1-char keystrokes are not pastes
+    // and fall through to the per-char dispatch below, one at a time.
+    if (state.isPasteToken && !activePanel?.isCapturingTextBurst?.()) {
+      state.onPasteDropped?.(activePanel?.name ?? 'the panel');
       state.requestRender();
-      return { handled: false, panelFocused };
+      return { handled: true, panelFocused };
     }
     if (activePanel?.handleInput) {
       for (const ch of token.value) {
@@ -150,7 +182,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 +204,9 @@ export function handleIndicatorFocusToken(state: IndicatorFocusRouteState, token
     }
     if (token.logicalName === 'enter') {
       indicatorFocused = false;
-      state.modalOpened('process');
-      state.processModal.open();
+      // W2.2: repointed from the retired process modal (removed in W6.2) to the
+      // Fleet panel — F2 also opens the Fleet panel (handlePromptKeyToken f2).
+      state.openFleetPanel();
       state.requestRender();
       return { handled: true, indicatorFocused };
     }
@@ -297,7 +331,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). */
@@ -570,8 +605,11 @@ export function handlePromptKeyToken(state: KeyRouteState, token: InputToken): {
 
   if (token.logicalName === 'f2') {
     indicatorFocused = false;
-    state.modalOpened('process');
-    state.processModal.open();
+    // W6.2 e: F2 opens AND focuses the Fleet panel, which subsumes the deleted
+    // process modal (ProcessModal/AgentDetailModal/LiveTailModal — removed in
+    // W6.1 once this repoint made them unreachable). openFleetPanel sets
+    // panelFocused on the shared context directly, so nothing more is returned.
+    state.openFleetPanel();
     return { handled: true, prompt, cursorPos, inputScrollTop, commandMode, indicatorFocused };
   }