@jmoyers/harness 0.1.0

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

@@ -0,0 +1,197 @@
+import type { WorkspaceModel } from '../domain/workspace.ts';
+
+interface RepositoryRecordShape {
+  readonly repositoryId: string;
+  readonly remoteUrl: string;
+  readonly metadata: Record<string, unknown>;
+}
+
+interface RuntimeRepositoryActionService<TRepository extends RepositoryRecordShape> {
+  upsertRepository(input: {
+    repositoryId?: string;
+    name: string;
+    remoteUrl: string;
+    defaultBranch?: string;
+    metadata?: Record<string, unknown>;
+  }): Promise<TRepository>;
+  updateRepository(input: {
+    repositoryId: string;
+    name?: string;
+    remoteUrl?: string;
+    defaultBranch?: string;
+    metadata?: Record<string, unknown>;
+  }): Promise<TRepository>;
+  archiveRepository(repositoryId: string): Promise<unknown>;
+}
+
+interface RuntimeRepositoryActionsOptions<TRepository extends RepositoryRecordShape> {
+  readonly workspace: WorkspaceModel;
+  readonly repositories: Map<string, TRepository>;
+  readonly controlPlaneService: RuntimeRepositoryActionService<TRepository>;
+  readonly normalizeGitHubRemoteUrl: (value: string) => string | null;
+  readonly repositoryNameFromGitHubRemoteUrl: (value: string) => string;
+  readonly createRepositoryId: () => string;
+  readonly stopConversationTitleEdit: () => void;
+  readonly syncRepositoryAssociationsWithDirectorySnapshots: () => void;
+  readonly syncTaskPaneRepositorySelection: () => void;
+  readonly queueControlPlaneOp: (task: () => Promise<void>, label: string) => void;
+  readonly markDirty: () => void;
+}
+
+function repositoryHomePriority(repository: RepositoryRecordShape): number | null {
+  const raw = repository.metadata['homePriority'];
+  if (typeof raw !== 'number' || !Number.isFinite(raw)) {
+    return null;
+  }
+  if (!Number.isInteger(raw) || raw < 0) {
+    return null;
+  }
+  return raw;
+}
+
+export class RuntimeRepositoryActions<TRepository extends RepositoryRecordShape> {
+  constructor(private readonly options: RuntimeRepositoryActionsOptions<TRepository>) {}
+
+  openRepositoryPromptForCreate(): void {
+    this.options.workspace.newThreadPrompt = null;
+    this.options.workspace.addDirectoryPrompt = null;
+    if (this.options.workspace.conversationTitleEdit !== null) {
+      this.options.stopConversationTitleEdit();
+    }
+    this.options.workspace.conversationTitleEditClickState = null;
+    this.options.workspace.repositoryPrompt = {
+      mode: 'add',
+      repositoryId: null,
+      value: '',
+      error: null,
+    };
+    this.options.markDirty();
+  }
+
+  openRepositoryPromptForEdit(repositoryId: string): void {
+    const repository = this.options.repositories.get(repositoryId);
+    if (repository === undefined) {
+      return;
+    }
+    this.options.workspace.newThreadPrompt = null;
+    this.options.workspace.addDirectoryPrompt = null;
+    if (this.options.workspace.conversationTitleEdit !== null) {
+      this.options.stopConversationTitleEdit();
+    }
+    this.options.workspace.conversationTitleEditClickState = null;
+    this.options.workspace.repositoryPrompt = {
+      mode: 'edit',
+      repositoryId,
+      value: repository.remoteUrl,
+      error: null,
+    };
+    this.options.workspace.taskPaneSelectionFocus = 'repository';
+    this.options.markDirty();
+  }
+
+  queueRepositoryPriorityOrder(orderedRepositoryIds: readonly string[], label: string): void {
+    const updates: Array<{ repositoryId: string; metadata: Record<string, unknown> }> = [];
+    for (let index = 0; index < orderedRepositoryIds.length; index += 1) {
+      const repositoryId = orderedRepositoryIds[index]!;
+      const repository = this.options.repositories.get(repositoryId);
+      if (repository === undefined) {
+        continue;
+      }
+      if (repositoryHomePriority(repository) === index) {
+        continue;
+      }
+      updates.push({
+        repositoryId,
+        metadata: {
+          ...repository.metadata,
+          homePriority: index,
+        },
+      });
+    }
+    if (updates.length === 0) {
+      return;
+    }
+    this.options.queueControlPlaneOp(async () => {
+      for (const update of updates) {
+        const repository = await this.options.controlPlaneService.updateRepository({
+          repositoryId: update.repositoryId,
+          metadata: update.metadata,
+        });
+        this.options.repositories.set(repository.repositoryId, repository);
+      }
+      this.options.syncTaskPaneRepositorySelection();
+      this.options.markDirty();
+    }, label);
+  }
+
+  reorderRepositoryByDrop(
+    draggedRepositoryId: string,
+    targetRepositoryId: string,
+    orderedRepositoryIds: readonly string[],
+  ): void {
+    const reordered = this.reorderIdsByMove(
+      orderedRepositoryIds,
+      draggedRepositoryId,
+      targetRepositoryId,
+    );
+    if (reordered === null) {
+      return;
+    }
+    this.queueRepositoryPriorityOrder(reordered, 'repositories-reorder-drag');
+  }
+
+  async upsertRepositoryByRemoteUrl(
+    remoteUrl: string,
+    existingRepositoryId?: string,
+  ): Promise<void> {
+    const normalizedRemoteUrl = this.options.normalizeGitHubRemoteUrl(remoteUrl);
+    if (normalizedRemoteUrl === null) {
+      throw new Error('github url required');
+    }
+    const repositoryName = this.options.repositoryNameFromGitHubRemoteUrl(normalizedRemoteUrl);
+    const repository =
+      existingRepositoryId === undefined
+        ? await this.options.controlPlaneService.upsertRepository({
+            repositoryId: this.options.createRepositoryId(),
+            name: repositoryName,
+            remoteUrl: normalizedRemoteUrl,
+            defaultBranch: 'main',
+            metadata: {
+              source: 'mux-manual',
+            },
+          })
+        : await this.options.controlPlaneService.updateRepository({
+            repositoryId: existingRepositoryId,
+            name: repositoryName,
+            remoteUrl: normalizedRemoteUrl,
+          });
+    this.options.repositories.set(repository.repositoryId, repository);
+    this.options.syncRepositoryAssociationsWithDirectorySnapshots();
+    this.options.syncTaskPaneRepositorySelection();
+    this.options.markDirty();
+  }
+
+  async archiveRepositoryById(repositoryId: string): Promise<void> {
+    await this.options.controlPlaneService.archiveRepository(repositoryId);
+    this.options.repositories.delete(repositoryId);
+    this.options.syncRepositoryAssociationsWithDirectorySnapshots();
+    this.options.syncTaskPaneRepositorySelection();
+    this.options.markDirty();
+  }
+
+  private reorderIdsByMove(
+    orderedIds: readonly string[],
+    movedId: string,
+    targetId: string,
+  ): readonly string[] | null {
+    const fromIndex = orderedIds.indexOf(movedId);
+    const targetIndex = orderedIds.indexOf(targetId);
+    if (fromIndex < 0 || targetIndex < 0 || fromIndex === targetIndex) {
+      return null;
+    }
+    const reordered = [...orderedIds];
+    const moved = reordered.splice(fromIndex, 1)[0]!;
+    reordered.splice(targetIndex, 0, moved);
+    return reordered;
+  }
+}

