@jmoyers/harness 0.1.0

package/src/services/runtime-envelope-handler.ts

@@ -0,0 +1,198 @@
+import type {
+  StreamObservedEvent,
+  StreamServerEnvelope,
+} from '../control-plane/stream-protocol.ts';
+import type { PtyExit } from '../pty/pty_host.ts';
+
+interface RuntimeEnvelopeConversationLike {
+  directoryId: string | null;
+  agentType: string;
+  adapterState: Record<string, unknown>;
+  scope: unknown;
+  lastEventAt: string | null;
+}
+
+interface RuntimeEnvelopeOutputIngestResult<TConversation extends RuntimeEnvelopeConversationLike> {
+  readonly conversation: TConversation;
+  readonly cursorRegressed: boolean;
+  readonly previousCursor: number;
+}
+
+interface RuntimeEnvelopeHandlerOptions<
+  TConversation extends RuntimeEnvelopeConversationLike,
+  TNormalizedEvent extends { ts: string },
+> {
+  readonly perfNowNs: () => bigint;
+  readonly isRemoved: (sessionId: string) => boolean;
+  readonly ensureConversation: (sessionId: string) => TConversation;
+  readonly ingestOutputChunk: (input: {
+    sessionId: string;
+    cursor: number;
+    chunk: Buffer;
+    ensureConversation: (sessionId: string) => TConversation;
+  }) => RuntimeEnvelopeOutputIngestResult<TConversation>;
+  readonly noteGitActivity: (directoryId: string | null) => void;
+  readonly recordOutputChunk: (input: {
+    sessionId: string;
+    chunkLength: number;
+    active: boolean;
+  }) => void;
+  readonly startupOutputChunk: (sessionId: string, chunkLength: number) => void;
+  readonly startupPaintOutputChunk: (sessionId: string) => void;
+  readonly recordPerfEvent: (
+    name: string,
+    attrs: Record<string, string | number | boolean>,
+  ) => void;
+  readonly mapTerminalOutputToNormalizedEvent: (
+    chunk: Buffer,
+    scope: unknown,
+    idFactory: () => string,
+  ) => TNormalizedEvent;
+  readonly mapSessionEventToNormalizedEvent: (
+    event: unknown,
+    scope: unknown,
+    idFactory: () => string,
+  ) => TNormalizedEvent | null;
+  readonly observedAtFromSessionEvent: (event: unknown) => string;
+  readonly mergeAdapterStateFromSessionEvent: (
+    agentType: string,
+    adapterState: Record<string, unknown>,
+    event: unknown,
+    observedAt: string,
+  ) => Record<string, unknown> | null;
+  readonly enqueueEvent: (event: TNormalizedEvent) => void;
+  readonly activeConversationId: () => string | null;
+  readonly markSessionExited: (input: {
+    sessionId: string;
+    exit: PtyExit;
+    exitedAt: string;
+  }) => void;
+  readonly deletePtySize: (sessionId: string) => void;
+  readonly setExit: (exit: PtyExit) => void;
+  readonly markDirty: () => void;
+  readonly nowIso: () => string;
+  readonly recordOutputHandled: (durationMs: number) => void;
+  readonly conversationById: (sessionId: string) => TConversation | undefined;
+  readonly applyObservedWorkspaceEvent: (event: StreamObservedEvent) => void;
+  readonly applyObservedGitStatusEvent: (event: StreamObservedEvent) => void;
+  readonly applyObservedTaskPlanningEvent: (event: StreamObservedEvent) => void;
+  readonly idFactory: () => string;
+}
+
+export class RuntimeEnvelopeHandler<
+  TConversation extends RuntimeEnvelopeConversationLike,
+  TNormalizedEvent extends { ts: string },
+> {
+  constructor(
+    private readonly options: RuntimeEnvelopeHandlerOptions<TConversation, TNormalizedEvent>,
+  ) {}
+
+  handleEnvelope(envelope: StreamServerEnvelope): void {
+    if (envelope.kind === 'pty.output') {
+      const outputHandledStartedAtNs = this.options.perfNowNs();
+      if (this.options.isRemoved(envelope.sessionId)) {
+        return;
+      }
+      const chunk = Buffer.from(envelope.chunkBase64, 'base64');
+      const outputIngest = this.options.ingestOutputChunk({
+        sessionId: envelope.sessionId,
+        cursor: envelope.cursor,
+        chunk,
+        ensureConversation: this.options.ensureConversation,
+      });
+      const conversation = outputIngest.conversation;
+      this.options.noteGitActivity(conversation.directoryId);
+      this.options.recordOutputChunk({
+        sessionId: envelope.sessionId,
+        chunkLength: chunk.length,
+        active: this.options.activeConversationId() === envelope.sessionId,
+      });
+      this.options.startupOutputChunk(envelope.sessionId, chunk.length);
+      this.options.startupPaintOutputChunk(envelope.sessionId);
+      if (outputIngest.cursorRegressed) {
+        this.options.recordPerfEvent('mux.output.cursor-regression', {
+          sessionId: envelope.sessionId,
+          previousCursor: outputIngest.previousCursor,
+          cursor: envelope.cursor,
+        });
+      }
+
+      const normalized = this.options.mapTerminalOutputToNormalizedEvent(
+        chunk,
+        conversation.scope,
+        this.options.idFactory,
+      );
+      this.options.enqueueEvent(normalized);
+      conversation.lastEventAt = normalized.ts;
+      if (this.options.activeConversationId() === envelope.sessionId) {
+        this.options.markDirty();
+      }
+      const outputHandledDurationMs =
+        Number(this.options.perfNowNs() - outputHandledStartedAtNs) / 1e6;
+      this.options.recordOutputHandled(outputHandledDurationMs);
+      return;
+    }
+
+    if (envelope.kind === 'pty.event') {
+      if (this.options.isRemoved(envelope.sessionId)) {
+        return;
+      }
+      const conversation = this.options.ensureConversation(envelope.sessionId);
+      this.options.noteGitActivity(conversation.directoryId);
+      const observedAt = this.options.observedAtFromSessionEvent(envelope.event);
+      const updatedAdapterState = this.options.mergeAdapterStateFromSessionEvent(
+        conversation.agentType,
+        conversation.adapterState,
+        envelope.event,
+        observedAt,
+      );
+      if (updatedAdapterState !== null) {
+        conversation.adapterState = updatedAdapterState;
+      }
+      const normalized = this.options.mapSessionEventToNormalizedEvent(
+        envelope.event,
+        conversation.scope,
+        this.options.idFactory,
+      );
+      if (normalized !== null) {
+        this.options.enqueueEvent(normalized);
+      }
+      if (envelope.event.type === 'session-exit') {
+        this.options.setExit(envelope.event.exit);
+        this.options.markSessionExited({
+          sessionId: envelope.sessionId,
+          exit: envelope.event.exit,
+          exitedAt: this.options.nowIso(),
+        });
+        this.options.deletePtySize(envelope.sessionId);
+      }
+      this.options.markDirty();
+      return;
+    }
+
+    if (envelope.kind === 'pty.exit') {
+      if (this.options.isRemoved(envelope.sessionId)) {
+        return;
+      }
+      const conversation = this.options.conversationById(envelope.sessionId);
+      if (conversation !== undefined) {
+        this.options.noteGitActivity(conversation.directoryId);
+        this.options.setExit(envelope.exit);
+        this.options.markSessionExited({
+          sessionId: envelope.sessionId,
+          exit: envelope.exit,
+          exitedAt: this.options.nowIso(),
+        });
+        this.options.deletePtySize(envelope.sessionId);
+      }
+      this.options.markDirty();
+      return;
+    }
+
+    if (envelope.kind === 'stream.event') {
+      this.options.applyObservedWorkspaceEvent(envelope.event);
+      this.options.applyObservedGitStatusEvent(envelope.event);
+      this.options.applyObservedTaskPlanningEvent(envelope.event);
+    }
+  }
+}

