@jmoyers/harness 0.1.10 → 0.1.20

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

@@ -1,11 +1,19 @@
 import type { WorkspaceModel } from '../domain/workspace.ts';
 import type { PaneSelection, PaneSelectionDrag } from '../mux/live-mux/selection.ts';
 
-interface RuntimeRenderStateOptions<TConversation, TFrame> {
+interface RuntimeRenderStateDirectoryLookup {
+  hasDirectory(directoryId: string): boolean;
+}
+
+interface RuntimeRenderStateConversationLookup<TConversation> {
+  readonly activeConversationId: string | null;
+  getActiveConversation(): TConversation | null;
+}
+
+export interface RuntimeRenderStateOptions<TConversation, TFrame> {
   readonly workspace: WorkspaceModel;
-  readonly hasDirectory: (directoryId: string) => boolean;
-  readonly activeConversationId: () => string | null;
-  readonly activeConversation: () => TConversation | null;
+  readonly directories: RuntimeRenderStateDirectoryLookup;
+  readonly conversations: RuntimeRenderStateConversationLookup<TConversation>;
   readonly snapshotFrame: (conversation: TConversation) => TFrame;
   readonly selectionVisibleRows: (
     frame: TFrame,
@@ -13,60 +21,65 @@ interface RuntimeRenderStateOptions<TConversation, TFrame> {
   ) => readonly number[];
 }
 
-interface RuntimeRenderStateResult<TConversation, TFrame> {
+export interface RuntimeRenderStateResult<TConversation, TFrame> {
   readonly projectPaneActive: boolean;
   readonly homePaneActive: boolean;
+  readonly nimPaneActive: boolean;
   readonly activeConversation: TConversation | null;
   readonly rightFrame: TFrame | null;
   readonly renderSelection: PaneSelection | null;
   readonly selectionRows: readonly number[];
 }
 
-export class RuntimeRenderState<TConversation, TFrame> {
-  constructor(private readonly options: RuntimeRenderStateOptions<TConversation, TFrame>) {}
-
-  prepareRenderState(
-    selection: PaneSelection | null,
-    selectionDrag: PaneSelectionDrag | null,
-  ): RuntimeRenderStateResult<TConversation, TFrame> | null {
-    const workspace = this.options.workspace;
-    const projectPaneActive =
-      workspace.mainPaneMode === 'project' &&
-      workspace.activeDirectoryId !== null &&
-      this.options.hasDirectory(workspace.activeDirectoryId);
-    const homePaneActive = workspace.mainPaneMode === 'home';
-    if (!projectPaneActive && !homePaneActive && this.options.activeConversationId() === null) {
-      return null;
-    }
+export function prepareRuntimeRenderState<TConversation, TFrame>(
+  options: RuntimeRenderStateOptions<TConversation, TFrame>,
+  selection: PaneSelection | null,
+  selectionDrag: PaneSelectionDrag | null,
+): RuntimeRenderStateResult<TConversation, TFrame> | null {
+  const workspace = options.workspace;
+  const projectPaneActive =
+    workspace.mainPaneMode === 'project' &&
+    workspace.activeDirectoryId !== null &&
+    options.directories.hasDirectory(workspace.activeDirectoryId);
+  const homePaneActive = workspace.mainPaneMode === 'home';
+  const nimPaneActive = workspace.mainPaneMode === 'nim';
+  if (
+    !projectPaneActive &&
+    !homePaneActive &&
+    !nimPaneActive &&
+    options.conversations.activeConversationId === null
+  ) {
+    return null;
+  }
 
-    const activeConversation = this.options.activeConversation();
-    if (!projectPaneActive && !homePaneActive && activeConversation === null) {
-      return null;
-    }
+  const activeConversation = options.conversations.getActiveConversation();
+  if (!projectPaneActive && !homePaneActive && !nimPaneActive && activeConversation === null) {
+    return null;
+  }
 
-    const rightFrame =
-      !projectPaneActive && !homePaneActive && activeConversation !== null
-        ? this.options.snapshotFrame(activeConversation)
+  const rightFrame =
+    !projectPaneActive && !homePaneActive && !nimPaneActive && activeConversation !== null
+      ? options.snapshotFrame(activeConversation)
+      : null;
+  const renderSelection =
+    rightFrame !== null && selectionDrag !== null && selectionDrag.hasDragged
+      ? {
+          anchor: selectionDrag.anchor,
+          focus: selectionDrag.focus,
+          text: '',
+        }
+      : rightFrame !== null
+        ? selection
         : null;
-    const renderSelection =
-      rightFrame !== null && selectionDrag !== null && selectionDrag.hasDragged
-        ? {
-            anchor: selectionDrag.anchor,
-            focus: selectionDrag.focus,
-            text: '',
-          }
-        : rightFrame !== null
-          ? selection
-          : null;
-    const selectionRows =
-      rightFrame === null ? [] : this.options.selectionVisibleRows(rightFrame, renderSelection);
-    return {
-      projectPaneActive,
-      homePaneActive,
-      activeConversation,
-      rightFrame,
-      renderSelection,
-      selectionRows,
-    };
-  }
+  const selectionRows =
+    rightFrame === null ? [] : options.selectionVisibleRows(rightFrame, renderSelection);
+  return {
+    projectPaneActive,
+    homePaneActive,
+    nimPaneActive,
+    activeConversation,
+    rightFrame,
+    renderSelection,
+    selectionRows,
+  };
 }

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

@@ -24,7 +24,7 @@ interface RuntimeRepositoryActionService<TRepository extends RepositoryRecordSha
   archiveRepository(repositoryId: string): Promise<unknown>;
 }
 
-interface RuntimeRepositoryActionsOptions<TRepository extends RepositoryRecordShape> {
+export interface RuntimeRepositoryActionsOptions<TRepository extends RepositoryRecordShape> {
   readonly workspace: WorkspaceModel;
   readonly repositories: Map<string, TRepository>;
   readonly controlPlaneService: RuntimeRepositoryActionService<TRepository>;
@@ -49,51 +49,85 @@ function repositoryHomePriority(repository: RepositoryRecordShape): number | nul
   return raw;
 }
 
-export class RuntimeRepositoryActions<TRepository extends RepositoryRecordShape> {
-  constructor(private readonly options: RuntimeRepositoryActionsOptions<TRepository>) {}
+export interface RuntimeRepositoryActions {
+  openRepositoryPromptForCreate(): void;
+  openRepositoryPromptForEdit(repositoryId: string): void;
+  queueRepositoryPriorityOrder(orderedRepositoryIds: readonly string[], label: string): void;
+  reorderRepositoryByDrop(
+    draggedRepositoryId: string,
+    targetRepositoryId: string,
+    orderedRepositoryIds: readonly string[],
+  ): void;
+  upsertRepositoryByRemoteUrl(remoteUrl: string, existingRepositoryId?: string): Promise<void>;
+  archiveRepositoryById(repositoryId: string): Promise<void>;
+}
+
+export function createRuntimeRepositoryActions<TRepository extends RepositoryRecordShape>(
+  options: RuntimeRepositoryActionsOptions<TRepository>,
+): RuntimeRepositoryActions {
+  const 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;
+  };
 
-  openRepositoryPromptForCreate(): void {
-    this.options.workspace.newThreadPrompt = null;
-    this.options.workspace.addDirectoryPrompt = null;
-    if (this.options.workspace.conversationTitleEdit !== null) {
-      this.options.stopConversationTitleEdit();
+  const openRepositoryPromptForCreate = (): void => {
+    options.workspace.newThreadPrompt = null;
+    options.workspace.addDirectoryPrompt = null;
+    options.workspace.apiKeyPrompt = null;
+    if (options.workspace.conversationTitleEdit !== null) {
+      options.stopConversationTitleEdit();
     }
-    this.options.workspace.conversationTitleEditClickState = null;
-    this.options.workspace.repositoryPrompt = {
+    options.workspace.conversationTitleEditClickState = null;
+    options.workspace.repositoryPrompt = {
       mode: 'add',
       repositoryId: null,
       value: '',
       error: null,
     };
-    this.options.markDirty();
-  }
+    options.markDirty();
+  };
 
-  openRepositoryPromptForEdit(repositoryId: string): void {
-    const repository = this.options.repositories.get(repositoryId);
+  const openRepositoryPromptForEdit = (repositoryId: string): void => {
+    const repository = 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();
+    options.workspace.newThreadPrompt = null;
+    options.workspace.addDirectoryPrompt = null;
+    options.workspace.apiKeyPrompt = null;
+    if (options.workspace.conversationTitleEdit !== null) {
+      options.stopConversationTitleEdit();
     }
-    this.options.workspace.conversationTitleEditClickState = null;
-    this.options.workspace.repositoryPrompt = {
+    options.workspace.conversationTitleEditClickState = null;
+    options.workspace.repositoryPrompt = {
       mode: 'edit',
       repositoryId,
       value: repository.remoteUrl,
       error: null,
     };
-    this.options.workspace.taskPaneSelectionFocus = 'repository';
-    this.options.markDirty();
-  }
+    options.workspace.taskPaneSelectionFocus = 'repository';
+    options.markDirty();
+  };
 
-  queueRepositoryPriorityOrder(orderedRepositoryIds: readonly string[], label: string): void {
+  const 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);
+      const repository = options.repositories.get(repositoryId);
       if (repository === undefined) {
         continue;
       }
@@ -111,25 +145,25 @@ export class RuntimeRepositoryActions<TRepository extends RepositoryRecordShape>
     if (updates.length === 0) {
       return;
     }
-    this.options.queueControlPlaneOp(async () => {
+    options.queueControlPlaneOp(async () => {
       for (const update of updates) {
-        const repository = await this.options.controlPlaneService.updateRepository({
+        const repository = await options.controlPlaneService.updateRepository({
           repositoryId: update.repositoryId,
           metadata: update.metadata,
         });
-        this.options.repositories.set(repository.repositoryId, repository);
+        options.repositories.set(repository.repositoryId, repository);
       }
-      this.options.syncTaskPaneRepositorySelection();
-      this.options.markDirty();
+      options.syncTaskPaneRepositorySelection();
+      options.markDirty();
     }, label);
-  }
+  };
 
-  reorderRepositoryByDrop(
+  const reorderRepositoryByDrop = (
     draggedRepositoryId: string,
     targetRepositoryId: string,
     orderedRepositoryIds: readonly string[],
-  ): void {
-    const reordered = this.reorderIdsByMove(
+  ): void => {
+    const reordered = reorderIdsByMove(
       orderedRepositoryIds,
       draggedRepositoryId,
       targetRepositoryId,
@@ -137,22 +171,22 @@ export class RuntimeRepositoryActions<TRepository extends RepositoryRecordShape>
     if (reordered === null) {
       return;
     }
-    this.queueRepositoryPriorityOrder(reordered, 'repositories-reorder-drag');
-  }
+    queueRepositoryPriorityOrder(reordered, 'repositories-reorder-drag');
+  };
 
-  async upsertRepositoryByRemoteUrl(
+  const upsertRepositoryByRemoteUrl = async (
     remoteUrl: string,
     existingRepositoryId?: string,
-  ): Promise<void> {
-    const normalizedRemoteUrl = this.options.normalizeGitHubRemoteUrl(remoteUrl);
+  ): Promise<void> => {
+    const normalizedRemoteUrl = options.normalizeGitHubRemoteUrl(remoteUrl);
     if (normalizedRemoteUrl === null) {
       throw new Error('github url required');
     }
-    const repositoryName = this.options.repositoryNameFromGitHubRemoteUrl(normalizedRemoteUrl);
+    const repositoryName = options.repositoryNameFromGitHubRemoteUrl(normalizedRemoteUrl);
     const repository =
       existingRepositoryId === undefined
-        ? await this.options.controlPlaneService.upsertRepository({
-            repositoryId: this.options.createRepositoryId(),
+        ? await options.controlPlaneService.upsertRepository({
+            repositoryId: options.createRepositoryId(),
             name: repositoryName,
             remoteUrl: normalizedRemoteUrl,
             defaultBranch: 'main',
@@ -160,38 +194,31 @@ export class RuntimeRepositoryActions<TRepository extends RepositoryRecordShape>
               source: 'mux-manual',
             },
           })
-        : await this.options.controlPlaneService.updateRepository({
+        : await 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();
-  }
+    options.repositories.set(repository.repositoryId, repository);
+    options.syncRepositoryAssociationsWithDirectorySnapshots();
+    options.syncTaskPaneRepositorySelection();
+    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();
-  }
+  const archiveRepositoryById = async (repositoryId: string): Promise<void> => {
+    await options.controlPlaneService.archiveRepository(repositoryId);
+    options.repositories.delete(repositoryId);
+    options.syncRepositoryAssociationsWithDirectorySnapshots();
+    options.syncTaskPaneRepositorySelection();
+    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;
-  }
+  return {
+    openRepositoryPromptForCreate,
+    openRepositoryPromptForEdit,
+    queueRepositoryPriorityOrder,
+    reorderRepositoryByDrop,
+    upsertRepositoryByRemoteUrl,
+    archiveRepositoryById,
+  };
 }

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

@@ -1,7 +1,7 @@
 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 { NimPaneViewModel } from '../ui/panes/nim.ts';
 import type {
   TaskFocusedPaneRepositoryRecord,
   TaskFocusedPaneTaskRecord,
@@ -9,7 +9,7 @@ import type {
 } from '../mux/task-focused-pane.ts';
 import type { TerminalSnapshotFrameCore } from '../terminal/snapshot-oracle.ts';
 
-interface RuntimeRightPaneLayout {
+export interface RuntimeRightPaneLayout {
   readonly rightCols: number;
   readonly paneRows: number;
 }
@@ -25,6 +25,7 @@ interface HomePaneRenderInput<
   readonly layout: RuntimeRightPaneLayout;
   readonly repositories: ReadonlyMap<string, TRepositoryRecord>;
   readonly tasks: ReadonlyMap<string, TTaskRecord>;
+  readonly showTaskPlanningUi?: boolean;
   readonly selectedRepositoryId: string | null;
   readonly repositoryDropdownOpen: boolean;
   readonly editorTarget: WorkspaceModel['taskEditorTarget'];
@@ -52,81 +53,107 @@ interface ProjectPaneLike {
   };
 }
 
-interface RuntimeRightPaneRenderInput {
+interface NimPaneLike {
+  render(input: { layout: RuntimeRightPaneLayout; viewModel: NimPaneViewModel }): {
+    readonly rows: readonly string[];
+  };
+}
+
+export interface RuntimeRightPaneRenderInput<
+  TRepositoryRecord extends TaskFocusedPaneRepositoryRecord,
+  TTaskRecord extends TaskFocusedPaneTaskRecord,
+> {
   readonly layout: RuntimeRightPaneLayout;
   readonly rightFrame: TerminalSnapshotFrameCore | null;
   readonly homePaneActive: boolean;
+  readonly nimPaneActive: boolean;
   readonly projectPaneActive: boolean;
   readonly activeDirectoryId: string | null;
+  readonly snapshot: RuntimeRightPaneRenderSnapshot<TRepositoryRecord, TTaskRecord>;
 }
 
-interface RuntimeRightPaneRenderOptions<
+export interface RuntimeRightPaneRenderSnapshot<
   TRepositoryRecord extends TaskFocusedPaneRepositoryRecord,
   TTaskRecord extends TaskFocusedPaneTaskRecord,
 > {
-  readonly workspace: WorkspaceModel;
   readonly repositories: ReadonlyMap<string, TRepositoryRecord>;
-  readonly taskManager: TaskManager<TTaskRecord, TaskComposerBuffer, NodeJS.Timeout>;
+  readonly tasks: ReadonlyMap<string, TTaskRecord>;
+  readonly taskComposers: ReadonlyMap<string, TaskComposerBuffer>;
+}
+
+export interface RuntimeRightPaneRenderOptions<
+  TRepositoryRecord extends TaskFocusedPaneRepositoryRecord,
+  TTaskRecord extends TaskFocusedPaneTaskRecord,
+> {
+  readonly workspace: WorkspaceModel;
+  readonly showTasks?: boolean;
   readonly conversationPane: ConversationPaneLike;
   readonly homePane: HomePaneLike<TRepositoryRecord, TTaskRecord>;
   readonly projectPane: ProjectPaneLike;
+  readonly nimPane: NimPaneLike;
+  readonly getNimViewModel: () => NimPaneViewModel;
   readonly refreshProjectPaneSnapshot: (directoryId: string) => ProjectPaneSnapshot | null;
   readonly emptyTaskPaneView: () => TaskFocusedPaneView;
 }
 
-export class RuntimeRightPaneRender<
+export function renderRuntimeRightPaneRows<
   TRepositoryRecord extends TaskFocusedPaneRepositoryRecord,
   TTaskRecord extends TaskFocusedPaneTaskRecord,
-> {
-  constructor(
-    private readonly options: RuntimeRightPaneRenderOptions<TRepositoryRecord, TTaskRecord>,
-  ) {}
+>(
+  options: RuntimeRightPaneRenderOptions<TRepositoryRecord, TTaskRecord>,
+  input: RuntimeRightPaneRenderInput<TRepositoryRecord, TTaskRecord>,
+): readonly string[] {
+  const workspace = options.workspace;
+  workspace.latestTaskPaneView = options.emptyTaskPaneView();
 
-  renderRightRows(input: RuntimeRightPaneRenderInput): readonly string[] {
-    const workspace = this.options.workspace;
-    workspace.latestTaskPaneView = this.options.emptyTaskPaneView();
+  if (input.rightFrame !== null) {
+    return options.conversationPane.render(input.rightFrame, input.layout);
+  }
 
-    if (input.rightFrame !== null) {
-      return this.options.conversationPane.render(input.rightFrame, input.layout);
-    }
+  if (input.homePaneActive) {
+    const view = options.homePane.render({
+      layout: input.layout,
+      repositories: input.snapshot.repositories,
+      tasks: input.snapshot.tasks,
+      showTaskPlanningUi:
+        (options.showTasks ?? true) && workspace.leftNavSelection.kind === 'tasks',
+      selectedRepositoryId: workspace.taskPaneSelectedRepositoryId,
+      repositoryDropdownOpen: workspace.taskRepositoryDropdownOpen,
+      editorTarget: workspace.taskEditorTarget,
+      draftBuffer: workspace.taskDraftComposer,
+      taskBufferById: input.snapshot.taskComposers,
+      notice: workspace.taskPaneNotice,
+      scrollTop: workspace.taskPaneScrollTop,
+    });
+    workspace.taskPaneSelectedRepositoryId = view.selectedRepositoryId;
+    workspace.taskPaneScrollTop = view.top;
+    workspace.latestTaskPaneView = view;
+    return view.rows;
+  }
 
-    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.nimPaneActive) {
+    const view = options.nimPane.render({
+      layout: input.layout,
+      viewModel: options.getNimViewModel(),
+    });
+    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;
+  if (input.projectPaneActive && input.activeDirectoryId !== null) {
+    const needsSnapshotRefresh =
+      workspace.projectPaneSnapshot === null ||
+      workspace.projectPaneSnapshot.directoryId !== input.activeDirectoryId;
+    if (needsSnapshotRefresh) {
+      workspace.projectPaneSnapshot = options.refreshProjectPaneSnapshot(input.activeDirectoryId);
     }
-
-    return Array.from({ length: input.layout.paneRows }, () => ' '.repeat(input.layout.rightCols));
+    const view = 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

@@ -1,4 +1,4 @@
-interface RuntimeShutdownServiceOptions {
+export interface RuntimeShutdownServiceOptions {
   readonly screen: {
     clearDirty: () => void;
   };
@@ -11,12 +11,15 @@ interface RuntimeShutdownServiceOptions {
   readonly clearResizeTimer: () => void;
   readonly clearPtyResizeTimer: () => void;
   readonly clearHomePaneBackgroundTimer: () => void;
+  readonly clearStorageLifecycleTimer: () => void;
+  readonly clearProjectPaneGitHubReviewRefreshTimer: () => void;
   readonly persistMuxUiStateNow: () => void;
   readonly clearConversationTitleEditTimer: () => void;
   readonly flushTaskComposerPersist: () => void;
   readonly clearRenderScheduled: () => void;
   readonly detachProcessListeners: () => void;
   readonly removeEnvelopeListener: () => void;
+  readonly stopWorkspaceObservedEvents: () => void;
   readonly unsubscribeTaskPlanningEvents: () => Promise<void>;
   readonly closeKeyEventSubscription: () => Promise<void>;
   readonly clearRuntimeFatalExitTimer: () => void;
@@ -41,39 +44,39 @@ interface RuntimeShutdownServiceOptions {
   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();
+export async function finalizeRuntimeShutdown(
+  options: RuntimeShutdownServiceOptions,
+): Promise<void> {
+  options.screen.clearDirty();
+  options.outputLoadSampler.stop();
+  options.startupBackgroundProbeService.stop();
+  options.clearResizeTimer();
+  options.clearPtyResizeTimer();
+  options.clearHomePaneBackgroundTimer();
+  options.clearStorageLifecycleTimer();
+  options.clearProjectPaneGitHubReviewRefreshTimer();
+  options.persistMuxUiStateNow();
+  options.clearConversationTitleEditTimer();
+  options.flushTaskComposerPersist();
+  options.clearRenderScheduled();
+  options.detachProcessListeners();
+  options.removeEnvelopeListener();
+  options.stopWorkspaceObservedEvents();
+  await options.unsubscribeTaskPlanningEvents();
+  await options.closeKeyEventSubscription();
+  options.clearRuntimeFatalExitTimer();
+  try {
+    await options.waitForControlPlaneDrain();
+    await options.controlPlaneClient.close();
+  } catch {
+    // Best-effort shutdown only.
   }
+
+  options.eventPersistence.flush('shutdown');
+  const recordingCloseError = await options.recordingService.closeWriter();
+  options.store.close();
+  options.restoreTerminalState();
+  await options.recordingService.finalizeAfterShutdown(recordingCloseError);
+  options.startupShutdownService.finalize();
+  options.shutdownPerfCore();
 }