package/src/services/runtime-right-pane-render.ts

@@ -0,0 +1,132 @@
+import type { WorkspaceModel } from '../domain/workspace.ts';
+import type { TaskManager } from '../domain/tasks.ts';
+import type { ProjectPaneSnapshot } from '../mux/harness-core-ui.ts';
+import type { TaskComposerBuffer } from '../mux/task-composer.ts';
+import type {
+  TaskFocusedPaneRepositoryRecord,
+  TaskFocusedPaneTaskRecord,
+  TaskFocusedPaneView,
+} from '../mux/task-focused-pane.ts';
+import type { TerminalSnapshotFrameCore } from '../terminal/snapshot-oracle.ts';
+
+interface RuntimeRightPaneLayout {
+  readonly rightCols: number;
+  readonly paneRows: number;
+}
+
+interface ConversationPaneLike {
+  render(frame: TerminalSnapshotFrameCore, layout: RuntimeRightPaneLayout): readonly string[];
+}
+
+interface HomePaneRenderInput<
+  TRepositoryRecord extends TaskFocusedPaneRepositoryRecord,
+  TTaskRecord extends TaskFocusedPaneTaskRecord,
+> {
+  readonly layout: RuntimeRightPaneLayout;
+  readonly repositories: ReadonlyMap<string, TRepositoryRecord>;
+  readonly tasks: ReadonlyMap<string, TTaskRecord>;
+  readonly selectedRepositoryId: string | null;
+  readonly repositoryDropdownOpen: boolean;
+  readonly editorTarget: WorkspaceModel['taskEditorTarget'];
+  readonly draftBuffer: TaskComposerBuffer;
+  readonly taskBufferById: ReadonlyMap<string, TaskComposerBuffer>;
+  readonly notice: string | null;
+  readonly scrollTop: number;
+}
+
+interface HomePaneLike<
+  TRepositoryRecord extends TaskFocusedPaneRepositoryRecord,
+  TTaskRecord extends TaskFocusedPaneTaskRecord,
+> {
+  render(input: HomePaneRenderInput<TRepositoryRecord, TTaskRecord>): TaskFocusedPaneView;
+}
+
+interface ProjectPaneLike {
+  render(input: {
+    layout: RuntimeRightPaneLayout;
+    snapshot: ProjectPaneSnapshot | null;
+    scrollTop: number;
+  }): {
+    readonly rows: readonly string[];
+    readonly scrollTop: number;
+  };
+}
+
+interface RuntimeRightPaneRenderInput {
+  readonly layout: RuntimeRightPaneLayout;
+  readonly rightFrame: TerminalSnapshotFrameCore | null;
+  readonly homePaneActive: boolean;
+  readonly projectPaneActive: boolean;
+  readonly activeDirectoryId: string | null;
+}
+
+interface RuntimeRightPaneRenderOptions<
+  TRepositoryRecord extends TaskFocusedPaneRepositoryRecord,
+  TTaskRecord extends TaskFocusedPaneTaskRecord,
+> {
+  readonly workspace: WorkspaceModel;
+  readonly repositories: ReadonlyMap<string, TRepositoryRecord>;
+  readonly taskManager: TaskManager<TTaskRecord, TaskComposerBuffer, NodeJS.Timeout>;
+  readonly conversationPane: ConversationPaneLike;
+  readonly homePane: HomePaneLike<TRepositoryRecord, TTaskRecord>;
+  readonly projectPane: ProjectPaneLike;
+  readonly refreshProjectPaneSnapshot: (directoryId: string) => ProjectPaneSnapshot | null;
+  readonly emptyTaskPaneView: () => TaskFocusedPaneView;
+}
+
+export class RuntimeRightPaneRender<
+  TRepositoryRecord extends TaskFocusedPaneRepositoryRecord,
+  TTaskRecord extends TaskFocusedPaneTaskRecord,
+> {
+  constructor(
+    private readonly options: RuntimeRightPaneRenderOptions<TRepositoryRecord, TTaskRecord>,
+  ) {}
+
+  renderRightRows(input: RuntimeRightPaneRenderInput): readonly string[] {
+    const workspace = this.options.workspace;
+    workspace.latestTaskPaneView = this.options.emptyTaskPaneView();
+
+    if (input.rightFrame !== null) {
+      return this.options.conversationPane.render(input.rightFrame, input.layout);
+    }
+
+    if (input.homePaneActive) {
+      const view = this.options.homePane.render({
+        layout: input.layout,
+        repositories: this.options.repositories,
+        tasks: this.options.taskManager.readonlyTasks(),
+        selectedRepositoryId: workspace.taskPaneSelectedRepositoryId,
+        repositoryDropdownOpen: workspace.taskRepositoryDropdownOpen,
+        editorTarget: workspace.taskEditorTarget,
+        draftBuffer: workspace.taskDraftComposer,
+        taskBufferById: this.options.taskManager.readonlyTaskComposers(),
+        notice: workspace.taskPaneNotice,
+        scrollTop: workspace.taskPaneScrollTop,
+      });
+      workspace.taskPaneSelectedRepositoryId = view.selectedRepositoryId;
+      workspace.taskPaneScrollTop = view.top;
+      workspace.latestTaskPaneView = view;
+      return view.rows;
+    }
+
+    if (input.projectPaneActive && input.activeDirectoryId !== null) {
+      const needsSnapshotRefresh =
+        workspace.projectPaneSnapshot === null ||
+        workspace.projectPaneSnapshot.directoryId !== input.activeDirectoryId;
+      if (needsSnapshotRefresh) {
+        workspace.projectPaneSnapshot = this.options.refreshProjectPaneSnapshot(
+          input.activeDirectoryId,
+        );
+      }
+      const view = this.options.projectPane.render({
+        layout: input.layout,
+        snapshot: workspace.projectPaneSnapshot,
+        scrollTop: workspace.projectPaneScrollTop,
+      });
+      workspace.projectPaneScrollTop = view.scrollTop;
+      return view.rows;
+    }
+
+    return Array.from({ length: input.layout.paneRows }, () => ' '.repeat(input.layout.rightCols));
+  }
+}