package/src/services/runtime-git-state.ts

@@ -0,0 +1,92 @@
+import type { StreamObservedEvent } from '../control-plane/stream-protocol.ts';
+import {
+  applyObservedGitStatusEvent as applyObservedGitStatusEventFn,
+  deleteDirectoryGitState as deleteDirectoryGitStateFn,
+  type GitRepositorySnapshot,
+  type GitSummary,
+} from '../mux/live-mux/git-state.ts';
+
+interface RepositoryRecordShape {
+  readonly repositoryId: string;
+  readonly name: string;
+  readonly remoteUrl: string;
+  readonly defaultBranch: string;
+  readonly archivedAt: string | null;
+}
+
+interface RuntimeGitStateDirectoryManager {
+  hasDirectory(directoryId: string): boolean;
+  ensureGitSummary(directoryId: string, loadingSummary: GitSummary): void;
+  syncGitSummariesWithDirectories(loadingSummary: GitSummary): void;
+  mutableGitSummaries(): Map<string, GitSummary>;
+}
+
+interface RuntimeGitStateOptions<TRepositoryRecord extends RepositoryRecordShape> {
+  readonly enabled: boolean;
+  readonly directoryManager: RuntimeGitStateDirectoryManager;
+  readonly directoryRepositorySnapshotByDirectoryId: Map<string, GitRepositorySnapshot>;
+  readonly repositoryAssociationByDirectoryId: Map<string, string>;
+  readonly repositories: Map<string, TRepositoryRecord>;
+  readonly parseRepositoryRecord: (input: unknown) => TRepositoryRecord | null;
+  readonly loadingSummary: GitSummary;
+  readonly emptyRepositorySnapshot: GitRepositorySnapshot;
+  readonly syncRepositoryAssociationsWithDirectorySnapshots: () => void;
+  readonly syncTaskPaneRepositorySelection: () => void;
+  readonly markDirty: () => void;
+}
+
+export class RuntimeGitState<TRepositoryRecord extends RepositoryRecordShape> {
+  constructor(private readonly options: RuntimeGitStateOptions<TRepositoryRecord>) {}
+
+  deleteDirectoryGitState(directoryId: string): void {
+    deleteDirectoryGitStateFn(
+      directoryId,
+      this.options.directoryManager.mutableGitSummaries(),
+      this.options.directoryRepositorySnapshotByDirectoryId,
+      this.options.repositoryAssociationByDirectoryId,
+    );
+  }
+
+  syncGitStateWithDirectories(): void {
+    this.options.directoryManager.syncGitSummariesWithDirectories(this.options.loadingSummary);
+    this.options.syncRepositoryAssociationsWithDirectorySnapshots();
+  }
+
+  noteGitActivity(directoryId: string | null): void {
+    if (directoryId === null || !this.options.directoryManager.hasDirectory(directoryId)) {
+      return;
+    }
+    this.options.directoryManager.ensureGitSummary(directoryId, this.options.loadingSummary);
+  }
+
+  applyObservedGitStatusEvent(observed: StreamObservedEvent): void {
+    const reduced = applyObservedGitStatusEventFn({
+      enabled: this.options.enabled,
+      observed,
+      gitSummaryByDirectoryId: this.options.directoryManager.mutableGitSummaries(),
+      loadingSummary: this.options.loadingSummary,
+      directoryRepositorySnapshotByDirectoryId:
+        this.options.directoryRepositorySnapshotByDirectoryId,
+      emptyRepositorySnapshot: this.options.emptyRepositorySnapshot,
+      repositoryAssociationByDirectoryId: this.options.repositoryAssociationByDirectoryId,
+      repositories: this.options.repositories,
+      parseRepositoryRecord: this.options.parseRepositoryRecord,
+      repositoryRecordChanged: (previous, repository) =>
+        previous === undefined ||
+        previous.name !== repository.name ||
+        previous.remoteUrl !== repository.remoteUrl ||
+        previous.defaultBranch !== repository.defaultBranch ||
+        previous.archivedAt !== repository.archivedAt,
+    });
+    if (!reduced.handled) {
+      return;
+    }
+    if (reduced.repositoryRecordChanged) {
+      this.options.syncRepositoryAssociationsWithDirectorySnapshots();
+      this.options.syncTaskPaneRepositorySelection();
+    }
+    if (reduced.changed) {
+      this.options.markDirty();
+    }
+  }
+}

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

