@jmoyers/harness 0.1.0

package/src/services/runtime-modal-input.ts

@@ -0,0 +1,119 @@
+import type { WorkspaceModel } from '../domain/workspace.ts';
+import type { CommandMenuActionDescriptor } from '../mux/live-mux/command-menu.ts';
+import { InputRouter } from '../ui/input.ts';
+
+type InputRouterOptions = ConstructorParameters<typeof InputRouter>[0];
+
+interface RuntimeModalInputWorkspaceActions {
+  archiveConversation(sessionId: string): Promise<void>;
+  createAndActivateConversationInDirectory(directoryId: string, agentType: string): Promise<void>;
+  addDirectoryByPath(rawPath: string): Promise<void>;
+  upsertRepositoryByRemoteUrl(remoteUrl: string, existingRepositoryId?: string): Promise<void>;
+}
+
+interface RuntimeModalInputTaskEditorActions {
+  submitTaskEditorPayload(
+    payload: Parameters<InputRouterOptions['submitTaskEditorPayload']>[0],
+  ): void;
+}
+
+interface RuntimeModalInputOptions {
+  readonly workspace: WorkspaceModel;
+  readonly conversations: ReadonlyMap<string, { title: string }>;
+  readonly workspaceActions: RuntimeModalInputWorkspaceActions;
+  readonly taskEditorActions: RuntimeModalInputTaskEditorActions;
+  readonly isModalDismissShortcut: (input: Buffer) => boolean;
+  readonly isCommandMenuToggleShortcut: (input: Buffer) => boolean;
+  readonly isArchiveConversationShortcut: (input: Buffer) => boolean;
+  readonly dismissOnOutsideClick: InputRouterOptions['dismissOnOutsideClick'];
+  readonly buildCommandMenuModalOverlay: InputRouterOptions['buildCommandMenuModalOverlay'];
+  readonly buildConversationTitleModalOverlay: InputRouterOptions['buildConversationTitleModalOverlay'];
+  readonly buildNewThreadModalOverlay: InputRouterOptions['buildNewThreadModalOverlay'];
+  readonly resolveNewThreadPromptAgentByRow: InputRouterOptions['resolveNewThreadPromptAgentByRow'];
+  readonly stopConversationTitleEdit: (persistPending: boolean) => void;
+  readonly queueControlPlaneOp: (task: () => Promise<void>, label: string) => void;
+  readonly normalizeGitHubRemoteUrl: (remoteUrl: string) => string | null;
+  readonly repositoriesHas: (repositoryId: string) => boolean;
+  readonly scheduleConversationTitlePersist: () => void;
+  readonly resolveCommandMenuActions: () => readonly CommandMenuActionDescriptor[];
+  readonly executeCommandMenuAction: (actionId: string) => void;
+  readonly markDirty: () => void;
+}
+
+interface RuntimeModalInputDependencies {
+  readonly createInputRouter?: (
+    options: InputRouterOptions,
+  ) => Pick<InputRouter, 'routeModalInput'>;
+}
+
+export class RuntimeModalInput {
+  private readonly inputRouter: Pick<InputRouter, 'routeModalInput'>;
+
+  constructor(options: RuntimeModalInputOptions, dependencies: RuntimeModalInputDependencies = {}) {
+    const createInputRouter =
+      dependencies.createInputRouter ??
+      ((routerOptions: InputRouterOptions) => new InputRouter(routerOptions));
+    this.inputRouter = createInputRouter({
+      isModalDismissShortcut: options.isModalDismissShortcut,
+      isCommandMenuToggleShortcut: options.isCommandMenuToggleShortcut,
+      isArchiveConversationShortcut: options.isArchiveConversationShortcut,
+      dismissOnOutsideClick: options.dismissOnOutsideClick,
+      buildCommandMenuModalOverlay: options.buildCommandMenuModalOverlay,
+      buildConversationTitleModalOverlay: options.buildConversationTitleModalOverlay,
+      buildNewThreadModalOverlay: options.buildNewThreadModalOverlay,
+      resolveNewThreadPromptAgentByRow: options.resolveNewThreadPromptAgentByRow,
+      stopConversationTitleEdit: options.stopConversationTitleEdit,
+      queueControlPlaneOp: options.queueControlPlaneOp,
+      archiveConversation: async (sessionId) => {
+        await options.workspaceActions.archiveConversation(sessionId);
+      },
+      createAndActivateConversationInDirectory: async (directoryId, agentType) => {
+        await options.workspaceActions.createAndActivateConversationInDirectory(
+          directoryId,
+          agentType,
+        );
+      },
+      addDirectoryByPath: async (rawPath) => {
+        await options.workspaceActions.addDirectoryByPath(rawPath);
+      },
+      normalizeGitHubRemoteUrl: options.normalizeGitHubRemoteUrl,
+      upsertRepositoryByRemoteUrl: async (remoteUrl, existingRepositoryId) => {
+        await options.workspaceActions.upsertRepositoryByRemoteUrl(remoteUrl, existingRepositoryId);
+      },
+      repositoriesHas: options.repositoriesHas,
+      markDirty: options.markDirty,
+      conversations: options.conversations,
+      scheduleConversationTitlePersist: options.scheduleConversationTitlePersist,
+      getCommandMenu: () => options.workspace.commandMenu,
+      setCommandMenu: (menu) => {
+        options.workspace.commandMenu = menu;
+      },
+      resolveCommandMenuActions: options.resolveCommandMenuActions,
+      executeCommandMenuAction: options.executeCommandMenuAction,
+      getTaskEditorPrompt: () => options.workspace.taskEditorPrompt,
+      setTaskEditorPrompt: (next) => {
+        options.workspace.taskEditorPrompt = next;
+      },
+      submitTaskEditorPayload: (payload) => {
+        options.taskEditorActions.submitTaskEditorPayload(payload);
+      },
+      getConversationTitleEdit: () => options.workspace.conversationTitleEdit,
+      getNewThreadPrompt: () => options.workspace.newThreadPrompt,
+      setNewThreadPrompt: (prompt) => {
+        options.workspace.newThreadPrompt = prompt;
+      },
+      getAddDirectoryPrompt: () => options.workspace.addDirectoryPrompt,
+      setAddDirectoryPrompt: (next) => {
+        options.workspace.addDirectoryPrompt = next;
+      },
+      getRepositoryPrompt: () => options.workspace.repositoryPrompt,
+      setRepositoryPrompt: (next) => {
+        options.workspace.repositoryPrompt = next;
+      },
+    });
+  }
+
+  routeModalInput(input: Buffer): boolean {
+    return this.inputRouter.routeModalInput(input);
+  }
+}

