@jmoyers/harness 0.1.10 → 0.1.20

package/{src/ui → packages/harness-ui/src/interaction}/input-token-router.ts

@@ -1,34 +1,49 @@
-import {
-  classifyPaneAt as classifyPaneAtFrame,
-  type computeDualPaneLayout,
-  type parseMuxInputChunk,
-} from '../mux/dual-pane-core.ts';
-import {
-  hasAltModifier as hasAltModifierFrame,
-  hasShiftModifier as hasShiftModifierFrame,
-  isLeftButtonPress as isLeftButtonPressFrame,
-  isMotionMouseCode as isMotionMouseCodeFrame,
-  type PaneSelection,
-} from '../mux/live-mux/selection.ts';
-import type { TerminalSnapshotFrameCore } from '../terminal/snapshot-oracle.ts';
+import type {
+  ConversationSelectionSnapshotFrame,
+  PaneSelection,
+} from './conversation-selection-input.ts';
 
-type MainPaneMode = 'conversation' | 'project' | 'home';
-type DualPaneLayout = ReturnType<typeof computeDualPaneLayout>;
-type MuxInputToken = ReturnType<typeof parseMuxInputChunk>['tokens'][number];
-type PointerTarget = ReturnType<typeof classifyPaneAtFrame>;
+type MainPaneMode = 'conversation' | 'project' | 'home' | 'nim';
+type PointerTarget = 'left' | 'right' | 'separator' | 'status' | 'outside';
 
 interface MouseSelectionEvent {
+  readonly sequence: string;
   readonly col: number;
   readonly row: number;
   readonly code: number;
   readonly final: 'M' | 'm';
 }
 
+export interface InputTokenRouterLayout {
+  readonly paneRows: number;
+  readonly leftCols: number;
+  readonly rightCols: number;
+  readonly rightStartCol: number;
+}
+
+export interface InputTokenRouterMouseToken {
+  readonly kind: 'mouse';
+  readonly event: MouseSelectionEvent;
+}
+
+export interface InputTokenRouterPassthroughToken {
+  readonly kind: 'passthrough';
+  readonly text: string;
+}
+
+type MuxInputToken = InputTokenRouterMouseToken | InputTokenRouterPassthroughToken;
+
+interface HomePaneSelectionContext {
+  readonly viewportTop: number;
+  readonly totalRows: number;
+  readonly resolveSelectionText: (selection: PaneSelection) => string;
+}
+
 interface ConversationInputLike {
   readonly oracle: {
     isMouseTrackingEnabled: () => boolean;
     scrollViewport: (delta: number) => void;
-    snapshotWithoutHash: () => TerminalSnapshotFrameCore;
+    snapshotWithoutHash: () => ConversationSelectionSnapshotFrame;
     selectionText: (anchor: PaneSelection['anchor'], focus: PaneSelection['focus']) => string;
   };
 }