@@ -0,0 +1,50 @@
+import { ConversationInputForwarder } from '../ui/conversation-input-forwarder.ts';
+import { InputPreflight } from '../ui/input-preflight.ts';
+
+type InputPreflightOptions = ConstructorParameters<typeof InputPreflight>[0];
+type ConversationInputForwarderOptions = ConstructorParameters<
+  typeof ConversationInputForwarder
+>[0];
+
+interface RuntimeInputPipelineOptions {
+  readonly preflight: InputPreflightOptions;
+  readonly forwarder: ConversationInputForwarderOptions;
+}
+
+interface RuntimeInputPipelineDependencies {
+  readonly createInputPreflight?: (
+    options: InputPreflightOptions,
+  ) => Pick<InputPreflight, 'nextInput'>;
+  readonly createConversationInputForwarder?: (
+    options: ConversationInputForwarderOptions,
+  ) => Pick<ConversationInputForwarder, 'handleInput'>;
+}
+
+export class RuntimeInputPipeline {
+  private readonly inputPreflight: Pick<InputPreflight, 'nextInput'>;
+  private readonly conversationInputForwarder: Pick<ConversationInputForwarder, 'handleInput'>;
+
+  constructor(
+    options: RuntimeInputPipelineOptions,
+    dependencies: RuntimeInputPipelineDependencies = {},
+  ) {
+    const createInputPreflight =
+      dependencies.createInputPreflight ??
+      ((preflightOptions: InputPreflightOptions) => new InputPreflight(preflightOptions));
+    const createConversationInputForwarder =
+      dependencies.createConversationInputForwarder ??
+      ((forwarderOptions: ConversationInputForwarderOptions) =>
+        new ConversationInputForwarder(forwarderOptions));
+
+    this.inputPreflight = createInputPreflight(options.preflight);
+    this.conversationInputForwarder = createConversationInputForwarder(options.forwarder);
+  }
+
+  handleInput(input: Buffer): void {
+    const sanitized = this.inputPreflight.nextInput(input);
+    if (sanitized === null) {
+      return;
+    }
+    this.conversationInputForwarder.handleInput(sanitized);
+  }
+}

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