package/src/services/runtime-navigation-input.ts

@@ -0,0 +1,207 @@
+import type { WorkspaceModel } from '../domain/workspace.ts';
+import type { resolveMuxShortcutBindings } from '../mux/input-shortcuts.ts';
+import { GlobalShortcutInput } from '../ui/global-shortcut-input.ts';
+import { LeftNavInput } from '../ui/left-nav-input.ts';
+import { RepositoryFoldInput } from '../ui/repository-fold-input.ts';
+
+type LeftNavInputOptions = ConstructorParameters<typeof LeftNavInput>[0];
+type RepositoryFoldInputOptions = ConstructorParameters<typeof RepositoryFoldInput>[0];
+type GlobalShortcutInputOptions = ConstructorParameters<typeof GlobalShortcutInput>[0];
+
+type MainPaneMode = 'conversation' | 'project' | 'home';
+
+interface RuntimeNavigationWorkspaceActions {
+  activateConversation(sessionId: string): Promise<void>;
+  openOrCreateCritiqueConversationInDirectory(directoryId: string): Promise<void>;
+  toggleGatewayProfiler(): Promise<void>;
+  toggleGatewayStatusTimeline(): Promise<void>;
+  toggleGatewayRenderTrace(conversationId: string | null): Promise<void>;
+  archiveConversation(sessionId: string): Promise<void>;
+  interruptConversation(sessionId: string): Promise<void>;
+  takeoverConversation(sessionId: string): Promise<void>;
+  closeDirectory(directoryId: string): Promise<void>;
+}
+
+interface RuntimeNavigationInputOptions {
+  readonly workspace: WorkspaceModel;
+  readonly shortcutBindings: ReturnType<typeof resolveMuxShortcutBindings>;
+  readonly requestStop: () => void;
+  readonly resolveDirectoryForAction: () => string | null;
+  readonly openNewThreadPrompt: (directoryId: string) => void;
+  readonly toggleCommandMenu: () => void;
+  readonly openAddDirectoryPrompt: () => void;
+  readonly queueControlPlaneOp: (task: () => Promise<void>, label: string) => void;
+  readonly firstDirectoryForRepositoryGroup: (repositoryGroupId: string) => string | null;
+  readonly enterHomePane: () => void;
+  readonly enterProjectPane: (directoryId: string) => void;
+  readonly markDirty: () => void;
+  readonly conversations: ReadonlyMap<string, { directoryId: string | null }>;
+  readonly repositoryGroupIdForDirectory: (directoryId: string) => string;
+  readonly collapseRepositoryGroup: (repositoryGroupId: string) => void;
+  readonly expandRepositoryGroup: (repositoryGroupId: string) => void;
+  readonly collapseAllRepositoryGroups: () => void;
+  readonly expandAllRepositoryGroups: () => void;
+  readonly directoriesHas: (directoryId: string) => boolean;
+  readonly conversationDirectoryId: (sessionId: string) => string | null;
+  readonly conversationsHas: (sessionId: string) => boolean;
+  readonly getMainPaneMode: () => MainPaneMode;
+  readonly getActiveConversationId: () => string | null;
+  readonly getActiveDirectoryId: () => string | null;
+  readonly forwardInterruptAllToActiveConversation?: (input: Buffer) => boolean;
+  readonly interruptAllDoubleTapWindowMs?: number;
+  readonly workspaceActions: RuntimeNavigationWorkspaceActions;
+  readonly chordTimeoutMs: number;
+  readonly collapseAllChordPrefix: Buffer;
+  readonly nowMs?: () => number;
+}
+
+interface RuntimeNavigationInputDependencies {
+  readonly createLeftNavInput?: (
+    options: LeftNavInputOptions,
+  ) => Pick<LeftNavInput, 'cycleSelection'>;
+  readonly createRepositoryFoldInput?: (
+    options: RepositoryFoldInputOptions,
+  ) => Pick<RepositoryFoldInput, 'handleRepositoryFoldChords' | 'handleRepositoryTreeArrow'>;
+  readonly createGlobalShortcutInput?: (
+    options: GlobalShortcutInputOptions,
+  ) => Pick<GlobalShortcutInput, 'handleInput'>;
+}
+
+export class RuntimeNavigationInput {
+  private readonly leftNavInput: Pick<LeftNavInput, 'cycleSelection'>;
+  private readonly repositoryFoldInput: Pick<
+    RepositoryFoldInput,
+    'handleRepositoryFoldChords' | 'handleRepositoryTreeArrow'
+  >;
+  private readonly globalShortcutInput: Pick<GlobalShortcutInput, 'handleInput'>;
+
+  constructor(
+    options: RuntimeNavigationInputOptions,
+    dependencies: RuntimeNavigationInputDependencies = {},
+  ) {
+    const nowMs = options.nowMs ?? (() => Date.now());
+    const createLeftNavInput =
+      dependencies.createLeftNavInput ??
+      ((leftNavOptions: LeftNavInputOptions) => new LeftNavInput(leftNavOptions));
+    const createRepositoryFoldInput =
+      dependencies.createRepositoryFoldInput ??
+      ((repositoryFoldOptions: RepositoryFoldInputOptions) =>
+        new RepositoryFoldInput(repositoryFoldOptions));
+    const createGlobalShortcutInput =
+      dependencies.createGlobalShortcutInput ??
+      ((globalShortcutOptions: GlobalShortcutInputOptions) =>
+        new GlobalShortcutInput(globalShortcutOptions));
+    const selectLeftNavRepository = options.workspace.selectLeftNavRepository.bind(
+      options.workspace,
+    );
+
+    this.leftNavInput = createLeftNavInput({
+      getLatestRailRows: () => options.workspace.latestRailViewRows,
+      getCurrentSelection: () => options.workspace.leftNavSelection,
+      enterHomePane: options.enterHomePane,
+      firstDirectoryForRepositoryGroup: options.firstDirectoryForRepositoryGroup,
+      enterProjectPane: options.enterProjectPane,
+      setMainPaneProjectMode: () => {
+        options.workspace.mainPaneMode = 'project';
+      },
+      selectLeftNavRepository,
+      markDirty: options.markDirty,
+      directoriesHas: options.directoriesHas,
+      conversationDirectoryId: options.conversationDirectoryId,
+      queueControlPlaneOp: options.queueControlPlaneOp,
+      activateConversation: async (sessionId) => {
+        await options.workspaceActions.activateConversation(sessionId);
+      },
+      conversationsHas: options.conversationsHas,
+    });
+
+    this.repositoryFoldInput = createRepositoryFoldInput({
+      getLeftNavSelection: () => options.workspace.leftNavSelection,
+      getRepositoryToggleChordPrefixAtMs: () => options.workspace.repositoryToggleChordPrefixAtMs,
+      setRepositoryToggleChordPrefixAtMs: (value) => {
+        options.workspace.repositoryToggleChordPrefixAtMs = value;
+      },
+      conversations: options.conversations,
+      repositoryGroupIdForDirectory: options.repositoryGroupIdForDirectory,
+      collapseRepositoryGroup: options.collapseRepositoryGroup,
+      expandRepositoryGroup: options.expandRepositoryGroup,
+      collapseAllRepositoryGroups: options.collapseAllRepositoryGroups,
+      expandAllRepositoryGroups: options.expandAllRepositoryGroups,
+      selectLeftNavRepository,
+      markDirty: options.markDirty,
+      chordTimeoutMs: options.chordTimeoutMs,
+      collapseAllChordPrefix: options.collapseAllChordPrefix,
+      nowMs,
+    });
+
+    const globalShortcutOptions: GlobalShortcutInputOptions = {
+      shortcutBindings: options.shortcutBindings,
+      requestStop: options.requestStop,
+      resolveDirectoryForAction: options.resolveDirectoryForAction,
+      openNewThreadPrompt: options.openNewThreadPrompt,
+      toggleCommandMenu: options.toggleCommandMenu,
+      openOrCreateCritiqueConversationInDirectory: async (directoryId) => {
+        await options.workspaceActions.openOrCreateCritiqueConversationInDirectory(directoryId);
+      },
+      toggleGatewayProfile: async () => {
+        await options.workspaceActions.toggleGatewayProfiler();
+      },
+      toggleGatewayStatusTimeline: async () => {
+        await options.workspaceActions.toggleGatewayStatusTimeline();
+      },
+      toggleGatewayRenderTrace: async (conversationId) => {
+        await options.workspaceActions.toggleGatewayRenderTrace(conversationId);
+      },
+      getMainPaneMode: options.getMainPaneMode,
+      getActiveConversationId: options.getActiveConversationId,
+      conversationsHas: options.conversationsHas,
+      queueControlPlaneOp: options.queueControlPlaneOp,
+      archiveConversation: async (sessionId) => {
+        await options.workspaceActions.archiveConversation(sessionId);
+      },
+      interruptConversation: async (sessionId) => {
+        await options.workspaceActions.interruptConversation(sessionId);
+      },
+      takeoverConversation: async (sessionId) => {
+        await options.workspaceActions.takeoverConversation(sessionId);
+      },
+      openAddDirectoryPrompt: options.openAddDirectoryPrompt,
+      getActiveDirectoryId: options.getActiveDirectoryId,
+      directoryExists: options.directoriesHas,
+      closeDirectory: async (directoryId) => {
+        await options.workspaceActions.closeDirectory(directoryId);
+      },
+      cycleLeftNavSelection: (direction) => {
+        this.leftNavInput.cycleSelection(direction);
+      },
+      nowMs,
+      ...(options.forwardInterruptAllToActiveConversation === undefined
+        ? {}
+        : {
+            forwardInterruptAllToActiveConversation:
+              options.forwardInterruptAllToActiveConversation,
+          }),
+      ...(options.interruptAllDoubleTapWindowMs === undefined
+        ? {}
+        : {
+            interruptAllDoubleTapWindowMs: options.interruptAllDoubleTapWindowMs,
+          }),
+    };
+    this.globalShortcutInput = createGlobalShortcutInput(globalShortcutOptions);
+  }
+
+  cycleLeftNavSelection(direction: 'next' | 'previous'): boolean {
+    return this.leftNavInput.cycleSelection(direction);
+  }
+
+  handleRepositoryFoldInput(input: Buffer): boolean {
+    return (
+      this.repositoryFoldInput.handleRepositoryFoldChords(input) ||
+      this.repositoryFoldInput.handleRepositoryTreeArrow(input)
+    );
+  }
+
+  handleGlobalShortcutInput(input: Buffer): boolean {
+    return this.globalShortcutInput.handleInput(input);
+  }
+}