package/src/services/runtime-shutdown.ts

@@ -0,0 +1,79 @@
+interface RuntimeShutdownServiceOptions {
+  readonly screen: {
+    clearDirty: () => void;
+  };
+  readonly outputLoadSampler: {
+    stop: () => void;
+  };
+  readonly startupBackgroundProbeService: {
+    stop: () => void;
+  };
+  readonly clearResizeTimer: () => void;
+  readonly clearPtyResizeTimer: () => void;
+  readonly clearHomePaneBackgroundTimer: () => void;
+  readonly persistMuxUiStateNow: () => void;
+  readonly clearConversationTitleEditTimer: () => void;
+  readonly flushTaskComposerPersist: () => void;
+  readonly clearRenderScheduled: () => void;
+  readonly detachProcessListeners: () => void;
+  readonly removeEnvelopeListener: () => void;
+  readonly unsubscribeTaskPlanningEvents: () => Promise<void>;
+  readonly closeKeyEventSubscription: () => Promise<void>;
+  readonly clearRuntimeFatalExitTimer: () => void;
+  readonly waitForControlPlaneDrain: () => Promise<void>;
+  readonly controlPlaneClient: {
+    close: () => Promise<void>;
+  };
+  readonly eventPersistence: {
+    flush: (reason: 'timer' | 'immediate' | 'shutdown') => void;
+  };
+  readonly recordingService: {
+    closeWriter: () => Promise<unknown>;
+    finalizeAfterShutdown: (recordingCloseError: unknown) => Promise<void>;
+  };
+  readonly store: {
+    close: () => void;
+  };
+  readonly restoreTerminalState: () => void;
+  readonly startupShutdownService: {
+    finalize: () => void;
+  };
+  readonly shutdownPerfCore: () => void;
+}
+
+export class RuntimeShutdownService {
+  constructor(private readonly options: RuntimeShutdownServiceOptions) {}
+
+  async finalize(): Promise<void> {
+    this.options.screen.clearDirty();
+    this.options.outputLoadSampler.stop();
+    this.options.startupBackgroundProbeService.stop();
+    this.options.clearResizeTimer();
+    this.options.clearPtyResizeTimer();
+    this.options.clearHomePaneBackgroundTimer();
+    this.options.persistMuxUiStateNow();
+    this.options.clearConversationTitleEditTimer();
+    this.options.flushTaskComposerPersist();
+    this.options.clearRenderScheduled();
+    this.options.detachProcessListeners();
+    this.options.removeEnvelopeListener();
+    await this.options.unsubscribeTaskPlanningEvents();
+    await this.options.closeKeyEventSubscription();
+    this.options.clearRuntimeFatalExitTimer();
+
+    try {
+      await this.options.waitForControlPlaneDrain();
+      await this.options.controlPlaneClient.close();
+    } catch {
+      // Best-effort shutdown only.
+    }
+
+    this.options.eventPersistence.flush('shutdown');
+    const recordingCloseError = await this.options.recordingService.closeWriter();
+    this.options.store.close();
+    this.options.restoreTerminalState();
+    await this.options.recordingService.finalizeAfterShutdown(recordingCloseError);
+    this.options.startupShutdownService.finalize();
+    this.options.shutdownPerfCore();
+  }
+}

