@jmoyers/harness 0.1.10 → 0.1.11

package/src/control-plane/stream-server.ts

@@ -1381,7 +1381,18 @@ export class ControlPlaneStreamServer {
   }
 
   private pollHistoryTimerTick(): void {
-    void this.pollHistoryFile();
+    void this.pollHistoryFile().catch((error: unknown) => {
+      if (this.markStateStoreClosedIfDetected(error)) {
+        return;
+      }
+      if (this.shouldSkipStateStoreWork()) {
+        return;
+      }
+      const message = error instanceof Error ? error.message : String(error);
+      recordPerfEvent('control-plane.history.poll.failed', {
+        error: message,
+      });
+    });
   }
 
   private stopHistoryPolling(): void {
@@ -1399,9 +1410,9 @@ export class ControlPlaneStreamServer {
       return;
     }
     this.reloadGitStatusDirectoriesFromStore();
-    void this.pollGitStatus();
+    this.triggerGitStatusPoll();
     this.gitStatusPollTimer = setInterval(() => {
-      void this.pollGitStatus();
+      this.triggerGitStatusPoll();
     }, this.gitStatusMonitor.pollMs);
     this.gitStatusPollTimer.unref();
   }
@@ -1494,6 +1505,9 @@ export class ControlPlaneStreamServer {
 
   private triggerGitHubPoll(): void {
     void this.pollGitHub().catch((error: unknown) => {
+      if (this.markStateStoreClosedIfDetected(error)) {
+        return;
+      }
       if (this.shouldIgnoreGitHubPollError(error)) {
         return;
       }
@@ -1504,10 +1518,40 @@ export class ControlPlaneStreamServer {
     });
   }
 
+  private triggerGitStatusPoll(): void {
+    void this.pollGitStatus().catch((error: unknown) => {
+      if (this.markStateStoreClosedIfDetected(error)) {
+        return;
+      }
+      if (this.shouldSkipStateStoreWork()) {
+        return;
+      }
+      const message = error instanceof Error ? error.message : String(error);
+      recordPerfEvent('control-plane.git-status.poll.failed', {
+        error: message,
+      });
+    });
+  }
+
   private isStateStoreClosedError(error: unknown): boolean {
     const message = error instanceof Error ? error.message : String(error);
     const normalized = message.trim().toLowerCase();
-    return normalized.includes('database has closed') || normalized.includes('database is closed');
+    return (
+      normalized.includes('database has closed') ||
+      normalized.includes('database is closed') ||
+      normalized.includes('cannot use a closed database')
+    );
+  }
+
+  private markStateStoreClosedIfDetected(error: unknown): boolean {
+    if (!this.isStateStoreClosedError(error)) {
+      return false;
+    }
+    this.stateStoreClosed = true;
+    this.stopGitHubPolling();
+    this.stopGitStatusPolling();
+    this.stopHistoryPolling();
+    return true;
   }
 
   private shouldSkipStateStoreWork(): boolean {
@@ -1526,6 +1570,9 @@ export class ControlPlaneStreamServer {
     try {
       await pollPromise;
     } catch (error: unknown) {
+      if (this.markStateStoreClosedIfDetected(error)) {
+        return;
+      }
       if (!this.shouldIgnoreGitHubPollError(error)) {
         const message = error instanceof Error ? error.message : String(error);
         recordPerfEvent('control-plane.github.poll.failed-on-close', {
@@ -2205,9 +2252,15 @@ export class ControlPlaneStreamServer {
   }
 
   private async pollHistoryFile(): Promise<void> {
-    await pollStreamServerHistoryFile(
-      this as unknown as Parameters<typeof pollStreamServerHistoryFile>[0],
-    );
+    try {
+      await pollStreamServerHistoryFile(
+        this as unknown as Parameters<typeof pollStreamServerHistoryFile>[0],
+      );
+    } catch (error: unknown) {
+      if (!this.markStateStoreClosedIfDetected(error)) {
+        throw error;
+      }
+    }
   }
 
   private async pollHistoryFileUnsafe(): Promise<boolean> {
@@ -2217,9 +2270,15 @@ export class ControlPlaneStreamServer {
   }
 
   private async pollGitStatus(): Promise<void> {
-    await pollStreamServerGitStatus(
-      this as unknown as Parameters<typeof pollStreamServerGitStatus>[0],
-    );
+    try {
+      await pollStreamServerGitStatus(
+        this as unknown as Parameters<typeof pollStreamServerGitStatus>[0],
+      );
+    } catch (error: unknown) {
+      if (!this.markStateStoreClosedIfDetected(error)) {
+        throw error;
+      }
+    }
   }
 
   private async refreshGitStatusForDirectory(
@@ -2314,6 +2373,10 @@ export class ControlPlaneStreamServer {
     this.githubPollPromise = pollPromise;
     try {
       await pollPromise;
+    } catch (error: unknown) {
+      if (!this.markStateStoreClosedIfDetected(error)) {
+        throw error;
+      }
     } finally {
       if (this.githubPollPromise === pollPromise) {
         this.githubPollPromise = null;
@@ -2491,6 +2554,9 @@ export class ControlPlaneStreamServer {
         lastErrorAt: null,
       });
     } catch (error: unknown) {
+      if (this.markStateStoreClosedIfDetected(error)) {
+        return;
+      }
       if (this.shouldIgnoreGitHubPollError(error)) {
         return;
       }
@@ -2510,6 +2576,9 @@ export class ControlPlaneStreamServer {
           lastErrorAt: now,
         });
       } catch (syncStateError: unknown) {
+        if (this.markStateStoreClosedIfDetected(syncStateError)) {
+          return;
+        }
         if (!this.shouldIgnoreGitHubPollError(syncStateError)) {
           throw syncStateError;
         }

package/src/domain/conversations.ts

@@ -290,6 +290,8 @@ export class ConversationManager {
 
   upsertFromPersistedRecord(input: UpsertPersistedConversationInput): ConversationState {
     const { record } = input;
+    const existing = this.conversationsBySessionId.get(record.conversationId);
+    const preserveLiveRuntime = existing?.live === true;
     const conversation = input.ensureConversation(record.conversationId, {
       directoryId: record.directoryId,
       title: record.title,
@@ -299,14 +301,16 @@ export class ConversationManager {
     conversation.scope.tenantId = record.tenantId;
     conversation.scope.userId = record.userId;
     conversation.scope.workspaceId = record.workspaceId;
-    const runtimeStatusModel = record.runtimeStatusModel;
-    conversation.status = record.runtimeStatus;
-    conversation.statusModel = runtimeStatusModel;
-    conversation.attentionReason = runtimeStatusModel?.attentionReason ?? null;
-    conversation.lastKnownWork = runtimeStatusModel?.lastKnownWork ?? null;
-    conversation.lastKnownWorkAt = runtimeStatusModel?.lastKnownWorkAt ?? null;
+    if (!preserveLiveRuntime) {
+      const runtimeStatusModel = record.runtimeStatusModel;
+      conversation.status = record.runtimeStatus;
+      conversation.statusModel = runtimeStatusModel;
+      conversation.attentionReason = runtimeStatusModel?.attentionReason ?? null;
+      conversation.lastKnownWork = runtimeStatusModel?.lastKnownWork ?? null;
+      conversation.lastKnownWorkAt = runtimeStatusModel?.lastKnownWorkAt ?? null;
+    }
     // Persisted runtime flags are advisory; session.list is authoritative for live sessions.
-    conversation.live = false;
+    conversation.live = preserveLiveRuntime ? true : false;
     return conversation;
   }
 

package/src/domain/workspace.ts

@@ -25,6 +25,14 @@ export interface RepositoryPromptState {
   readonly error: string | null;
 }
 
+export interface ApiKeyPromptState {
+  readonly keyName: string;
+  readonly displayName: string;
+  readonly value: string;
+  readonly error: string | null;
+  readonly hasExistingValue: boolean;
+}
+
 export interface TaskEditorPromptState {
   mode: 'create' | 'edit';
   taskId: string | null;
@@ -80,6 +88,7 @@ export class WorkspaceModel {
   selectionDrag: PaneSelectionDrag | null = null;
   selectionPinnedFollowOutput: boolean | null = null;
   repositoryPrompt: RepositoryPromptState | null = null;
+  apiKeyPrompt: ApiKeyPromptState | null = null;
   commandMenu: CommandMenuState | null = null;
   newThreadPrompt: ReturnType<typeof createNewThreadPromptState> | null = null;
   addDirectoryPrompt: { value: string; error: string | null } | null = null;

package/src/mux/input-shortcuts.ts

@@ -541,10 +541,38 @@ function strokesEqual(left: KeyStroke, right: KeyStroke): boolean {
 
 function parseBindingsForAction(rawBindings: readonly string[]): readonly ParsedShortcutBinding[] {
   const parsed: ParsedShortcutBinding[] = [];
+
+  const pushIfUnique = (candidate: ParsedShortcutBinding): void => {
+    if (parsed.some((existing) => strokesEqual(existing.stroke, candidate.stroke))) {
+      return;
+    }
+    parsed.push(candidate);
+  };
+
+  const ctrlMetaAliasStroke = (stroke: KeyStroke): KeyStroke | null => {
+    if (stroke.ctrl === stroke.meta) {
+      return null;
+    }
+    return {
+      key: stroke.key,
+      ctrl: !stroke.ctrl,
+      alt: stroke.alt,
+      shift: stroke.shift,
+      meta: !stroke.meta,
+    };
+  };
+
   for (const raw of rawBindings) {
     const normalized = parseShortcutBinding(raw);
     if (normalized !== null) {
-      parsed.push(normalized);
+      pushIfUnique(normalized);
+      const aliasStroke = ctrlMetaAliasStroke(normalized.stroke);
+      if (aliasStroke !== null) {
+        pushIfUnique({
+          stroke: aliasStroke,
+          originalText: normalized.originalText,
+        });
+      }
     }
   }
   return parsed;

package/src/mux/live-mux/git-parsing.ts

@@ -82,6 +82,22 @@ export function repositoryNameFromGitHubRemoteUrl(remoteUrl: string): string {
   return name;
 }
 
+function normalizeDefaultBranchForActions(value: string | null): string | null {
+  const trimmed = value?.trim() ?? '';
+  return trimmed.length > 0 ? trimmed : null;
+}
+
+export function resolveGitHubDefaultBranchForActions(input: {
+  repositoryDefaultBranch: string | null;
+  snapshotDefaultBranch: string | null;
+}): string | null {
+  const repositoryDefaultBranch = normalizeDefaultBranchForActions(input.repositoryDefaultBranch);
+  if (repositoryDefaultBranch !== null) {
+    return repositoryDefaultBranch;
+  }
+  return normalizeDefaultBranchForActions(input.snapshotDefaultBranch);
+}
+
 export function shouldShowGitHubPrActions(input: {
   trackedBranch: string | null;
   defaultBranch: string | null;

package/src/mux/live-mux/left-rail-conversation-click.ts

@@ -46,9 +46,12 @@ export function handleLeftRailConversationClick(
     options.selectedConversationId === options.activeConversationId
   ) {
     if (!options.isConversationPaneActive) {
-      options.ensureConversationPaneActive(options.selectedConversationId);
-    }
-    if (conversationClick.doubleClick) {
+      if (conversationClick.doubleClick) {
+        options.queueActivateConversationAndEdit(options.selectedConversationId);
+      } else {
+        options.queueActivateConversation(options.selectedConversationId);
+      }
+    } else if (conversationClick.doubleClick) {
       options.beginConversationTitleEdit(options.selectedConversationId);
     }
     options.markDirty();

package/src/mux/live-mux/modal-input-reducers.ts

@@ -19,10 +19,43 @@ interface LinePromptReduction {
   submit: boolean;
 }
 
+const BRACKETED_PASTE_START = Buffer.from('\u001b[200~', 'utf8');
+const BRACKETED_PASTE_END = Buffer.from('\u001b[201~', 'utf8');
+
+function matchesSequence(input: Buffer, startIndex: number, sequence: Buffer): boolean {
+  if (startIndex < 0 || startIndex + sequence.length > input.length) {
+    return false;
+  }
+  for (let index = 0; index < sequence.length; index += 1) {
+    if (input[startIndex + index] !== sequence[index]) {
+      return false;
+    }
+  }
+  return true;
+}
+
 export function reduceLinePromptInput(value: string, input: Buffer): LinePromptReduction {
   let nextValue = value;
   let submit = false;
-  for (const byte of input) {
+  let inBracketedPaste = false;
+  for (let index = 0; index < input.length; index += 1) {
+    if (!inBracketedPaste && matchesSequence(input, index, BRACKETED_PASTE_START)) {
+      inBracketedPaste = true;
+      index += BRACKETED_PASTE_START.length - 1;
+      continue;
+    }
+    if (inBracketedPaste && matchesSequence(input, index, BRACKETED_PASTE_END)) {
+      inBracketedPaste = false;
+      index += BRACKETED_PASTE_END.length - 1;
+      continue;
+    }
+    const byte = input[index]!;
+    if (inBracketedPaste) {
+      if (byte >= 32 && byte <= 126) {
+        nextValue += String.fromCharCode(byte);
+      }
+      continue;
+    }
     if (byte === 0x0d || byte === 0x0a) {
       submit = true;
       break;

package/src/mux/live-mux/modal-overlays.ts

@@ -36,6 +36,14 @@ interface RepositoryPromptOverlayState {
   readonly error: string | null;
 }
 
+interface ApiKeyPromptOverlayState {
+  readonly keyName: string;
+  readonly displayName: string;
+  readonly value: string;
+  readonly error: string | null;
+  readonly hasExistingValue: boolean;
+}
+
 interface ConversationTitleOverlayState {
   value: string;
   lastSavedValue: string;
@@ -252,6 +260,43 @@ export function buildRepositoryModalOverlay(
   });
 }
 
+export function buildApiKeyModalOverlay(
+  layoutCols: number,
+  viewportRows: number,
+  prompt: ApiKeyPromptOverlayState | null,
+  theme: UiModalThemeInput,
+): ReturnType<typeof buildUiModalOverlay> | null {
+  if (prompt === null) {
+    return null;
+  }
+  const modalSize = resolveGoldenModalSize(layoutCols, viewportRows, {
+    preferredHeight: 16,
+    minWidth: 34,
+    maxWidth: 64,
+  });
+  const promptValue = prompt.value.length > 0 ? prompt.value : '(enter value)';
+  const bodyLines = [`${prompt.keyName}: ${promptValue}_`];
+  if (prompt.error !== null && prompt.error.length > 0) {
+    bodyLines.push(`error: ${prompt.error}`);
+  } else if (prompt.hasExistingValue) {
+    bodyLines.push('warning: existing value detected (submit will overwrite)');
+  } else {
+    bodyLines.push('value is saved to user-global secrets.env');
+  }
+  return buildUiModalOverlay({
+    viewportCols: layoutCols,
+    viewportRows,
+    width: modalSize.width,
+    height: modalSize.height,
+    anchor: 'center',
+    marginRows: 1,
+    title: `Set ${prompt.displayName}`,
+    bodyLines,
+    footer: 'enter save  esc',
+    theme,
+  });
+}
+
 export function buildConversationTitleModalOverlay(
   layoutCols: number,
   viewportRows: number,

package/src/mux/live-mux/modal-prompt-handlers.ts

@@ -12,6 +12,14 @@ interface RepositoryPromptState {
   readonly error: string | null;
 }
 
+interface ApiKeyPromptState {
+  readonly keyName: string;
+  readonly displayName: string;
+  readonly value: string;
+  readonly error: string | null;
+  readonly hasExistingValue: boolean;
+}
+
 interface HandleAddDirectoryPromptInputOptions {
   input: Buffer;
   prompt: AddDirectoryPromptState | null;
@@ -36,6 +44,16 @@ interface HandleRepositoryPromptInputOptions {
   upsertRepositoryByRemoteUrl: (remoteUrl: string, existingRepositoryId?: string) => Promise<void>;
 }
 
+interface HandleApiKeyPromptInputOptions {
+  input: Buffer;
+  prompt: ApiKeyPromptState | null;
+  isQuitShortcut: (input: Buffer) => boolean;
+  dismissOnOutsideClick: (input: Buffer, dismiss: () => void) => boolean;
+  setPrompt: (next: ApiKeyPromptState | null) => void;
+  markDirty: () => void;
+  persistApiKey: (keyName: string, value: string) => void;
+}
+
 export function handleAddDirectoryPromptInput(
   options: HandleAddDirectoryPromptInputOptions,
 ): boolean {
@@ -185,3 +203,70 @@ export function handleRepositoryPromptInput(options: HandleRepositoryPromptInput
   markDirty();
   return true;
 }
+
+export function handleApiKeyPromptInput(options: HandleApiKeyPromptInputOptions): boolean {
+  const {
+    input,
+    prompt,
+    isQuitShortcut,
+    dismissOnOutsideClick,
+    setPrompt,
+    markDirty,
+    persistApiKey,
+  } = options;
+  if (prompt === null) {
+    return false;
+  }
+  if (input.length === 1 && input[0] === 0x03) {
+    return false;
+  }
+  if (isQuitShortcut(input)) {
+    setPrompt(null);
+    markDirty();
+    return true;
+  }
+  if (
+    dismissOnOutsideClick(input, () => {
+      setPrompt(null);
+      markDirty();
+    })
+  ) {
+    return true;
+  }
+
+  const reduced = reduceLinePromptInput(prompt.value, input);
+  const value = reduced.value;
+  if (!reduced.submit) {
+    setPrompt({
+      ...prompt,
+      value,
+      error: null,
+    });
+    markDirty();
+    return true;
+  }
+
+  const trimmed = value.trim();
+  if (trimmed.length === 0) {
+    setPrompt({
+      ...prompt,
+      value,
+      error: `${prompt.displayName.toLowerCase()} required`,
+    });
+    markDirty();
+    return true;
+  }
+  try {
+    persistApiKey(prompt.keyName, trimmed);
+    setPrompt(null);
+  } catch (error: unknown) {
+    const message = error instanceof Error ? error.message : String(error);
+    setPrompt({
+      ...prompt,
+      value,
+      error: message,
+    });
+  }
+  markDirty();
+  return true;
+}

package/src/mux/task-screen-keybindings.ts

@@ -437,10 +437,38 @@ function parseBinding(input: string): ParsedBinding | null {
 
 function bindingsForAction(raw: readonly string[]): readonly ParsedBinding[] {
   const parsed: ParsedBinding[] = [];
+
+  const pushIfUnique = (candidate: ParsedBinding): void => {
+    if (parsed.some((existing) => strokesEqual(existing.stroke, candidate.stroke))) {
+      return;
+    }
+    parsed.push(candidate);
+  };
+
+  const ctrlMetaAliasStroke = (stroke: KeyStroke): KeyStroke | null => {
+    if (stroke.ctrl === stroke.meta) {
+      return null;
+    }
+    return {
+      key: stroke.key,
+      ctrl: !stroke.ctrl,
+      alt: stroke.alt,
+      shift: stroke.shift,
+      meta: !stroke.meta,
+    };
+  };
+
   for (const value of raw) {
     const next = parseBinding(value);
     if (next !== null) {
-      parsed.push(next);
+      pushIfUnique(next);
+      const aliasStroke = ctrlMetaAliasStroke(next.stroke);
+      if (aliasStroke !== null) {
+        pushIfUnique({
+          stroke: aliasStroke,
+          originalText: next.originalText,
+        });
+      }
     }
   }
   return parsed;

package/src/services/runtime-conversation-activation.ts

@@ -30,7 +30,32 @@ export class RuntimeConversationActivation {
   async activateConversation(sessionId: string): Promise<void> {
     if (this.options.getActiveConversationId() === sessionId) {
       if (!this.options.isConversationPaneMode()) {
+        const targetConversation = this.options.conversationById(sessionId);
         this.options.enterConversationPaneForActiveSession(sessionId);
+        this.options.noteGitActivity(targetConversation?.directoryId ?? null);
+        if (
+          targetConversation !== undefined &&
+          !targetConversation.live &&
+          targetConversation.status !== 'exited'
+        ) {
+          await this.options.startConversation(sessionId);
+        }
+        if (targetConversation?.status !== 'exited') {
+          try {
+            await this.options.attachConversation(sessionId);
+          } catch (error: unknown) {
+            if (
+              !this.options.isSessionNotFoundError(error) &&
+              !this.options.isSessionNotLiveError(error)
+            ) {
+              throw error;
+            }
+            this.options.markSessionUnavailable(sessionId);
+            await this.options.startConversation(sessionId);
+            await this.options.attachConversation(sessionId);
+          }
+        }
+        this.options.schedulePtyResizeImmediate();
         this.options.markDirty();
       }
       return;

package/src/services/runtime-conversation-starter.ts

@@ -33,6 +33,13 @@ interface RuntimeConversationStarterLaunchArgsInput {
 
 type RuntimeConversationStarterSpanAttributes = Record<string, string | number | boolean>;
 
+function isSessionAlreadyExistsError(error: unknown): boolean {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  return error.message.includes('session already exists');
+}
+
 export interface RuntimeConversationStarterOptions<
   TConversation extends RuntimeConversationStarterConversationRecord,
   TSessionSummary,
@@ -134,19 +141,36 @@ export class RuntimeConversationStarter<
       if (this.options.terminalBackgroundHex !== undefined) {
         ptyStartInput.terminalBackgroundHex = this.options.terminalBackgroundHex;
       }
-      await this.options.startPtySession(ptyStartInput);
+      let startedSession = false;
+      try {
+        await this.options.startPtySession(ptyStartInput);
+        startedSession = true;
+      } catch (error: unknown) {
+        if (!isSessionAlreadyExistsError(error)) {
+          throw error;
+        }
+      }
       this.options.setPtySize(sessionId, {
         cols: layout.rightCols,
         rows: layout.paneRows,
       });
       this.options.sendResize(sessionId, layout.rightCols, layout.paneRows);
-      this.endStartCommandSpanIfTarget(sessionId, {
-        alreadyLive: false,
-        argCount: launchArgs.length,
-        resumed: launchArgs[0] === 'resume',
-      });
+      if (startedSession) {
+        this.endStartCommandSpanIfTarget(sessionId, {
+          alreadyLive: false,
+          argCount: launchArgs.length,
+          resumed: launchArgs[0] === 'resume',
+        });
+      } else {
+        this.endStartCommandSpanIfTarget(sessionId, {
+          alreadyLive: true,
+          recoveredDuplicateStart: true,
+        });
+      }
       const state = this.options.ensureConversation(sessionId);
-      this.options.recordStartCommand(sessionId, launchArgs);
+      if (startedSession) {
+        this.options.recordStartCommand(sessionId, launchArgs);
+      }
       const statusSummary = await this.options.getSessionStatus(sessionId);
       if (statusSummary !== null) {
         this.options.upsertFromSessionSummary(statusSummary);

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

@@ -41,6 +41,7 @@ interface RuntimeInputRouterOptions {
   readonly scheduleConversationTitlePersist: () => void;
   readonly resolveCommandMenuActions: () => readonly CommandMenuActionDescriptor[];
   readonly executeCommandMenuAction: (actionId: string) => void;
+  readonly persistApiKey?: RuntimeModalInputOptions['persistApiKey'];
   readonly requestStop: RuntimeRailInputOptions['requestStop'];
   readonly resolveDirectoryForAction: RuntimeRailInputOptions['resolveDirectoryForAction'];
   readonly toggleCommandMenu: RuntimeRailInputOptions['toggleCommandMenu'];
@@ -112,6 +113,11 @@ export class RuntimeInputRouter {
       scheduleConversationTitlePersist: options.scheduleConversationTitlePersist,
       resolveCommandMenuActions: options.resolveCommandMenuActions,
       executeCommandMenuAction: options.executeCommandMenuAction,
+      ...(options.persistApiKey === undefined
+        ? {}
+        : {
+            persistApiKey: options.persistApiKey,
+          }),
     });
     const runtimeRailOptions: RuntimeRailInputOptions = {
       workspace: options.workspace,

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

@@ -37,6 +37,7 @@ interface RuntimeModalInputOptions {
   readonly scheduleConversationTitlePersist: () => void;
   readonly resolveCommandMenuActions: () => readonly CommandMenuActionDescriptor[];
   readonly executeCommandMenuAction: (actionId: string) => void;
+  readonly persistApiKey?: (keyName: string, value: string) => void;
   readonly markDirty: () => void;
 }
 
@@ -97,6 +98,23 @@ export class RuntimeModalInput {
       submitTaskEditorPayload: (payload) => {
         options.taskEditorActions.submitTaskEditorPayload(payload);
       },
+      ...(options.persistApiKey === undefined
+        ? {}
+        : {
+            getApiKeyPrompt: () => options.workspace.apiKeyPrompt,
+            setApiKeyPrompt: (
+              next: {
+                keyName: string;
+                displayName: string;
+                value: string;
+                error: string | null;
+                hasExistingValue: boolean;
+              } | null,
+            ) => {
+              options.workspace.apiKeyPrompt = next;
+            },
+            persistApiKey: options.persistApiKey,
+          }),
       getConversationTitleEdit: () => options.workspace.conversationTitleEdit,
       getNewThreadPrompt: () => options.workspace.newThreadPrompt,
       setNewThreadPrompt: (prompt) => {