package/src/services/runtime-process-wiring.ts

@@ -0,0 +1,68 @@
+interface RuntimeProcessTarget {
+  readonly stdin: Pick<NodeJS.ReadStream, 'on' | 'off'>;
+  readonly stdout: Pick<NodeJS.WriteStream, 'on' | 'off'>;
+  once(event: 'SIGINT' | 'SIGTERM', listener: () => void): RuntimeProcessTarget;
+  once(event: 'uncaughtException', listener: (error: Error) => void): RuntimeProcessTarget;
+  once(event: 'unhandledRejection', listener: (reason: unknown) => void): RuntimeProcessTarget;
+  off(event: 'SIGINT' | 'SIGTERM', listener: () => void): RuntimeProcessTarget;
+  off(event: 'uncaughtException', listener: (error: Error) => void): RuntimeProcessTarget;
+  off(event: 'unhandledRejection', listener: (reason: unknown) => void): RuntimeProcessTarget;
+}
+
+interface RuntimeProcessWiringOptions {
+  readonly onInput: (chunk: Buffer) => void;
+  readonly onResize: () => void;
+  readonly requestStop: () => void;
+  readonly handleRuntimeFatal: (origin: string, error: unknown) => void;
+  readonly target?: RuntimeProcessTarget;
+}
+
+export class RuntimeProcessWiring {
+  private readonly target: RuntimeProcessTarget;
+
+  constructor(private readonly options: RuntimeProcessWiringOptions) {
+    this.target = options.target ?? process;
+  }
+
+  attach(): void {
+    this.target.stdin.on('data', this.onInputSafe);
+    this.target.stdout.on('resize', this.onResizeSafe);
+    this.target.once('SIGINT', this.options.requestStop);
+    this.target.once('SIGTERM', this.options.requestStop);
+    this.target.once('uncaughtException', this.onUncaughtException);
+    this.target.once('unhandledRejection', this.onUnhandledRejection);
+  }
+
+  detach(): void {
+    this.target.stdin.off('data', this.onInputSafe);
+    this.target.stdout.off('resize', this.onResizeSafe);
+    this.target.off('SIGINT', this.options.requestStop);
+    this.target.off('SIGTERM', this.options.requestStop);
+    this.target.off('uncaughtException', this.onUncaughtException);
+    this.target.off('unhandledRejection', this.onUnhandledRejection);
+  }
+
+  private readonly onInputSafe = (chunk: Buffer): void => {
+    try {
+      this.options.onInput(chunk);
+    } catch (error: unknown) {
+      this.options.handleRuntimeFatal('stdin-data', error);
+    }
+  };
+
+  private readonly onResizeSafe = (): void => {
+    try {
+      this.options.onResize();
+    } catch (error: unknown) {
+      this.options.handleRuntimeFatal('stdout-resize', error);
+    }
+  };
+
+  private readonly onUncaughtException = (error: Error): void => {
+    this.options.handleRuntimeFatal('uncaught-exception', error);
+  };
+
+  private readonly onUnhandledRejection = (reason: unknown): void => {
+    this.options.handleRuntimeFatal('unhandled-rejection', reason);
+  };
+}