package/src/services/runtime-stream-subscriptions.ts

@@ -0,0 +1,56 @@
+export interface RuntimeStreamSubscriptionsOptions {
+  readonly subscribePtyEvents: (sessionId: string) => Promise<void>;
+  readonly unsubscribePtyEvents: (sessionId: string) => Promise<void>;
+  readonly isSessionNotFoundError: (error: unknown) => boolean;
+  readonly isSessionNotLiveError: (error: unknown) => boolean;
+  readonly subscribeObservedStream: (afterCursor: number | null) => Promise<string>;
+  readonly unsubscribeObservedStream: (subscriptionId: string) => Promise<void>;
+}
+
+export class RuntimeStreamSubscriptions {
+  private observedStreamSubscriptionId: string | null = null;
+
+  constructor(private readonly options: RuntimeStreamSubscriptionsOptions) {}
+
+  async subscribeConversationEvents(sessionId: string): Promise<void> {
+    try {
+      await this.options.subscribePtyEvents(sessionId);
+    } catch (error: unknown) {
+      if (
+        !this.options.isSessionNotFoundError(error) &&
+        !this.options.isSessionNotLiveError(error)
+      ) {
+        throw error;
+      }
+    }
+  }
+
+  async unsubscribeConversationEvents(sessionId: string): Promise<void> {
+    try {
+      await this.options.unsubscribePtyEvents(sessionId);
+    } catch (error: unknown) {
+      if (
+        !this.options.isSessionNotFoundError(error) &&
+        !this.options.isSessionNotLiveError(error)
+      ) {
+        throw error;
+      }
+    }
+  }
+
+  async subscribeTaskPlanningEvents(afterCursor: number | null): Promise<void> {
+    if (this.observedStreamSubscriptionId !== null) {
+      return;
+    }
+    this.observedStreamSubscriptionId = await this.options.subscribeObservedStream(afterCursor);
+  }
+
+  async unsubscribeTaskPlanningEvents(): Promise<void> {
+    if (this.observedStreamSubscriptionId === null) {
+      return;
+    }
+    const subscriptionId = this.observedStreamSubscriptionId;
+    this.observedStreamSubscriptionId = null;
+    await this.options.unsubscribeObservedStream(subscriptionId);
+  }
+}

