@jmoyers/harness 0.1.0

package/src/services/runtime-task-pane-actions.ts

@@ -0,0 +1,198 @@
+import type { WorkspaceModel } from '../domain/workspace.ts';
+import type { TaskPaneAction } from '../mux/harness-core-ui.ts';
+import { runTaskPaneAction as runTaskPaneActionFrame } from '../mux/live-mux/actions-task.ts';
+
+interface TaskRecordShape {
+  readonly taskId: string;
+  readonly repositoryId: string | null;
+  readonly status: string;
+}
+
+interface RuntimeTaskPaneActionService<TTaskRecord extends TaskRecordShape> {
+  reorderTasks(orderedTaskIds: readonly string[]): Promise<readonly TTaskRecord[]>;
+  deleteTask(taskId: string): Promise<unknown>;
+  taskReady(taskId: string): Promise<TTaskRecord>;
+  taskDraft(taskId: string): Promise<TTaskRecord>;
+  taskComplete(taskId: string): Promise<TTaskRecord>;
+}
+
+interface RuntimeTaskPaneActionsOptions<TTaskRecord extends TaskRecordShape> {
+  readonly workspace: WorkspaceModel;
+  readonly controlPlaneService: RuntimeTaskPaneActionService<TTaskRecord>;
+  readonly repositoriesHas: (repositoryId: string) => boolean;
+  readonly setTask: (task: TTaskRecord) => void;
+  readonly getTask: (taskId: string) => TTaskRecord | undefined;
+  readonly taskReorderPayloadIds: (orderedActiveTaskIds: readonly string[]) => readonly string[];
+  readonly reorderedActiveTaskIdsForDrop: (
+    draggedTaskId: string,
+    targetTaskId: string,
+  ) => readonly string[] | 'cannot-reorder-completed' | null;
+  readonly clearTaskAutosaveTimer: (taskId: string) => void;
+  readonly deleteTask: (taskId: string) => void;
+  readonly deleteTaskComposer: (taskId: string) => void;
+  readonly focusDraftComposer: () => void;
+  readonly focusTaskComposer: (taskId: string) => void;
+  readonly selectedTask: () => TTaskRecord | null;
+  readonly orderedTaskRecords: () => readonly TTaskRecord[];
+  readonly queueControlPlaneOp: (task: () => Promise<void>, label?: string) => void;
+  readonly syncTaskPaneSelection: () => void;
+  readonly syncTaskPaneRepositorySelection: () => void;
+  readonly openRepositoryPromptForCreate: () => void;
+  readonly openRepositoryPromptForEdit: (repositoryId: string) => void;
+  readonly archiveRepositoryById: (repositoryId: string) => Promise<void>;
+  readonly markDirty: () => void;
+  readonly runTaskPaneAction?: typeof runTaskPaneActionFrame;
+}
+
+export class RuntimeTaskPaneActions<TTaskRecord extends TaskRecordShape> {
+  private readonly runTaskPaneActionFn: typeof runTaskPaneActionFrame;
+
+  constructor(private readonly options: RuntimeTaskPaneActionsOptions<TTaskRecord>) {
+    this.runTaskPaneActionFn = options.runTaskPaneAction ?? runTaskPaneActionFrame;
+  }
+
+  openTaskCreatePrompt(): void {
+    const repositoryId = this.options.workspace.taskPaneSelectedRepositoryId;
+    if (repositoryId === null || !this.options.repositoriesHas(repositoryId)) {
+      this.options.workspace.taskPaneNotice = 'select a repository first';
+      this.options.markDirty();
+      return;
+    }
+    this.options.focusDraftComposer();
+    this.options.workspace.taskPaneNotice = null;
+    this.options.markDirty();
+  }
+
+  openTaskEditPrompt(taskId: string): void {
+    const task = this.options.getTask(taskId);
+    if (task === undefined) {
+      return;
+    }
+    if (task.repositoryId !== null) {
+      this.options.workspace.taskPaneSelectedRepositoryId = task.repositoryId;
+    }
+    this.options.focusTaskComposer(task.taskId);
+    this.options.workspace.taskPaneNotice = null;
+    this.options.markDirty();
+  }
+
+  applyTaskRecord(task: TTaskRecord): TTaskRecord {
+    this.options.setTask(task);
+    this.options.workspace.taskPaneSelectedTaskId = task.taskId;
+    if (task.repositoryId !== null && this.options.repositoriesHas(task.repositoryId)) {
+      this.options.workspace.taskPaneSelectedRepositoryId = task.repositoryId;
+    }
+    this.options.workspace.taskPaneSelectionFocus = 'task';
+    this.options.syncTaskPaneSelection();
+    this.options.markDirty();
+    return task;
+  }
+
+  applyTaskList(tasks: readonly TTaskRecord[]): boolean {
+    let changed = false;
+    for (const task of tasks) {
+      this.options.setTask(task);
+      changed = true;
+    }
+    if (changed) {
+      this.options.syncTaskPaneSelection();
+      this.options.markDirty();
+    }
+    return changed;
+  }
+
+  queueTaskReorderByIds(orderedActiveTaskIds: readonly string[], label: string): void {
+    this.options.queueControlPlaneOp(async () => {
+      const tasks = await this.options.controlPlaneService.reorderTasks(
+        this.options.taskReorderPayloadIds(orderedActiveTaskIds),
+      );
+      this.applyTaskList(tasks);
+    }, label);
+  }
+
+  reorderTaskByDrop(draggedTaskId: string, targetTaskId: string): void {
+    const reordered = this.options.reorderedActiveTaskIdsForDrop(draggedTaskId, targetTaskId);
+    if (reordered === 'cannot-reorder-completed') {
+      this.options.workspace.taskPaneNotice = 'cannot reorder completed tasks';
+      this.options.markDirty();
+      return;
+    }
+    if (reordered === null) {
+      return;
+    }
+    this.queueTaskReorderByIds(reordered, 'tasks-reorder-drag');
+  }
+
+  runTaskPaneAction(action: TaskPaneAction): void {
+    this.runTaskPaneActionFn({
+      action,
+      openTaskCreatePrompt: () => {
+        this.openTaskCreatePrompt();
+      },
+      openRepositoryPromptForCreate: () => {
+        this.options.openRepositoryPromptForCreate();
+      },
+      selectedRepositoryId: this.options.workspace.taskPaneSelectedRepositoryId,
+      repositoryExists: (repositoryId) => this.options.repositoriesHas(repositoryId),
+      setTaskPaneNotice: (notice) => {
+        this.options.workspace.taskPaneNotice = notice;
+      },
+      markDirty: () => {
+        this.options.markDirty();
+      },
+      setTaskPaneSelectionFocus: (focus) => {
+        this.options.workspace.taskPaneSelectionFocus = focus;
+      },
+      openRepositoryPromptForEdit: (repositoryId) => {
+        this.options.openRepositoryPromptForEdit(repositoryId);
+      },
+      queueArchiveRepository: (repositoryId) => {
+        this.options.queueControlPlaneOp(async () => {
+          await this.options.archiveRepositoryById(repositoryId);
+          this.options.syncTaskPaneRepositorySelection();
+        }, 'tasks-archive-repository');
+      },
+      selectedTask: this.options.selectedTask(),
+      openTaskEditPrompt: (taskId) => {
+        this.openTaskEditPrompt(taskId);
+      },
+      queueDeleteTask: (taskId) => {
+        this.options.queueControlPlaneOp(async () => {
+          this.options.clearTaskAutosaveTimer(taskId);
+          await this.options.controlPlaneService.deleteTask(taskId);
+          this.options.deleteTask(taskId);
+          this.options.deleteTaskComposer(taskId);
+          if (
+            this.options.workspace.taskEditorTarget.kind === 'task' &&
+            this.options.workspace.taskEditorTarget.taskId === taskId
+          ) {
+            this.options.workspace.taskEditorTarget = {
+              kind: 'draft',
+            };
+          }
+          this.options.syncTaskPaneSelection();
+          this.options.markDirty();
+        }, 'tasks-delete');
+      },
+      queueTaskReady: (taskId) => {
+        this.options.queueControlPlaneOp(async () => {
+          this.applyTaskRecord(await this.options.controlPlaneService.taskReady(taskId));
+        }, 'tasks-ready');
+      },
+      queueTaskDraft: (taskId) => {
+        this.options.queueControlPlaneOp(async () => {
+          this.applyTaskRecord(await this.options.controlPlaneService.taskDraft(taskId));
+        }, 'tasks-draft');
+      },
+      queueTaskComplete: (taskId) => {
+        this.options.queueControlPlaneOp(async () => {
+          this.applyTaskRecord(await this.options.controlPlaneService.taskComplete(taskId));
+        }, 'tasks-complete');
+      },
+      orderedTaskRecords: () => this.options.orderedTaskRecords(),
+      queueTaskReorderByIds: (orderedTaskIds, label) => {
+        this.queueTaskReorderByIds(orderedTaskIds, label);
+      },
+    });
+  }
+}