package/src/services/runtime-rail-input.ts

@@ -0,0 +1,287 @@
+import type { WorkspaceModel } from '../domain/workspace.ts';
+import type { resolveMuxShortcutBindings } from '../mux/input-shortcuts.ts';
+import { LeftRailPointerInput } from '../ui/left-rail-pointer-input.ts';
+import { RuntimeNavigationInput } from './runtime-navigation-input.ts';
+
+type MainPaneMode = 'conversation' | 'project' | 'home';
+type RuntimeNavigationInputOptions = ConstructorParameters<typeof RuntimeNavigationInput>[0];
+type LeftRailPointerInputOptions = ConstructorParameters<typeof LeftRailPointerInput>[0];
+type LeftRailPointerClickInput = Parameters<LeftRailPointerInput['handlePointerClick']>[0];
+
+interface RuntimeRailWorkspaceActions {
+  activateConversation(sessionId: string): Promise<void>;
+  openOrCreateCritiqueConversationInDirectory(directoryId: string): Promise<void>;
+  toggleGatewayProfiler(): Promise<void>;
+  toggleGatewayStatusTimeline(): Promise<void>;
+  toggleGatewayRenderTrace(conversationId: string | null): Promise<void>;
+  archiveConversation(sessionId: string): Promise<void>;
+  interruptConversation(sessionId: string): Promise<void>;
+  takeoverConversation(sessionId: string): Promise<void>;
+  closeDirectory(directoryId: string): Promise<void>;
+  openRepositoryPromptForCreate(): void;
+  openRepositoryPromptForEdit(repositoryId: string): void;
+  archiveRepositoryById(repositoryId: string): Promise<void>;
+}
+
+interface RuntimeRailInputOptions {
+  readonly workspace: WorkspaceModel;
+  readonly shortcutBindings: ReturnType<typeof resolveMuxShortcutBindings>;
+  readonly queueControlPlaneOp: (task: () => Promise<void>, label: string) => void;
+  readonly runtimeWorkspaceActions: RuntimeRailWorkspaceActions;
+  readonly requestStop: () => void;
+  readonly resolveDirectoryForAction: () => string | null;
+  readonly openNewThreadPrompt: (directoryId: string) => void;
+  readonly toggleCommandMenu: () => void;
+  readonly firstDirectoryForRepositoryGroup: (repositoryGroupId: string) => string | null;
+  readonly enterHomePane: () => void;
+  readonly enterProjectPane: (directoryId: string) => void;
+  readonly markDirty: () => void;
+  readonly queuePersistMuxUiState: () => void;
+  readonly conversations: RuntimeNavigationInputOptions['conversations'];
+  readonly repositoryGroupIdForDirectory: RuntimeNavigationInputOptions['repositoryGroupIdForDirectory'];
+  readonly toggleRepositoryGroup: (repositoryGroupId: string) => void;
+  readonly collapseRepositoryGroup: RuntimeNavigationInputOptions['collapseRepositoryGroup'];
+  readonly expandRepositoryGroup: RuntimeNavigationInputOptions['expandRepositoryGroup'];
+  readonly collapseAllRepositoryGroups: RuntimeNavigationInputOptions['collapseAllRepositoryGroups'];
+  readonly expandAllRepositoryGroups: RuntimeNavigationInputOptions['expandAllRepositoryGroups'];
+  readonly directoriesHas: RuntimeNavigationInputOptions['directoriesHas'];
+  readonly conversationDirectoryId: RuntimeNavigationInputOptions['conversationDirectoryId'];
+  readonly conversationsHas: RuntimeNavigationInputOptions['conversationsHas'];
+  readonly getMainPaneMode: () => MainPaneMode;
+  readonly getActiveConversationId: () => string | null;
+  readonly getActiveDirectoryId: () => string | null;
+  readonly forwardInterruptAllToActiveConversation?: (input: Buffer) => boolean;
+  readonly interruptAllDoubleTapWindowMs?: number;
+  readonly repositoriesHas: (repositoryId: string) => boolean;
+  readonly chordTimeoutMs: number;
+  readonly collapseAllChordPrefix: Buffer;
+  readonly stopConversationTitleEdit: (persistPending: boolean) => void;
+  readonly releaseViewportPinForSelection: () => void;
+  readonly beginConversationTitleEdit: (conversationId: string) => void;
+  readonly resetConversationPaneFrameCache: () => void;
+  readonly conversationTitleEditDoubleClickWindowMs: number;
+  readonly nowMs?: () => number;
+}
+
+interface RuntimeRailInputDependencies {
+  readonly createRuntimeNavigationInput?: (
+    options: RuntimeNavigationInputOptions,
+  ) => Pick<
+    RuntimeNavigationInput,
+    'cycleLeftNavSelection' | 'handleRepositoryFoldInput' | 'handleGlobalShortcutInput'
+  >;
+  readonly createLeftRailPointerInput?: (
+    options: LeftRailPointerInputOptions,
+  ) => Pick<LeftRailPointerInput, 'handlePointerClick'>;
+}
+
+export class RuntimeRailInput {
+  private readonly navigationInput: Pick<
+    RuntimeNavigationInput,
+    'cycleLeftNavSelection' | 'handleRepositoryFoldInput' | 'handleGlobalShortcutInput'
+  >;
+  private readonly leftRailPointerInput: Pick<LeftRailPointerInput, 'handlePointerClick'>;
+
+  constructor(
+    private readonly options: RuntimeRailInputOptions,
+    dependencies: RuntimeRailInputDependencies = {},
+  ) {
+    const nowMs = options.nowMs ?? (() => Date.now());
+    const createRuntimeNavigationInput =
+      dependencies.createRuntimeNavigationInput ??
+      ((navigationOptions: RuntimeNavigationInputOptions) =>
+        new RuntimeNavigationInput(navigationOptions));
+    const createLeftRailPointerInput =
+      dependencies.createLeftRailPointerInput ??
+      ((leftRailOptions: LeftRailPointerInputOptions) => new LeftRailPointerInput(leftRailOptions));
+
+    const runtimeNavigationOptions: RuntimeNavigationInputOptions = {
+      workspace: options.workspace,
+      shortcutBindings: options.shortcutBindings,
+      requestStop: options.requestStop,
+      resolveDirectoryForAction: options.resolveDirectoryForAction,
+      openNewThreadPrompt: options.openNewThreadPrompt,
+      toggleCommandMenu: options.toggleCommandMenu,
+      openAddDirectoryPrompt: () => {
+        this.openAddDirectoryPrompt();
+        options.markDirty();
+      },
+      queueControlPlaneOp: options.queueControlPlaneOp,
+      firstDirectoryForRepositoryGroup: options.firstDirectoryForRepositoryGroup,
+      enterHomePane: options.enterHomePane,
+      enterProjectPane: options.enterProjectPane,
+      markDirty: options.markDirty,
+      conversations: options.conversations,
+      repositoryGroupIdForDirectory: options.repositoryGroupIdForDirectory,
+      collapseRepositoryGroup: options.collapseRepositoryGroup,
+      expandRepositoryGroup: options.expandRepositoryGroup,
+      collapseAllRepositoryGroups: options.collapseAllRepositoryGroups,
+      expandAllRepositoryGroups: options.expandAllRepositoryGroups,
+      directoriesHas: options.directoriesHas,
+      conversationDirectoryId: options.conversationDirectoryId,
+      conversationsHas: options.conversationsHas,
+      getMainPaneMode: options.getMainPaneMode,
+      getActiveConversationId: options.getActiveConversationId,
+      getActiveDirectoryId: options.getActiveDirectoryId,
+      workspaceActions: {
+        activateConversation: async (sessionId) => {
+          await options.runtimeWorkspaceActions.activateConversation(sessionId);
+        },
+        openOrCreateCritiqueConversationInDirectory: async (directoryId) => {
+          await options.runtimeWorkspaceActions.openOrCreateCritiqueConversationInDirectory(
+            directoryId,
+          );
+        },
+        toggleGatewayProfiler: async () => {
+          await options.runtimeWorkspaceActions.toggleGatewayProfiler();
+        },
+        toggleGatewayStatusTimeline: async () => {
+          await options.runtimeWorkspaceActions.toggleGatewayStatusTimeline();
+        },
+        toggleGatewayRenderTrace: async (conversationId) => {
+          await options.runtimeWorkspaceActions.toggleGatewayRenderTrace(conversationId);
+        },
+        archiveConversation: async (sessionId) => {
+          await options.runtimeWorkspaceActions.archiveConversation(sessionId);
+        },
+        interruptConversation: async (sessionId) => {
+          await options.runtimeWorkspaceActions.interruptConversation(sessionId);
+        },
+        takeoverConversation: async (sessionId) => {
+          await options.runtimeWorkspaceActions.takeoverConversation(sessionId);
+        },
+        closeDirectory: async (directoryId) => {
+          await options.runtimeWorkspaceActions.closeDirectory(directoryId);
+        },
+      },
+      chordTimeoutMs: options.chordTimeoutMs,
+      collapseAllChordPrefix: options.collapseAllChordPrefix,
+      nowMs,
+      ...(options.forwardInterruptAllToActiveConversation === undefined
+        ? {}
+        : {
+            forwardInterruptAllToActiveConversation:
+              options.forwardInterruptAllToActiveConversation,
+          }),
+      ...(options.interruptAllDoubleTapWindowMs === undefined
+        ? {}
+        : {
+            interruptAllDoubleTapWindowMs: options.interruptAllDoubleTapWindowMs,
+          }),
+    };
+    this.navigationInput = createRuntimeNavigationInput(runtimeNavigationOptions);
+
+    this.leftRailPointerInput = createLeftRailPointerInput({
+      getLatestRailRows: () => options.workspace.latestRailViewRows,
+      hasConversationTitleEdit: () => options.workspace.conversationTitleEdit !== null,
+      conversationTitleEditConversationId: () =>
+        options.workspace.conversationTitleEdit?.conversationId ?? null,
+      stopConversationTitleEdit: () => {
+        options.stopConversationTitleEdit(true);
+      },
+      hasSelection: () =>
+        options.workspace.selection !== null || options.workspace.selectionDrag !== null,
+      clearSelection: () => {
+        options.workspace.selection = null;
+        options.workspace.selectionDrag = null;
+        options.releaseViewportPinForSelection();
+      },
+      activeConversationId: options.getActiveConversationId,
+      repositoriesCollapsed: () => options.workspace.repositoriesCollapsed,
+      clearConversationTitleEditClickState: () => {
+        options.workspace.conversationTitleEditClickState = null;
+      },
+      resolveDirectoryForAction: options.resolveDirectoryForAction,
+      openNewThreadPrompt: options.openNewThreadPrompt,
+      queueArchiveConversation: (conversationId) => {
+        options.queueControlPlaneOp(async () => {
+          await options.runtimeWorkspaceActions.archiveConversation(conversationId);
+        }, 'mouse-archive-conversation');
+      },
+      openAddDirectoryPrompt: () => {
+        this.openAddDirectoryPrompt();
+      },
+      openRepositoryPromptForCreate: () => {
+        options.runtimeWorkspaceActions.openRepositoryPromptForCreate();
+      },
+      repositoryExists: options.repositoriesHas,
+      openRepositoryPromptForEdit: (repositoryId) => {
+        options.runtimeWorkspaceActions.openRepositoryPromptForEdit(repositoryId);
+      },
+      queueArchiveRepository: (repositoryId) => {
+        options.queueControlPlaneOp(async () => {
+          await options.runtimeWorkspaceActions.archiveRepositoryById(repositoryId);
+        }, 'mouse-archive-repository');
+      },
+      queueCloseDirectory: (directoryId) => {
+        options.queueControlPlaneOp(async () => {
+          await options.runtimeWorkspaceActions.closeDirectory(directoryId);
+        }, 'mouse-close-directory');
+      },
+      toggleRepositoryGroup: options.toggleRepositoryGroup,
+      selectLeftNavRepository: (repositoryGroupId) => {
+        options.workspace.selectLeftNavRepository(repositoryGroupId);
+      },
+      expandAllRepositoryGroups: options.expandAllRepositoryGroups,
+      collapseAllRepositoryGroups: options.collapseAllRepositoryGroups,
+      enterHomePane: options.enterHomePane,
+      toggleShortcutsCollapsed: () => {
+        options.workspace.shortcutsCollapsed = !options.workspace.shortcutsCollapsed;
+        options.queuePersistMuxUiState();
+      },
+      previousConversationClickState: () => options.workspace.conversationTitleEditClickState,
+      setConversationClickState: (next) => {
+        options.workspace.conversationTitleEditClickState = next;
+      },
+      nowMs,
+      conversationTitleEditDoubleClickWindowMs: options.conversationTitleEditDoubleClickWindowMs,
+      isConversationPaneActive: () => options.getMainPaneMode() === 'conversation',
+      ensureConversationPaneActive: (conversationId) => {
+        options.workspace.mainPaneMode = 'conversation';
+        options.workspace.selectLeftNavConversation(conversationId);
+        options.workspace.projectPaneSnapshot = null;
+        options.workspace.projectPaneScrollTop = 0;
+        options.resetConversationPaneFrameCache();
+      },
+      beginConversationTitleEdit: options.beginConversationTitleEdit,
+      queueActivateConversation: (conversationId) => {
+        options.queueControlPlaneOp(async () => {
+          await options.runtimeWorkspaceActions.activateConversation(conversationId);
+        }, 'mouse-activate-conversation');
+      },
+      queueActivateConversationAndEdit: (conversationId) => {
+        options.queueControlPlaneOp(async () => {
+          await options.runtimeWorkspaceActions.activateConversation(conversationId);
+          options.beginConversationTitleEdit(conversationId);
+        }, 'mouse-activate-edit-conversation');
+      },
+      directoriesHas: options.directoriesHas,
+      enterProjectPane: options.enterProjectPane,
+      markDirty: options.markDirty,
+    });
+  }
+
+  cycleLeftNavSelection(direction: 'next' | 'previous'): boolean {
+    return this.navigationInput.cycleLeftNavSelection(direction);
+  }
+
+  handleRepositoryFoldInput(input: Buffer): boolean {
+    return this.navigationInput.handleRepositoryFoldInput(input);
+  }
+
+  handleGlobalShortcutInput(input: Buffer): boolean {
+    return this.navigationInput.handleGlobalShortcutInput(input);
+  }
+
+  handlePointerClick(input: LeftRailPointerClickInput): boolean {
+    return this.leftRailPointerInput.handlePointerClick(input);
+  }
+
+  private openAddDirectoryPrompt(): void {
+    this.options.workspace.repositoryPrompt = null;
+    this.options.workspace.addDirectoryPrompt = {
+      value: '',
+      error: null,
+    };
+  }
+}