package/src/services/runtime-task-composer-persistence.ts

@@ -0,0 +1,139 @@
+interface TaskComposerFields {
+  readonly title: string;
+  readonly description: string;
+}
+
+interface TaskRecordShape {
+  readonly taskId: string;
+  readonly repositoryId: string | null;
+  readonly title: string;
+  readonly description: string;
+}
+
+interface TaskComposerBufferShape {
+  readonly text: string;
+}
+
+interface RuntimeTaskComposerPersistenceOptions<
+  TTaskRecord extends TaskRecordShape,
+  TTaskComposerBuffer extends TaskComposerBufferShape,
+  TTaskAutosaveTimer extends { unref?: () => void },
+> {
+  readonly getTask: (taskId: string) => TTaskRecord | undefined;
+  readonly getTaskComposer: (taskId: string) => TTaskComposerBuffer | undefined;
+  readonly setTaskComposer: (taskId: string, buffer: TTaskComposerBuffer) => void;
+  readonly deleteTaskComposer: (taskId: string) => void;
+  readonly getTaskAutosaveTimer: (taskId: string) => TTaskAutosaveTimer | undefined;
+  readonly setTaskAutosaveTimer: (taskId: string, timer: TTaskAutosaveTimer) => void;
+  readonly deleteTaskAutosaveTimer: (taskId: string) => void;
+  readonly buildComposerFromTask: (task: TTaskRecord) => TTaskComposerBuffer;
+  readonly normalizeTaskComposerBuffer: (buffer: TTaskComposerBuffer) => TTaskComposerBuffer;
+  readonly taskFieldsFromComposerText: (text: string) => TaskComposerFields;
+  readonly updateTask: (input: {
+    taskId: string;
+    repositoryId: string | null;
+    title: string;
+    description: string;
+  }) => Promise<TTaskRecord>;
+  readonly applyTaskRecord: (task: TTaskRecord) => void;
+  readonly queueControlPlaneOp: (task: () => Promise<void>, label: string) => void;
+  readonly setTaskPaneNotice: (text: string | null) => void;
+  readonly markDirty: () => void;
+  readonly autosaveDebounceMs: number;
+  readonly setTimeoutFn?: (callback: () => void, ms: number) => TTaskAutosaveTimer;
+  readonly clearTimeoutFn?: (timer: TTaskAutosaveTimer) => void;
+}
+
+export class RuntimeTaskComposerPersistenceService<
+  TTaskRecord extends TaskRecordShape,
+  TTaskComposerBuffer extends TaskComposerBufferShape,
+  TTaskAutosaveTimer extends { unref?: () => void } = NodeJS.Timeout,
+> {
+  private readonly setTimeoutFn: (callback: () => void, ms: number) => TTaskAutosaveTimer;
+  private readonly clearTimeoutFn: (timer: TTaskAutosaveTimer) => void;
+
+  constructor(
+    private readonly options: RuntimeTaskComposerPersistenceOptions<
+      TTaskRecord,
+      TTaskComposerBuffer,
+      TTaskAutosaveTimer
+    >,
+  ) {
+    this.setTimeoutFn =
+      options.setTimeoutFn ??
+      ((callback, ms) => setTimeout(callback, ms) as unknown as TTaskAutosaveTimer);
+    this.clearTimeoutFn =
+      options.clearTimeoutFn ?? ((timer) => clearTimeout(timer as unknown as NodeJS.Timeout));
+  }
+
+  taskComposerForTask(taskId: string): TTaskComposerBuffer | null {
+    const existing = this.options.getTaskComposer(taskId);
+    if (existing !== undefined) {
+      return existing;
+    }
+    const task = this.options.getTask(taskId);
+    if (task === undefined) {
+      return null;
+    }
+    return this.options.buildComposerFromTask(task);
+  }
+
+  setTaskComposerForTask(taskId: string, buffer: TTaskComposerBuffer): void {
+    this.options.setTaskComposer(taskId, this.options.normalizeTaskComposerBuffer(buffer));
+  }
+
+  clearTaskAutosaveTimer(taskId: string): void {
+    const timer = this.options.getTaskAutosaveTimer(taskId);
+    if (timer !== undefined) {
+      this.clearTimeoutFn(timer);
+      this.options.deleteTaskAutosaveTimer(taskId);
+    }
+  }
+
+  scheduleTaskComposerPersist(taskId: string): void {
+    this.clearTaskAutosaveTimer(taskId);
+    const timer = this.setTimeoutFn(() => {
+      this.options.deleteTaskAutosaveTimer(taskId);
+      this.queuePersistTaskComposer(taskId, 'debounced');
+    }, this.options.autosaveDebounceMs);
+    timer.unref?.();
+    this.options.setTaskAutosaveTimer(taskId, timer);
+  }
+
+  flushTaskComposerPersist(taskId: string): void {
+    this.clearTaskAutosaveTimer(taskId);
+    this.queuePersistTaskComposer(taskId, 'flush');
+  }
+
+  private queuePersistTaskComposer(taskId: string, reason: 'debounced' | 'flush'): void {
+    const task = this.options.getTask(taskId);
+    const buffer = this.options.getTaskComposer(taskId);
+    if (task === undefined || buffer === undefined) {
+      return;
+    }
+    const fields = this.options.taskFieldsFromComposerText(buffer.text);
+    if (fields.title.length === 0) {
+      this.options.setTaskPaneNotice('first line is required');
+      this.options.markDirty();
+      return;
+    }
+    if (fields.title === task.title && fields.description === task.description) {
+      return;
+    }
+    this.options.queueControlPlaneOp(async () => {
+      const parsed = await this.options.updateTask({
+        taskId,
+        repositoryId: task.repositoryId,
+        title: fields.title,
+        description: fields.description,
+      });
+      this.options.applyTaskRecord(parsed);
+      const persistedText =
+        parsed.description.length === 0 ? parsed.title : `${parsed.title}\n${parsed.description}`;
+      const latestBuffer = this.options.getTaskComposer(taskId);
+      if (latestBuffer !== undefined && latestBuffer.text === persistedText) {
+        this.options.deleteTaskComposer(taskId);
+      }
+    }, `task-editor-save:${reason}:${taskId}`);
+  }
+}

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