@@ -94,58 +109,85 @@ interface LeftRailPointerInputLike {
 interface ConversationSelectionInputLike {
   clearSelectionOnTextToken(textLength: number): boolean;
   handleMouseSelection(input: {
-    layout: DualPaneLayout;
-    frame: TerminalSnapshotFrameCore;
+    layout: InputTokenRouterLayout;
+    frame: ConversationSelectionSnapshotFrame;
     isMainPaneTarget: boolean;
     resolveSelectionText?: (selection: PaneSelection) => string;
     event: MouseSelectionEvent;
   }): boolean;
 }
 
-interface InputTokenRouterOptions {
+export interface InputTokenRouterOptions {
   readonly getMainPaneMode: () => MainPaneMode;
+  readonly getHomePaneSelectionContext?: () => HomePaneSelectionContext | null;
   readonly pointerRoutingInput: PointerRoutingInputLike;
   readonly mainPanePointerInput: MainPanePointerInputLike;
   readonly leftRailPointerInput: LeftRailPointerInputLike;
   readonly conversationSelectionInput: ConversationSelectionInputLike;
 }
 
-interface InputTokenRouterDependencies {
-  readonly classifyPaneAt?: typeof classifyPaneAtFrame;
-  readonly isLeftButtonPress?: typeof isLeftButtonPressFrame;
-  readonly hasAltModifier?: typeof hasAltModifierFrame;
-  readonly hasShiftModifier?: typeof hasShiftModifierFrame;
-  readonly isMotionMouseCode?: typeof isMotionMouseCodeFrame;
+export interface InputTokenRouterStrategies {
+  classifyPaneAt(layout: InputTokenRouterLayout, col: number, row: number): PointerTarget;
+  isLeftButtonPress(code: number, final: 'M' | 'm'): boolean;
+  hasAltModifier(code: number): boolean;
+  hasShiftModifier(code: number): boolean;
+  isMotionMouseCode(code: number): boolean;
 }
 
 interface RouteTokensInput {
   readonly tokens: readonly MuxInputToken[];
-  readonly layout: DualPaneLayout;
+  readonly layout: InputTokenRouterLayout;
   readonly conversation: ConversationInputLike | null;
-  readonly snapshotForInput: TerminalSnapshotFrameCore | null;
+  readonly snapshotForInput: ConversationSelectionSnapshotFrame | null;
 }
 
 interface RouteTokensResult {
   readonly routedTokens: MuxInputToken[];
-  readonly snapshotForInput: TerminalSnapshotFrameCore | null;
+  readonly snapshotForInput: ConversationSelectionSnapshotFrame | null;
 }
 
 export class InputTokenRouter {
-  private readonly classifyPaneAt: typeof classifyPaneAtFrame;
-  private readonly isLeftButtonPress: typeof isLeftButtonPressFrame;
-  private readonly hasAltModifier: typeof hasAltModifierFrame;
-  private readonly hasShiftModifier: typeof hasShiftModifierFrame;
-  private readonly isMotionMouseCode: typeof isMotionMouseCodeFrame;
-
   constructor(
     private readonly options: InputTokenRouterOptions,
-    dependencies: InputTokenRouterDependencies = {},
-  ) {
-    this.classifyPaneAt = dependencies.classifyPaneAt ?? classifyPaneAtFrame;
-    this.isLeftButtonPress = dependencies.isLeftButtonPress ?? isLeftButtonPressFrame;
-    this.hasAltModifier = dependencies.hasAltModifier ?? hasAltModifierFrame;
-    this.hasShiftModifier = dependencies.hasShiftModifier ?? hasShiftModifierFrame;
-    this.isMotionMouseCode = dependencies.isMotionMouseCode ?? isMotionMouseCodeFrame;
+    private readonly strategies: InputTokenRouterStrategies,
+  ) {}
+
+  private buildHomeSelectionFrame(
+    layout: InputTokenRouterLayout,
+    context: HomePaneSelectionContext | null,
+  ): ConversationSelectionSnapshotFrame | null {
+    if (context === null) {
+      return null;
+    }
+    return {
+      rows: Math.max(1, layout.paneRows),
+      cols: Math.max(1, layout.rightCols),
+      activeScreen: 'primary',
+      modes: {
+        bracketedPaste: false,
+        decMouseX10: false,
+        decMouseButtonEvent: false,
+        decMouseAnyEvent: false,
+        decFocusTracking: false,
+        decMouseSgrEncoding: false,
+      },
+      cursor: {
+        row: 0,
+        col: 0,
+        visible: false,
+        style: {
+          shape: 'block',
+          blinking: false,
+        },
+      },
+      viewport: {
+        top: Math.max(0, context.viewportTop),
+        totalRows: Math.max(1, context.totalRows),
+        followOutput: true,
+      },
+      lines: [],
+      richLines: [],
+    };
   }
 
   routeTokens(input: RouteTokensInput): RouteTokensResult {
@@ -174,7 +216,7 @@ export class InputTokenRouter {
         continue;
       }
 
-      const target = this.classifyPaneAt(input.layout, token.event.col, token.event.row);
+      const target = this.strategies.classifyPaneAt(input.layout, token.event.col, token.event.row);
       const rowIndex = Math.max(0, Math.min(input.layout.paneRows - 1, token.event.row - 1));
       const passThroughConversationMouse =
         input.conversation !== null &&
@@ -184,7 +226,7 @@ export class InputTokenRouter {
         snapshotForInput.activeScreen === 'alternate' &&
         snapshotForInput.viewport.followOutput &&
         input.conversation.oracle.isMouseTrackingEnabled() &&
-        !this.hasShiftModifier(token.event.code);
+        !this.strategies.hasShiftModifier(token.event.code);
       if (
         this.options.pointerRoutingInput.handleHomePaneDragRelease({
           final: token.event.final,
@@ -265,9 +307,9 @@ export class InputTokenRouter {
       }
       const leftPaneConversationSelect =
         target === 'left' &&
-        this.isLeftButtonPress(token.event.code, token.event.final) &&
-        !this.hasAltModifier(token.event.code) &&
-        !this.isMotionMouseCode(token.event.code);
+        this.strategies.isLeftButtonPress(token.event.code, token.event.final) &&
+        !this.strategies.hasAltModifier(token.event.code) &&
+        !this.strategies.isMotionMouseCode(token.event.code);
       if (
         this.options.leftRailPointerInput.handlePointerClick({
           clickEligible: leftPaneConversationSelect,
@@ -279,27 +321,36 @@ export class InputTokenRouter {
       ) {
         continue;
       }
-      if (snapshotForInput === null || this.options.getMainPaneMode() !== 'conversation') {
-        routedTokens.push(token);
-        continue;
-      }
-      const mouseSelectionInput =
-        resolveSelectionText === null
-          ? {
-              layout: input.layout,
-              frame: snapshotForInput,
-              isMainPaneTarget,
-              event: token.event,
-            }
-          : {
-              layout: input.layout,
-              frame: snapshotForInput,
-              isMainPaneTarget,
-              resolveSelectionText,
-              event: token.event,
-            };
-      if (this.options.conversationSelectionInput.handleMouseSelection(mouseSelectionInput)) {
-        continue;
+      const mainPaneMode = this.options.getMainPaneMode();
+      const homeSelectionContext =
+        mainPaneMode === 'home' ? (this.options.getHomePaneSelectionContext?.() ?? null) : null;
+      const selectionFrame =
+        mainPaneMode === 'conversation'
+          ? snapshotForInput
+          : this.buildHomeSelectionFrame(input.layout, homeSelectionContext);
+      const selectionResolver =
+        mainPaneMode === 'conversation'
+          ? resolveSelectionText
+          : (homeSelectionContext?.resolveSelectionText ?? null);
+      if (selectionFrame !== null) {
+        const mouseSelectionInput =
+          selectionResolver === null
+            ? {
+                layout: input.layout,
+                frame: selectionFrame,
+                isMainPaneTarget,
+                event: token.event,
+              }
+            : {
+                layout: input.layout,
+                frame: selectionFrame,
+                isMainPaneTarget,
+                resolveSelectionText: selectionResolver,
+                event: token.event,
+              };
+        if (this.options.conversationSelectionInput.handleMouseSelection(mouseSelectionInput)) {
+          continue;
+        }
       }
 
       routedTokens.push(token);

package/packages/harness-ui/src/interaction/input.ts

@@ -0,0 +1,420 @@
+export type ThreadAgentType = 'codex' | 'claude' | 'cursor' | 'terminal' | 'critique';
+
+type CommandMenuScope = 'all' | 'thread-start' | 'theme-select' | 'shortcuts';
+
+export interface CommandMenuState {
+  readonly scope: CommandMenuScope;
+  readonly query: string;
+  readonly selectedIndex: number;
+}
+
+export interface CommandMenuActionDescriptor {
+  readonly id: string;
+  readonly title: string;
+  readonly aliases?: readonly string[];
+  readonly keywords?: readonly string[];
+  readonly detail?: string;
+  readonly screenLabel?: string;
+  readonly sectionLabel?: string;
+  readonly bindingHint?: string;
+  readonly priority?: number;
+}
+
+export interface NewThreadPromptState {
+  readonly directoryId: string;
+  readonly selectedAgentType: ThreadAgentType;
+}
+
+export interface TaskEditorPromptState {
+  readonly mode: 'create' | 'edit';
+  readonly taskId: string | null;
+  readonly title: string;
+  readonly body: string;
+  readonly repositoryIds: readonly string[];
+  readonly repositoryIndex: number;
+  readonly fieldIndex: 0 | 1 | 2;
+  readonly error: string | null;
+}
+
+export interface RepositoryPromptState {
+  readonly mode: 'add' | 'edit';
+  readonly repositoryId: string | null;
+  readonly value: string;
+  readonly error: string | null;
+}
+
+export interface ConversationTitleEditState {
+  readonly conversationId: string;
+  readonly value: string;
+  readonly lastSavedValue: string;
+  readonly error: string | null;
+  readonly persistInFlight: boolean;
+  readonly debounceTimer: NodeJS.Timeout | null;
+}
+
+export interface TaskEditorSubmitPayload {
+  readonly mode: 'create' | 'edit';
+  readonly taskId: string | null;
+  readonly repositoryId: string | null;
+  readonly projectId?: string | null;
+  readonly title: string | null;
+  readonly body: string;
+  readonly commandLabel: string;
+}
+
+export interface ApiKeyPromptState {
+  readonly keyName: string;
+  readonly displayName: string;
+  readonly value: string;
+  readonly error: string | null;
+  readonly hasExistingValue: boolean;
+}
+
+export interface InputRouterShortcutPorts {
+  readonly isModalDismissShortcut: (input: Buffer) => boolean;
+  readonly isCommandMenuToggleShortcut: (input: Buffer) => boolean;
+  readonly isArchiveConversationShortcut: (input: Buffer) => boolean;
+}
+
+export interface InputRouterOverlayPorts {
+  readonly dismissOnOutsideClick: (
+    input: Buffer,
+    dismiss: () => void,
+    onInsidePointerPress?: (col: number, row: number) => boolean,
+  ) => boolean;
+  readonly buildConversationTitleModalOverlay: () => { top: number } | null;
+  readonly buildCommandMenuModalOverlay: () => { top: number } | null;
+  readonly buildNewThreadModalOverlay: () => { top: number } | null;
+  readonly resolveNewThreadPromptAgentByRow: (
+    overlayTop: number,
+    row: number,
+  ) => ThreadAgentType | null;
+}
+
+export interface InputRouterActionPorts {
+  readonly stopConversationTitleEdit: (persistPending: boolean) => void;
+  readonly queueControlPlaneOp: (task: () => Promise<void>, label: string) => void;
+  readonly archiveConversation: (sessionId: string) => Promise<void>;
+  readonly createAndActivateConversationInDirectory: (
+    directoryId: string,
+    agentType: ThreadAgentType,
+  ) => Promise<void>;
+  readonly addDirectoryByPath: (path: string) => Promise<void>;
+  readonly normalizeGitHubRemoteUrl: (remoteUrl: string) => string | null;
+  readonly upsertRepositoryByRemoteUrl: (
+    remoteUrl: string,
+    existingRepositoryId?: string,
+  ) => Promise<void>;
+  readonly repositoriesHas: (repositoryId: string) => boolean;
+  readonly submitTaskEditorPayload: (payload: TaskEditorSubmitPayload) => void;
+  readonly resolveCommandMenuActions: () => readonly CommandMenuActionDescriptor[];
+  readonly executeCommandMenuAction: (actionId: string) => void;
+  readonly persistApiKey?: (keyName: string, value: string) => void;
+}
+
+export interface InputRouterStatePorts {
+  readonly markDirty: () => void;
+  readonly conversations: ReadonlyMap<string, { title: string }>;
+  readonly scheduleConversationTitlePersist: () => void;
+  readonly getTaskEditorPrompt: () => TaskEditorPromptState | null;
+  readonly setTaskEditorPrompt: (next: TaskEditorPromptState | null) => void;
+  readonly getApiKeyPrompt?: () => ApiKeyPromptState | null;
+  readonly setApiKeyPrompt?: (next: ApiKeyPromptState | null) => void;
+  readonly getConversationTitleEdit: () => ConversationTitleEditState | null;
+  readonly getCommandMenu: () => CommandMenuState | null;
+  readonly setCommandMenu: (menu: CommandMenuState | null) => void;
+  readonly getNewThreadPrompt: () => NewThreadPromptState | null;
+  readonly setNewThreadPrompt: (prompt: NewThreadPromptState | null) => void;
+  readonly getAddDirectoryPrompt: () => { value: string; error: string | null } | null;
+  readonly setAddDirectoryPrompt: (
+    next: {
+      value: string;
+      error: string | null;
+    } | null,
+  ) => void;
+  readonly getRepositoryPrompt: () => RepositoryPromptState | null;
+  readonly setRepositoryPrompt: (next: RepositoryPromptState | null) => void;
+}
+
+export interface InputRouterOptions {
+  readonly shortcuts: InputRouterShortcutPorts;
+  readonly overlays: InputRouterOverlayPorts;
+  readonly actions: InputRouterActionPorts;
+  readonly state: InputRouterStatePorts;
+}
+
+export interface HandleCommandMenuInputOptions {
+  readonly input: Buffer;
+  readonly menu: CommandMenuState | null;
+  readonly isQuitShortcut: (input: Buffer) => boolean;
+  readonly isToggleShortcut: (input: Buffer) => boolean;
+  readonly dismissOnOutsideClick: (
+    input: Buffer,
+    dismiss: () => void,
+    onInsidePointerPress?: (col: number, row: number) => boolean,
+  ) => boolean;
+  readonly buildCommandMenuModalOverlay: () => { top: number } | null;
+  readonly resolveActions: () => readonly CommandMenuActionDescriptor[];
+  readonly executeAction: (actionId: string) => void;
+  readonly setMenu: (next: CommandMenuState | null) => void;
+  readonly markDirty: () => void;
+}
+
+export interface HandleTaskEditorPromptInputOptions {
+  readonly input: Buffer;
+  readonly prompt: TaskEditorPromptState | null;
+  readonly isQuitShortcut: (input: Buffer) => boolean;
+  readonly dismissOnOutsideClick: (input: Buffer, dismiss: () => void) => boolean;
+}
+
+export interface HandleTaskEditorPromptInputResult {
+  readonly handled: boolean;
+  readonly nextPrompt?: TaskEditorPromptState | null;
+  readonly markDirty: boolean;
+  readonly submitPayload?: TaskEditorSubmitPayload;
+}
+
+export interface HandleApiKeyPromptInputOptions {
+  readonly input: Buffer;
+  readonly prompt: ApiKeyPromptState | null;
+  readonly isQuitShortcut: (input: Buffer) => boolean;
+  readonly dismissOnOutsideClick: (input: Buffer, dismiss: () => void) => boolean;
+  readonly setPrompt: (next: ApiKeyPromptState | null) => void;
+  readonly markDirty: () => void;
+  readonly persistApiKey: (keyName: string, value: string) => void;
+}
+
+export interface HandleConversationTitleEditInputOptions {
+  readonly input: Buffer;
+  readonly edit: ConversationTitleEditState | null;
+  readonly isQuitShortcut: (input: Buffer) => boolean;
+  readonly isArchiveShortcut: (input: Buffer) => boolean;
+  readonly dismissOnOutsideClick: (
+    input: Buffer,
+    dismiss: () => void,
+    onInsidePointerPress?: (col: number, row: number) => boolean,
+  ) => boolean;
+  readonly buildConversationTitleModalOverlay: () => { top: number } | null;
+  readonly stopConversationTitleEdit: (persistPending: boolean) => void;
+  readonly queueControlPlaneOp: (task: () => Promise<void>, label: string) => void;
+  readonly archiveConversation: (sessionId: string) => Promise<void>;
+  readonly markDirty: () => void;
+  readonly conversations: ReadonlyMap<string, { title: string }>;
+  readonly scheduleConversationTitlePersist: () => void;
+}
+
+export interface HandleNewThreadPromptInputOptions {
+  readonly input: Buffer;
+  readonly prompt: NewThreadPromptState | null;
+  readonly isQuitShortcut: (input: Buffer) => boolean;
+  readonly dismissOnOutsideClick: (
+    input: Buffer,
+    dismiss: () => void,
+    onInsidePointerPress?: (col: number, row: number) => boolean,
+  ) => boolean;
+  readonly buildNewThreadModalOverlay: () => { top: number } | null;
+  readonly resolveNewThreadPromptAgentByRow: (
+    overlayTop: number,
+    row: number,
+  ) => ThreadAgentType | null;
+  readonly queueControlPlaneOp: (task: () => Promise<void>, label: string) => void;
+  readonly createAndActivateConversationInDirectory: (
+    directoryId: string,
+    agentType: ThreadAgentType,
+  ) => Promise<void>;
+  readonly markDirty: () => void;
+  readonly setPrompt: (prompt: NewThreadPromptState | null) => void;
+}
+
+export interface HandleAddDirectoryPromptInputOptions {
+  readonly input: Buffer;
+  readonly prompt: { value: string; error: string | null } | null;
+  readonly isQuitShortcut: (input: Buffer) => boolean;
+  readonly dismissOnOutsideClick: (input: Buffer, dismiss: () => void) => boolean;
+  readonly setPrompt: (
+    next: {
+      value: string;
+      error: string | null;
+    } | null,
+  ) => void;
+  readonly markDirty: () => void;
+  readonly queueControlPlaneOp: (task: () => Promise<void>, label: string) => void;
+  readonly addDirectoryByPath: (path: string) => Promise<void>;
+}
+
+export interface HandleRepositoryPromptInputOptions {
+  readonly input: Buffer;
+  readonly prompt: RepositoryPromptState | null;
+  readonly isQuitShortcut: (input: Buffer) => boolean;
+  readonly dismissOnOutsideClick: (input: Buffer, dismiss: () => void) => boolean;
+  readonly setPrompt: (next: RepositoryPromptState | null) => void;
+  readonly markDirty: () => void;
+  readonly repositoriesHas: (repositoryId: string) => boolean;
+  readonly normalizeGitHubRemoteUrl: (remoteUrl: string) => string | null;
+  readonly queueControlPlaneOp: (task: () => Promise<void>, label: string) => void;
+  readonly upsertRepositoryByRemoteUrl: (
+    remoteUrl: string,
+    existingRepositoryId?: string,
+  ) => Promise<void>;
+}
+
+export interface InputRouterStrategies {
+  handleCommandMenuInput(options: HandleCommandMenuInputOptions): boolean;
+  handleTaskEditorPromptInput(
+    options: HandleTaskEditorPromptInputOptions,
+  ): HandleTaskEditorPromptInputResult;
+  handleApiKeyPromptInput(options: HandleApiKeyPromptInputOptions): boolean;
+  handleConversationTitleEditInput(options: HandleConversationTitleEditInputOptions): boolean;
+  handleNewThreadPromptInput(options: HandleNewThreadPromptInputOptions): boolean;
+  handleAddDirectoryPromptInput(options: HandleAddDirectoryPromptInputOptions): boolean;
+  handleRepositoryPromptInput(options: HandleRepositoryPromptInputOptions): boolean;
+}
+
+export class InputRouter {
+  constructor(
+    private readonly options: InputRouterOptions,
+    private readonly strategies: InputRouterStrategies,
+  ) {}
+
+  handleCommandMenuInput(input: Buffer): boolean {
+    return this.strategies.handleCommandMenuInput({
+      input,
+      menu: this.options.state.getCommandMenu(),
+      isQuitShortcut: this.options.shortcuts.isModalDismissShortcut,
+      isToggleShortcut: this.options.shortcuts.isCommandMenuToggleShortcut,
+      dismissOnOutsideClick: this.options.overlays.dismissOnOutsideClick,
+      buildCommandMenuModalOverlay: this.options.overlays.buildCommandMenuModalOverlay,
+      resolveActions: this.options.actions.resolveCommandMenuActions,
+      executeAction: this.options.actions.executeCommandMenuAction,
+      setMenu: this.options.state.setCommandMenu,
+      markDirty: this.options.state.markDirty,
+    });
+  }
+
+  handleTaskEditorPromptInput(input: Buffer): boolean {
+    const handled = this.strategies.handleTaskEditorPromptInput({
+      input,
+      prompt: this.options.state.getTaskEditorPrompt(),
+      isQuitShortcut: this.options.shortcuts.isModalDismissShortcut,
+      dismissOnOutsideClick: this.options.overlays.dismissOnOutsideClick,
+    });
+    if (!handled.handled) {
+      return false;
+    }
+    if (handled.nextPrompt !== undefined) {
+      this.options.state.setTaskEditorPrompt(handled.nextPrompt);
+    }
+    if (handled.markDirty) {
+      this.options.state.markDirty();
+    }
+    if (handled.submitPayload !== undefined) {
+      this.options.actions.submitTaskEditorPayload(handled.submitPayload);
+    }
+    return true;
+  }
+
+  handleRepositoryPromptInput(input: Buffer): boolean {
+    return this.strategies.handleRepositoryPromptInput({
+      input,
+      prompt: this.options.state.getRepositoryPrompt(),
+      isQuitShortcut: this.options.shortcuts.isModalDismissShortcut,
+      dismissOnOutsideClick: this.options.overlays.dismissOnOutsideClick,
+      setPrompt: this.options.state.setRepositoryPrompt,
+      markDirty: this.options.state.markDirty,
+      repositoriesHas: this.options.actions.repositoriesHas,
+      normalizeGitHubRemoteUrl: this.options.actions.normalizeGitHubRemoteUrl,
+      queueControlPlaneOp: this.options.actions.queueControlPlaneOp,
+      upsertRepositoryByRemoteUrl: this.options.actions.upsertRepositoryByRemoteUrl,
+    });
+  }
+
+  handleApiKeyPromptInput(input: Buffer): boolean {
+    if (
+      this.options.state.getApiKeyPrompt === undefined ||
+      this.options.state.setApiKeyPrompt === undefined ||
+      this.options.actions.persistApiKey === undefined
+    ) {
+      return false;
+    }
+    return this.strategies.handleApiKeyPromptInput({
+      input,
+      prompt: this.options.state.getApiKeyPrompt(),
+      isQuitShortcut: this.options.shortcuts.isModalDismissShortcut,
+      dismissOnOutsideClick: this.options.overlays.dismissOnOutsideClick,
+      setPrompt: this.options.state.setApiKeyPrompt,
+      markDirty: this.options.state.markDirty,
+      persistApiKey: this.options.actions.persistApiKey,
+    });
+  }
+
+  handleNewThreadPromptInput(input: Buffer): boolean {
+    return this.strategies.handleNewThreadPromptInput({
+      input,
+      prompt: this.options.state.getNewThreadPrompt(),
+      isQuitShortcut: this.options.shortcuts.isModalDismissShortcut,
+      dismissOnOutsideClick: this.options.overlays.dismissOnOutsideClick,
+      buildNewThreadModalOverlay: this.options.overlays.buildNewThreadModalOverlay,
+      resolveNewThreadPromptAgentByRow: this.options.overlays.resolveNewThreadPromptAgentByRow,
+      queueControlPlaneOp: this.options.actions.queueControlPlaneOp,
+      createAndActivateConversationInDirectory:
+        this.options.actions.createAndActivateConversationInDirectory,
+      markDirty: this.options.state.markDirty,
+      setPrompt: this.options.state.setNewThreadPrompt,
+    });
+  }
+
+  handleConversationTitleEditInput(input: Buffer): boolean {
+    return this.strategies.handleConversationTitleEditInput({
+      input,
+      edit: this.options.state.getConversationTitleEdit(),
+      isQuitShortcut: this.options.shortcuts.isModalDismissShortcut,
+      isArchiveShortcut: this.options.shortcuts.isArchiveConversationShortcut,
+      dismissOnOutsideClick: this.options.overlays.dismissOnOutsideClick,
+      buildConversationTitleModalOverlay: this.options.overlays.buildConversationTitleModalOverlay,
+      stopConversationTitleEdit: this.options.actions.stopConversationTitleEdit,
+      queueControlPlaneOp: this.options.actions.queueControlPlaneOp,
+      archiveConversation: this.options.actions.archiveConversation,
+      markDirty: this.options.state.markDirty,
+      conversations: this.options.state.conversations,
+      scheduleConversationTitlePersist: this.options.state.scheduleConversationTitlePersist,
+    });
+  }
+
+  handleAddDirectoryPromptInput(input: Buffer): boolean {
+    return this.strategies.handleAddDirectoryPromptInput({
+      input,
+      prompt: this.options.state.getAddDirectoryPrompt(),
+      isQuitShortcut: this.options.shortcuts.isModalDismissShortcut,
+      dismissOnOutsideClick: this.options.overlays.dismissOnOutsideClick,
+      setPrompt: this.options.state.setAddDirectoryPrompt,
+      markDirty: this.options.state.markDirty,
+      queueControlPlaneOp: this.options.actions.queueControlPlaneOp,
+      addDirectoryByPath: this.options.actions.addDirectoryByPath,
+    });
+  }
+
+  routeModalInput(input: Buffer): boolean {
+    if (this.handleCommandMenuInput(input)) {
+      return true;
+    }
+    if (this.handleTaskEditorPromptInput(input)) {
+      return true;
+    }
+    if (this.handleRepositoryPromptInput(input)) {
+      return true;
+    }
+    if (this.handleApiKeyPromptInput(input)) {
+      return true;
+    }
+    if (this.handleNewThreadPromptInput(input)) {
+      return true;
+    }
+    if (this.handleConversationTitleEditInput(input)) {
+      return true;
+    }
+    if (this.handleAddDirectoryPromptInput(input)) {
+      return true;
+    }
+    return false;
+  }
+}