@jmoyers/harness 0.1.9 → 0.1.11

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

@@ -9,6 +9,7 @@ type MuxGlobalShortcutAction =
   | 'mux.conversation.critique.open-or-create'
   | 'mux.conversation.next'
   | 'mux.conversation.previous'
+  | 'mux.conversation.titles.refresh-all'
   | 'mux.conversation.interrupt'
   | 'mux.conversation.archive'
   | 'mux.conversation.takeover'
@@ -47,6 +48,7 @@ const ACTION_ORDER: readonly MuxGlobalShortcutAction[] = [
   'mux.conversation.critique.open-or-create',
   'mux.conversation.next',
   'mux.conversation.previous',
+  'mux.conversation.titles.refresh-all',
   'mux.conversation.interrupt',
   'mux.conversation.archive',
   'mux.conversation.takeover',
@@ -68,6 +70,7 @@ const DEFAULT_MUX_SHORTCUT_BINDINGS_RAW: Readonly<
   'mux.conversation.critique.open-or-create': ['ctrl+g'],
   'mux.conversation.next': ['ctrl+j'],
   'mux.conversation.previous': ['ctrl+k'],
+  'mux.conversation.titles.refresh-all': ['ctrl+r'],
   'mux.conversation.interrupt': [],
   'mux.conversation.archive': [],
   'mux.conversation.takeover': ['ctrl+l'],
@@ -538,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;
@@ -580,6 +611,9 @@ function withDefaultBindings(
     'mux.conversation.previous':
       overrides?.['mux.conversation.previous'] ??
       DEFAULT_MUX_SHORTCUT_BINDINGS_RAW['mux.conversation.previous'],
+    'mux.conversation.titles.refresh-all':
+      overrides?.['mux.conversation.titles.refresh-all'] ??
+      DEFAULT_MUX_SHORTCUT_BINDINGS_RAW['mux.conversation.titles.refresh-all'],
     'mux.conversation.interrupt':
       overrides?.['mux.conversation.interrupt'] ??
       DEFAULT_MUX_SHORTCUT_BINDINGS_RAW['mux.conversation.interrupt'],
@@ -625,6 +659,9 @@ export function resolveMuxShortcutBindings(
       ),
       'mux.conversation.next': parseBindingsForAction(rawByAction['mux.conversation.next']),
       'mux.conversation.previous': parseBindingsForAction(rawByAction['mux.conversation.previous']),
+      'mux.conversation.titles.refresh-all': parseBindingsForAction(
+        rawByAction['mux.conversation.titles.refresh-all'],
+      ),
       'mux.conversation.interrupt': parseBindingsForAction(
         rawByAction['mux.conversation.interrupt'],
       ),

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;
@@ -98,6 +114,30 @@ export function shouldShowGitHubPrActions(input: {
   return normalizedTrackedBranch !== 'main';
 }
 
+function normalizeTrackedBranchForActions(value: string | null): string | null {
+  const trimmed = value?.trim() ?? '';
+  if (
+    trimmed.length === 0 ||
+    trimmed === '(detached)' ||
+    trimmed === '(loading)' ||
+    trimmed === 'HEAD'
+  ) {
+    return null;
+  }
+  return trimmed;
+}
+
+export function resolveGitHubTrackedBranchForActions(input: {
+  projectTrackedBranch: string | null;
+  currentBranch: string | null;
+}): string | null {
+  const trackedBranch = normalizeTrackedBranchForActions(input.projectTrackedBranch);
+  if (trackedBranch !== null) {
+    return trackedBranch;
+  }
+  return normalizeTrackedBranchForActions(input.currentBranch);
+}
+
 export function parseCommitCount(output: string): number | null {
   const trimmed = output.trim();
   if (trimmed.length === 0 || !/^\d+$/u.test(trimmed)) {

package/src/mux/live-mux/global-shortcut-handlers.ts

@@ -14,6 +14,7 @@ interface HandleGlobalShortcutOptions {
   conversationsHas: (sessionId: string) => boolean;
   queueControlPlaneOp: (task: () => Promise<void>, label: string) => void;
   archiveConversation: (sessionId: string) => Promise<void>;
+  refreshAllConversationTitles: () => Promise<void>;
   interruptConversation: (sessionId: string) => Promise<void>;
   takeoverConversation: (sessionId: string) => Promise<void>;
   openAddDirectoryPrompt: () => void;
@@ -37,6 +38,7 @@ export function handleGlobalShortcut(options: HandleGlobalShortcutOptions): bool
     conversationsHas,
     queueControlPlaneOp,
     archiveConversation,
+    refreshAllConversationTitles,
     interruptConversation,
     takeoverConversation,
     openAddDirectoryPrompt,
@@ -104,6 +106,12 @@ export function handleGlobalShortcut(options: HandleGlobalShortcutOptions): bool
     }
     return true;
   }
+  if (shortcut === 'mux.conversation.titles.refresh-all') {
+    queueControlPlaneOp(async () => {
+      await refreshAllConversationTitles();
+    }, 'shortcut-refresh-conversation-titles');
+    return true;
+  }
   if (shortcut === 'mux.conversation.interrupt') {
     const targetConversationId = resolveConversationForAction();
     if (targetConversationId !== null && conversationsHas(targetConversationId)) {

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/render-frame.ts

@@ -51,7 +51,7 @@ export function buildRenderRows(
   const statusText =
     statusRowDetailText === undefined || statusRowDetailText.length === 0
       ? defaultStatus
-      : `${defaultStatus}  ${statusRowDetailText}`;
+      : `${statusRowDetailText}  ${defaultStatus}`;
   const status = padOrTrimDisplay(statusText, layout.cols);
   rows.push(status);
   return rows;

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/control-plane.ts

@@ -245,6 +245,28 @@ export class ControlPlaneService {
     return parseConversationRecord(result['conversation']);
   }
 
+  async refreshConversationTitle(conversationId: string): Promise<{
+    status: 'updated' | 'unchanged' | 'skipped';
+    reason: string | null;
+  }> {
+    const result = await this.client.sendCommand({
+      type: 'conversation.title.refresh',
+      conversationId,
+    });
+    const status = result['status'];
+    if (status !== 'updated' && status !== 'unchanged' && status !== 'skipped') {
+      throw new Error('control-plane conversation.title.refresh returned malformed status');
+    }
+    const reason = result['reason'];
+    if (reason !== null && reason !== undefined && typeof reason !== 'string') {
+      throw new Error('control-plane conversation.title.refresh returned malformed reason');
+    }
+    return {
+      status,
+      reason: reason ?? null,
+    };
+  }
+
   async archiveConversation(conversationId: string): Promise<void> {
     await this.client.sendCommand({
       type: 'conversation.archive',

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

@@ -21,6 +21,13 @@ interface RuntimeGatewayRenderTraceResult {
   readonly message: string;
 }
 
+interface RuntimeConversationTitleRefreshResult {
+  readonly status: 'updated' | 'unchanged' | 'skipped';
+  readonly reason: string | null;
+}
+
+const THREAD_TITLE_AGENT_TYPES = new Set(['codex', 'claude', 'cursor']);
+
 interface RuntimeControlActionsOptions<TConversation extends RuntimeConversationControlState> {
   readonly conversationById: (sessionId: string) => TConversation | undefined;
   readonly interruptSession: (sessionId: string) => Promise<RuntimeInterruptResult>;
@@ -43,6 +50,11 @@ interface RuntimeControlActionsOptions<TConversation extends RuntimeConversation
   readonly sessionName: string | null;
   readonly setTaskPaneNotice: (message: string) => void;
   readonly setDebugFooterNotice: (message: string) => void;
+  readonly listConversationIdsForTitleRefresh?: () => readonly string[];
+  readonly conversationAgentTypeForTitleRefresh?: (sessionId: string) => string | null;
+  readonly refreshConversationTitle?: (
+    sessionId: string,
+  ) => Promise<RuntimeConversationTitleRefreshResult>;
 }
 
 export class RuntimeControlActions<TConversation extends RuntimeConversationControlState> {
@@ -109,6 +121,63 @@ export class RuntimeControlActions<TConversation extends RuntimeConversationCont
     }
   }
 
+  async refreshAllConversationTitles(): Promise<void> {
+    const listConversationIds = this.options.listConversationIdsForTitleRefresh;
+    const resolveAgentType = this.options.conversationAgentTypeForTitleRefresh;
+    const refreshConversationTitle = this.options.refreshConversationTitle;
+    if (
+      listConversationIds === undefined ||
+      resolveAgentType === undefined ||
+      refreshConversationTitle === undefined
+    ) {
+      this.setNotices(this.scopeMessage('thread-title', 'refresh unavailable'));
+      this.options.markDirty();
+      return;
+    }
+    const allConversationIds = listConversationIds();
+    const eligibleConversationIds = allConversationIds.filter((sessionId) => {
+      const agentType = resolveAgentType(sessionId)?.trim().toLowerCase();
+      return agentType !== undefined && THREAD_TITLE_AGENT_TYPES.has(agentType);
+    });
+    if (eligibleConversationIds.length === 0) {
+      this.setNotices(this.scopeMessage('thread-title', 'no agent threads to refresh'));
+      this.options.markDirty();
+      return;
+    }
+    const total = eligibleConversationIds.length;
+    let updated = 0;
+    let unchanged = 0;
+    let skipped = 0;
+    this.setNotices(this.scopeMessage('thread-title', `refreshing names 0/${String(total)}`));
+    this.options.markDirty();
+    for (let index = 0; index < eligibleConversationIds.length; index += 1) {
+      const sessionId = eligibleConversationIds[index]!;
+      try {
+        const result = await refreshConversationTitle(sessionId);
+        if (result.status === 'updated') {
+          updated += 1;
+        } else if (result.status === 'unchanged') {
+          unchanged += 1;
+        } else {
+          skipped += 1;
+        }
+      } catch {
+        skipped += 1;
+      }
+      this.setNotices(
+        this.scopeMessage('thread-title', `refreshing names ${String(index + 1)}/${String(total)}`),
+      );
+      this.options.markDirty();
+    }
+    this.setNotices(
+      this.scopeMessage(
+        'thread-title',
+        `refreshed ${String(updated)} updated ${String(unchanged)} unchanged ${String(skipped)} skipped`,
+      ),
+    );
+    this.options.markDirty();
+  }
+
   private scopeMessage(prefix: string, message: string): string {
     if (this.options.sessionName === null) {
       return `[${prefix}] ${message}`;

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;