@pellux/goodvibes-tui 1.0.0 → 1.7.0

package/src/input/config-modal-types.ts

@@ -0,0 +1,161 @@
+import type { ModalSectionStyle } from '../renderer/modal-factory.ts';
+
+/**
+ * Config-modal host — the shared seam every W6.1 MIGRATE-TO-MODAL surface
+ * (provider-health, services, subscription, remote, local-auth, settings-sync,
+ * sandbox, and the WO-B ecosystem/governance set) is expressed through.
+ *
+ * A surface is PURE DATA + ACTIONS: it hands the host a `buildView()` that maps
+ * live read-models to a tabbed, list-structured view, plus a declarative action
+ * table. The host owns all key routing (tab switch, list nav, Esc, confirm) and
+ * the stable-layout liveness contract — the surface never touches the input
+ * system directly (the charter's "do not invent a parallel input system").
+ *
+ * Liveness doctrine (charter: "live data, stable layout"): `buildView()` is
+ * called every render tick so values (latency, status, counts) update in place,
+ * but the host renders against the row/tab STRUCTURE captured at the last
+ * interaction boundary (open, or a key press). Rows never reflow under the
+ * cursor mid-interaction; a structural change (a row appears/disappears) is
+ * deferred until the next key press. See ConfigModal for the mechanism.
+ */
+
+/** A single row within a tab. Identity is `id` (structural); `label` is live. */
+export interface ConfigModalRow {
+  /**
+   * Stable identity across live-refresh ticks. The liveness contract keys
+   * structural stability off this: two builds with the same ordered id set are
+   * "structurally identical" and repaint values in place; a differing id set is
+   * a structural change, deferred to the next interaction boundary.
+   */
+  readonly id: string;
+  /** Display label. MAY embed live value fields (latency, status dot, counts). */
+  readonly label: string;
+  /** Optional per-row style (e.g. bad/warn tone for an errored row). */
+  readonly style?: ModalSectionStyle;
+  /**
+   * Non-selectable informational row (sub-header, spacer text). Skipped by
+   * up/down navigation and never receives an action. Defaults to selectable.
+   */
+  readonly selectable?: boolean;
+}
+
+/** One tab (section) of a surface. Tabs are switched with left/right or Tab. */
+export interface ConfigModalTab {
+  /** Stable id — preserves the active tab across refresh + re-open. */
+  readonly id: string;
+  /** Tab-strip label. */
+  readonly label: string;
+  /** Live status/posture lines rendered above the list (non-selectable). */
+  readonly header?: readonly string[];
+  /** Selectable/informational rows. */
+  readonly rows: readonly ConfigModalRow[];
+  /** Honest empty-state text shown when `rows` is empty. */
+  readonly emptyText?: string;
+  /** Footer hints specific to this tab, appended after the surface hints. */
+  readonly hints?: readonly string[];
+}
+
+/** The whole surface view for one render tick. */
+export interface ConfigModalView {
+  /** Live title (may change tick-to-tick; not structural). */
+  readonly title: string;
+  readonly tabs: readonly ConfigModalTab[];
+  /**
+   * Non-null when the read-model is unavailable/degraded — the host renders a
+   * banner and still shows whatever tabs/rows are present (honest degraded
+   * state rather than a blank or a throw).
+   */
+  readonly degraded?: string;
+  /** Base footer hints (Esc close is always appended by the host). */
+  readonly hints?: readonly string[];
+}
+
+/** Context handed to a surface's action handler when an action key fires. */
+export interface ConfigModalActionContext {
+  /** The selected row the action targets (null when the active tab has none). */
+  readonly row: ConfigModalRow | null;
+  /** The active tab's id. */
+  readonly tabId: string;
+  /** Print a line to the conversation transcript. */
+  readonly print: (message: string) => void;
+  /**
+   * Execute a slash command — the same seam panels used via
+   * `PanelIntegrationContext.executeCommand`. This is how a migrated action
+   * preserves parity: the mutation still runs through its existing, tested
+   * command (e.g. `/settings-sync resolve`, `/local-auth delete-user`).
+   */
+  readonly executeCommand?: (name: string, args: string[]) => Promise<unknown>;
+  /** Open another named modal surface (cross-surface navigation, e.g. the
+   *  services surface jumping to the subscription surface). Swaps the active
+   *  surface in place — the same seam ctx.openModal uses. */
+  readonly openModal?: (name: string) => void;
+  /** Request a re-render. */
+  readonly requestRender: () => void;
+  /** Set the modal's transient status line (e.g. a result or error message). */
+  readonly setStatus: (message: string) => void;
+  /** Close the modal (focus returns to whatever opened it). */
+  readonly close: () => void;
+}
+
+/** A declarative action bound to a key. */
+export interface ConfigModalAction {
+  /**
+   * Trigger key: a single printable char ('r', 'd') or a named key ('enter').
+   * Must not collide with the host-reserved nav keys (up/down/left/right/tab/
+   * j/k/escape) — those are consumed by the host before actions are consulted.
+   */
+  readonly key: string;
+  /** Action id passed to `onAction`. */
+  readonly id: string;
+  /** Short verb for the footer hint (e.g. "refresh", "delete user"). */
+  readonly label: string;
+  /**
+   * Destructive: require an explicit second press of the same key to fire
+   * (the host shows "press <key> again to <label>" between presses). Matches
+   * the session-picker delete-confirm precedent.
+   */
+  readonly confirm?: boolean;
+  /**
+   * When set, the action is only offered while the selected row's id satisfies
+   * this predicate (e.g. sandbox "stop" only on a session row). Rows failing
+   * the predicate neither show the hint nor fire the action.
+   */
+  readonly enabledFor?: (row: ConfigModalRow | null, tabId: string) => boolean;
+}
+
+/**
+ * A named config-modal surface. Pure seam — the host knows nothing about the
+ * surface's data. Built once (closing over its read-models) and registered on
+ * PanelManager via `registerModalSurface`; opened by name from a panel-id
+ * redirect hit or `ctx.openModal(name)`.
+ */
+export interface ConfigModalSurface {
+  /** Modal name — the key `registerModalRedirect` / `ctx.openModal` use. */
+  readonly name: string;
+  /** Fallback title (buildView().title wins per tick). */
+  readonly title: string;
+  /**
+   * Build the current view from live read-models. Called on open, on every
+   * interaction boundary, AND on every render tick. MUST be pure and cheap —
+   * snapshot reads only, no async, no mutation.
+   */
+  buildView(): ConfigModalView;
+  /** Declarative action table (optional — a read-only surface has none). */
+  readonly actions?: readonly ConfigModalAction[];
+  /** Handle an action fired by its key. */
+  onAction?(actionId: string, ctx: ConfigModalActionContext): void;
+  /**
+   * Optional lifecycle: called when the modal opens this surface and when it
+   * closes. A live surface uses `onOpen` to subscribe to its read-model/events
+   * (calling the provided `requestRender` on change so live values refresh
+   * between key presses) and `onClose` to unsubscribe. The host guarantees
+   * `onClose` runs exactly once per `onOpen`.
+   */
+  onOpen?(requestRender: () => void): void;
+  onClose?(): void;
+}
+
+/** Read-only registry the host consults to resolve a modal name to a surface. */
+export interface ConfigModalSurfaceRegistry {
+  getModalSurface(name: string): ConfigModalSurface | undefined;
+}

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