clisbot 0.1.54-beta.2 → 0.1.54-beta.3

package/dist/main.js

@@ -88771,6 +88771,11 @@ import { dirname as dirname6, join as join8, sep } from "node:path";
 // src/control/runner/runner-exit-diagnostics.ts
 import { unlink as unlink2 } from "node:fs/promises";
 import { dirname as dirname5, join as join7 } from "node:path";
+var RUNNER_EXIT_SENTINEL_PREFIX = "[clisbot] runner exited with status";
+var RUNNER_EXIT_LINGER_SECONDS = 8;
+function paneShowsRunnerExitSentinel(snapshot) {
+  return snapshot.includes(RUNNER_EXIT_SENTINEL_PREFIX);
+}
 function shellQuote(value) {
   if (/^[a-zA-Z0-9_./:@=-]+$/.test(value)) {
     return value;
@@ -88787,6 +88792,7 @@ function getRunnerExitRecordPath(stateDir, sessionName) {
   return join7(stateDir, "runner-exits", `${sanitizeSessionName2(sessionName)}.json`);
 }
 function buildRunnerLaunchCommand(params) {
+  const exitLingerSeconds = params.exitLingerSeconds ?? RUNNER_EXIT_LINGER_SECONDS;
   const runnerCommand = buildCommandString(params.command, params.args);
   const exitRecordPath = getRunnerExitRecordPath(params.stateDir, params.sessionName);
   const exitWriterScript = [
@@ -88809,6 +88815,7 @@ function buildRunnerLaunchCommand(params) {
     runnerCommand,
     "status=$?",
     `node -e ${shellQuote(exitWriterScript)} ${shellQuote(exitRecordPath)} ${shellQuote(params.sessionName)} "$status" ${shellQuote(runnerCommand)} || true`,
+    `if [ "$status" -ne 0 ]; then echo ${shellQuote(`${RUNNER_EXIT_SENTINEL_PREFIX} `)}"$status"; sleep ${exitLingerSeconds}; fi`,
     'exit "$status"'
   ].join("; ");
 }
@@ -92148,9 +92155,8 @@ var PASTE_CONFIRM_MAX_ATTEMPTS = 3;
 var PASTE_CAPTURE_REVALIDATE_POLL_INTERVAL_MS = 40;
 var PASTE_CAPTURE_REVALIDATE_MAX_WAIT_MS = 160;
 var SUBMIT_CONFIRM_POLL_INTERVAL_MS = 40;
-var SUBMIT_CONFIRM_MAX_WAIT_MS = 160;
-var SUBMIT_SNAPSHOT_CONFIRM_POLL_INTERVAL_MS = 40;
-var SUBMIT_SNAPSHOT_CONFIRM_MAX_WAIT_MS = 320;
+var SUBMIT_CONFIRM_MAX_WAIT_MS = 600;
+var SUBMIT_ENTER_MAX_ATTEMPTS = 3;
 var POST_STATUS_SETTLE_POLL_INTERVAL_MS = 40;
 var POST_STATUS_SETTLE_QUIET_WINDOW_MS = 80;
 var POST_STATUS_SETTLE_MAX_WAIT_MS = 240;
@@ -92160,9 +92166,11 @@ var TMUX_SERVER_UNAVAILABLE_PATTERN = /(?:No such file or directory|error connec
 
 class TmuxBootstrapSessionLostError extends Error {
   sessionName;
-  constructor(sessionName, detail) {
+  lastSnapshot;
+  constructor(sessionName, detail, lastSnapshot = "") {
     super(`tmux bootstrap lost session "${sessionName}": ${detail}`);
     this.sessionName = sessionName;
+    this.lastSnapshot = lastSnapshot;
     this.name = "TmuxBootstrapSessionLostError";
   }
 }
@@ -92178,7 +92186,11 @@ class TmuxPasteUnconfirmedError extends Error {
 
 class TmuxSubmitUnconfirmedError extends Error {
   constructor() {
-    super("tmux submit was not confirmed after Enter. The pane state did not change, so clisbot did not treat the prompt as truthfully submitted.");
+    super([
+      "tmux submit was not confirmed after Enter: the pane did not change, so clisbot does not treat the prompt as truthfully submitted.",
+      "The runner may be busy, redrawing slowly, or showing a blocking prompt.",
+      "Check the live pane with `clisbot watch --latest --lines 100`; if your text is sitting unsubmitted there, send /nudge, otherwise resend the message."
+    ].join(" "));
     this.name = "TmuxSubmitUnconfirmedError";
   }
 }
@@ -92215,36 +92227,97 @@ async function submitTmuxSessionInput(params) {
   }
   const preSubmitState = pasteDelivery.state;
   const preSubmitSnapshot = normalizePaneText(await params.tmux.capturePane(params.sessionName, captureLines));
-  await params.tmux.sendKey(params.sessionName, "Enter");
-  const submitted = await waitForPaneSubmitConfirmation({
-    tmux: params.tmux,
-    sessionName: params.sessionName,
-    baseline: preSubmitState,
-    baselineSnapshot: preSubmitSnapshot,
-    captureLines
-  });
-  if (submitted.confirmed) {
-    return { submittedSnapshot: preSubmitSnapshot };
-  }
-  logLatencyDebug("tmux-submit-enter-retry", params.timingContext, {
-    sessionName: params.sessionName
-  });
-  await params.tmux.sendKey(params.sessionName, "Enter");
-  const retrySubmitted = await waitForPaneSubmitConfirmation({
-    tmux: params.tmux,
-    sessionName: params.sessionName,
-    baseline: preSubmitState,
-    baselineSnapshot: preSubmitSnapshot,
-    captureLines
-  });
-  if (retrySubmitted.confirmed) {
-    return { submittedSnapshot: preSubmitSnapshot };
+  for (let attempt = 1;attempt <= SUBMIT_ENTER_MAX_ATTEMPTS; attempt += 1) {
+    if (attempt > 1) {
+      logLatencyDebug("tmux-submit-enter-retry", params.timingContext, {
+        sessionName: params.sessionName,
+        attempt
+      });
+    }
+    await params.tmux.sendKey(params.sessionName, "Enter");
+    const outcome = await waitForSubmitSettled({
+      tmux: params.tmux,
+      sessionName: params.sessionName,
+      baseline: preSubmitState,
+      baselineSnapshot: preSubmitSnapshot,
+      text: params.text,
+      captureLines
+    });
+    if (outcome === "submitted") {
+      return { submittedSnapshot: preSubmitSnapshot };
+    }
   }
   logLatencyDebug("tmux-submit-unconfirmed", params.timingContext, {
     sessionName: params.sessionName
   });
   throw new TmuxSubmitUnconfirmedError;
 }
+async function waitForSubmitSettled(params) {
+  const deadline = Date.now() + SUBMIT_CONFIRM_MAX_WAIT_MS;
+  let sawChange = false;
+  while (true) {
+    let changed = sawChange;
+    if (!changed) {
+      const state = await params.tmux.getPaneState(params.sessionName);
+      changed = hasPaneStateChanged(params.baseline, state);
+    }
+    const snapshot = normalizePaneText(await params.tmux.capturePane(params.sessionName, params.captureLines));
+    if (!changed) {
+      changed = snapshot !== params.baselineSnapshot;
+    }
+    if (changed) {
+      sawChange = true;
+      if (!paneShowsPendingComposerText(snapshot, params.text)) {
+        return "submitted";
+      }
+    }
+    const remainingMs = deadline - Date.now();
+    if (remainingMs <= 0) {
+      return sawChange ? "pending-input" : "unchanged";
+    }
+    await sleep(Math.min(SUBMIT_CONFIRM_POLL_INTERVAL_MS, remainingMs));
+  }
+}
+var COMPOSER_HINT_LINE_PATTERN = /^\?\s+for shortcuts|^Type your message or @path\/to\/file|^\d+%\s+context left|^press enter to send/i;
+var COMPOSER_RUNNING_INDICATOR_PATTERN = /esc to interrupt/i;
+var COMPOSER_BORDER_LINE_PATTERN = /^[─━═╌╍╭╮╰╯┌┐└┘+|\-_=\s]+$/;
+var COMPOSER_TAIL_SCAN_LINES = 12;
+function paneShowsPendingComposerText(snapshot, text) {
+  const lastPromptLine = collapseWhitespace(lastNonEmptyLine(text));
+  if (!lastPromptLine) {
+    return false;
+  }
+  const lines = trimBlankLines(splitNormalizedLines(snapshot));
+  for (let index = lines.length - 1;index >= Math.max(0, lines.length - COMPOSER_TAIL_SCAN_LINES); index -= 1) {
+    const line = (lines[index] ?? "").trim();
+    if (!line || COMPOSER_HINT_LINE_PATTERN.test(line) || isPromptMetadataLine(line)) {
+      continue;
+    }
+    if (COMPOSER_RUNNING_INDICATOR_PATTERN.test(line)) {
+      return false;
+    }
+    if (COMPOSER_BORDER_LINE_PATTERN.test(line)) {
+      continue;
+    }
+    const stripped = stripComposerChrome(line);
+    if (!stripped) {
+      return false;
+    }
+    return stripped === lastPromptLine;
+  }
+  return false;
+}
+function stripComposerChrome(line) {
+  return collapseWhitespace(line.replace(/^[│┃]\s*/, "").replace(/\s*[│┃]$/, "").replace(/^[›❯>]+\s*/, ""));
+}
+function lastNonEmptyLine(text) {
+  const lines = text.split(`
+`).map((line) => line.trim()).filter(Boolean);
+  return lines[lines.length - 1] ?? "";
+}
+function collapseWhitespace(value) {
+  return value.replace(/\s+/g, " ").trim();
+}
 async function captureTmuxSessionIdentity(params) {
   await acceptTmuxStartupContinuePromptIfPresent({
     tmux: params.tmux,
@@ -92389,7 +92462,7 @@ async function waitForTmuxSessionBootstrap(params) {
         continue;
       }
       if (isBootstrapSessionGoneError(error)) {
-        throw buildBootstrapSessionLostError(params.sessionName, error);
+        throw buildBootstrapSessionLostError(params.sessionName, error, lastSnapshot);
       }
       throw error;
     }
@@ -92407,6 +92480,18 @@ async function waitForTmuxSessionBootstrap(params) {
         await sleep(SESSION_BOOTSTRAP_POLL_INTERVAL_MS);
         continue;
       }
+      if (params.resumeRejection?.detect(snapshot)) {
+        return {
+          status: "resume-rejected",
+          snapshot
+        };
+      }
+      if (params.exitDetection?.detect(snapshot)) {
+        return {
+          status: "exited",
+          snapshot
+        };
+      }
       for (const blocker of blockerPatterns) {
         if (blocker.regex.test(snapshot)) {
           return {
@@ -92457,56 +92542,6 @@ async function acceptStartupContinuePrompt(params) {
     return;
   }
 }
-async function waitForPaneSubmitConfirmation(params) {
-  const deadline = Date.now() + SUBMIT_CONFIRM_MAX_WAIT_MS;
-  while (true) {
-    const state = await params.tmux.getPaneState(params.sessionName);
-    if (hasPaneStateChanged(params.baseline, state)) {
-      return {
-        confirmed: true,
-        snapshot: normalizePaneText(await params.tmux.capturePane(params.sessionName, params.captureLines))
-      };
-    }
-    const snapshotChange = await waitForPaneSubmitSnapshotConfirmation({
-      tmux: params.tmux,
-      sessionName: params.sessionName,
-      baselineSnapshot: params.baselineSnapshot,
-      captureLines: params.captureLines,
-      maxWaitMs: Math.min(SUBMIT_SNAPSHOT_CONFIRM_MAX_WAIT_MS, Math.max(0, deadline - Date.now()))
-    });
-    if (snapshotChange.confirmed) {
-      return snapshotChange;
-    }
-    const remainingMs = deadline - Date.now();
-    if (remainingMs <= 0) {
-      return {
-        confirmed: false,
-        snapshot: params.baselineSnapshot
-      };
-    }
-    await sleep(Math.min(SUBMIT_CONFIRM_POLL_INTERVAL_MS, remainingMs));
-  }
-}
-async function waitForPaneSubmitSnapshotConfirmation(params) {
-  const deadline = Date.now() + params.maxWaitMs;
-  while (true) {
-    const snapshot = normalizePaneText(await params.tmux.capturePane(params.sessionName, params.captureLines));
-    if (snapshot !== params.baselineSnapshot) {
-      return {
-        confirmed: true,
-        snapshot
-      };
-    }
-    const remainingMs = deadline - Date.now();
-    if (remainingMs <= 0) {
-      return {
-        confirmed: false,
-        snapshot: params.baselineSnapshot
-      };
-    }
-    await sleep(Math.min(SUBMIT_SNAPSHOT_CONFIRM_POLL_INTERVAL_MS, remainingMs));
-  }
-}
 async function deliverTmuxPasteWithConfirmation(params) {
   for (let attempt = 1;attempt <= PASTE_CONFIRM_MAX_ATTEMPTS; attempt += 1) {
     if (attempt > 1) {
@@ -92645,9 +92680,9 @@ function isBootstrapSessionGoneError(error) {
   const message = error instanceof Error ? error.message : String(error);
   return TMUX_MISSING_SESSION_PATTERN.test(message) || TMUX_SERVER_UNAVAILABLE_PATTERN.test(message);
 }
-function buildBootstrapSessionLostError(sessionName, error) {
+function buildBootstrapSessionLostError(sessionName, error, lastSnapshot = "") {
   const message = error instanceof Error ? error.message : String(error);
-  return new TmuxBootstrapSessionLostError(sessionName, message);
+  return new TmuxBootstrapSessionLostError(sessionName, message, lastSnapshot);
 }
 function arePaneStatesEqual(left, right) {
   return left.cursorX === right.cursorX && left.cursorY === right.cursorY && left.historySize === right.historySize;
@@ -92863,6 +92898,132 @@ function escapeRegExp(raw) {
   return raw.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
+// src/runners/resume-rejection.ts
+var RESUME_REJECTED_PATTERNS = [
+  /no saved session found with id/i,
+  /no conversation found with session id/i,
+  /no conversation found to resume/i,
+  /no session found with id/i,
+  /could not find (?:a )?session (?:with )?id/i
+];
+function paneShowsResumeRejected(snapshot) {
+  if (!snapshot) {
+    return false;
+  }
+  return RESUME_REJECTED_PATTERNS.some((pattern) => pattern.test(snapshot));
+}
+
+class RunnerResumeRejectedError extends Error {
+  sessionName;
+  storedSessionId;
+  lastPane;
+  constructor(sessionName, storedSessionId, lastPane = "") {
+    super(`Runner session "${sessionName}" could not resume stored session id ${storedSessionId}: the runner reported that this saved session no longer exists.`);
+    this.sessionName = sessionName;
+    this.storedSessionId = storedSessionId;
+    this.lastPane = lastPane;
+    this.name = "RunnerResumeRejectedError";
+  }
+}
+
+// src/runners/runner-state-failures.ts
+var STATE_CONTENTION_PATTERNS = [
+  /database (?:table )?is locked/i,
+  /SQLITE_BUSY/i,
+  /timed out waiting for state db backfill/i,
+  /unable to open database file/i
+];
+var STATE_CORRUPTION_PATTERNS = [
+  /file is not a database/i,
+  /database disk image is malformed/i,
+  /migration \d+ was previously applied but has been modified/i,
+  /cannot access its local database/i
+];
+function paneShowsRunnerStateContention(snapshot) {
+  if (!snapshot) {
+    return false;
+  }
+  return STATE_CONTENTION_PATTERNS.some((pattern) => pattern.test(snapshot));
+}
+function paneShowsRunnerStateCorruption(snapshot) {
+  if (!snapshot) {
+    return false;
+  }
+  return STATE_CORRUPTION_PATTERNS.some((pattern) => pattern.test(snapshot));
+}
+
+class RunnerStateContentionError extends Error {
+  sessionName;
+  lastPane;
+  constructor(sessionName, lastPane = "") {
+    super([
+      `Runner session "${sessionName}" could not start because the runner's local state database is locked by another running runner process (shared CODEX_HOME contention).`,
+      "Nothing was lost: the stored session id and saved conversation were preserved.",
+      "Resend your prompt to retry once the other run settles.",
+      "If this keeps happening, avoid starting many runner sessions at the same time or give this agent its own CODEX_HOME."
+    ].join(" "));
+    this.sessionName = sessionName;
+    this.lastPane = lastPane;
+    this.name = "RunnerStateContentionError";
+  }
+}
+
+class RunnerStateCorruptionError extends Error {
+  sessionName;
+  lastPane;
+  constructor(sessionName, lastPane = "") {
+    super([
+      `Runner session "${sessionName}" cannot start: the runner reported that its local state database is corrupted or version-mismatched.`,
+      "Retrying will not help. An operator must repair the runner state in CODEX_HOME (for codex this is usually state_5.sqlite / logs_2.sqlite; see the runner's own error output).",
+      "The stored session id was preserved for after the repair."
+    ].join(" "));
+    this.sessionName = sessionName;
+    this.lastPane = lastPane;
+    this.name = "RunnerStateCorruptionError";
+  }
+}
+
+// src/agents/session/run-recovery.ts
+var MID_RUN_RECOVERY_MAX_ATTEMPTS = 2;
+var MID_RUN_RECOVERY_CONTINUE_PROMPT = "continue exactly where you left off";
+function mergeRunSnapshot(snapshotPrefix, snapshot) {
+  return appendInteractionText(snapshotPrefix, snapshot);
+}
+function buildRunRecoveryNote(kind, params) {
+  const storedIdDetail = params?.storedSessionId ? ` (stored session id ${params.storedSessionId})` : "";
+  if (kind === "resume-attempt") {
+    const attempt = params?.attempt ?? 1;
+    const maxAttempts = params?.maxAttempts ?? MID_RUN_RECOVERY_MAX_ATTEMPTS;
+    return `Runner session was lost. Attempting recovery ${attempt}/${maxAttempts} by reopening the same conversation context.`;
+  }
+  if (kind === "resume-success") {
+    return "Recovery succeeded. Asking the runner to continue exactly where it left off.";
+  }
+  if (kind === "fresh-attempt") {
+    return "The previous runner session could not be resumed. Opening a fresh runner session 2/2 without replaying your prompt.";
+  }
+  if (kind === "resume-failed") {
+    return `The previous runner session could not be resumed${storedIdDetail}. The stored session id was preserved so the conversation can still be retried.`;
+  }
+  if (kind === "manual-new-required") {
+    return [
+      `The previous runner session could not be resumed, so the interrupted run stopped${storedIdDetail}.`,
+      "clisbot preserved the stored session id instead of silently opening a new conversation, because the run was already in progress and its context may matter.",
+      "Next steps: resend your prompt - clisbot will retry resuming this conversation and automatically fall back to a fresh one if the runner no longer has it.",
+      "Send `/new` first if you prefer to start a clean conversation."
+    ].join(" ");
+  }
+  return "The previous runner session could not be resumed. clisbot opened a new fresh session, but did not replay your prompt because the prior conversation context is no longer guaranteed. Please resend the full prompt/context to continue.";
+}
+function buildResumeRejectedFreshStartNote(params) {
+  const cause = params.reason === "rejected" ? `the runner reported that saved session ${params.storedSessionId} no longer exists` : `the runner kept exiting while resuming saved session ${params.storedSessionId}`;
+  const inspectHint = params.resumeCommand ? ` To inspect the old session manually, try \`${params.resumeCommand}\` in the workspace terminal.` : "";
+  return [
+    `The previous runner conversation could not be resumed: ${cause}.`,
+    "clisbot opened a fresh conversation and is running your prompt there; earlier conversation context is not carried over."
+  ].join(" ") + inspectHint;
+}
+
 // src/agents/runtime/runner-service.ts
 var TMUX_MISSING_SESSION_PATTERN2 = /(?:can't find session:|no server running on )/i;
 var TMUX_SERVER_UNAVAILABLE_PATTERN2 = /(?:No such file or directory|error connecting to|failed to connect to server)/i;
@@ -92873,7 +93034,6 @@ var SESSION_READY_CAPTURE_RETRY_DELAY_MS = 100;
 var STARTUP_SESSION_ID_CAPTURE_RETRY_COUNT = 2;
 var STARTUP_SESSION_ID_CAPTURE_RETRY_DELAY_MS = 500;
 var SESSION_ID_CAPTURE_FAILURE_COOLDOWN_MS = 15000;
-var PRESERVED_SESSION_ID_RETRY_MESSAGE = "The previous runner session could not be resumed. clisbot preserved the stored session id instead of opening a new conversation automatically. Use `/new` if you want to trigger a new runner conversation, then resend the prompt.";
 function summarizeSnapshot(snapshot) {
   const compact = snapshot.split(`
 `).map((line) => line.trim()).filter(Boolean).join(" ").slice(0, 220);
@@ -92924,15 +93084,18 @@ class RunnerService {
   async mapSessionError(error, sessionName, action, lastSnapshot = "") {
     if (isRecoverableStartupSessionLoss(error)) {
       const exitRecord = await readRunnerExitRecord(this.loadedConfig.stateDir, sessionName);
+      const paneSnapshot = lastSnapshot || (error instanceof TmuxBootstrapSessionLostError ? error.lastSnapshot : "");
       console.error("runner session disappeared", {
         sessionName,
         action,
         exitCode: exitRecord?.exitCode,
         exitedAt: exitRecord?.exitedAt,
         runnerCommand: exitRecord?.command,
-        lastVisiblePane: lastSnapshot ? summarizeSnapshot(lastSnapshot).trim() : undefined
+        lastVisiblePane: paneSnapshot ? summarizeSnapshot(paneSnapshot).trim() : undefined
       });
-      return new Error(`Runner session "${sessionName}" disappeared ${action}.`);
+      const exitDetail = typeof exitRecord?.exitCode === "number" ? ` The runner process exited with code ${exitRecord.exitCode}.` : "";
+      const nextStep = action === "while the prompt was running" ? `The prompt may have partially run; check ${renderCliCommand("watch --latest --lines 100", { inline: true })} before resending.` : "Your prompt was not submitted; resend it to retry.";
+      return new Error(`Runner session "${sessionName}" disappeared ${action}.${exitDetail} ${nextStep} If this keeps happening, verify the runner CLI starts cleanly in the workspace terminal and inspect ${renderCliCommand("logs", { inline: true })}.${summarizeSnapshot(paneSnapshot)}`);
     }
     if (isTransientTmuxTargetError(error)) {
       return new Error(`Runner session "${sessionName}" lost its tmux target ${action}. clisbot stayed alive, but this request could not continue cleanly. Retry once. If it keeps happening, inspect ${renderCliCommand("status", { inline: true })} and ${renderCliCommand("logs", { inline: true })}.${summarizeSnapshot(lastSnapshot)}`);
@@ -93030,7 +93193,7 @@ class RunnerService {
       pollIntervalMs: capture.pollIntervalMs
     });
   }
-  async retryRunnerRestartPreservingSessionId(target, resolved, remainingFreshRetries) {
+  async retryRunnerRestartPreservingSessionId(target, resolved, remainingFreshRetries, startupNotes) {
     if (remainingFreshRetries <= 0) {
       return null;
     }
@@ -93039,44 +93202,113 @@ class RunnerService {
       await sleep(resolved.runner.startupRetryDelayMs);
     }
     return this.ensureSessionReady(target, {
-      remainingFreshRetries: remainingFreshRetries - 1
+      remainingFreshRetries: remainingFreshRetries - 1,
+      startupNotes
     });
   }
-  async retryAfterStartupFault(target, resolved, error, remainingFreshRetries, allowFreshResumeFallback) {
+  classifyRunnerStartupExit(resolved, snapshot) {
+    if (paneShowsRunnerStateCorruption(snapshot)) {
+      return new RunnerStateCorruptionError(resolved.sessionName, snapshot);
+    }
+    if (paneShowsRunnerStateContention(snapshot)) {
+      return new RunnerStateContentionError(resolved.sessionName, snapshot);
+    }
+    return new TmuxBootstrapSessionLostError(resolved.sessionName, "runner exited during startup", snapshot);
+  }
+  async retryAfterStateContention(target, resolved, remainingFreshRetries, startupNotes) {
+    if (remainingFreshRetries <= 0) {
+      return null;
+    }
+    const attempt = resolved.runner.startupRetryCount - remainingFreshRetries + 1;
+    const backoffMs = resolved.runner.startupRetryDelayMs * attempt + Math.floor(Math.random() * 250);
+    console.log(`clisbot runner state database contention for ${resolved.sessionName}; retrying startup with the preserved session id in ${backoffMs}ms`);
+    await this.killRunnerAndPreserveSessionId(resolved);
+    if (backoffMs > 0) {
+      await sleep(backoffMs);
+    }
+    return this.ensureSessionReady(target, {
+      remainingFreshRetries: remainingFreshRetries - 1,
+      startupNotes
+    });
+  }
+  async retryAfterStartupFault(target, resolved, error, remainingFreshRetries, allowFreshResumeFallback, startupNotes) {
+    if (error instanceof RunnerStateContentionError) {
+      return this.retryAfterStateContention(target, resolved, remainingFreshRetries, startupNotes);
+    }
+    if (error instanceof RunnerStateCorruptionError) {
+      return null;
+    }
     if (allowFreshResumeFallback) {
-      const resumedFresh = await this.retryFreshStartAfterStoredResumeFailure(target, resolved, error, remainingFreshRetries);
-      if (resumedFresh) {
-        return resumedFresh;
+      const fallback = await this.fallBackToFreshAfterRejectedResume(target, resolved, error, remainingFreshRetries, startupNotes);
+      if (fallback) {
+        return fallback;
       }
     }
     if (!isRetryableFreshStartFault(error)) {
       return null;
     }
-    return this.retryRunnerRestartPreservingSessionId(target, resolved, remainingFreshRetries);
+    return this.retryRunnerRestartPreservingSessionId(target, resolved, remainingFreshRetries, startupNotes);
   }
-  async retryFreshStartAfterStoredResumeFailure(target, resolved, error, remainingFreshRetries) {
+  async classifyRejectedResumeStartup(resolved, error, remainingFreshRetries) {
+    const storedSessionId = (await this.sessionMapping.get(resolved.sessionKey))?.sessionId?.trim() || "";
+    if (!storedSessionId) {
+      return null;
+    }
+    if (error instanceof RunnerResumeRejectedError) {
+      return { storedSessionId, reason: "rejected" };
+    }
+    if (error instanceof TmuxBootstrapSessionLostError && paneShowsResumeRejected(error.lastSnapshot)) {
+      return { storedSessionId, reason: "rejected" };
+    }
     if (!isRecoverableStartupSessionLoss(error)) {
       return null;
     }
     if (resolved.runner.sessionId.resume.mode !== "command" || resolved.runner.sessionId.create.mode !== "runner") {
       return null;
     }
-    const existing = await this.sessionMapping.get(resolved.sessionKey);
-    if (!existing?.sessionId) {
+    if (remainingFreshRetries > 0) {
       return null;
     }
     const exitRecord = await readRunnerExitRecord(this.loadedConfig.stateDir, resolved.sessionName);
     if (!exitRecord || exitRecord.exitCode === 0) {
       return null;
     }
-    console.log(`clisbot preserved stored sessionId after failed runner resume startup ${resolved.sessionName}`);
-    await this.sessionMapping.touch(resolved, {
+    return { storedSessionId, reason: "exit" };
+  }
+  async fallBackToFreshAfterRejectedResume(target, resolved, error, remainingFreshRetries, startupNotes) {
+    const rejection = await this.classifyRejectedResumeStartup(resolved, error, remainingFreshRetries);
+    if (!rejection) {
+      return null;
+    }
+    console.log(`clisbot resume rejected for ${resolved.sessionName}; opening a fresh runner conversation`, {
+      storedSessionId: rejection.storedSessionId,
+      reason: rejection.reason
+    });
+    await this.tmux.killSession(resolved.sessionName).catch(() => {
+      return;
+    });
+    await this.sessionMapping.clearActive(resolved, {
       runnerCommand: resolved.runner.command
     });
-    throw new Error(PRESERVED_SESSION_ID_RETRY_MESSAGE);
+    startupNotes?.push(buildResumeRejectedFreshStartNote({
+      storedSessionId: rejection.storedSessionId,
+      reason: rejection.reason,
+      resumeCommand: this.renderRunnerResumeCommand(resolved, rejection.storedSessionId)
+    }));
+    return this.ensureSessionReady(target, {
+      remainingFreshRetries: resolved.runner.startupRetryCount,
+      startupNotes
+    });
   }
-  async retryAfterStartupTimeout(target, resolved, remainingFreshRetries) {
-    return this.retryRunnerRestartPreservingSessionId(target, resolved, remainingFreshRetries);
+  renderRunnerResumeCommand(resolved, sessionId) {
+    if (resolved.runner.sessionId.resume.mode !== "command") {
+      return;
+    }
+    const launch = this.buildRunnerArgs(resolved, { sessionId, resume: true });
+    return [launch.command, ...launch.args].join(" ");
+  }
+  async retryAfterStartupTimeout(target, resolved, remainingFreshRetries, startupNotes) {
+    return this.retryRunnerRestartPreservingSessionId(target, resolved, remainingFreshRetries, startupNotes);
   }
   resolveRemainingFreshRetries(resolved, options) {
     if (typeof options.remainingFreshRetries === "number") {
@@ -93170,21 +93402,28 @@ class RunnerService {
     const preparedMapping = await this.sessionMapping.prepareStartup(resolved);
     const serverRunning = await this.tmux.isServerRunning();
     if (serverRunning && await this.tmux.hasSession(resolved.sessionName)) {
-      logLatencyDebug("ensure-session-ready-existing-session", timingContext, {
-        hasStoredSessionId: Boolean(preparedMapping.storedSessionId)
-      });
-      try {
-        await clearRunnerExitRecord(this.loadedConfig.stateDir, resolved.sessionName);
-        await this.acceptStartupContinuePromptIfPresent(resolved);
-        await this.syncActiveSessionMappingForResolvedTarget(resolved);
-      } catch (error) {
-        throw await this.mapSessionError(error, resolved.sessionName, "during startup");
+      const lingeringExitSnapshot = await this.captureSessionSnapshot(resolved).catch(() => "");
+      if (paneShowsRunnerExitSentinel(lingeringExitSnapshot)) {
+        await this.tmux.killSession(resolved.sessionName).catch(() => {
+          return;
+        });
+      } else {
+        logLatencyDebug("ensure-session-ready-existing-session", timingContext, {
+          hasStoredSessionId: Boolean(preparedMapping.storedSessionId)
+        });
+        try {
+          await clearRunnerExitRecord(this.loadedConfig.stateDir, resolved.sessionName);
+          await this.acceptStartupContinuePromptIfPresent(resolved);
+          await this.syncActiveSessionMappingForResolvedTarget(resolved);
+        } catch (error) {
+          throw await this.mapSessionError(error, resolved.sessionName, "during startup");
+        }
+        logLatencyDebug("ensure-session-ready-complete", timingContext, {
+          startupDelayMs: 0,
+          reusedSession: true
+        });
+        return resolved;
       }
-      logLatencyDebug("ensure-session-ready-complete", timingContext, {
-        startupDelayMs: 0,
-        reusedSession: true
-      });
-      return resolved;
     }
     if (!resolved.session.createIfMissing) {
       throw new Error(`tmux session "${resolved.sessionName}" does not exist`);
@@ -93229,24 +93468,38 @@ class RunnerService {
         startupDelayMs: resolved.runner.startupDelayMs,
         trustWorkspace: resolved.runner.trustWorkspace,
         readyPattern: resolved.runner.startupReadyPattern,
-        blockers: resolved.runner.startupBlockers
+        blockers: resolved.runner.startupBlockers,
+        resumeRejection: resumingExistingSession && storedOrExplicitSessionId ? { detect: paneShowsResumeRejected } : undefined,
+        exitDetection: { detect: paneShowsRunnerExitSentinel }
       });
+      if (bootstrapResult.status === "exited") {
+        await this.tmux.killSession(resolved.sessionName).catch(() => {
+          return;
+        });
+        throw this.classifyRunnerStartupExit(resolved, bootstrapResult.snapshot);
+      }
+      if (bootstrapResult.status === "resume-rejected") {
+        await this.tmux.killSession(resolved.sessionName).catch(() => {
+          return;
+        });
+        throw new RunnerResumeRejectedError(resolved.sessionName, storedOrExplicitSessionId, bootstrapResult.snapshot);
+      }
       if (bootstrapResult.status === "blocked") {
         await this.abortUnreadySession(resolved, bootstrapResult.message, bootstrapResult.snapshot);
       }
       if (bootstrapResult.status === "timeout" && resolved.runner.startupReadyPattern) {
-        const retried = await this.retryAfterStartupTimeout(target, resolved, remainingFreshRetries);
+        const retried = await this.retryAfterStartupTimeout(target, resolved, remainingFreshRetries, options.startupNotes);
         if (retried) {
           return retried;
         }
-        await this.abortUnreadySession(resolved, `Runner session "${resolved.sessionName}" did not reach the configured ready state within ${resolved.runner.startupDelayMs}ms.`, bootstrapResult.snapshot);
+        await this.abortUnreadySession(resolved, `Runner session "${resolved.sessionName}" did not reach the configured ready state within ${resolved.runner.startupDelayMs}ms, so your prompt was not submitted. Verify that \`${resolved.runner.command}\` starts cleanly in the workspace terminal, then resend. Inspect ${renderCliCommand("runner inspect --latest --lines 120", { inline: true })} and ${renderCliCommand("logs", { inline: true })} if it keeps happening.`, bootstrapResult.snapshot);
       }
       await this.finalizeSessionStartup(resolved, {
         storedOrExplicitSessionId,
         runnerCommand: runnerLaunch.command
       });
     } catch (error) {
-      const retried = await this.retryAfterStartupFault(target, resolved, error, remainingFreshRetries, options.allowFreshRetry !== false);
+      const retried = await this.retryAfterStartupFault(target, resolved, error, remainingFreshRetries, options.allowFreshRetry !== false, options.startupNotes);
       if (retried) {
         return retried;
       }
@@ -93309,30 +93562,65 @@ class RunnerService {
     return normalizePaneText(await this.tmux.capturePane(resolved.sessionName, resolved.stream.captureLines));
   }
   async ensureRunnerReady(target, options = {}) {
+    const startupNotes = [];
     let resolved = await this.ensureSessionReady(target, {
       allowFreshRetry: options.allowFreshRetryBeforePrompt,
-      timingContext: options.timingContext
+      timingContext: options.timingContext,
+      startupNotes
     });
     try {
       return {
         resolved,
-        initialSnapshot: await this.captureSessionSnapshot(resolved)
+        initialSnapshot: await this.captureSessionSnapshot(resolved),
+        startupNotes
       };
     } catch (error) {
       if (options.allowFreshRetryBeforePrompt === false || !isRecoverableStartupSessionLoss(error)) {
         throw await this.mapSessionError(error, resolved.sessionName, "before prompt submission", resolved.sessionName ? await this.captureSessionSnapshot(resolved).catch(() => "") : "");
       }
-      const retried = await this.retryRunnerRestartPreservingSessionId(target, resolved, resolved.runner.startupRetryCount);
+      const retried = await this.retryRunnerRestartPreservingSessionId(target, resolved, resolved.runner.startupRetryCount, startupNotes);
       if (!retried) {
         throw await this.mapSessionError(error, resolved.sessionName, "before prompt submission", resolved.sessionName ? await this.captureSessionSnapshot(resolved).catch(() => "") : "");
       }
       resolved = retried;
       return {
         resolved,
-        initialSnapshot: await this.captureSessionSnapshot(resolved)
+        initialSnapshot: await this.captureSessionSnapshot(resolved),
+        startupNotes
       };
     }
   }
+  async recaptureSessionIdAfterRun(target) {
+    const resolved = this.resolveTarget(target);
+    if (resolved.runner.sessionId.capture.mode !== "status-command") {
+      return null;
+    }
+    const existing = await this.sessionMapping.get(resolved.sessionKey);
+    if (existing?.sessionId) {
+      return existing.sessionId;
+    }
+    if (!await this.tmux.hasSession(resolved.sessionName)) {
+      return null;
+    }
+    let sessionId = null;
+    try {
+      sessionId = await this.captureSessionIdFromRunner(resolved);
+    } catch (error) {
+      console.warn(`clisbot post-run session id recapture failed for ${resolved.sessionName}`, error);
+      this.deferSessionIdCapture(resolved.sessionKey);
+      return null;
+    }
+    if (!sessionId) {
+      this.deferSessionIdCapture(resolved.sessionKey);
+      return null;
+    }
+    const recorded = await this.recordActiveSessionIdBestEffort(resolved, sessionId);
+    if (!recorded) {
+      return null;
+    }
+    console.log(`clisbot captured durable session id after run completion for ${resolved.sessionName}`);
+    return sessionId;
+  }
   canRecoverMidRun(error) {
     return isRecoverableStartupSessionLoss(error) || isTransientTmuxTargetError(error);
   }
@@ -93467,7 +93755,9 @@ class RunnerService {
     throw new Error(`${command} completed and clisbot captured session id ${sessionId}, but could not persist it. The durable session mapping was left unchanged.${details}`);
   }
   async killRunnerAndPreserveSessionId(resolved) {
-    await this.tmux.killSession(resolved.sessionName);
+    await this.tmux.killSession(resolved.sessionName).catch(() => {
+      return;
+    });
     await this.sessionMapping.touch(resolved, {
       runnerCommand: resolved.runner.command
     });
@@ -93589,33 +93879,6 @@ class RunnerService {
   }
 }
 
-// src/agents/session/run-recovery.ts
-var MID_RUN_RECOVERY_MAX_ATTEMPTS = 2;
-var MID_RUN_RECOVERY_CONTINUE_PROMPT = "continue exactly where you left off";
-function mergeRunSnapshot(snapshotPrefix, snapshot) {
-  return appendInteractionText(snapshotPrefix, snapshot);
-}
-function buildRunRecoveryNote(kind, params) {
-  if (kind === "resume-attempt") {
-    const attempt = params?.attempt ?? 1;
-    const maxAttempts = params?.maxAttempts ?? MID_RUN_RECOVERY_MAX_ATTEMPTS;
-    return `Runner session was lost. Attempting recovery ${attempt}/${maxAttempts} by reopening the same conversation context.`;
-  }
-  if (kind === "resume-success") {
-    return "Recovery succeeded. Asking the runner to continue exactly where it left off.";
-  }
-  if (kind === "fresh-attempt") {
-    return "The previous runner session could not be resumed. Opening a fresh runner session 2/2 without replaying your prompt.";
-  }
-  if (kind === "resume-failed") {
-    return "The previous runner session could not be resumed. The stored session id was preserved; use `/new` to intentionally trigger a new runner conversation.";
-  }
-  if (kind === "manual-new-required") {
-    return "The previous runner session could not be resumed. clisbot preserved the stored session id instead of opening a new conversation automatically. Use `/new` if you want to trigger a new runner conversation, then resend the prompt.";
-  }
-  return "The previous runner session could not be resumed. clisbot opened a new fresh session, but did not replay your prompt because the prior conversation context is no longer guaranteed. Please resend the full prompt/context to continue.";
-}
-
 // src/runners/tmux/run-monitor.ts
 var FIRST_OUTPUT_POLL_INTERVAL_MS = 250;
 var RUNNING_REWRITE_PREVIEW_MAX_LINES = 8;
@@ -93801,8 +94064,10 @@ function isRetryableObserverDeliveryError(error) {
 }
 function buildMissingSessionIdStartupWarning() {
   return [
-    "Runner session started, but clisbot could not capture a durable session id yet.",
-    "This session is running, but it is not resumable until a session id is captured and persisted."
+    "Runner session started, but clisbot could not capture a durable session id yet,",
+    "so this conversation is not resumable if the runner restarts.",
+    "clisbot keeps retrying automatically and will persist the id once the runner reports it; no action is needed.",
+    "If this warning keeps appearing, the runner status output may have changed; check the pane with `clisbot watch --latest`."
   ].join(" ");
 }
 
@@ -93929,7 +94194,7 @@ class SessionService {
     });
     try {
       await this.sessionState.markPromptAdmitted(provisionalResolved);
-      const { resolved, initialSnapshot } = await this.runnerSessions.ensureRunnerReady(target, {
+      const { resolved, initialSnapshot, startupNotes } = await this.runnerSessions.ensureRunnerReady(target, {
         ...options,
         timingContext: observer.timingContext
       });
@@ -93960,6 +94225,17 @@ class SessionService {
         state: "running",
         startedAt
       });
+      for (const startupNote of startupNotes ?? []) {
+        await this.notifyRunObservers(run, this.createRunUpdate({
+          resolved,
+          status: "running",
+          snapshot: "",
+          fullSnapshot: initialSnapshot,
+          initialSnapshot,
+          note: startupNote,
+          forceVisible: true
+        }));
+      }
       if (!run.sessionId) {
         await this.notifyRunObservers(run, this.createRunUpdate({
           resolved,
@@ -94227,6 +94503,14 @@ class SessionService {
     if (!run) {
       return;
     }
+    if (!run.sessionId) {
+      try {
+        run.sessionId = await this.runnerSessions.recaptureSessionIdAfterRun({
+          agentId: run.resolved.agentId,
+          sessionKey: run.resolved.sessionKey
+        }) ?? undefined;
+      } catch {}
+    }
     await this.sessionState.setSessionRuntime(run.resolved, {
       state: "idle"
     });
@@ -94364,8 +94648,10 @@ class SessionService {
         return true;
       }
       if (await this.requiresManualNewAfterFailedResume(currentRun)) {
-        await this.notifyRecoveryStep(currentRun, buildRunRecoveryNote("resume-failed"));
-        await this.failActiveRun(sessionKey, currentRun.runId, new Error(buildRunRecoveryNote("manual-new-required")));
+        await this.notifyRecoveryStep(currentRun, buildRunRecoveryNote("resume-failed", { storedSessionId: currentRun.sessionId }));
+        await this.failActiveRun(sessionKey, currentRun.runId, new Error(buildRunRecoveryNote("manual-new-required", {
+          storedSessionId: currentRun.sessionId
+        })));
         return true;
       }
       await this.notifyRecoveryStep(currentRun, buildRunRecoveryNote("fresh-attempt"));
@@ -101281,6 +101567,7 @@ import { readFile as readFile3 } from "node:fs/promises";
 
 // src/channels/slack/content.ts
 var SLACK_MAX_BLOCKS = 50;
+var SLACK_BULLET_MARKERS = ["•", "◦", "▪"];
 function normalizeMarkdownLinks(text) {
   return text.replace(/\[([^\]]+)\]\(([^)\s]+)\)/g, (_match, label, href) => {
     const trimmedHref = href.trim();
@@ -101293,6 +101580,20 @@ function normalizeMarkdownLinks(text) {
 function renderInlineMarkdownToSlackMrkdwn(text) {
   return normalizeMarkdownLinks(text).replace(/~~([^~]+)~~/g, "~$1~").replace(/\*\*([^*\n][\s\S]*?[^*\n])\*\*/g, "*$1*");
 }
+function trimOuterBlankLines(text) {
+  return text.replace(/^\n+/, "").replace(/\n+$/, "");
+}
+function getMarkdownListDepth(rawIndent) {
+  const width = rawIndent.replaceAll("\t", "    ").length;
+  return Math.floor(width / 2);
+}
+function renderSlackListIndent(depth) {
+  return "  ".repeat(Math.min(Math.max(depth, 0), 6));
+}
+function renderSlackBulletPrefix(depth) {
+  const marker = SLACK_BULLET_MARKERS[Math.min(depth, SLACK_BULLET_MARKERS.length - 1)] ?? SLACK_BULLET_MARKERS[0];
+  return `${renderSlackListIndent(depth)}${marker}`;
+}
 function stripMarkdownInline(text) {
   return text.replace(/`([^`\n]+)`/g, "$1").replace(/\[([^\]]+)\]\(([^)\s]+)\)/g, "$1").replace(/\*\*([^*\n][\s\S]*?[^*\n])\*\*/g, "$1").replace(/\*([^*\n][\s\S]*?[^*\n])\*/g, "$1").replace(/~~([^~]+)~~/g, "$1").trim();
 }
@@ -101373,10 +101674,10 @@ function parseSlackBlocksInput(text) {
   return validateSlackBlocksArray(parsed);
 }
 function renderMarkdownToSlackMrkdwn(markdown) {
-  const normalized = markdown.replaceAll(`\r
+  const normalized = trimOuterBlankLines(markdown.replaceAll(`\r
 `, `
 `).replaceAll("\r", `
-`).trim();
+`));
   if (!normalized) {
     return "";
   }
@@ -101391,13 +101692,15 @@ function renderMarkdownToSlackMrkdwn(markdown) {
       }
       return content;
     }
-    const bulletMatch = line.match(/^\s*[-*+]\s+(.+)$/);
+    const bulletMatch = line.match(/^(\s*)[-*+]\s+(.+)$/);
     if (bulletMatch) {
-      return `• ${renderInlineMarkdownToSlackMrkdwn(bulletMatch[1] ?? "")}`;
+      const depth = getMarkdownListDepth(bulletMatch[1] ?? "");
+      return `${renderSlackBulletPrefix(depth)} ${renderInlineMarkdownToSlackMrkdwn(bulletMatch[2] ?? "")}`;
     }
-    const orderedMatch = line.match(/^\s*(\d+)\.\s+(.+)$/);
+    const orderedMatch = line.match(/^(\s*)(\d+)\.\s+(.+)$/);
     if (orderedMatch) {
-      return `${orderedMatch[1]}. ${renderInlineMarkdownToSlackMrkdwn(orderedMatch[2] ?? "")}`;
+      const depth = getMarkdownListDepth(orderedMatch[1] ?? "");
+      return `${renderSlackListIndent(depth)}${orderedMatch[2]}. ${renderInlineMarkdownToSlackMrkdwn(orderedMatch[3] ?? "")}`;
     }
     return renderInlineMarkdownToSlackMrkdwn(line);
   }).join(`
@@ -101462,10 +101765,10 @@ function renderMarkdownTableToFallbackSlackBlock(headers, rows) {
   };
 }
 function renderMarkdownToSlackBlocks(markdown) {
-  const normalized = markdown.replaceAll(`\r
+  const normalized = trimOuterBlankLines(markdown.replaceAll(`\r
 `, `
 `).replaceAll("\r", `
-`).trim();
+`));
   if (!normalized) {
     return [];
   }
@@ -101499,7 +101802,7 @@ function renderMarkdownToSlackBlocks(markdown) {
       return;
     }
     const text = paragraph.join(`
-`).trim();
+`).trimEnd();
     if (text) {
       const shouldRenderAsPreamble = !hasSeenHeading && firstHeadingLineIndex > 0 && blocks.length === 0;
       pushBlock({
@@ -101614,14 +101917,16 @@ ${codeLines.join(`
       }
       continue;
     }
-    const bulletMatch = line.match(/^\s*[-*+]\s+(.+)$/);
+    const bulletMatch = line.match(/^(\s*)[-*+]\s+(.+)$/);
     if (bulletMatch) {
-      paragraph.push(`• ${renderInlineMarkdownToSlackMrkdwn(bulletMatch[1] ?? "")}`);
+      const depth = getMarkdownListDepth(bulletMatch[1] ?? "");
+      paragraph.push(`${renderSlackBulletPrefix(depth)} ${renderInlineMarkdownToSlackMrkdwn(bulletMatch[2] ?? "")}`);
       continue;
     }
-    const orderedMatch = line.match(/^\s*(\d+)\.\s+(.+)$/);
+    const orderedMatch = line.match(/^(\s*)(\d+)\.\s+(.+)$/);
     if (orderedMatch) {
-      paragraph.push(`${orderedMatch[1]}. ${renderInlineMarkdownToSlackMrkdwn(orderedMatch[2] ?? "")}`);
+      const depth = getMarkdownListDepth(orderedMatch[1] ?? "");
+      paragraph.push(`${renderSlackListIndent(depth)}${orderedMatch[2]}. ${renderInlineMarkdownToSlackMrkdwn(orderedMatch[3] ?? "")}`);
       continue;
     }
     paragraph.push(renderInlineMarkdownToSlackMrkdwn(line));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clisbot",
-  "version": "0.1.54-beta.2",
+  "version": "0.1.54-beta.3",
   "private": false,
   "description": "Chat surfaces for durable AI coding agents running in tmux",
   "license": "MIT",