@@ -0,0 +1,83 @@
+import type { WorkspaceModel } from '../domain/workspace.ts';
+
+interface TaskRecordShape {
+  readonly taskId: string;
+}
+
+interface RuntimeTaskEditorActionService<TTaskRecord extends TaskRecordShape> {
+  createTask(input: {
+    repositoryId: string;
+    title: string;
+    description: string;
+  }): Promise<TTaskRecord>;
+  updateTask(input: {
+    taskId: string;
+    repositoryId: string;
+    title: string;
+    description: string;
+  }): Promise<TTaskRecord>;
+}
+
+export interface RuntimeTaskEditorSubmitPayload {
+  readonly mode: 'create' | 'edit';
+  readonly taskId: string | null;
+  readonly repositoryId: string;
+  readonly title: string;
+  readonly description: string;
+  readonly commandLabel: string;
+}
+
+interface RuntimeTaskEditorActionsOptions<TTaskRecord extends TaskRecordShape> {
+  readonly workspace: WorkspaceModel;
+  readonly controlPlaneService: RuntimeTaskEditorActionService<TTaskRecord>;
+  readonly applyTaskRecord: (task: TTaskRecord) => void;
+  readonly queueControlPlaneOp: (task: () => Promise<void>, label: string) => void;
+  readonly markDirty: () => void;
+}
+
+function formatErrorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+export class RuntimeTaskEditorActions<TTaskRecord extends TaskRecordShape> {
+  constructor(private readonly options: RuntimeTaskEditorActionsOptions<TTaskRecord>) {}
+
+  submitTaskEditorPayload(payload: RuntimeTaskEditorSubmitPayload): void {
+    this.options.queueControlPlaneOp(async () => {
+      try {
+        if (payload.mode === 'create') {
+          this.options.applyTaskRecord(
+            await this.options.controlPlaneService.createTask({
+              repositoryId: payload.repositoryId,
+              title: payload.title,
+              description: payload.description,
+            }),
+          );
+        } else {
+          if (payload.taskId === null) {
+            throw new Error('task edit state missing task id');
+          }
+          this.options.applyTaskRecord(
+            await this.options.controlPlaneService.updateTask({
+              taskId: payload.taskId,
+              repositoryId: payload.repositoryId,
+              title: payload.title,
+              description: payload.description,
+            }),
+          );
+        }
+        this.options.workspace.taskEditorPrompt = null;
+        this.options.workspace.taskPaneNotice = null;
+      } catch (error: unknown) {
+        const message = formatErrorMessage(error);
+        if (this.options.workspace.taskEditorPrompt !== null) {
+          this.options.workspace.taskEditorPrompt.error = message;
+        } else {
+          this.options.workspace.taskPaneNotice = message;
+        }
+      } finally {
+        this.options.markDirty();
+      }
+    }, payload.commandLabel);
+  }
+}