package/src/services/runtime-task-pane-shortcuts.ts

@@ -0,0 +1,189 @@
+import type { WorkspaceModel } from '../domain/workspace.ts';
+import {
+  createTaskComposerBuffer as createTaskComposerBufferFrame,
+  normalizeTaskComposerBuffer as normalizeTaskComposerBufferFrame,
+  taskFieldsFromComposerText as taskFieldsFromComposerTextFrame,
+  type TaskComposerBuffer,
+} from '../mux/task-composer.ts';
+import { handleTaskPaneShortcutInput as handleTaskPaneShortcutInputFrame } from '../mux/live-mux/task-pane-shortcuts.ts';
+import type { ResolvedTaskScreenKeybindings } from '../mux/task-screen-keybindings.ts';
+
+type TaskPaneShortcutAction = Parameters<
+  Parameters<typeof handleTaskPaneShortcutInputFrame>[0]['runTaskPaneAction']
+>[0];
+
+interface TaskRecordShape {
+  readonly taskId: string;
+  readonly repositoryId: string | null;
+  readonly title: string;
+  readonly description: string;
+}
+
+interface RuntimeTaskPaneShortcutsOptions<TTaskRecord extends TaskRecordShape> {
+  readonly workspace: WorkspaceModel;
+  readonly taskScreenKeybindings: ResolvedTaskScreenKeybindings;
+  readonly repositoriesHas: (repositoryId: string) => boolean;
+  readonly activeRepositoryIds: () => readonly string[];
+  readonly selectRepositoryById: (repositoryId: string) => void;
+  readonly taskComposerForTask: (taskId: string) => TaskComposerBuffer | null;
+  readonly setTaskComposerForTask: (taskId: string, buffer: TaskComposerBuffer) => void;
+  readonly scheduleTaskComposerPersist: (taskId: string) => void;
+  readonly selectedRepositoryTaskRecords: () => readonly TTaskRecord[];
+  readonly focusTaskComposer: (taskId: string) => void;
+  readonly focusDraftComposer: () => void;
+  readonly runTaskPaneAction: (action: TaskPaneShortcutAction) => void;
+  readonly queueControlPlaneOp: (task: () => Promise<void>, label?: string) => void;
+  readonly createTask: (payload: {
+    repositoryId: string;
+    title: string;
+    description: string;
+  }) => Promise<TTaskRecord>;
+  readonly applyTaskRecord: (task: TTaskRecord) => void;
+  readonly syncTaskPaneSelection: () => void;
+  readonly markDirty: () => void;
+  readonly createTaskComposerBuffer?: typeof createTaskComposerBufferFrame;
+  readonly normalizeTaskComposerBuffer?: typeof normalizeTaskComposerBufferFrame;
+  readonly taskFieldsFromComposerText?: typeof taskFieldsFromComposerTextFrame;
+  readonly handleTaskPaneShortcutInput?: typeof handleTaskPaneShortcutInputFrame;
+}
+
+export class RuntimeTaskPaneShortcuts<TTaskRecord extends TaskRecordShape> {
+  private readonly createTaskComposerBuffer: typeof createTaskComposerBufferFrame;
+  private readonly normalizeTaskComposerBuffer: typeof normalizeTaskComposerBufferFrame;
+  private readonly taskFieldsFromComposerText: typeof taskFieldsFromComposerTextFrame;
+  private readonly handleTaskPaneShortcutInput: typeof handleTaskPaneShortcutInputFrame;
+
+  constructor(private readonly options: RuntimeTaskPaneShortcutsOptions<TTaskRecord>) {
+    this.createTaskComposerBuffer =
+      options.createTaskComposerBuffer ?? createTaskComposerBufferFrame;
+    this.normalizeTaskComposerBuffer =
+      options.normalizeTaskComposerBuffer ?? normalizeTaskComposerBufferFrame;
+    this.taskFieldsFromComposerText =
+      options.taskFieldsFromComposerText ?? taskFieldsFromComposerTextFrame;
+    this.handleTaskPaneShortcutInput =
+      options.handleTaskPaneShortcutInput ?? handleTaskPaneShortcutInputFrame;
+  }
+
+  homeEditorBuffer(): TaskComposerBuffer {
+    const taskEditorTarget = this.options.workspace.taskEditorTarget;
+    if (taskEditorTarget.kind === 'task') {
+      return (
+        this.options.taskComposerForTask(taskEditorTarget.taskId) ??
+        this.createTaskComposerBuffer('')
+      );
+    }
+    return this.options.workspace.taskDraftComposer;
+  }
+
+  updateHomeEditorBuffer(next: TaskComposerBuffer): void {
+    const taskEditorTarget = this.options.workspace.taskEditorTarget;
+    if (taskEditorTarget.kind === 'task') {
+      this.options.setTaskComposerForTask(taskEditorTarget.taskId, next);
+      this.options.scheduleTaskComposerPersist(taskEditorTarget.taskId);
+    } else {
+      this.options.workspace.taskDraftComposer = this.normalizeTaskComposerBuffer(next);
+    }
+    this.options.markDirty();
+  }
+
+  selectRepositoryByDirection(direction: 1 | -1): void {
+    const orderedIds = this.options.activeRepositoryIds();
+    if (orderedIds.length === 0) {
+      return;
+    }
+    const currentIndex = Math.max(
+      0,
+      orderedIds.indexOf(this.options.workspace.taskPaneSelectedRepositoryId ?? ''),
+    );
+    const nextIndex = Math.max(0, Math.min(orderedIds.length - 1, currentIndex + direction));
+    const nextRepositoryId = orderedIds[nextIndex];
+    if (nextRepositoryId !== undefined) {
+      this.options.selectRepositoryById(nextRepositoryId);
+    }
+  }
+
+  submitDraftTaskFromComposer(): void {
+    const repositoryId = this.options.workspace.taskPaneSelectedRepositoryId;
+    if (repositoryId === null || !this.options.repositoriesHas(repositoryId)) {
+      this.options.workspace.taskPaneNotice = 'select a repository first';
+      this.options.markDirty();
+      return;
+    }
+    const fields = this.taskFieldsFromComposerText(this.options.workspace.taskDraftComposer.text);
+    if (fields.title.length === 0) {
+      this.options.workspace.taskPaneNotice = 'first line is required';
+      this.options.markDirty();
+      return;
+    }
+    this.options.queueControlPlaneOp(async () => {
+      const task = await this.options.createTask({
+        repositoryId,
+        title: fields.title,
+        description: fields.description,
+      });
+      this.options.applyTaskRecord(task);
+      this.options.workspace.taskDraftComposer = this.createTaskComposerBuffer('');
+      this.options.workspace.taskPaneNotice = null;
+      this.options.syncTaskPaneSelection();
+      this.options.markDirty();
+    }, 'task-composer-create');
+  }
+
+  moveTaskEditorFocusUp(): void {
+    const workspace = this.options.workspace;
+    const scopedTasks = this.options.selectedRepositoryTaskRecords();
+    if (workspace.taskEditorTarget.kind === 'draft') {
+      const fallback = scopedTasks[scopedTasks.length - 1];
+      if (fallback !== undefined) {
+        this.options.focusTaskComposer(fallback.taskId);
+      }
+      return;
+    }
+
+    const focusedTaskId = workspace.taskEditorTarget.taskId;
+    const index = scopedTasks.findIndex((task) => task.taskId === focusedTaskId);
+    if (index <= 0) {
+      return;
+    }
+    const target = scopedTasks[index - 1];
+    if (target !== undefined) {
+      this.options.focusTaskComposer(target.taskId);
+    }
+  }
+
+  handleInput(input: Buffer): boolean {
+    const workspace = this.options.workspace;
+    return this.handleTaskPaneShortcutInput({
+      input,
+      mainPaneMode: workspace.mainPaneMode,
+      taskScreenKeybindings: this.options.taskScreenKeybindings,
+      taskEditorTarget: workspace.taskEditorTarget,
+      homeEditorBuffer: () => this.homeEditorBuffer(),
+      updateHomeEditorBuffer: (next) => {
+        this.updateHomeEditorBuffer(next);
+      },
+      moveTaskEditorFocusUp: () => {
+        this.moveTaskEditorFocusUp();
+      },
+      focusDraftComposer: () => {
+        this.options.focusDraftComposer();
+      },
+      submitDraftTaskFromComposer: () => {
+        this.submitDraftTaskFromComposer();
+      },
+      runTaskPaneAction: (action) => {
+        this.options.runTaskPaneAction(action);
+      },
+      selectRepositoryByDirection: (direction) => {
+        this.selectRepositoryByDirection(direction);
+      },
+      getTaskRepositoryDropdownOpen: () => workspace.taskRepositoryDropdownOpen,
+      setTaskRepositoryDropdownOpen: (open) => {
+        workspace.taskRepositoryDropdownOpen = open;
+      },
+      markDirty: () => {
+        this.options.markDirty();
+      },
+    });
+  }
+}