@@ -0,0 +1,202 @@
+import { RuntimeMainPaneInput } from './runtime-main-pane-input.ts';
+import { RuntimeModalInput } from './runtime-modal-input.ts';
+import { RuntimeRailInput } from './runtime-rail-input.ts';
+import type { CommandMenuActionDescriptor } from '../mux/live-mux/command-menu.ts';
+
+type RuntimeModalInputOptions = ConstructorParameters<typeof RuntimeModalInput>[0];
+type RuntimeRailInputOptions = ConstructorParameters<typeof RuntimeRailInput>[0];
+type RuntimeMainPaneInputOptions = ConstructorParameters<typeof RuntimeMainPaneInput>[0];
+type RuntimeMainPaneInputWithoutLeftRail = Omit<
+  RuntimeMainPaneInputOptions,
+  'leftRailPointerInput'
+>;
+type RuntimeWorkspaceActions = RuntimeModalInputOptions['workspaceActions'] &
+  RuntimeRailInputOptions['runtimeWorkspaceActions'] &
+  RuntimeMainPaneInputWithoutLeftRail['workspaceActions'];
+type RuntimeTaskEditorActions = RuntimeModalInputOptions['taskEditorActions'];
+type RuntimeShortcutBindings = RuntimeRailInputOptions['shortcutBindings'];
+type RuntimeConversationRecord = {
+  title: string;
+  directoryId: string | null;
+};
+
+interface RuntimeInputRouterOptions {
+  readonly workspace: RuntimeModalInputOptions['workspace'];
+  readonly conversations: ReadonlyMap<string, RuntimeConversationRecord>;
+  readonly runtimeWorkspaceActions: RuntimeWorkspaceActions;
+  readonly runtimeTaskEditorActions: RuntimeTaskEditorActions;
+  readonly detectShortcut: (input: Buffer, bindings: RuntimeShortcutBindings) => string | null;
+  readonly modalDismissShortcutBindings: RuntimeShortcutBindings;
+  readonly shortcutBindings: RuntimeShortcutBindings;
+  readonly dismissOnOutsideClick: RuntimeModalInputOptions['dismissOnOutsideClick'];
+  readonly buildCommandMenuModalOverlay: RuntimeModalInputOptions['buildCommandMenuModalOverlay'];
+  readonly buildConversationTitleModalOverlay: RuntimeModalInputOptions['buildConversationTitleModalOverlay'];
+  readonly buildNewThreadModalOverlay: RuntimeModalInputOptions['buildNewThreadModalOverlay'];
+  readonly resolveNewThreadPromptAgentByRow: RuntimeModalInputOptions['resolveNewThreadPromptAgentByRow'];
+  readonly stopConversationTitleEdit: (persistPending: boolean) => void;
+  readonly queueControlPlaneOp: RuntimeModalInputOptions['queueControlPlaneOp'];
+  readonly normalizeGitHubRemoteUrl: RuntimeModalInputOptions['normalizeGitHubRemoteUrl'];
+  readonly repositoriesHas: (repositoryId: string) => boolean;
+  readonly markDirty: () => void;
+  readonly scheduleConversationTitlePersist: () => void;
+  readonly resolveCommandMenuActions: () => readonly CommandMenuActionDescriptor[];
+  readonly executeCommandMenuAction: (actionId: string) => void;
+  readonly requestStop: RuntimeRailInputOptions['requestStop'];
+  readonly resolveDirectoryForAction: RuntimeRailInputOptions['resolveDirectoryForAction'];
+  readonly toggleCommandMenu: RuntimeRailInputOptions['toggleCommandMenu'];
+  readonly openNewThreadPrompt: RuntimeRailInputOptions['openNewThreadPrompt'];
+  readonly firstDirectoryForRepositoryGroup: RuntimeRailInputOptions['firstDirectoryForRepositoryGroup'];
+  readonly enterHomePane: RuntimeRailInputOptions['enterHomePane'];
+  readonly enterProjectPane: RuntimeRailInputOptions['enterProjectPane'];
+  readonly queuePersistMuxUiState: RuntimeRailInputOptions['queuePersistMuxUiState'];
+  readonly repositoryGroupIdForDirectory: RuntimeRailInputOptions['repositoryGroupIdForDirectory'];
+  readonly toggleRepositoryGroup: RuntimeRailInputOptions['toggleRepositoryGroup'];
+  readonly collapseRepositoryGroup: RuntimeRailInputOptions['collapseRepositoryGroup'];
+  readonly expandRepositoryGroup: RuntimeRailInputOptions['expandRepositoryGroup'];
+  readonly collapseAllRepositoryGroups: RuntimeRailInputOptions['collapseAllRepositoryGroups'];
+  readonly expandAllRepositoryGroups: RuntimeRailInputOptions['expandAllRepositoryGroups'];
+  readonly directoriesHas: RuntimeRailInputOptions['directoriesHas'];
+  readonly conversationDirectoryId: RuntimeRailInputOptions['conversationDirectoryId'];
+  readonly conversationsHas: RuntimeRailInputOptions['conversationsHas'];
+  readonly getMainPaneMode: RuntimeRailInputOptions['getMainPaneMode'];
+  readonly getActiveConversationId: RuntimeRailInputOptions['getActiveConversationId'];
+  readonly getActiveDirectoryId: RuntimeRailInputOptions['getActiveDirectoryId'];
+  readonly forwardInterruptAllToActiveConversation?: RuntimeRailInputOptions['forwardInterruptAllToActiveConversation'];
+  readonly interruptAllDoubleTapWindowMs?: RuntimeRailInputOptions['interruptAllDoubleTapWindowMs'];
+  readonly chordTimeoutMs: RuntimeRailInputOptions['chordTimeoutMs'];
+  readonly collapseAllChordPrefix: RuntimeRailInputOptions['collapseAllChordPrefix'];
+  readonly releaseViewportPinForSelection: RuntimeRailInputOptions['releaseViewportPinForSelection'];
+  readonly beginConversationTitleEdit: RuntimeRailInputOptions['beginConversationTitleEdit'];
+  readonly resetConversationPaneFrameCache: RuntimeRailInputOptions['resetConversationPaneFrameCache'];
+  readonly conversationTitleEditDoubleClickWindowMs: RuntimeRailInputOptions['conversationTitleEditDoubleClickWindowMs'];
+  readonly projectPaneActionAtRow: RuntimeMainPaneInputWithoutLeftRail['projectPaneActionAtRow'];
+  readonly queueCloseDirectory: RuntimeMainPaneInputWithoutLeftRail['queueCloseDirectory'];
+  readonly selectTaskById: RuntimeMainPaneInputWithoutLeftRail['selectTaskById'];
+  readonly selectRepositoryById: RuntimeMainPaneInputWithoutLeftRail['selectRepositoryById'];
+  readonly taskPaneActionAtCell: RuntimeMainPaneInputWithoutLeftRail['taskPaneActionAtCell'];
+  readonly taskPaneActionAtRow: RuntimeMainPaneInputWithoutLeftRail['taskPaneActionAtRow'];
+  readonly taskPaneTaskIdAtRow: RuntimeMainPaneInputWithoutLeftRail['taskPaneTaskIdAtRow'];
+  readonly taskPaneRepositoryIdAtRow: RuntimeMainPaneInputWithoutLeftRail['taskPaneRepositoryIdAtRow'];
+  readonly applyPaneDividerAtCol: RuntimeMainPaneInputWithoutLeftRail['applyPaneDividerAtCol'];
+  readonly pinViewportForSelection: RuntimeMainPaneInputWithoutLeftRail['pinViewportForSelection'];
+  readonly homePaneEditDoubleClickWindowMs: RuntimeMainPaneInputWithoutLeftRail['homePaneEditDoubleClickWindowMs'];
+}
+
+export class RuntimeInputRouter {
+  private readonly modalInput: RuntimeModalInput;
+  private readonly railInput: RuntimeRailInput;
+  private readonly mainPaneInput: RuntimeMainPaneInput;
+
+  constructor(options: RuntimeInputRouterOptions) {
+    this.modalInput = new RuntimeModalInput({
+      workspace: options.workspace,
+      conversations: options.conversations,
+      workspaceActions: options.runtimeWorkspaceActions,
+      taskEditorActions: options.runtimeTaskEditorActions,
+      isModalDismissShortcut: (input) =>
+        options.detectShortcut(input, options.modalDismissShortcutBindings) === 'mux.app.quit',
+      isCommandMenuToggleShortcut: (input) =>
+        options.detectShortcut(input, options.shortcutBindings) === 'mux.command-menu.toggle',
+      isArchiveConversationShortcut: (input) => {
+        const action = options.detectShortcut(input, options.shortcutBindings);
+        return action === 'mux.conversation.archive' || action === 'mux.conversation.delete';
+      },
+      dismissOnOutsideClick: options.dismissOnOutsideClick,
+      buildCommandMenuModalOverlay: options.buildCommandMenuModalOverlay,
+      buildConversationTitleModalOverlay: options.buildConversationTitleModalOverlay,
+      buildNewThreadModalOverlay: options.buildNewThreadModalOverlay,
+      resolveNewThreadPromptAgentByRow: options.resolveNewThreadPromptAgentByRow,
+      stopConversationTitleEdit: options.stopConversationTitleEdit,
+      queueControlPlaneOp: options.queueControlPlaneOp,
+      normalizeGitHubRemoteUrl: options.normalizeGitHubRemoteUrl,
+      repositoriesHas: options.repositoriesHas,
+      markDirty: options.markDirty,
+      scheduleConversationTitlePersist: options.scheduleConversationTitlePersist,
+      resolveCommandMenuActions: options.resolveCommandMenuActions,
+      executeCommandMenuAction: options.executeCommandMenuAction,
+    });
+    const runtimeRailOptions: RuntimeRailInputOptions = {
+      workspace: options.workspace,
+      shortcutBindings: options.shortcutBindings,
+      queueControlPlaneOp: options.queueControlPlaneOp,
+      runtimeWorkspaceActions: options.runtimeWorkspaceActions,
+      requestStop: options.requestStop,
+      resolveDirectoryForAction: options.resolveDirectoryForAction,
+      openNewThreadPrompt: options.openNewThreadPrompt,
+      toggleCommandMenu: options.toggleCommandMenu,
+      firstDirectoryForRepositoryGroup: options.firstDirectoryForRepositoryGroup,
+      enterHomePane: options.enterHomePane,
+      enterProjectPane: options.enterProjectPane,
+      markDirty: options.markDirty,
+      queuePersistMuxUiState: options.queuePersistMuxUiState,
+      conversations: options.conversations,
+      repositoryGroupIdForDirectory: options.repositoryGroupIdForDirectory,
+      toggleRepositoryGroup: options.toggleRepositoryGroup,
+      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,
+      repositoriesHas: options.repositoriesHas,
+      chordTimeoutMs: options.chordTimeoutMs,
+      collapseAllChordPrefix: options.collapseAllChordPrefix,
+      stopConversationTitleEdit: options.stopConversationTitleEdit,
+      releaseViewportPinForSelection: options.releaseViewportPinForSelection,
+      beginConversationTitleEdit: options.beginConversationTitleEdit,
+      resetConversationPaneFrameCache: options.resetConversationPaneFrameCache,
+      conversationTitleEditDoubleClickWindowMs: options.conversationTitleEditDoubleClickWindowMs,
+      ...(options.forwardInterruptAllToActiveConversation === undefined
+        ? {}
+        : {
+            forwardInterruptAllToActiveConversation:
+              options.forwardInterruptAllToActiveConversation,
+          }),
+      ...(options.interruptAllDoubleTapWindowMs === undefined
+        ? {}
+        : {
+            interruptAllDoubleTapWindowMs: options.interruptAllDoubleTapWindowMs,
+          }),
+    };
+    this.railInput = new RuntimeRailInput(runtimeRailOptions);
+    this.mainPaneInput = new RuntimeMainPaneInput({
+      workspace: options.workspace,
+      workspaceActions: options.runtimeWorkspaceActions,
+      projectPaneActionAtRow: options.projectPaneActionAtRow,
+      openNewThreadPrompt: options.openNewThreadPrompt,
+      queueCloseDirectory: options.queueCloseDirectory,
+      selectTaskById: options.selectTaskById,
+      selectRepositoryById: options.selectRepositoryById,
+      taskPaneActionAtCell: options.taskPaneActionAtCell,
+      taskPaneActionAtRow: options.taskPaneActionAtRow,
+      taskPaneTaskIdAtRow: options.taskPaneTaskIdAtRow,
+      taskPaneRepositoryIdAtRow: options.taskPaneRepositoryIdAtRow,
+      applyPaneDividerAtCol: options.applyPaneDividerAtCol,
+      pinViewportForSelection: options.pinViewportForSelection,
+      releaseViewportPinForSelection: options.releaseViewportPinForSelection,
+      markDirty: options.markDirty,
+      homePaneEditDoubleClickWindowMs: options.homePaneEditDoubleClickWindowMs,
+      leftRailPointerInput: this.railInput,
+    });
+  }
+
+  routeModalInput(input: Buffer): boolean {
+    return this.modalInput.routeModalInput(input);
+  }
+
+  handleRepositoryFoldInput(input: Buffer): boolean {
+    return this.railInput.handleRepositoryFoldInput(input);
+  }
+
+  handleGlobalShortcutInput(input: Buffer): boolean {
+    return this.railInput.handleGlobalShortcutInput(input);
+  }
+
+  inputTokenRouter(): Pick<RuntimeMainPaneInput, 'routeTokens'> {
+    return this.mainPaneInput;
+  }
+}