@aiden-ade/sandbox-agent 0.1.41 → 0.1.43

package/dist/index.cjs

@@ -13315,13 +13315,13 @@ function resolveViaWhere(command, env) {
   }
   return null;
 }
-function runCliVersionProbe(executable, env, args = ["--version"]) {
+function runCliVersionProbe(executable, env, args = ["--version"], timeoutMs = 3e3) {
   const isWin = (0, import_node_os3.platform)() === "win32";
   if (isWin && /\.(cmd|bat)$/i.test(executable)) {
     const comSpec = env.ComSpec ?? process.env.ComSpec ?? "cmd.exe";
     return (0, import_node_child_process2.spawnSync)(comSpec, ["/d", "/s", "/c", executable, ...args], {
       encoding: "utf8",
-      timeout: 3e3,
+      timeout: timeoutMs,
       env,
       windowsHide: true
     });
@@ -13329,7 +13329,7 @@ function runCliVersionProbe(executable, env, args = ["--version"]) {
   const useShell = isWin && !/[\\/]/.test(executable);
   return (0, import_node_child_process2.spawnSync)(executable, args, {
     encoding: "utf8",
-    timeout: 3e3,
+    timeout: timeoutMs,
     env,
     shell: useShell,
     windowsHide: isWin ? true : void 0
@@ -13514,6 +13514,16 @@ function resolveBackendRuntimeCommand(backendKind, env = getDaemonCliEnvironment
   cacheResolvedCli(command, resolved);
   return resolved ?? void 0;
 }
+function revalidateBackendRuntimeCommand(backendKind, env = getDaemonCliEnvironment()) {
+  if (!backendKind) return void 0;
+  const command = BACKEND_CLI_COMMANDS[backendKind];
+  if (!command) return void 0;
+  resolvedCliCache.delete(command);
+  const spec = Object.values(PROVIDER_CLI_COMMANDS).find((entry) => entry.command === command);
+  const envOverride = spec ? spec.envVars.map((name) => env[name]?.trim()).find(Boolean) : void 0;
+  if (envOverride) resolvedCliCache.delete(envOverride);
+  return resolveBackendRuntimeCommand(backendKind, env);
+}
 
 // src/computer-readiness.ts
 var import_node_fs5 = require("fs");
@@ -14545,15 +14555,6 @@ If the index returns no useful path, say so and run one targeted local search in
 function buildAlanTeamCodeContextOverlay(teamId) {
   return [buildAlanTeamScopePrompt(teamId), ALAN_CODE_CONTEXT_PROMPT].join("\n\n");
 }
-function buildCodeDiscoveryEnforcementTail() {
-  return [
-    "## MANDATORY \u2014 index once, then use local source",
-    "1. For codebase discovery, make one `mcp__alan__search_code_context` call (hybrid, topK 5). Omit teamId \u2014 Alan session headers resolve it.",
-    "2. Once useful paths are returned, stop querying the index and read those local files. The current worktree is the source of truth.",
-    "3. Use narrow local `Grep`/graph queries only after the orientation pass. If the index has no useful path, run one targeted local search in the likely package.",
-    "Do not repeat or rephrase index searches once paths are known, and do not claim current behavior from index excerpts alone."
-  ].join("\n");
-}
 var PLAN_MODE_PROMPT = [
   "You are in Alan plan mode.",
   "Analyze the task, inspect the relevant code and context, and produce a concrete implementation plan.",
@@ -15282,11 +15283,12 @@ var import_os3 = require("os");
 var import_path3 = require("path");
 var import_readline = require("readline");
 var import_child_process2 = require("child_process");
+var import_child_process3 = require("child_process");
 var import_crypto2 = require("crypto");
 var import_fs4 = require("fs");
 var import_os4 = require("os");
 var import_path4 = require("path");
-var import_child_process3 = require("child_process");
+var import_child_process4 = require("child_process");
 var import_util10 = require("util");
 var import_fs5 = require("fs");
 var import_os5 = require("os");
@@ -15432,6 +15434,11 @@ function buildSessionHeaders(input) {
   if (input.allowedTools?.length) {
     headers["x-allowed-tools"] = input.allowedTools.join(",");
   }
+  if (input.runHeaders) {
+    for (const [key, value2] of Object.entries(input.runHeaders)) {
+      if (typeof value2 === "string" && value2.length > 0) headers[key] = value2;
+    }
+  }
   return headers;
 }
 function getTomlSectionName(line) {
@@ -15642,6 +15649,23 @@ function syncAlanMcpSessionHeaders(input) {
   }
   return written;
 }
+var mcpConfigWriteGateTail = Promise.resolve();
+function acquireMcpConfigWriteGate() {
+  const previous = mcpConfigWriteGateTail;
+  let releaseCurrent;
+  const current = new Promise((resolve22) => {
+    releaseCurrent = resolve22;
+  });
+  mcpConfigWriteGateTail = previous.then(() => current);
+  return previous.then(() => {
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      releaseCurrent();
+    };
+  });
+}
 function buildPromptWithSystem(config, promptText) {
   const parts2 = [
     config.systemPrompt?.trim(),
@@ -15650,6 +15674,13 @@ function buildPromptWithSystem(config, promptText) {
   ].filter((value2) => Boolean(value2 && value2.length > 0));
   return parts2.join("\n\n");
 }
+function buildResumeAwarePrompt(config, promptText, options) {
+  const systemParts = options.isResume ? [config.systemPromptAppend?.trim()] : [config.systemPrompt?.trim()];
+  const parts2 = [...systemParts, promptText.trim()].filter(
+    (value2) => Boolean(value2 && value2.length > 0)
+  );
+  return parts2.join("\n\n");
+}
 function buildPlanModePrefix(promptText) {
   return [
     "You are in plan-only mode.",
@@ -15816,7 +15847,7 @@ var ERROR_SPECS = {
     recoveryClass: "needs_env"
   },
   auth_expired: {
-    message: "The provider connection expired. Reconnect it in Cloud settings, then restart or recreate the machine.",
+    message: "The provider connection expired. Re-authenticate the agent CLI on this runtime (or reconnect it in your provider/Cloud settings), then retry.",
     recoveryClass: "user_fixable"
   },
   subscription_required: {
@@ -15876,6 +15907,7 @@ function specForErrorKind(errorKind) {
   const spec = ERROR_SPECS[errorKind];
   return { message: spec.message, errorKind, recoveryClass: spec.recoveryClass };
 }
+var RESUME_SESSION_UNAVAILABLE_MESSAGE = ERROR_SPECS.resume_failed.message;
 function isLikelyProviderAuthError(stderr) {
   const lower = stderr.toLowerCase();
   return lower.includes("api key") || lower.includes("api_key") || lower.includes("invalid api key") || lower.includes("api key invalid") || lower.includes("unauthorized") || lower.includes("authentication failed") || lower.includes("authentication error") || lower.includes("provider settings") || lower.includes("invalid token") || lower.includes("token expired");
@@ -15905,7 +15937,7 @@ function normalizeCodexCliErrorMessage(message) {
     return "Codex connection to OpenAI timed out while waiting for the turn to continue. Retry the message; if it repeats, check network/API latency or reduce slow MCP/tool calls in the turn.";
   }
   if (lower.includes("access token could not be refreshed") || lower.includes("refresh_token_invalidated") || lower.includes("refresh token has been invalidated")) {
-    return "Codex CLI connection expired. Reconnect OpenAI Codex CLI in Cloud settings, then restart or recreate the machine.";
+    return "Codex CLI connection expired. Re-authenticate the Codex CLI on this computer (run `codex login`) or reconnect it in Cloud settings, then retry.";
   }
   return message;
 }
@@ -16031,6 +16063,54 @@ function spawnCli(command, args, context) {
     detached: process.platform !== "win32"
   });
 }
+function isAlreadyDead(error) {
+  return error?.code === "ESRCH";
+}
+function killProcessTree(pid, options = {}) {
+  const { signal = "SIGTERM", child, onError } = options;
+  if (typeof pid !== "number" || !Number.isInteger(pid) || pid <= 0) {
+    if (child) {
+      try {
+        child.kill(signal);
+      } catch (err) {
+        if (!isAlreadyDead(err)) onError?.("fallback", err);
+      }
+    }
+    return;
+  }
+  if (process.platform === "win32") {
+    try {
+      const killer = (0, import_child_process3.spawn)("taskkill", ["/pid", String(pid), "/t", "/f"], {
+        stdio: "ignore",
+        windowsHide: true
+      });
+      killer.once("error", (err) => {
+        if (child) {
+          try {
+            child.kill();
+          } catch {
+          }
+        }
+        onError?.("taskkill", err);
+      });
+    } catch (err) {
+      onError?.("taskkill", err);
+    }
+    return;
+  }
+  try {
+    process.kill(-pid, signal);
+  } catch (groupErr) {
+    if (!isAlreadyDead(groupErr)) onError?.("group", groupErr);
+    if (child) {
+      try {
+        child.kill(signal);
+      } catch (fallbackErr) {
+        if (!isAlreadyDead(fallbackErr)) onError?.("fallback", fallbackErr);
+      }
+    }
+  }
+}
 function emitSessionNotice(presenter, kind, message) {
   if (presenter.onNotice) {
     void presenter.onNotice(kind, message);
@@ -16095,6 +16175,12 @@ function formatCliSpawnError(command, error) {
   }
   return error;
 }
+function waitForSpawnOutcome(child) {
+  return new Promise((resolve22) => {
+    child.once("spawn", () => resolve22(null));
+    child.once("error", (error) => resolve22(error));
+  });
+}
 function createGenericCliBackend(options) {
   return {
     kind: options.kind,
@@ -16108,7 +16194,23 @@ function createGenericCliBackend(options) {
       };
       const prompt = options.augmentPrompt?.(context) ?? (context.config.mode === "plan" ? buildPlanModePrefix(buildPromptWithSystem(context.config, context.promptText)) : buildPromptWithSystem(context.config, context.promptText));
       const args = options.buildArgs?.(context, prompt) ?? options.args.map((arg) => arg === "{{prompt}}" ? prompt : arg);
-      const child = spawnCli(options.command, args, context);
+      let command = options.command;
+      let child = spawnCli(command, args, context);
+      if (context.revalidateCommand) {
+        const spawnError = await waitForSpawnOutcome(child);
+        if (spawnError) {
+          const fresh = spawnError.code === "ENOENT" ? context.revalidateCommand()?.trim() || null : null;
+          if (fresh && fresh !== command) {
+            console.warn(
+              `[${options.kind}] Spawn failed ENOENT for "${command}" \u2014 re-resolved to "${fresh}", retrying once`
+            );
+            command = fresh;
+            child = spawnCli(command, args, context);
+          } else {
+            throw formatCliSpawnError(command, spawnError);
+          }
+        }
+      }
       state.process = child;
       state.lastRawOutputAtMs = Date.now();
       context.onProcessSpawned?.(child);
@@ -16119,8 +16221,8 @@ function createGenericCliBackend(options) {
       const safeArgs = args.map(
         (a, i) => i > 0 && args[i - 1] === "--system-prompt" ? `"<system-prompt ${a.length} chars>"` : a
       );
-      console.info(`[${options.kind}] Spawning: ${options.command} ${safeArgs.join(" ")}`);
-      presenter.recordRawTranscript?.("system", `${options.command} ${args.join(" ")}`, {
+      console.info(`[${options.kind}] Spawning: ${command} ${safeArgs.join(" ")}`);
+      presenter.recordRawTranscript?.("system", `${command} ${args.join(" ")}`, {
         backendKind: options.kind
       });
       child.stdin.on("error", (err) => {
@@ -16152,14 +16254,7 @@ function createGenericCliBackend(options) {
           console.warn(
             `[${options.kind}] No stdout within ${options.startupTimeoutMs}ms of spawn \u2014 killing hung process`
           );
-          try {
-            if (process.platform === "win32") {
-              child.kill("SIGKILL");
-            } else if (child.pid) {
-              process.kill(-child.pid, "SIGKILL");
-            }
-          } catch {
-          }
+          killProcessTree(child.pid, { signal: "SIGKILL", child });
         }, options.startupTimeoutMs);
       }
       stdoutRl.on("line", (line) => {
@@ -16202,16 +16297,7 @@ function createGenericCliBackend(options) {
           });
           child.on("exit", (code) => resolve22(code ?? 0));
           const onAbort = () => {
-            const pid = child.pid;
-            if (!pid) return;
-            try {
-              process.kill(-pid, "SIGTERM");
-            } catch {
-              try {
-                child.kill("SIGTERM");
-              } catch {
-              }
-            }
+            killProcessTree(child.pid, { signal: "SIGTERM", child });
           };
           context.abortController.signal.addEventListener("abort", onAbort, { once: true });
         });
@@ -16232,6 +16318,9 @@ function createGenericCliBackend(options) {
                 } else if (state.resultDeferredOnBackgroundWork && state.activeBackgroundTaskIds?.size) {
                   idleTimeoutReason = "background_task";
                   resolve22("idle_timeout");
+                } else if (options.postStartupSilenceTimeoutMs && sawStdoutLine && typeof state.lastRawOutputAtMs === "number" && Date.now() - state.lastRawOutputAtMs >= options.postStartupSilenceTimeoutMs) {
+                  idleTimeoutReason = "post_startup_silence";
+                  resolve22("idle_timeout");
                 } else {
                   armIdleTimer();
                 }
@@ -16244,17 +16333,11 @@ function createGenericCliBackend(options) {
           if (idleTimer) clearTimeout(idleTimer);
           if (raceResult === "idle_timeout") {
             idleTimedOut = true;
+            const idleWaitLabel = idleTimeoutReason === "background_task" ? "a background task terminal event" : idleTimeoutReason === "post_startup_silence" ? "any further output (silent hang)" : "a pending user answer";
             console.warn(
-              `[${options.kind}] Idle timeout (${IDLE_MS}ms) waiting for ${idleTimeoutReason === "background_task" ? "a background task terminal event" : "a pending user answer"} \u2014 force-killing orphaned process`
+              `[${options.kind}] Idle timeout (${IDLE_MS}ms) waiting for ${idleWaitLabel} \u2014 force-killing orphaned process`
             );
-            try {
-              if (process.platform === "win32") {
-                child.kill("SIGKILL");
-              } else if (child.pid) {
-                process.kill(-child.pid, "SIGKILL");
-              }
-            } catch {
-            }
+            killProcessTree(child.pid, { signal: "SIGKILL", child });
             exitCode = await Promise.race([
               exitPromise,
               new Promise((resolve22) => setTimeout(() => resolve22(1), 5e3))
@@ -16270,14 +16353,7 @@ function createGenericCliBackend(options) {
               console.warn(
                 `[${options.kind}] Process still alive ${GRACE_MS}ms after result event, killing`
               );
-              try {
-                if (process.platform === "win32") {
-                  child.kill("SIGKILL");
-                } else if (child.pid) {
-                  process.kill(-child.pid, "SIGKILL");
-                }
-              } catch {
-              }
+              killProcessTree(child.pid, { signal: "SIGKILL", child });
             }
           } else {
             exitCode = raceResult;
@@ -16332,6 +16408,25 @@ function createGenericCliBackend(options) {
         console.error(`[${options.kind}] Process force-killed by startup watchdog`, {
           stderrLines: stderrLines.slice(-10)
         });
+        const startupStderr = stderrLines.join("\n").trim();
+        if (startupStderr) {
+          const classified = classifyCliErrorDetailed(startupStderr, exitCode);
+          return {
+            success: false,
+            summary: state.summary.trim() || classified.message,
+            filesModified: [],
+            planFilesCreated: [],
+            iterations: Math.max(state.iterations, 1),
+            error: classified.message,
+            ...classified.errorKind !== "unknown_cli_error" ? { errorKind: classified.errorKind } : {},
+            recoveryClass: classified.recoveryClass,
+            providerSessionId: state.runtimeSessionId,
+            runtimeSessionId: state.runtimeSessionId,
+            backendKind: options.kind,
+            supportTier: options.supportTier,
+            usage: state.usage
+          };
+        }
         return {
           success: false,
           summary: "Agent produced no output",
@@ -16381,7 +16476,7 @@ function createGenericCliBackend(options) {
           filesModified: [],
           planFilesCreated: [],
           iterations: Math.max(state.iterations, 1),
-          error: idleTimeoutReason === "background_task" ? "Agent timed out waiting for a background task to finish \u2014 no terminal event arrived, so the run was stopped. Send your message again to continue." : "Agent timed out waiting for your answer to its question \u2014 no response arrived, so the run was stopped. Send your reply as a new message to continue.",
+          error: idleTimeoutReason === "background_task" ? "Agent timed out waiting for a background task to finish \u2014 no terminal event arrived, so the run was stopped. Send your message again to continue." : idleTimeoutReason === "post_startup_silence" ? "The agent went silent and stopped responding, so the run was stopped. Send your message again to retry." : "Agent timed out waiting for your answer to its question \u2014 no response arrived, so the run was stopped. Send your reply as a new message to continue.",
           providerSessionId: state.runtimeSessionId,
           runtimeSessionId: state.runtimeSessionId,
           backendKind: options.kind,
@@ -16440,6 +16535,9 @@ function createGenericCliBackend(options) {
           classifiedErrorKind = detailed.errorKind;
           classifiedRecoveryClass = detailed.recoveryClass;
         }
+        if (classifiedErrorKind === "resume_failed" && !requestedResumeId) {
+          classifiedErrorKind = void 0;
+        }
       }
       return {
         success: !failed,
@@ -16448,7 +16546,11 @@ function createGenericCliBackend(options) {
         planFilesCreated: [],
         iterations: Math.max(state.iterations, 1),
         error: classifiedError,
-        ...classifiedErrorKind ? { errorKind: classifiedErrorKind } : {},
+        // Surface every recognized, machine-actionable kind (model_mismatch,
+        // resume_failed, auth_*, …). The catch-all unknown_cli_error carries no routing
+        // signal — nothing downstream keys on it — so leave errorKind absent for it,
+        // keeping an unrelated failure untagged even when a resume id was set.
+        ...classifiedErrorKind && classifiedErrorKind !== "unknown_cli_error" ? { errorKind: classifiedErrorKind } : {},
         ...classifiedRecoveryClass ? { recoveryClass: classifiedRecoveryClass } : {},
         providerSessionId: state.runtimeSessionId,
         runtimeSessionId: state.runtimeSessionId,
@@ -16906,7 +17008,7 @@ function claudeSessionLogExists(input) {
   if (!(0, import_fs4.existsSync)(projectDir)) return false;
   return (0, import_fs4.existsSync)((0, import_path4.join)(projectDir, `${input.sessionId}.jsonl`));
 }
-var execFileAsync = (0, import_util10.promisify)(import_child_process3.execFile);
+var execFileAsync = (0, import_util10.promisify)(import_child_process4.execFile);
 var flagSupportCache = /* @__PURE__ */ new Map();
 function helpAdvertisesFlag(helpText, flag) {
   return helpText.includes(flag);
@@ -17082,6 +17184,16 @@ var TERMINAL_TASK_NOTIFICATION_STATUSES = /* @__PURE__ */ new Set([
   "cancelled",
   "canceled"
 ]);
+var NON_TERMINAL_TASK_NOTIFICATION_STATUSES = /* @__PURE__ */ new Set([
+  "running",
+  "in_progress",
+  "inprogress",
+  "started",
+  "pending",
+  "active",
+  "working",
+  "queued"
+]);
 function extractToolResultContent(content) {
   if (typeof content === "string") return content;
   if (!Array.isArray(content)) return "";
@@ -17099,6 +17211,7 @@ function stringField2(record, key) {
 function isTerminalTaskNotification(record) {
   const status = stringField2(record, "status")?.toLowerCase();
   if (status && TERMINAL_TASK_NOTIFICATION_STATUSES.has(status)) return true;
+  if (status && NON_TERMINAL_TASK_NOTIFICATION_STATUSES.has(status)) return false;
   return typeof record.duration_ms === "number" || typeof record.durationMs === "number" || typeof record.total_tokens === "number" || typeof record.totalTokens === "number" || typeof record.tool_uses === "number" || typeof record.toolUses === "number";
 }
 function isFailedTaskNotification(record) {
@@ -17190,20 +17303,25 @@ function handleClaudeStructuredEvent(parsed, context, state) {
       state.iterations += 1;
       const message = typeof parsed.message === "object" && parsed.message !== null ? parsed.message : null;
       const content = Array.isArray(message?.content) ? message.content : [];
+      let previousBlockWasText = false;
       for (const block of content) {
         if (typeof block !== "object" || block === null || !("type" in block)) continue;
         if (block.type === "text" && typeof block.text === "string") {
           const text = block.text;
           state.summary += `${text}
 `;
-          void presenter.onAssistantText(text);
+          void presenter.onAssistantText(previousBlockWasText ? `
+${text}` : text);
+          previousBlockWasText = true;
           continue;
         }
         if (block.type === "thinking" && typeof block.thinking === "string") {
+          previousBlockWasText = false;
           void presenter.onThinking(block.thinking);
           continue;
         }
         if (block.type === "tool_use" && typeof block.id === "string" && typeof block.name === "string") {
+          previousBlockWasText = false;
           const toolBlock = block;
           void presenter.onToolUse(
             toolBlock.name,
@@ -17319,7 +17437,7 @@ function handleClaudeStructuredEvent(parsed, context, state) {
         state.iterations = parsed.num_turns;
       }
       const subtype = typeof parsed.subtype === "string" ? parsed.subtype : "";
-      if ((subtype === "error_during_execution" || subtype === "error_max_turns") && !state.error) {
+      if (subtype.startsWith("error") && !state.error) {
         const errObj = typeof parsed.error === "object" && parsed.error !== null ? parsed.error : null;
         const resumeId = context.config.runtimeSessionId?.trim() || context.config.providerSessionId?.trim();
         const errMsg = subtype === "error_during_execution" && resumeId ? SESSION_RESUME_FAILED_MESSAGE : typeof parsed.error === "string" && parsed.error.trim() || errObj && typeof errObj.message === "string" && errObj.message.trim() || typeof parsed.message === "string" && parsed.message.trim() || typeof parsed.result === "string" && parsed.result.trim() || subtype;
@@ -17470,7 +17588,7 @@ function createClaudeCliBackend(command = "claude", defaultArgs = []) {
           const basePromptText = resumeContextPrefix ? `${resumeContextPrefix}
 
 ${ctx.promptText}` : ctx.promptText;
-          const promptText = ctx.config.mode === "plan" ? buildPlanModePrefix(buildPromptWithSystem(ctx.config, basePromptText)) : buildPromptWithSystem(ctx.config, basePromptText);
+          const promptText = ctx.config.mode === "plan" ? buildPlanModePrefix(basePromptText) : basePromptText;
           if (promptText.trim()) {
             contentBlocks.push({ type: "text", text: promptText });
           }
@@ -17561,6 +17679,25 @@ function buildGeneratedImageFromCodexPayload(payload) {
     idFields: []
   });
 }
+function extractRolloutMessageText(payload) {
+  const content = payload.content;
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    for (const block of content) {
+      if (block && typeof block === "object" && typeof block.text === "string") {
+        return block.text;
+      }
+    }
+  }
+  return "";
+}
+function isSyntheticUserRolloutMessage(payload) {
+  const text = extractRolloutMessageText(payload).trimStart();
+  if (!text) return false;
+  const lower = text.toLowerCase();
+  return lower.startsWith("<environment_context") || lower.startsWith("<user_instructions") || // Auto-compaction bridge summaries are tagged in the rollout content.
+  lower.startsWith("<compact") || lower.startsWith("[compact");
+}
 function latestUserMessageLineIndex(lines) {
   let latestIndex = -1;
   for (let index = 0; index < lines.length; index += 1) {
@@ -17568,7 +17705,7 @@ function latestUserMessageLineIndex(lines) {
     if (!line) continue;
     const entry = parseJsonObject(line);
     const payload = entry && typeof entry.payload === "object" && entry.payload !== null ? entry.payload : null;
-    if (payload?.type === "message" && payload.role === "user") {
+    if (payload?.type === "message" && payload.role === "user" && !isSyntheticUserRolloutMessage(payload)) {
       latestIndex = index;
     }
   }
@@ -17632,7 +17769,9 @@ async function replayCodexMcpToolEventsFromSessionLog(context, state) {
   }
 }
 var CODEX_EXIT_GRACE_MS = 3e4;
-function armCodexExitGraceKill(state) {
+var CODEX_BACKGROUND_EXIT_GRACE_MS = 10 * 6e4;
+var CODEX_EXIT_GRACE_SIGKILL_MS = 3e3;
+function armCodexExitGraceKill(state, graceMs = CODEX_EXIT_GRACE_MS) {
   if (state.exitGraceKillTimer) return;
   const child = state.process;
   if (!child) return;
@@ -17641,19 +17780,16 @@ function armCodexExitGraceKill(state) {
     console.warn(
       "[codex_app_server] Process did not exit after turn completion; killing process group"
     );
-    const pid = child.pid;
-    if (pid) {
-      try {
-        process.kill(-pid, "SIGTERM");
-        return;
-      } catch {
-      }
-    }
-    try {
-      child.kill("SIGTERM");
-    } catch {
-    }
-  }, CODEX_EXIT_GRACE_MS);
+    killProcessTree(child.pid, { signal: "SIGTERM", child });
+    const killTimer = setTimeout(() => {
+      if (child.exitCode !== null) return;
+      console.warn(
+        "[codex_app_server] Process still alive after grace SIGTERM; escalating to SIGKILL"
+      );
+      killProcessTree(child.pid, { signal: "SIGKILL", child });
+    }, CODEX_EXIT_GRACE_SIGKILL_MS);
+    killTimer.unref?.();
+  }, graceMs);
   timer.unref?.();
   state.exitGraceKillTimer = timer;
 }
@@ -17662,6 +17798,167 @@ function disarmCodexExitGraceKill(state) {
   clearTimeout(state.exitGraceKillTimer);
   state.exitGraceKillTimer = void 0;
 }
+function completeCodexTurnRespectingWorkers(state) {
+  disarmCodexExitGraceKill(state);
+  const activeWorkers = state.activeBackgroundTaskIds?.size ?? 0;
+  if (activeWorkers > 0) {
+    state.resultDeferredOnBackgroundWork = true;
+    state.codexAwaitingWorkersAfterTurnEnd = true;
+    console.info(
+      `[codex_app_server] Turn completed with ${activeWorkers} background worker id(s) still active \u2014 deferring exit grace`
+    );
+    armCodexExitGraceKill(state, CODEX_BACKGROUND_EXIT_GRACE_MS);
+    return;
+  }
+  armCodexExitGraceKill(state);
+}
+function touchCodexBackgroundGrace(state) {
+  if (!state.codexAwaitingWorkersAfterTurnEnd) return;
+  disarmCodexExitGraceKill(state);
+  armCodexExitGraceKill(state, CODEX_BACKGROUND_EXIT_GRACE_MS);
+}
+function maybeReleaseCodexDeferredTurn(state) {
+  if (!state.codexAwaitingWorkersAfterTurnEnd) return;
+  if (state.activeBackgroundTaskIds?.size) return;
+  state.codexAwaitingWorkersAfterTurnEnd = false;
+  state.resultDeferredOnBackgroundWork = false;
+  disarmCodexExitGraceKill(state);
+  armCodexExitGraceKill(state);
+  console.info(
+    "[codex_app_server] All background workers finished after turn completion \u2014 arming normal exit grace"
+  );
+}
+var TERMINAL_COLLAB_AGENT_STATUSES = /* @__PURE__ */ new Set([
+  "completed",
+  "errored",
+  "shutdown",
+  "interrupted",
+  "not_found"
+]);
+var FAILED_COLLAB_AGENT_STATUSES = /* @__PURE__ */ new Set(["errored", "interrupted", "not_found"]);
+var COLLAB_COORDINATION_TOOL_NAMES = {
+  send_input: "collab_send_input",
+  wait: "collab_wait",
+  close_agent: "collab_close_agent"
+};
+function firstLine(text, maxLength = 140) {
+  const line = text.split("\n").find((candidate) => candidate.trim().length > 0)?.trim() ?? "";
+  return line.length > maxLength ? `${line.slice(0, maxLength - 1)}\u2026` : line;
+}
+function finishCodexWorker(context, state, options) {
+  const launcherId = options.launcherId ?? (options.threadId ? state.backgroundToolIdByTaskId?.get(options.threadId) : void 0) ?? (options.agentPath ? state.codexWorkerToolIdByPath?.get(options.agentPath) : void 0);
+  if (!launcherId) {
+    if (options.threadId) clearBackgroundTaskIds(state, [options.threadId]);
+    maybeReleaseCodexDeferredTurn(state);
+    return;
+  }
+  const launcherStillActive = state.activeBackgroundTaskIds?.has(launcherId) === true || (state.backgroundTaskIdsByToolId?.get(launcherId)?.size ?? 0) > 0;
+  if (!launcherStillActive) {
+    if (options.threadId) clearBackgroundTaskIds(state, [options.threadId]);
+    maybeReleaseCodexDeferredTurn(state);
+    return;
+  }
+  clearBackgroundTaskIds(state, [options.threadId ?? launcherId]);
+  const remainingSiblings = state.backgroundTaskIdsByToolId?.get(launcherId)?.size ?? 0;
+  if (remainingSiblings === 0) {
+    clearBackgroundTaskIds(state, [launcherId]);
+    const isError = FAILED_COLLAB_AGENT_STATUSES.has(options.status);
+    const resultText = options.message?.trim() || `Background worker ${options.status}.`;
+    void context.presenter.onToolResult?.(launcherId, resultText, isError);
+  }
+  maybeReleaseCodexDeferredTurn(state);
+}
+function applyCodexCollabAgentStates(context, state, agentsStates) {
+  for (const [threadId, raw] of Object.entries(agentsStates)) {
+    if (!raw || typeof raw !== "object") continue;
+    const entry = raw;
+    const status = typeof entry.status === "string" ? entry.status : "";
+    if (!TERMINAL_COLLAB_AGENT_STATUSES.has(status)) continue;
+    finishCodexWorker(context, state, {
+      threadId,
+      status,
+      message: typeof entry.message === "string" ? entry.message : void 0
+    });
+  }
+}
+function summarizeCodexAgentStates(agentsStates) {
+  return Object.entries(agentsStates).map(([threadId, raw]) => {
+    const entry = raw && typeof raw === "object" ? raw : {};
+    const status = typeof entry.status === "string" ? entry.status : "unknown";
+    const message = typeof entry.message === "string" && entry.message.trim() ? ` \u2014 ${firstLine(entry.message)}` : "";
+    return `${threadId}: ${status}${message}`;
+  }).join("\n");
+}
+function handleCodexCollabToolCallItem(context, state, item, phase) {
+  const itemId = typeof item.id === "string" ? item.id : "";
+  const tool = typeof item.tool === "string" ? item.tool : "";
+  if (!itemId || !tool) return true;
+  const senderThreadId = typeof item.sender_thread_id === "string" ? item.sender_thread_id : "";
+  const receiverThreadIds = Array.isArray(item.receiver_thread_ids) ? item.receiver_thread_ids.filter(
+    (value2) => typeof value2 === "string" && value2.length > 0
+  ) : [];
+  const prompt = typeof item.prompt === "string" ? item.prompt : "";
+  const agentsStates = typeof item.agents_states === "object" && item.agents_states !== null ? item.agents_states : {};
+  const itemStatus = typeof item.status === "string" ? item.status : "";
+  if (tool === "spawn_agent") {
+    if (trackCodexStreamedToolId(state, itemId)) {
+      const parentToolUseId = senderThreadId ? state.backgroundToolIdByTaskId?.get(senderThreadId) ?? null : null;
+      void context.presenter.onToolUse(
+        "Agent",
+        {
+          subagent_type: "codex-worker",
+          description: firstLine(prompt) || "Codex background worker",
+          ...prompt ? { prompt } : {},
+          ...receiverThreadIds.length > 0 ? { agent_thread_ids: receiverThreadIds } : {}
+        },
+        itemId,
+        parentToolUseId
+      );
+      registerBackgroundLauncher(state, itemId);
+    }
+    for (const threadId of receiverThreadIds) {
+      if (state.backgroundToolIdByTaskId?.get(threadId)) continue;
+      registerBackgroundTaskRecord(state, { task_id: threadId, tool_use_id: itemId });
+    }
+    applyCodexCollabAgentStates(context, state, agentsStates);
+    if (phase === "completed" && itemStatus === "failed") {
+      finishCodexWorker(context, state, {
+        launcherId: itemId,
+        status: "errored",
+        message: "Failed to spawn background worker."
+      });
+    }
+    return true;
+  }
+  const coordinationToolName = COLLAB_COORDINATION_TOOL_NAMES[tool];
+  if (!coordinationToolName) return false;
+  if (trackCodexStreamedToolId(state, itemId)) {
+    void context.presenter.onToolUse(
+      coordinationToolName,
+      {
+        ...receiverThreadIds.length > 0 ? { receiver_thread_ids: receiverThreadIds } : {},
+        ...prompt ? { prompt } : {}
+      },
+      itemId
+    );
+  }
+  if (phase === "completed") {
+    const isError = itemStatus === "failed";
+    const summary = summarizeCodexAgentStates(agentsStates);
+    void context.presenter.onToolResult?.(
+      itemId,
+      summary || (isError ? "Failed." : "Done."),
+      isError
+    );
+  }
+  applyCodexCollabAgentStates(context, state, agentsStates);
+  if (tool === "close_agent" && phase === "completed" && itemStatus !== "failed") {
+    for (const threadId of receiverThreadIds) {
+      finishCodexWorker(context, state, { threadId, status: "shutdown" });
+    }
+  }
+  return true;
+}
 function trackCodexStreamedToolId(state, toolId) {
   if (!state.codexStreamedToolIds) state.codexStreamedToolIds = /* @__PURE__ */ new Set();
   if (state.codexStreamedToolIds.has(toolId)) return false;
@@ -17692,6 +17989,7 @@ function handleCodexStructuredEvent(parsed, context, state) {
   const presenter = context.presenter;
   const type = typeof parsed.type === "string" ? parsed.type : "";
   if (!type) return false;
+  touchCodexBackgroundGrace(state);
   if (typeof parsed.thread_id === "string") {
     state.runtimeSessionId = parsed.thread_id;
   }
@@ -17716,7 +18014,12 @@ function handleCodexStructuredEvent(parsed, context, state) {
       return true;
     case "turn.started":
       disarmCodexExitGraceKill(state);
-      state.iterations += 1;
+      state.codexAwaitingWorkersAfterTurnEnd = false;
+      state.resultDeferredOnBackgroundWork = false;
+      if (state.codexIterationEventFamily !== "legacy") {
+        state.codexIterationEventFamily = "modern";
+        state.iterations += 1;
+      }
       return true;
     case "session_configured":
       if (typeof parsed.session_id === "string") {
@@ -17725,7 +18028,12 @@ function handleCodexStructuredEvent(parsed, context, state) {
       return true;
     case "task_started":
       disarmCodexExitGraceKill(state);
-      state.iterations += 1;
+      state.codexAwaitingWorkersAfterTurnEnd = false;
+      state.resultDeferredOnBackgroundWork = false;
+      if (state.codexIterationEventFamily !== "modern") {
+        state.codexIterationEventFamily = "legacy";
+        state.iterations += 1;
+      }
       return true;
     case "item.started": {
       const item = typeof parsed.item === "object" && parsed.item !== null ? parsed.item : null;
@@ -17752,6 +18060,8 @@ function handleCodexStructuredEvent(parsed, context, state) {
           }
           return true;
         }
+        case "collab_tool_call":
+          return handleCodexCollabToolCallItem(context, state, item, "started");
         // Text-bearing and patch/todo items carry no useful live-start payload; they
         // are surfaced on item.completed. Recognized (do not count as unhandled).
         case "reasoning":
@@ -17763,6 +18073,21 @@ function handleCodexStructuredEvent(parsed, context, state) {
           return false;
       }
     }
+    case "item.updated": {
+      const item = typeof parsed.item === "object" && parsed.item !== null ? parsed.item : null;
+      if (!item || typeof item.type !== "string") return true;
+      switch (item.type) {
+        case "collab_tool_call":
+          return handleCodexCollabToolCallItem(context, state, item, "updated");
+        case "todo_list": {
+          const todos = Array.isArray(item.items) ? item.items : [];
+          void presenter.onTodoWrite?.(todos);
+          return true;
+        }
+        default:
+          return false;
+      }
+    }
     case "item.completed": {
       const item = typeof parsed.item === "object" && parsed.item !== null ? parsed.item : null;
       if (!item || typeof item.type !== "string") return true;
@@ -17827,6 +18152,8 @@ function handleCodexStructuredEvent(parsed, context, state) {
           void presenter.onTodoWrite?.(todos);
           return true;
         }
+        case "collab_tool_call":
+          return handleCodexCollabToolCallItem(context, state, item, "completed");
         default:
           return false;
       }
@@ -17848,7 +18175,9 @@ function handleCodexStructuredEvent(parsed, context, state) {
       return true;
     }
     case "exec_command_begin": {
-      const toolId = typeof parsed.call_id === "string" ? parsed.call_id : `exec-${Date.now()}`;
+      const hasCallId = typeof parsed.call_id === "string" && parsed.call_id.length > 0;
+      const toolId = hasCallId ? parsed.call_id : `exec-${Date.now()}`;
+      if (!hasCallId) state.lastAnonymousExecId = toolId;
       const command = Array.isArray(parsed.command) ? parsed.command.join(" ") : "";
       const cwd = typeof parsed.cwd === "string" ? parsed.cwd : context.cwd;
       trackCodexStreamedToolId(state, toolId);
@@ -17856,7 +18185,10 @@ function handleCodexStructuredEvent(parsed, context, state) {
       return true;
     }
     case "exec_command_end": {
-      const toolId = typeof parsed.call_id === "string" ? parsed.call_id : `exec-${Date.now()}`;
+      const hasCallId = typeof parsed.call_id === "string" && parsed.call_id.length > 0;
+      const toolId = hasCallId ? parsed.call_id : state.lastAnonymousExecId;
+      if (!hasCallId) state.lastAnonymousExecId = void 0;
+      if (!toolId) return true;
       const output = typeof parsed.formatted_output === "string" ? parsed.formatted_output : typeof parsed.aggregated_output === "string" ? parsed.aggregated_output : "";
       void presenter.onToolResult?.(toolId, output);
       return true;
@@ -17864,9 +18196,8 @@ function handleCodexStructuredEvent(parsed, context, state) {
     case "mcp_tool_call_begin": {
       const toolId = typeof parsed.call_id === "string" ? parsed.call_id : `mcp-${Date.now()}`;
       const invocation = typeof parsed.invocation === "object" && parsed.invocation !== null ? parsed.invocation : {};
-      const tool = typeof invocation.tool_name === "string" ? invocation.tool_name : typeof invocation.tool === "string" ? invocation.tool : "MCP Tool";
       trackCodexStreamedToolId(state, toolId);
-      void presenter.onToolUse(tool, invocation, toolId);
+      void presenter.onToolUse(buildCodexMcpToolName(invocation), invocation, toolId);
       return true;
     }
     case "mcp_tool_call_end": {
@@ -17904,7 +18235,7 @@ function handleCodexStructuredEvent(parsed, context, state) {
       const lastMessage = typeof parsed.last_agent_message === "string" ? parsed.last_agent_message : "";
       if (lastMessage.length > 0) state.summary = lastMessage;
       state.error = void 0;
-      armCodexExitGraceKill(state);
+      completeCodexTurnRespectingWorkers(state);
       return true;
     }
     case "turn.completed": {
@@ -17927,7 +18258,108 @@ function handleCodexStructuredEvent(parsed, context, state) {
         cacheCreationTokens: state.usage.cacheCreationTokens
       });
       state.error = void 0;
-      armCodexExitGraceKill(state);
+      completeCodexTurnRespectingWorkers(state);
+      return true;
+    }
+    case "sub_agent_activity": {
+      const kind = typeof parsed.kind === "string" ? parsed.kind : "";
+      const agentThreadId = typeof parsed.agent_thread_id === "string" ? parsed.agent_thread_id : "";
+      const agentPath = typeof parsed.agent_path === "string" ? parsed.agent_path : "";
+      const eventId = typeof parsed.event_id === "string" ? parsed.event_id : "";
+      const isRootPath = !agentPath || agentPath === "/root" || agentPath === "/";
+      switch (kind) {
+        case "started": {
+          if (isRootPath) return true;
+          if (agentThreadId && state.backgroundToolIdByTaskId?.has(agentThreadId)) return true;
+          const toolId = eventId || agentThreadId;
+          if (!toolId) return true;
+          if (trackCodexStreamedToolId(state, toolId)) {
+            const workerName = agentPath.slice(agentPath.lastIndexOf("/") + 1) || "codex-worker";
+            const parentPath = agentPath.slice(0, agentPath.lastIndexOf("/"));
+            const parentToolUseId = parentPath && parentPath !== "/root" ? state.codexWorkerToolIdByPath?.get(parentPath) ?? null : null;
+            void presenter.onToolUse(
+              "Agent",
+              {
+                subagent_type: workerName,
+                description: agentPath,
+                ...agentThreadId ? { agent_thread_id: agentThreadId } : {}
+              },
+              toolId,
+              parentToolUseId
+            );
+            registerBackgroundLauncher(state, toolId);
+            if (agentThreadId) {
+              registerBackgroundTaskRecord(state, { task_id: agentThreadId, tool_use_id: toolId });
+            }
+            if (!state.codexWorkerToolIdByPath) state.codexWorkerToolIdByPath = /* @__PURE__ */ new Map();
+            state.codexWorkerToolIdByPath.set(agentPath, toolId);
+          }
+          return true;
+        }
+        case "interacted":
+          return true;
+        case "interrupted": {
+          if (isRootPath) return true;
+          finishCodexWorker(context, state, {
+            threadId: agentThreadId || void 0,
+            agentPath: agentPath || void 0,
+            status: "interrupted",
+            message: "Background worker interrupted."
+          });
+          return true;
+        }
+        default:
+          return false;
+      }
+    }
+    // App-server EventMsg collab lifecycle notices. Begin/interaction/resume events
+    // carry no state Alan tracks beyond liveness (touched above); spawn_end and the
+    // waiting/close terminals map into the shared worker registry below.
+    case "collab_agent_spawn_begin":
+    case "collab_agent_interaction_begin":
+    case "collab_agent_interaction_end":
+    case "collab_waiting_begin":
+    case "collab_resume_begin":
+    case "collab_resume_end":
+    case "collab_close_begin":
+      return true;
+    case "collab_agent_spawn_end": {
+      const newThreadId = typeof parsed.new_thread_id === "string" ? parsed.new_thread_id : "";
+      if (!newThreadId || state.backgroundToolIdByTaskId?.has(newThreadId)) return true;
+      const callId = typeof parsed.call_id === "string" && parsed.call_id ? parsed.call_id : typeof parsed.event_id === "string" ? parsed.event_id : "";
+      const toolId = callId || `collab-spawn-${newThreadId}`;
+      if (trackCodexStreamedToolId(state, toolId)) {
+        const nickname = typeof parsed.new_agent_nickname === "string" ? parsed.new_agent_nickname : "";
+        const role = typeof parsed.new_agent_role === "string" ? parsed.new_agent_role : "";
+        void presenter.onToolUse(
+          "Agent",
+          {
+            subagent_type: nickname || role || "codex-worker",
+            description: [nickname, role].filter(Boolean).join(" \u2014 ") || "Codex background worker",
+            agent_thread_id: newThreadId
+          },
+          toolId
+        );
+        registerBackgroundLauncher(state, toolId);
+      }
+      registerBackgroundTaskRecord(state, { task_id: newThreadId, tool_use_id: toolId });
+      return true;
+    }
+    case "collab_waiting_end": {
+      const entries = Array.isArray(parsed.agent_statuses) ? parsed.agent_statuses : [];
+      for (const raw of entries) {
+        if (!raw || typeof raw !== "object") continue;
+        const entry = raw;
+        const threadId = typeof entry.agent_thread_id === "string" ? entry.agent_thread_id : typeof entry.thread_id === "string" ? entry.thread_id : "";
+        const status = typeof entry.status === "string" ? entry.status.toLowerCase() : "";
+        if (!threadId || !TERMINAL_COLLAB_AGENT_STATUSES.has(status)) continue;
+        finishCodexWorker(context, state, { threadId, status });
+      }
+      return true;
+    }
+    case "collab_close_end": {
+      const threadId = typeof parsed.receiver_thread_id === "string" ? parsed.receiver_thread_id : "";
+      if (threadId) finishCodexWorker(context, state, { threadId, status: "shutdown" });
       return true;
     }
     case "error": {
@@ -18046,10 +18478,11 @@ function createCodexRuntimeBackend(command = "codex", defaultArgs = []) {
           },
           promptViaStdin: true,
           augmentPrompt: (ctx) => {
+            const isResume = Boolean(resumableSessionId);
             const promptWithContext = resumeContextPrefix ? `${resumeContextPrefix}
 
 ${ctx.promptText}` : ctx.promptText;
-            const basePrompt = buildPromptWithSystem(ctx.config, promptWithContext);
+            const basePrompt = buildResumeAwarePrompt(ctx.config, promptWithContext, { isResume });
             return ctx.config.mode === "plan" ? buildPlanModePrefix(basePrompt) : basePrompt;
           },
           parseStructuredLine: parseCodexStructuredLine,
@@ -18255,10 +18688,21 @@ function handleCursorStructuredEvent(parsed, context, state) {
     }
     case "tool_call": {
       const subtype = typeof parsed.subtype === "string" ? parsed.subtype : "";
-      const toolId = typeof parsed.call_id === "string" ? parsed.call_id : `cursor-tool-${Date.now()}`;
+      const hasCallId = typeof parsed.call_id === "string" && parsed.call_id.length > 0;
       const toolCall = typeof parsed.tool_call === "object" && parsed.tool_call !== null ? parsed.tool_call : null;
       const entry = toolCall ? extractCursorToolEntry(toolCall) : null;
       if (!entry) return true;
+      let toolId;
+      if (hasCallId) {
+        toolId = parsed.call_id;
+      } else if (subtype === "started") {
+        state.cursorAnonymousToolCounter = (state.cursorAnonymousToolCounter ?? 0) + 1;
+        toolId = `cursor-tool-${state.cursorAnonymousToolCounter}`;
+        state.lastAnonymousCursorToolId = toolId;
+      } else {
+        toolId = state.lastAnonymousCursorToolId;
+      }
+      if (!toolId) return true;
       state.iterations = Math.max(state.iterations, 1);
       const toolName = formatCursorToolName(entry.rawName, entry.payload);
       const toolArgs = typeof entry.payload.args === "object" && entry.payload.args !== null ? entry.payload.args : typeof entry.payload.arguments === "object" && entry.payload.arguments !== null ? entry.payload.arguments : entry.payload;
@@ -18267,6 +18711,7 @@ function handleCursorStructuredEvent(parsed, context, state) {
         return true;
       }
       if (subtype === "completed") {
+        if (!hasCallId) state.lastAnonymousCursorToolId = void 0;
         void presenter.onToolResult?.(toolId, buildCursorToolResultText(entry.payload.result));
       }
       return true;
@@ -18345,7 +18790,10 @@ function buildCursorAgentModelArg(modelId, options) {
   const wireEffort = resolveWireEffort({
     harness: "cursor_agent_cli",
     modelId: baseId,
-    selectedEffortLevel: options?.selectedEffortLevel,
+    // Fall back to an effort baked into the model id (e.g. `gpt-5.5-high` from a
+    // session import or raw discovered id) when no explicit selection overrides it,
+    // so the SKU is preserved instead of silently downgraded to default effort.
+    selectedEffortLevel: options?.selectedEffortLevel ?? parsed.effort,
     effortLevels
   });
   let id = baseId;
@@ -18359,7 +18807,8 @@ function buildCursorAgentModelArg(modelId, options) {
     }
   }
   const contextWindow = asContextWindow(options?.selectedContextWindow);
-  if (contextWindow === "1m" && id === baseId) {
+  const modelSupports1m = (options?.contextWindows ?? []).includes("1m");
+  if (contextWindow === "1m" && id === baseId && modelSupports1m) {
     return `${baseId}[context=1m]`;
   }
   if (parsed.fast) return `${id}-fast`;
@@ -18449,7 +18898,8 @@ function createCursorAgentCliBackend(command = "cursor-agent", defaultArgs = [])
                 buildCursorAgentModelArg(model, {
                   selectedEffortLevel: ctx.config.selectedEffortLevel,
                   selectedContextWindow: ctx.config.selectedContextWindow,
-                  effortLevels: modelDef?.capabilities?.effortLevels
+                  effortLevels: modelDef?.capabilities?.effortLevels,
+                  contextWindows: modelDef?.capabilities?.contextWindows
                 })
               );
             }
@@ -18467,11 +18917,20 @@ function createCursorAgentCliBackend(command = "cursor-agent", defaultArgs = [])
           // with zero output; without this watchdog only the 30-min server reaper
           // would end the run.
           startupTimeoutMs: 18e4,
+          // Post-startup hang bound: cursor's asks use the non-blocking MCP model and it
+          // never populates the idle timer's ask/background fire conditions, so a cursor
+          // process that produced output then went silent (no result event) is otherwise
+          // bounded only by the ~30-min external reaper. Poll every 5 min; kill after 15
+          // min of continuous silence.
+          resultIdleTimeoutMs: 5 * 6e4,
+          postStartupSilenceTimeoutMs: 15 * 6e4,
           augmentPrompt: (ctx) => {
-            const prompt = buildPromptWithImagePathReferences(ctx, imageFiles);
-            return ctx.config.teamId?.trim() ? `${prompt}
-
-${buildCodeDiscoveryEnforcementTail()}` : prompt;
+            const isResume = Boolean(
+              ctx.config.runtimeSessionId?.trim() || ctx.config.providerSessionId?.trim()
+            );
+            const base = buildResumeAwarePrompt(ctx.config, ctx.promptText, { isResume });
+            const prompt = ctx.config.mode === "plan" ? buildPlanModePrefix(base) : base;
+            return appendImagePathReferences(prompt, imageFiles);
           },
           parseStructuredLine: parseCursorStructuredLine
         }).run(context);
@@ -19231,17 +19690,7 @@ function handleOpencodeStructuredEvent(parsed, context, state) {
         void presenter.onError(message);
         state.error = message;
       }
-      const pid = state.process?.pid;
-      if (pid) {
-        try {
-          process.kill(-pid, "SIGTERM");
-        } catch {
-          try {
-            state.process?.kill("SIGTERM");
-          } catch {
-          }
-        }
-      }
+      killProcessTree(state.process?.pid, { signal: "SIGTERM", child: state.process });
       return true;
     }
     default:
@@ -19435,7 +19884,7 @@ function createSupatestCliBackend(command = "supatest", defaultArgs = []) {
           const basePromptText = resumeContextPrefix ? `${resumeContextPrefix}
 
 ${ctx.promptText}` : ctx.promptText;
-          const promptText = ctx.config.mode === "plan" ? buildPlanModePrefix(buildPromptWithSystem(ctx.config, basePromptText)) : buildPromptWithSystem(ctx.config, basePromptText);
+          const promptText = ctx.config.mode === "plan" ? buildPlanModePrefix(basePromptText) : basePromptText;
           if (promptText.trim()) {
             contentBlocks.push({ type: "text", text: promptText });
           }
@@ -19620,6 +20069,8 @@ var BaseMachineAgent = class _BaseMachineAgent {
   presenter;
   runtime;
   abortController = null;
+  /** Log the "synced MCP session headers" line once per run(), not per respawn. */
+  mcpHeadersLogged = false;
   constructor(presenter, runtime) {
     this.presenter = presenter;
     this.runtime = runtime;
@@ -19676,7 +20127,52 @@ var BaseMachineAgent = class _BaseMachineAgent {
   getActivityHeartbeatIntervalMs() {
     return AGENT_ACTIVITY_HEARTBEAT_MS;
   }
+  /**
+   * Home directory whose CLI config files receive the Alan MCP session headers.
+   * Defaults to the process home (production behaviour); tests override to a
+   * temp dir so runs never touch the developer's real CLI configs.
+   */
+  getMcpConfigHomeDir() {
+    return void 0;
+  }
+  /**
+   * Re-assert this run's Alan MCP identity in the shared CLI config under the
+   * serialization gate, holding the gate until the provider spawns. Returns the
+   * gate release. Concurrent runs on one machine share ~/.codex/config.toml,
+   * ~/.cursor/mcp.json, and ~/.claude.json; the CLI reads its config once at
+   * spawn, so without serialization a concurrent run could rewrite the shared
+   * file between this write and this spawn and steal this run's session identity.
+   */
+  async beginMcpConfigCriticalSection(config) {
+    const conversationId = config.conversationId;
+    if (!conversationId) return () => {
+    };
+    const releaseGate = await acquireMcpConfigWriteGate();
+    try {
+      const writtenClis = syncAlanMcpSessionHeaders({
+        conversationId,
+        teamId: config.teamId,
+        runHeaders: config.alanMcp?.headers,
+        homeDir: this.getMcpConfigHomeDir()
+      });
+      if (writtenClis.length > 0 && !this.mcpHeadersLogged) {
+        this.mcpHeadersLogged = true;
+        void this.presenter.onLog(`Synced Alan MCP session headers to ${writtenClis.join(", ")}`);
+      }
+    } catch (error) {
+      console.warn("[base-machine-agent] Failed to sync MCP session headers", error);
+    }
+    return releaseGate;
+  }
   async runBackendWithActivityHeartbeat(backend, context) {
+    const releaseMcpGate = await this.beginMcpConfigCriticalSection(context.config);
+    let mcpGateReleased = false;
+    const releaseMcpGateOnce = () => {
+      if (mcpGateReleased) return;
+      mcpGateReleased = true;
+      releaseMcpGate();
+    };
+    const callerOnProcessSpawned = context.onProcessSpawned;
     const intervalMs = this.getActivityHeartbeatIntervalMs();
     let heartbeat = null;
     let livenessProbe = null;
@@ -19695,9 +20191,17 @@ var BaseMachineAgent = class _BaseMachineAgent {
         }
       }, intervalMs);
     }
+    const spawnAwareContext = {
+      ...context,
+      onProcessSpawned: (child) => {
+        releaseMcpGateOnce();
+        callerOnProcessSpawned?.(child);
+      }
+    };
     try {
-      return await backend.run(context);
+      return await backend.run(spawnAwareContext);
     } finally {
+      releaseMcpGateOnce();
       if (heartbeat) clearInterval(heartbeat);
     }
   }
@@ -19791,6 +20295,8 @@ Prefer relative paths and keep your work scoped to this project.`
       runtimeCommand || "generic-cli",
       runtimeArgs
     );
+    const revalidateRuntimeCommand = this.revalidateRuntimeCommand;
+    const revalidateCommand = revalidateRuntimeCommand ? () => revalidateRuntimeCommand.call(this) : void 0;
     let lastResult = null;
     for (let attempt = 0; attempt <= _BaseMachineAgent.MAX_RETRIES; attempt++) {
       if (this.abortController?.signal.aborted) break;
@@ -19801,7 +20307,8 @@ Prefer relative paths and keep your work scoped to this project.`
         cwd,
         env,
         promptText,
-        onProcessSpawned: this.getOnProcessSpawned()
+        onProcessSpawned: this.getOnProcessSpawned(),
+        revalidateCommand
       });
       lastResult = {
         ...result,
@@ -19851,7 +20358,8 @@ ${runtimeConfig.task}` } : {}
           cwd,
           env,
           promptText: fallbackContext ? this.buildPromptText(runtimeConfig) : promptText,
-          onProcessSpawned: this.getOnProcessSpawned()
+          onProcessSpawned: this.getOnProcessSpawned(),
+          revalidateCommand
         });
         lastResult = {
           ...retryResult,
@@ -19927,19 +20435,7 @@ ${runtimeConfig.task}` } : {}
       this.presenter.onComplete(result);
       return result;
     }
-    if (initialConfig.conversationId) {
-      try {
-        const writtenClis = syncAlanMcpSessionHeaders({
-          conversationId: initialConfig.conversationId,
-          teamId: initialConfig.teamId
-        });
-        if (writtenClis.length > 0) {
-          void this.presenter.onLog(`Synced Alan MCP session headers to ${writtenClis.join(", ")}`);
-        }
-      } catch (error) {
-        console.warn("[base-machine-agent] Failed to sync MCP session headers", error);
-      }
-    }
+    this.mcpHeadersLogged = false;
     try {
       return await this.runCliBackend(initialConfig, safeProjectPath);
     } catch (error) {
@@ -20271,38 +20767,32 @@ var CoreAgent = class _CoreAgent extends BaseMachineAgent {
     const pid = child.pid;
     if (!pid) return false;
     console.info("[CoreAgent] Killing agent process", { pid });
-    try {
-      if (process.platform === "win32") {
-        child.kill("SIGTERM");
-      } else {
-        process.kill(-pid, "SIGTERM");
-      }
-    } catch (err) {
-      if (err.code !== "ESRCH") {
-        console.warn("[CoreAgent] SIGTERM failed", { pid, err });
-      }
-      try {
-        child.kill("SIGTERM");
-      } catch {
-      }
-    }
+    killProcessTree(pid, {
+      signal: "SIGTERM",
+      child,
+      onError: (stage, err) => console.warn(`[CoreAgent] SIGTERM failed (${stage})`, { pid, err })
+    });
     setTimeout(() => {
       if (child.killed || child.exitCode !== null) return;
       console.warn("[CoreAgent] Escalating to SIGKILL", { pid });
-      try {
-        if (process.platform === "win32") {
-          child.kill("SIGKILL");
-        } else {
-          process.kill(-pid, "SIGKILL");
-        }
-      } catch (err) {
-        if (err.code !== "ESRCH") {
-          console.warn("[CoreAgent] SIGKILL failed", { pid, err });
-        }
-      }
+      killProcessTree(pid, {
+        signal: "SIGKILL",
+        child,
+        onError: (stage, err) => console.warn(`[CoreAgent] SIGKILL failed (${stage})`, { pid, err })
+      });
     }, _CoreAgent.SIGKILL_DELAY_MS);
     return true;
   }
+  /**
+   * Re-resolve this agent's CLI executable from scratch when a spawn fails
+   * ENOENT. The daemon caches resolved CLI paths, so a provider binary that was
+   * moved or reinstalled mid-session would otherwise fail every turn with
+   * "CLI command not found" until the daemon restarts. Invalidating the cache
+   * and re-resolving once lets the current run recover against the new location.
+   */
+  revalidateRuntimeCommand() {
+    return revalidateBackendRuntimeCommand(this.runtime.backendKind) ?? null;
+  }
   // ── Interactive tool response (WS relay → stdin) ───────────────────────
   /**
    * Send a tool_result to the CLI's stdin (stream-json format).
@@ -20633,7 +21123,7 @@ function encryptedFileSize(entries) {
   );
   return emptyEnvelopeBytes + base64UrlLength(plaintextBytes);
 }
-var EncryptedEventOutbox = class {
+var EncryptedEventOutbox = class _EncryptedEventOutbox {
   constructor(path, encodedKey, pushLog = () => {
   }, options = {}) {
     this.path = path;
@@ -20648,6 +21138,11 @@ var EncryptedEventOutbox = class {
       throw new Error("event outbox maxIntermediateEventsPerRun must be a non-negative integer");
     }
     this.entries = this.read();
+    if (!(0, import_node_fs6.existsSync)(this.path)) {
+      this.lastPersistedSignature = _EncryptedEventOutbox.EMPTY_SIGNATURE;
+    } else if (this.entries.length > 0) {
+      this.lastPersistedSignature = this.serializeForPersist().signature;
+    }
     this.enforceCaps();
     this.persist();
   }
@@ -20655,6 +21150,19 @@ var EncryptedEventOutbox = class {
   inFlightEventId = null;
   ackTimer = null;
   retryTimer = null;
+  /** Latch so a persistent disk failure logs once per streak, not per event. */
+  persistFailureLogged = false;
+  /**
+   * Signature of the entries last durably written, so a `persist()` whose entries
+   * are byte-identical to what is already on disk skips the AES-GCM re-encrypt +
+   * temp-file write + rename entirely. Under link flapping the spool is persisted
+   * on every enqueue/ack; this collapses redundant writes (e.g. a reconnect that
+   * replays from head without mutating the queue) to O(delta), not O(spool). Set
+   * to null on any write failure so the next persist retries rather than skips.
+   */
+  lastPersistedSignature = null;
+  /** Sentinel signature for the empty (no-entries) on-disk state. */
+  static EMPTY_SIGNATURE = "empty";
   key;
   maxEncryptedBytes;
   maxIntermediateEventsPerRun;
@@ -20857,31 +21365,53 @@ var EncryptedEventOutbox = class {
       throw new Error(`unable to decrypt durable event outbox: ${detail}`);
     }
   }
-  persist() {
+  /** Serialize the current entries to their plaintext + content signature (once). */
+  serializeForPersist() {
     if (this.entries.length === 0) {
-      (0, import_node_fs6.rmSync)(this.path, { force: true });
-      return;
+      return { plaintext: "", signature: _EncryptedEventOutbox.EMPTY_SIGNATURE };
     }
-    (0, import_node_fs6.mkdirSync)((0, import_node_path5.dirname)(this.path), { recursive: true, mode: 448 });
-    const iv = (0, import_node_crypto.randomBytes)(12);
-    const cipher = (0, import_node_crypto.createCipheriv)("aes-256-gcm", this.key, iv);
-    const ciphertext = Buffer.concat([
-      cipher.update(JSON.stringify({ entries: this.entries }), "utf8"),
-      cipher.final()
-    ]);
-    const envelope = {
-      version: OUTBOX_VERSION,
-      iv: iv.toString("base64url"),
-      authTag: cipher.getAuthTag().toString("base64url"),
-      ciphertext: ciphertext.toString("base64url")
-    };
-    const pendingPath = `${this.path}.pending-${process.pid}-${(0, import_node_crypto.randomBytes)(6).toString("hex")}`;
+    const plaintext = JSON.stringify({ entries: this.entries });
+    return { plaintext, signature: (0, import_node_crypto.createHash)("sha256").update(plaintext).digest("base64url") };
+  }
+  persist() {
+    const { plaintext, signature } = this.serializeForPersist();
+    if (signature === this.lastPersistedSignature) return;
     try {
-      (0, import_node_fs6.writeFileSync)(pendingPath, JSON.stringify(envelope), { mode: 384 });
-      (0, import_node_fs6.chmodSync)(pendingPath, 384);
-      (0, import_node_fs6.renameSync)(pendingPath, this.path);
-    } finally {
-      (0, import_node_fs6.rmSync)(pendingPath, { force: true });
+      if (this.entries.length === 0) {
+        (0, import_node_fs6.rmSync)(this.path, { force: true });
+        this.lastPersistedSignature = signature;
+        this.persistFailureLogged = false;
+        return;
+      }
+      (0, import_node_fs6.mkdirSync)((0, import_node_path5.dirname)(this.path), { recursive: true, mode: 448 });
+      const iv = (0, import_node_crypto.randomBytes)(12);
+      const cipher = (0, import_node_crypto.createCipheriv)("aes-256-gcm", this.key, iv);
+      const ciphertext = Buffer.concat([cipher.update(plaintext, "utf8"), cipher.final()]);
+      const envelope = {
+        version: OUTBOX_VERSION,
+        iv: iv.toString("base64url"),
+        authTag: cipher.getAuthTag().toString("base64url"),
+        ciphertext: ciphertext.toString("base64url")
+      };
+      const pendingPath = `${this.path}.pending-${process.pid}-${(0, import_node_crypto.randomBytes)(6).toString("hex")}`;
+      try {
+        (0, import_node_fs6.writeFileSync)(pendingPath, JSON.stringify(envelope), { mode: 384 });
+        (0, import_node_fs6.chmodSync)(pendingPath, 384);
+        (0, import_node_fs6.renameSync)(pendingPath, this.path);
+      } finally {
+        (0, import_node_fs6.rmSync)(pendingPath, { force: true });
+      }
+      this.lastPersistedSignature = signature;
+      this.persistFailureLogged = false;
+    } catch (error) {
+      this.lastPersistedSignature = null;
+      if (!this.persistFailureLogged) {
+        this.persistFailureLogged = true;
+        const detail = error instanceof Error ? error.message : String(error);
+        this.pushLog(
+          `event_outbox_persist_failed error=${detail} pending_entries=${this.entries.length}`
+        );
+      }
     }
   }
 };
@@ -21587,8 +22117,8 @@ var CONFIG_LOCK_STALE_MS = 3e4;
 var CONFIG_LOCK_WAIT_MS = 2e3;
 var CONFIG_LOCK_POLL_MS = 20;
 function compactProviderVersion(output) {
-  const firstLine = output.split(/\r?\n/).map((line) => line.trim()).find(Boolean);
-  return firstLine?.slice(0, 120);
+  const firstLine2 = output.split(/\r?\n/).map((line) => line.trim()).find(Boolean);
+  return firstLine2?.slice(0, 120);
 }
 var inspectAlanMcpThroughProviderCli = (backendKind, expectedUrl, home) => {
   const plan = getMcpCliInspectionPlan(backendKind);
@@ -21628,7 +22158,30 @@ var inspectAlanMcpThroughProviderCli = (backendKind, expectedUrl, home) => {
     };
   }
   const providerVersion = compactProviderVersion(versionProbe.stdout);
-  const probe = runCliVersionProbe(executable, env, plan.args);
+  const inspectTimeoutMs = Number(process.env.ALAN_MCP_INSPECT_TIMEOUT_MS) || 2e4;
+  const probe = runCliVersionProbe(executable, env, plan.args, inspectTimeoutMs);
+  const timedOut = probe.status === null && (probe.signal === "SIGTERM" || probe.error?.code === "ETIMEDOUT");
+  if (timedOut) {
+    const fileCheck = verifyAlanMcpRegistered(backendKind, home, () => ({
+      ok: true,
+      verification: { method: "file" }
+    }));
+    console.warn("[alan-agent] MCP CLI inspection timed out; falling back to file check", {
+      backendKind,
+      command,
+      inspectTimeoutMs,
+      fileOk: fileCheck.ok
+    });
+    return {
+      ok: fileCheck.ok,
+      issue: fileCheck.ok ? void 0 : {
+        code: "provider_mcp_repair_required",
+        command,
+        message: `Alan tools could not be verified for ${plan.providerLabel}. Repair Alan tools, then retry.`
+      },
+      verification: { method: "file", command, providerVersion }
+    };
+  }
   const classification = classifyMcpCliInspection(
     plan,
     {
@@ -22527,7 +23080,7 @@ var RunStartGate = class {
 };
 
 // src/version.ts
-var AGENT_VERSION = "0.1.41";
+var AGENT_VERSION = "0.1.43";
 
 // src/workspace-relocation.ts
 var import_node_child_process3 = require("child_process");
@@ -22603,11 +23156,19 @@ var import_node_child_process4 = require("child_process");
 var import_node_fs11 = require("fs");
 var import_node_path9 = require("path");
 var WORKSPACE_LEASE_CHECK_INTERVAL_MS = 1e3;
+function parsePositiveMs(value2, fallback) {
+  const parsed = value2 ? Number(value2) : Number.NaN;
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+var WORKSPACE_LEASE_GIT_TIMEOUT_MS = parsePositiveMs(
+  process.env.ALAN_WORKSPACE_LEASE_GIT_TIMEOUT_MS,
+  2e3
+);
 function gitValue(cwd, args) {
   const result = (0, import_node_child_process4.spawnSync)("git", ["-C", cwd, ...args], {
     encoding: "utf8",
     env: getDaemonCliEnvironment(),
-    timeout: 2e3
+    timeout: WORKSPACE_LEASE_GIT_TIMEOUT_MS
   });
   if (result.status !== 0) return null;
   return result.stdout.trim() || null;
@@ -22643,6 +23204,13 @@ var DEFAULT_PROBE2 = {
     } catch {
       return null;
     }
+  },
+  pathExists: (workspacePath) => {
+    try {
+      return (0, import_node_fs11.existsSync)((0, import_node_path9.resolve)(workspacePath));
+    } catch {
+      return true;
+    }
   }
 };
 function unavailableFailure(target) {
@@ -22690,6 +23258,57 @@ var WorkspaceRunLease = class _WorkspaceRunLease {
       failure: null
     };
   }
+  /**
+   * Classify the lease state for the run monitor.
+   *
+   * - `transient: true` — a null snapshot while the workspace path still exists:
+   *   the git probe timed out or failed transiently (OS throttling / IO
+   *   contention), NOT a vanished checkout. The monitor should retry (require N
+   *   consecutive transient failures) before declaring the workspace lost.
+   * - `transient: false` — a definitive change: the path is genuinely missing
+   *   (ENOENT), or the workspace/repository/worktree/branch identity changed.
+   *   These are real and fail fast.
+   */
+  verifyDetailed() {
+    for (const captured of this.captured) {
+      const current = this.probe.snapshot(captured.target.workspacePath);
+      if (!current) {
+        const pathGone = this.probe.pathExists?.(captured.target.workspacePath) === false;
+        return { failure: unavailableFailure(captured.target), transient: !pathGone };
+      }
+      if (current.workspaceIdentity !== captured.identity.workspaceIdentity) {
+        return {
+          failure: {
+            code: "workspace_lease_path_changed",
+            message: "The selected workspace folder changed while the run was active. The run stopped before continuing; choose the correct folder and start a new run.",
+            workspacePath: captured.target.workspacePath,
+            expectedBranch: captured.identity.branch,
+            actualBranch: current.branch
+          },
+          transient: false
+        };
+      }
+      if (current.repositoryIdentity !== captured.identity.repositoryIdentity || current.worktreeIdentity !== captured.identity.worktreeIdentity) {
+        return {
+          failure: {
+            code: "workspace_lease_repository_changed",
+            message: "The workspace now points to a different repository or worktree. The run stopped before continuing; restore the original checkout and start a new run.",
+            workspacePath: captured.target.workspacePath,
+            expectedBranch: captured.identity.branch,
+            actualBranch: current.branch
+          },
+          transient: false
+        };
+      }
+      if (current.branch !== captured.identity.branch) {
+        return {
+          failure: branchFailure(captured.target, captured.identity.branch, current.branch),
+          transient: false
+        };
+      }
+    }
+    return { failure: null, transient: false };
+  }
   verify() {
     for (const captured of this.captured) {
       const current = this.probe.snapshot(captured.target.workspacePath);
@@ -22719,6 +23338,40 @@ var WorkspaceRunLease = class _WorkspaceRunLease {
     return null;
   }
 };
+var FRESH_LEASE_MONITOR_STATE = {
+  transientStreak: 0,
+  nextCheckAtMs: 0
+};
+function isLeaseCheckDue(state, nowMs) {
+  return nowMs >= state.nextCheckAtMs;
+}
+function applyLeaseCheckResult(input) {
+  const { detailed, nowMs, policy } = input;
+  if (!detailed.failure) {
+    return { action: "ok", state: { ...FRESH_LEASE_MONITOR_STATE } };
+  }
+  if (!detailed.transient) {
+    return { action: "fail", state: input.state, failure: detailed.failure };
+  }
+  const transientStreak = input.state.transientStreak + 1;
+  if (transientStreak >= policy.maxTransientFailures) {
+    return {
+      action: "fail",
+      state: { transientStreak, nextCheckAtMs: input.state.nextCheckAtMs },
+      failure: detailed.failure
+    };
+  }
+  const backoffMs = Math.min(
+    policy.backoffBaseMs * 2 ** (transientStreak - 1),
+    policy.backoffMaxMs
+  );
+  return {
+    action: "transient",
+    state: { transientStreak, nextCheckAtMs: nowMs + backoffMs },
+    failure: detailed.failure,
+    backoffMs
+  };
+}
 
 // src/daemon.ts
 var STAGING_API_URL = process.env.ALAN_STAGING_API_URL ?? "https://staging-api.tryalan.ai";
@@ -24037,9 +24690,12 @@ function reconcileActiveRuns(input) {
     if (!staleByGrace && !staleByDeadPid) continue;
     if (awaitingAsk && staleByGrace && !staleByDeadPid) continue;
     if (staleByDeadPid && awaitingAsk) {
+      entry.presenter.onComplete(buildAbortResult("provider_exited"));
       entry.agent.kill();
       input.activeAgents.delete(runId);
-      input.pushLog?.(`reconciled dead provider pid run=${runId} (awaiting ask, no interrupt)`);
+      input.pushLog?.(
+        `reconciled dead provider pid run=${runId} (awaiting ask \u2014 finalized for resume)`
+      );
       continue;
     }
     abortActiveAgent(entry, { reason: staleByDeadPid ? "provider_exited" : "runner_stalled" });
@@ -24780,6 +25436,10 @@ async function startDaemon(args) {
   const versionRefresh = setInterval(() => {
     void refreshProviderVersions();
   }, VERSION_REFRESH_INTERVAL_MS);
+  const parsedMaxTransient = Number(process.env.ALAN_WORKSPACE_LEASE_MAX_TRANSIENT_FAILURES);
+  const WORKSPACE_LEASE_MAX_TRANSIENT_FAILURES = Number.isFinite(parsedMaxTransient) && parsedMaxTransient >= 1 ? Math.floor(parsedMaxTransient) : 3;
+  const WORKSPACE_LEASE_FAILURE_BACKOFF_BASE_MS = 1e3;
+  const WORKSPACE_LEASE_FAILURE_BACKOFF_MAX_MS = 15e3;
   const stopRunForWorkspaceLease = (runId, entry, failure) => {
     entry.stage = "failed";
     if (!entry.presenter.failWorkspaceLease(failure)) return;
@@ -24787,15 +25447,39 @@ async function startDaemon(args) {
     activeAgents.delete(runId);
     pushLog(`workspace-lease-lost run=${runId} code=${failure.code}`);
   };
-  const verifyActiveWorkspaceLease = (runId, entry) => {
-    const failure = entry.workspaceLease?.verify() ?? null;
-    if (!failure) return true;
-    stopRunForWorkspaceLease(runId, entry, failure);
-    return false;
+  const leaseCheckPolicy = {
+    maxTransientFailures: WORKSPACE_LEASE_MAX_TRANSIENT_FAILURES,
+    backoffBaseMs: WORKSPACE_LEASE_FAILURE_BACKOFF_BASE_MS,
+    backoffMaxMs: WORKSPACE_LEASE_FAILURE_BACKOFF_MAX_MS
+  };
+  const verifyActiveWorkspaceLease = (runId, entry, nowMs) => {
+    const lease = entry.workspaceLease;
+    if (!lease) return true;
+    const state = entry.leaseCheck ?? { ...FRESH_LEASE_MONITOR_STATE };
+    entry.leaseCheck = state;
+    if (!isLeaseCheckDue(state, nowMs)) return true;
+    const decision = applyLeaseCheckResult({
+      state,
+      detailed: lease.verifyDetailed(),
+      nowMs,
+      policy: leaseCheckPolicy
+    });
+    entry.leaseCheck = decision.state;
+    if (decision.action === "fail" && decision.failure) {
+      stopRunForWorkspaceLease(runId, entry, decision.failure);
+      return false;
+    }
+    if (decision.action === "transient" && decision.failure) {
+      pushLog(
+        `workspace-lease-transient run=${runId} streak=${decision.state.transientStreak}/${WORKSPACE_LEASE_MAX_TRANSIENT_FAILURES} code=${decision.failure.code} backoff_ms=${decision.backoffMs ?? 0}`
+      );
+    }
+    return true;
   };
   const workspaceLeaseMonitor = setInterval(() => {
+    const nowMs = Date.now();
     for (const [runId, entry] of activeAgents) {
-      verifyActiveWorkspaceLease(runId, entry);
+      verifyActiveWorkspaceLease(runId, entry, nowMs);
     }
   }, WORKSPACE_LEASE_CHECK_INTERVAL_MS);
   workspaceLeaseMonitor.unref?.();
@@ -25272,7 +25956,7 @@ async function startDaemon(args) {
       },
       () => {
         const entry = activeAgents.get(payload.runId);
-        return entry ? verifyActiveWorkspaceLease(payload.runId, entry) : false;
+        return entry ? verifyActiveWorkspaceLease(payload.runId, entry, Date.now()) : false;
       }
     );
     let agent;
@@ -25340,6 +26024,7 @@ async function startDaemon(args) {
       taskMeta: payload.taskMeta,
       prMeta: payload.prMeta,
       conversationId: payload.conversationId,
+      alanMcp: payload.alanMcp,
       taskId: payload.taskId ?? payload.taskMeta?.id,
       teamId: payload.teamId,
       currentUser: payload.currentUser,
@@ -25391,7 +26076,7 @@ async function startDaemon(args) {
         ([, entry]) => entry.conversationId === payload.conversationId
       ) : [...activeAgents.entries()];
       const delivered = entries.some(([runId, entry]) => {
-        if (!entry || !verifyActiveWorkspaceLease(runId, entry)) return false;
+        if (!entry || !verifyActiveWorkspaceLease(runId, entry, Date.now())) return false;
         return entry.agent.sendToolResponse(payload.toolId, payload.response) === true;
       });
       if (!delivered) {
@@ -26158,6 +26843,18 @@ function omitUndefined(record) {
   return Object.fromEntries(Object.entries(record).filter(([, value2]) => value2 !== void 0));
 }
 
+// src/resume-fallback-env.ts
+var RESUME_FALLBACK_CONTEXT_ENV = "ALAN_RESUME_FALLBACK_CONTEXT_B64";
+function decodeResumeFallbackContext(encoded) {
+  if (!encoded) return void 0;
+  try {
+    const decoded = Buffer.from(encoded, "base64").toString("utf8").trim();
+    return decoded.length > 0 ? decoded : void 0;
+  } catch {
+    return void 0;
+  }
+}
+
 // src/web-presenter.ts
 var WebPresenter = class {
   constructor(wsClient, _conversationId, cwd) {
@@ -26450,6 +27147,7 @@ var SandboxEventDispatcher = class {
       fireAndForget(event);
       return;
     }
+    if (isBackgroundHeartbeat(event) && !this.outboxSocket.connected) return;
     this.outbox.enqueue(this.conversationId, this.currentRunId ?? this.conversationId, event);
     this.outbox.flush(this.outboxSocket);
   }
@@ -26569,7 +27267,7 @@ var WSClient = class {
     if (this.heartbeatTimer) clearInterval(this.heartbeatTimer);
     this.heartbeatTimer = setInterval(() => {
       if (!this.socket.connected) return;
-      this.socket.emit("agent.heartbeat", this.buildHeartbeat());
+      this.socket.volatile.emit("agent.heartbeat", this.buildHeartbeat());
     }, AGENT_HEARTBEAT_INTERVAL_MS);
     this.heartbeatTimer.unref?.();
   }
@@ -26652,6 +27350,7 @@ var WSClient = class {
           images: data.images,
           files: data.files,
           providerSessionId: data.providerSessionId,
+          resumeFallbackContext: data.resumeFallbackContext,
           backendKind: data.backendKind,
           agentId: data.agentId,
           agentPrompt: data.agentPrompt,
@@ -26843,6 +27542,7 @@ async function runSandbox(config) {
   const presenter = new WebPresenter(wsClient, config.sessionId, config.projectPath);
   presenter.setSuppressSessionLifecycle(true);
   let lastProviderSessionId = config.providerSessionId;
+  let resumeFallbackContext = config.resumeFallbackContext;
   let activeBackendKind = config.backendKind || "claude_cli";
   let activeAgentId = config.agentId;
   let activeAgentPrompt = config.agentPrompt;
@@ -26926,10 +27626,12 @@ async function runSandbox(config) {
           selectedContextWindow: activeContextWindow ?? null,
           selectedEffortLevel: activeEffortLevel ?? null,
           providerSessionId: lastProviderSessionId ?? void 0,
+          resumeFallbackContext,
           taskMeta: currentTaskMeta,
           prMeta: currentPrMeta,
           taskId: currentTaskId,
           conversationId: currentConversationId,
+          alanMcp: currentAlanMcp,
           teamId: currentTeamId,
           workflowId,
           workflowExecutionId,
@@ -26977,6 +27679,7 @@ async function runSandbox(config) {
         }
       }
       currentAgent = null;
+      resumeFallbackContext = void 0;
       lifecycle.info("sandbox_agent_run_complete", {
         success: result.success,
         iterations: result.iterations,
@@ -27003,6 +27706,7 @@ async function runSandbox(config) {
     currentFiles = nextPayload.files ?? [];
     if (nextPayload.providerSessionId) {
       lastProviderSessionId = nextPayload.providerSessionId;
+      resumeFallbackContext = nextPayload.resumeFallbackContext;
     }
     if (nextPayload.backendKind) {
       activeBackendKind = nextPayload.backendKind;
@@ -27341,6 +28045,9 @@ async function runSessionFromEnv() {
   const contextWindow = process.env.ALAN_CONTEXT_WINDOW || void 0;
   const effortLevel = process.env.ALAN_EFFORT_LEVEL || void 0;
   const providerSessionId = process.env.ALAN_PROVIDER_SESSION_ID || void 0;
+  const resumeFallbackContext = decodeResumeFallbackContext(
+    process.env[RESUME_FALLBACK_CONTEXT_ENV]
+  );
   const workflowId = process.env.ALAN_WORKFLOW_ID || void 0;
   const workflowExecutionId = process.env.ALAN_WORKFLOW_EXECUTION_ID || void 0;
   const sandboxId = process.env.ALAN_SANDBOX_ID || void 0;
@@ -27382,6 +28089,7 @@ async function runSessionFromEnv() {
     contextWindow,
     effortLevel,
     providerSessionId,
+    resumeFallbackContext,
     workflowId,
     workflowExecutionId,
     sandboxId,