package/src/services/runtime-task-pane.ts

@@ -0,0 +1,62 @@
+import type { TaskPaneAction } from '../mux/harness-core-ui.ts';
+import { RuntimeTaskPaneActions } from './runtime-task-pane-actions.ts';
+import { RuntimeTaskPaneShortcuts } from './runtime-task-pane-shortcuts.ts';
+
+interface TaskRecordShape {
+  readonly taskId: string;
+  readonly repositoryId: string | null;
+  readonly status: string;
+  readonly title: string;
+  readonly description: string;
+}
+
+type RuntimeTaskPaneActionsOptions<TTaskRecord extends TaskRecordShape> = ConstructorParameters<
+  typeof RuntimeTaskPaneActions<TTaskRecord>
+>[0];
+type RuntimeTaskPaneShortcutsOptions<TTaskRecord extends TaskRecordShape> = Omit<
+  ConstructorParameters<typeof RuntimeTaskPaneShortcuts<TTaskRecord>>[0],
+  'runTaskPaneAction' | 'applyTaskRecord'
+>;
+
+interface RuntimeTaskPaneOptions<TTaskRecord extends TaskRecordShape> {
+  readonly actions: RuntimeTaskPaneActionsOptions<TTaskRecord>;
+  readonly shortcuts: RuntimeTaskPaneShortcutsOptions<TTaskRecord>;
+}
+
+export class RuntimeTaskPane<TTaskRecord extends TaskRecordShape> {
+  private readonly actions: RuntimeTaskPaneActions<TTaskRecord>;
+  private readonly shortcuts: RuntimeTaskPaneShortcuts<TTaskRecord>;
+
+  constructor(options: RuntimeTaskPaneOptions<TTaskRecord>) {
+    this.actions = new RuntimeTaskPaneActions<TTaskRecord>(options.actions);
+    this.shortcuts = new RuntimeTaskPaneShortcuts<TTaskRecord>({
+      ...options.shortcuts,
+      runTaskPaneAction: (action) => {
+        this.runTaskPaneAction(action);
+      },
+      applyTaskRecord: (task) => {
+        this.applyTaskRecord(task);
+      },
+    });
+  }
+
+  applyTaskRecord(task: TTaskRecord): TTaskRecord {
+    return this.actions.applyTaskRecord(task);
+  }
+
+  runTaskPaneAction(action: TaskPaneAction): void {
+    this.actions.runTaskPaneAction(action);
+  }
+
+  openTaskEditPrompt(taskId: string): void {
+    this.actions.openTaskEditPrompt(taskId);
+  }
+
+  reorderTaskByDrop(draggedTaskId: string, targetTaskId: string): void {
+    this.actions.reorderTaskByDrop(draggedTaskId, targetTaskId);
+  }
+
+  handleInput(input: Buffer): boolean {
+    return this.shortcuts.handleInput(input);
+  }
+}

package/src/services/runtime-workspace-actions.ts

@@ -0,0 +1,153 @@
+import type { TaskPaneAction } from '../mux/harness-core-ui.ts';
+
+interface RuntimeWorkspaceConversationActions {
+  activateConversation(sessionId: string): Promise<void>;
+  createAndActivateConversationInDirectory(directoryId: string, agentType: string): Promise<void>;
+  openOrCreateCritiqueConversationInDirectory(directoryId: string): Promise<void>;
+  takeoverConversation(sessionId: string): Promise<void>;
+}
+
+interface RuntimeWorkspaceDirectoryActions {
+  archiveConversation(sessionId: string): Promise<void>;
+  addDirectoryByPath(rawPath: string): Promise<void>;
+  closeDirectory(directoryId: string): Promise<void>;
+}
+
+interface RuntimeWorkspaceRepositoryActions {
+  openRepositoryPromptForCreate(): void;
+  openRepositoryPromptForEdit(repositoryId: string): void;
+  reorderRepositoryByDrop(
+    draggedRepositoryId: string,
+    targetRepositoryId: string,
+    orderedRepositoryIds: readonly string[],
+  ): void;
+  upsertRepositoryByRemoteUrl(remoteUrl: string, existingRepositoryId?: string): Promise<void>;
+  archiveRepositoryById(repositoryId: string): Promise<void>;
+}
+
+interface RuntimeWorkspaceControlActions {
+  interruptConversation(sessionId: string): Promise<void>;
+  toggleGatewayProfiler(): Promise<void>;
+  toggleGatewayStatusTimeline(): Promise<void>;
+  toggleGatewayRenderTrace(conversationId: string | null): Promise<void>;
+}
+
+interface RuntimeWorkspaceTaskPaneActions {
+  runTaskPaneAction(action: TaskPaneAction): void;
+  openTaskEditPrompt(taskId: string): void;
+  reorderTaskByDrop(draggedTaskId: string, targetTaskId: string): void;
+}
+
+interface RuntimeWorkspaceTaskPaneShortcuts {
+  handleInput(input: Buffer): boolean;
+}
+
+interface RuntimeWorkspaceActionsOptions {
+  readonly conversationActions: RuntimeWorkspaceConversationActions;
+  readonly directoryActions: RuntimeWorkspaceDirectoryActions;
+  readonly repositoryActions: RuntimeWorkspaceRepositoryActions;
+  readonly controlActions: RuntimeWorkspaceControlActions;
+  readonly taskPaneActions: RuntimeWorkspaceTaskPaneActions;
+  readonly taskPaneShortcuts: RuntimeWorkspaceTaskPaneShortcuts;
+  readonly orderedActiveRepositoryIds: () => readonly string[];
+}
+
+export class RuntimeWorkspaceActions {
+  constructor(private readonly options: RuntimeWorkspaceActionsOptions) {}
+
+  async activateConversation(sessionId: string): Promise<void> {
+    await this.options.conversationActions.activateConversation(sessionId);
+  }
+
+  async createAndActivateConversationInDirectory(
+    directoryId: string,
+    agentType: string,
+  ): Promise<void> {
+    await this.options.conversationActions.createAndActivateConversationInDirectory(
+      directoryId,
+      agentType,
+    );
+  }
+
+  async openOrCreateCritiqueConversationInDirectory(directoryId: string): Promise<void> {
+    await this.options.conversationActions.openOrCreateCritiqueConversationInDirectory(directoryId);
+  }
+
+  async takeoverConversation(sessionId: string): Promise<void> {
+    await this.options.conversationActions.takeoverConversation(sessionId);
+  }
+
+  async archiveConversation(sessionId: string): Promise<void> {
+    await this.options.directoryActions.archiveConversation(sessionId);
+  }
+
+  async addDirectoryByPath(rawPath: string): Promise<void> {
+    await this.options.directoryActions.addDirectoryByPath(rawPath);
+  }
+
+  async closeDirectory(directoryId: string): Promise<void> {
+    await this.options.directoryActions.closeDirectory(directoryId);
+  }
+
+  openRepositoryPromptForCreate(): void {
+    this.options.repositoryActions.openRepositoryPromptForCreate();
+  }
+
+  openRepositoryPromptForEdit(repositoryId: string): void {
+    this.options.repositoryActions.openRepositoryPromptForEdit(repositoryId);
+  }
+
+  reorderRepositoryByDrop(draggedRepositoryId: string, targetRepositoryId: string): void {
+    this.options.repositoryActions.reorderRepositoryByDrop(
+      draggedRepositoryId,
+      targetRepositoryId,
+      this.options.orderedActiveRepositoryIds(),
+    );
+  }
+
+  async upsertRepositoryByRemoteUrl(
+    remoteUrl: string,
+    existingRepositoryId?: string,
+  ): Promise<void> {
+    await this.options.repositoryActions.upsertRepositoryByRemoteUrl(
+      remoteUrl,
+      existingRepositoryId,
+    );
+  }
+
+  async archiveRepositoryById(repositoryId: string): Promise<void> {
+    await this.options.repositoryActions.archiveRepositoryById(repositoryId);
+  }
+
+  async interruptConversation(sessionId: string): Promise<void> {
+    await this.options.controlActions.interruptConversation(sessionId);
+  }
+
+  async toggleGatewayProfiler(): Promise<void> {
+    await this.options.controlActions.toggleGatewayProfiler();
+  }
+
+  async toggleGatewayStatusTimeline(): Promise<void> {
+    await this.options.controlActions.toggleGatewayStatusTimeline();
+  }
+
+  async toggleGatewayRenderTrace(conversationId: string | null): Promise<void> {
+    await this.options.controlActions.toggleGatewayRenderTrace(conversationId);
+  }
+
+  runTaskPaneAction(action: TaskPaneAction): void {
+    this.options.taskPaneActions.runTaskPaneAction(action);
+  }
+
+  openTaskEditPrompt(taskId: string): void {
+    this.options.taskPaneActions.openTaskEditPrompt(taskId);
+  }
+
+  reorderTaskByDrop(draggedTaskId: string, targetTaskId: string): void {
+    this.options.taskPaneActions.reorderTaskByDrop(draggedTaskId, targetTaskId);
+  }
+
+  handleTaskPaneShortcutInput(input: Buffer): boolean {
+    return this.options.taskPaneShortcuts.handleInput(input);
+  }
+}