@aiden-ade/sandbox-agent 0.1.42 → 0.1.44

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
@@ -14555,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.",
@@ -15305,6 +15296,8 @@ var import_path5 = require("path");
 var import_fs6 = require("fs");
 var import_os6 = require("os");
 var import_path6 = require("path");
+var import_readline2 = require("readline");
+var import_url2 = require("url");
 var import_fs7 = require("fs");
 var import_os7 = require("os");
 var import_path7 = require("path");
@@ -15443,6 +15436,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) {
@@ -15653,6 +15651,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(),
@@ -15661,6 +15676,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.",
@@ -15827,7 +15849,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: {
@@ -15917,7 +15939,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;
 }
@@ -16298,6 +16320,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();
                 }
@@ -16310,8 +16335,9 @@ 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`
             );
             killProcessTree(child.pid, { signal: "SIGKILL", child });
             exitCode = await Promise.race([
@@ -16384,6 +16410,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",
@@ -16433,7 +16478,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,
@@ -17141,6 +17186,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 "";
@@ -17158,6 +17213,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) {
@@ -17249,20 +17305,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,
@@ -17378,7 +17439,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;
@@ -17529,7 +17590,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 });
           }
@@ -17620,6 +17681,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) {
@@ -17627,7 +17707,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;
     }
   }
@@ -17691,7 +17771,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;
@@ -17701,7 +17783,15 @@ function armCodexExitGraceKill(state) {
       "[codex_app_server] Process did not exit after turn completion; killing process group"
     );
     killProcessTree(child.pid, { signal: "SIGTERM", child });
-  }, CODEX_EXIT_GRACE_MS);
+    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;
 }
@@ -17710,6 +17800,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;
@@ -17740,6 +17991,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;
   }
@@ -17764,7 +18016,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") {
@@ -17773,7 +18030,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;
@@ -17800,6 +18062,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":
@@ -17811,6 +18075,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;
@@ -17875,6 +18154,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;
       }
@@ -17896,7 +18177,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);
@@ -17904,7 +18187,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;
@@ -17912,9 +18198,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": {
@@ -17952,7 +18237,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": {
@@ -17975,7 +18260,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": {
@@ -18094,10 +18480,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,
@@ -18303,10 +18690,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;
@@ -18315,6 +18713,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;
@@ -18393,7 +18792,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;
@@ -18407,7 +18809,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`;
@@ -18497,7 +18900,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
                 })
               );
             }
@@ -18515,11 +18919,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);
@@ -18746,7 +19159,7 @@ function createGrokAcpDriver(imageFiles) {
     }
     newSession(context);
   }
-  function sendPrompt(context, state) {
+  function sendPrompt2(context, state) {
     const text = buildPromptWithImagePathReferences(context, imageFiles);
     isPromptActive = true;
     promptId = request("session/prompt", {
@@ -18789,7 +19202,7 @@ function createGrokAcpDriver(imageFiles) {
       const sessionId = asString(result?.sessionId);
       if (sessionId) state.runtimeSessionId = sessionId;
       state.iterations = Math.max(state.iterations, 1);
-      sendPrompt(context, state);
+      sendPrompt2(context, state);
       return;
     }
     if (message.id === promptId) {
@@ -19135,23 +19548,59 @@ function createKimiCliBackend(command = "kimi-cli", defaultArgs = []) {
     }
   };
 }
+var AUTONOMOUS_OPENCODE_CONFIG_CONTENT = JSON.stringify({
+  $schema: "https://opencode.ai/config.json",
+  permission: "allow"
+});
+function buildAutonomousOpenCodeConfigContent(existing) {
+  if (!existing?.trim()) return AUTONOMOUS_OPENCODE_CONFIG_CONTENT;
+  try {
+    const parsed = JSON.parse(existing);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return JSON.stringify({
+        ...parsed,
+        permission: "allow"
+      });
+    }
+  } catch {
+  }
+  return AUTONOMOUS_OPENCODE_CONFIG_CONTENT;
+}
+function withAutonomousOpenCodePermissions(context) {
+  if (shouldUseReadOnlyRuntimePermissions(context.config)) return context;
+  return {
+    ...context,
+    env: {
+      ...context.env,
+      OPENCODE_CONFIG_CONTENT: buildAutonomousOpenCodeConfigContent(
+        context.env.OPENCODE_CONFIG_CONTENT
+      )
+    }
+  };
+}
 function getRecord(value2) {
   return typeof value2 === "object" && value2 !== null ? value2 : null;
 }
 function getString(value2) {
   return typeof value2 === "string" ? value2.trim() : "";
 }
-function getOpenCodeToolError(parsed, part) {
-  const state = getRecord(part?.state) ?? getRecord(parsed.state);
-  const error = getRecord(part?.error) ?? getRecord(parsed.error) ?? getRecord(state?.error);
-  return getString(part?.error) || getString(state?.error) || getString(error?.message) || getString(parsed.error);
+function getOpenCodeToolError(part) {
+  const state = getRecord(part.state);
+  const error = getRecord(part.error) ?? getRecord(state?.error);
+  return getString(part.error) || getString(state?.error) || getString(error?.message);
+}
+function isOpenCodeToolError(part) {
+  const state = getRecord(part.state);
+  return part.is_error === true || part.isError === true || state?.status === "error" || Boolean(getOpenCodeToolError(part));
+}
+function getOpenCodePartId(part) {
+  return getString(part.id) || getString(part.partID);
 }
-function isOpenCodeToolError(parsed, part) {
-  const state = getRecord(part?.state) ?? getRecord(parsed.state);
-  return part?.is_error === true || part?.isError === true || state?.status === "error" || Boolean(getOpenCodeToolError(parsed, part));
+function getOpenCodeToolId(part) {
+  return getString(part.callID) || getString(part.id) || `opencode-tool-${Date.now()}`;
 }
-function getOpenCodePartId(parsed, part) {
-  return getString(part?.id) || getString(parsed.id) || getString(parsed.partID);
+function getOpenCodeToolName(part) {
+  return getString(part.tool) || (typeof part.name === "string" ? part.name.trim() : "") || "Tool";
 }
 function resolveOpenCodePartSnapshotDelta(text, partId, snapshots) {
   if (!partId) return text;
@@ -19168,93 +19617,92 @@ function resolveOpenCodeReasoningDelta(text, partId, state) {
   state.opencodeReasoningByPartId ??= /* @__PURE__ */ new Map();
   return resolveOpenCodePartSnapshotDelta(text, partId, state.opencodeReasoningByPartId);
 }
-function handleOpencodeStructuredEvent(parsed, context, state) {
+var TASK_TOOL_NAME = "task";
+var TASK_RESULT_TAG_PATTERN = /<task_result>\n?([\s\S]*?)\n?<\/task_result>/;
+var TASK_ERROR_TAG_PATTERN = /<task_error>\n?([\s\S]*?)\n?<\/task_error>/;
+function unwrapOpenCodeTaskOutput(output) {
+  const result = output.match(TASK_RESULT_TAG_PATTERN);
+  if (result?.[1] !== void 0) return result[1].trim();
+  const error = output.match(TASK_ERROR_TAG_PATTERN);
+  if (error?.[1] !== void 0) return error[1].trim();
+  return output;
+}
+function emitOpenCodeToolPart(presenter, state, part, opts) {
+  const stateRecord = getRecord(part.state);
+  const status = getString(stateRecord?.status);
+  if (status === "pending") return;
+  const toolName = getOpenCodeToolName(part);
+  const toolId = getOpenCodeToolId(part);
+  const isTask = toolName.toLowerCase() === TASK_TOOL_NAME;
+  const parentToolUseId = opts.parentToolUseId ?? void 0;
+  state.opencodeToolUseIds ??= /* @__PURE__ */ new Set();
+  if (!state.opencodeToolUseIds.has(toolId)) {
+    state.opencodeToolUseIds.add(toolId);
+    void presenter.onToolUse(toolName, stateRecord?.input ?? part, toolId, parentToolUseId);
+    if (isTask) registerBackgroundLauncher(state, toolId);
+  }
+  if (status !== "completed" && status !== "error") return;
+  const toolError = isOpenCodeToolError(part);
+  const rawOutput = getString(stateRecord?.output) || getString(stateRecord?.error) || JSON.stringify(stateRecord ?? part);
+  const output = isTask ? unwrapOpenCodeTaskOutput(rawOutput) : rawOutput;
+  void presenter.onToolResult?.(toolId, output, toolError, parentToolUseId);
+  if (isTask) clearBackgroundTaskIds(state, [toolId]);
+  if (toolError && !state.error) {
+    const message = getOpenCodeToolError(part) || "OpenCode tool call failed.";
+    state.error = message;
+    void presenter.onError(message);
+  }
+}
+function mapOpencodePart(part, context, state, opts = {}) {
   const presenter = context.presenter;
-  const type = typeof parsed.type === "string" ? parsed.type : "";
-  if (!type) return false;
-  const sessionID = typeof parsed.sessionID === "string" ? parsed.sessionID : void 0;
-  if (sessionID) state.runtimeSessionId = sessionID;
-  const part = typeof parsed.part === "object" && parsed.part !== null ? parsed.part : null;
+  const type = getString(part.type);
   switch (type) {
-    case "step_start": {
+    case "step-start": {
       state.iterations += 1;
       void presenter.onLog(`[opencode] Step ${state.iterations} started`);
       return true;
     }
     case "text": {
-      const text = part && typeof part.text === "string" ? part.text : "";
+      const text = typeof part.text === "string" ? part.text : "";
       if (text) {
-        const delta = resolveOpenCodeTextDelta(text, getOpenCodePartId(parsed, part), state);
-        if (!delta) return true;
-        state.summary += delta;
-        void presenter.onAssistantText(delta);
+        const delta = resolveOpenCodeTextDelta(text, getOpenCodePartId(part), state);
+        if (delta) {
+          state.summary += delta;
+          void presenter.onAssistantText(delta);
+        }
       }
       return true;
     }
+    // Real Part schema only ever uses "reasoning"; "thinking" is a defensive alias in
+    // case a CLI dialect ever names the part itself that way.
     case "reasoning":
     case "thinking": {
-      const text = part && typeof part.text === "string" ? part.text : "";
+      const text = typeof part.text === "string" ? part.text : "";
       if (!text) return true;
-      const delta = resolveOpenCodeReasoningDelta(text, getOpenCodePartId(parsed, part), state);
+      const delta = resolveOpenCodeReasoningDelta(text, getOpenCodePartId(part), state);
       if (!delta) return true;
       state.iterations = Math.max(state.iterations, 1);
       void presenter.onThinking(delta);
       return true;
     }
-    case "tool_use":
-    case "tool.execute": {
-      const toolName = getString(parsed.tool) || (part && typeof part.name === "string" ? part.name : "") || getString(parsed.name) || (part && typeof part.tool === "string" ? part.tool : "") || "Tool";
-      const toolId = part && typeof part.id === "string" ? part.id : `opencode-tool-${Date.now()}`;
-      void presenter.onToolUse(toolName, part ?? {}, toolId);
-      return true;
-    }
     case "tool": {
-      const stateRecord = getRecord(parsed.state);
-      const toolName = getString(parsed.tool) || (part && typeof part.name === "string" ? part.name : "") || getString(parsed.name) || (part && typeof part.tool === "string" ? part.tool : "") || "Tool";
-      const toolId = getString(parsed.id) || getString(parsed.callID) || `opencode-tool-${Date.now()}`;
-      state.opencodeToolUseIds ??= /* @__PURE__ */ new Set();
-      if (!state.opencodeToolUseIds.has(toolId)) {
-        state.opencodeToolUseIds.add(toolId);
-        void presenter.onToolUse(toolName, stateRecord?.input ?? part ?? parsed, toolId);
-      }
-      const status = getString(stateRecord?.status);
-      if (status === "completed" || status === "error") {
-        const toolError = isOpenCodeToolError(parsed, part);
-        const output = getString(stateRecord?.output) || getString(stateRecord?.error) || JSON.stringify(stateRecord ?? part ?? parsed);
-        void presenter.onToolResult?.(toolId, output, toolError);
-        if (toolError && !state.error) {
-          const message = getOpenCodeToolError(parsed, part) || "OpenCode tool call failed.";
-          state.error = message;
-          void presenter.onError(message);
-        }
-      }
+      emitOpenCodeToolPart(presenter, state, part, opts);
       return true;
     }
-    case "tool_result":
-    case "tool.result": {
-      const toolId = part && typeof part.id === "string" ? part.id : `opencode-tool-${Date.now()}`;
-      const output = part && typeof part.output === "string" ? part.output : JSON.stringify(part);
-      const toolError = isOpenCodeToolError(parsed, part);
-      void presenter.onToolResult?.(toolId, output, toolError);
-      if (toolError && !state.error) {
-        const message = getOpenCodeToolError(parsed, part) || "OpenCode tool call failed.";
-        state.error = message;
-        void presenter.onError(message);
-      }
-      return true;
-    }
-    case "step_finish": {
-      if (part && typeof part.tokens === "object" && part.tokens !== null) {
-        const tokens = part.tokens;
+    case "step-finish": {
+      const tokens = getRecord(part.tokens);
+      if (tokens) {
+        const cache2 = getRecord(tokens.cache);
+        const cost = typeof part.cost === "number" ? part.cost : 0;
         state.usage = {
           model: typeof context.config.selectedModel === "string" && context.config.selectedModel.trim() || "opencode",
           numTurns: Math.max(state.iterations, 1),
           durationMs: 0,
-          inputTokens: tokens.input ?? 0,
-          outputTokens: tokens.output ?? 0,
-          cacheReadTokens: tokens.cache_read ?? 0,
-          cacheCreationTokens: tokens.cache_creation ?? 0,
-          costUsd: 0
+          inputTokens: Number(tokens.input) || 0,
+          outputTokens: Number(tokens.output) || 0,
+          cacheReadTokens: Number(cache2?.read) || 0,
+          cacheCreationTokens: Number(cache2?.write) || 0,
+          costUsd: cost
         };
         void presenter.onUsageUpdate?.({
           model: state.usage.model,
@@ -19266,6 +19714,57 @@ function handleOpencodeStructuredEvent(parsed, context, state) {
       }
       return true;
     }
+    default:
+      return false;
+  }
+}
+function normalizeOpenCodePart(parsed, part, partType) {
+  return { ...parsed, ...part ?? {}, type: partType };
+}
+function handleOpencodeStructuredEvent(parsed, context, state) {
+  const presenter = context.presenter;
+  const type = typeof parsed.type === "string" ? parsed.type : "";
+  if (!type) return false;
+  const sessionID = typeof parsed.sessionID === "string" ? parsed.sessionID : void 0;
+  if (sessionID) state.runtimeSessionId = sessionID;
+  const part = typeof parsed.part === "object" && parsed.part !== null ? parsed.part : null;
+  switch (type) {
+    case "step_start":
+      return mapOpencodePart(normalizeOpenCodePart(parsed, part, "step-start"), context, state);
+    case "text":
+      return mapOpencodePart(normalizeOpenCodePart(parsed, part, "text"), context, state);
+    case "reasoning":
+    case "thinking":
+      return mapOpencodePart(normalizeOpenCodePart(parsed, part, "reasoning"), context, state);
+    // Real event: `opencode run --format json` emits exactly this shape — a single
+    // terminal event per tool call, carrying part.state.{input,output|error}. See
+    // notes/opencode-cli-reverse-engineering.md for the live-captured schema.
+    case "tool_use":
+    case "tool.execute":
+    case "tool":
+      return mapOpencodePart(normalizeOpenCodePart(parsed, part, "tool"), context, state);
+    case "step_finish":
+      return mapOpencodePart(normalizeOpenCodePart(parsed, part, "step-finish"), context, state);
+    // Defensive fallback only: no observed OpenCode version emits a separate
+    // tool_result/tool.result event in `--format json` mode (tool state always
+    // arrives via `tool_use` above). Kept in case a future/older CLI build splits
+    // the terminal tool event into a distinct result message. Deliberately NOT routed
+    // through mapOpencodePart — this shape has no part.state wrapper at all (output
+    // sits directly on the part), so it isn't a real Part-schema shape.
+    case "tool_result":
+    case "tool.result": {
+      const toolId = getString(part?.callID) || getString(parsed.callID) || getString(part?.id) || getString(parsed.id) || `opencode-tool-${Date.now()}`;
+      const output = part && typeof part.output === "string" ? part.output : JSON.stringify(part);
+      const stateRecord = getRecord(part?.state) ?? getRecord(parsed.state);
+      const toolError = part?.is_error === true || part?.isError === true || stateRecord?.status === "error" || Boolean(getString(part?.error) || getString(stateRecord?.error));
+      void presenter.onToolResult?.(toolId, output, toolError);
+      if (toolError && !state.error) {
+        const message = getString(part?.error) || getString(stateRecord?.error) || "OpenCode tool call failed.";
+        state.error = message;
+        void presenter.onError(message);
+      }
+      return true;
+    }
     case "session.error":
     case "error": {
       const errObj = typeof parsed.error === "object" && parsed.error !== null ? parsed.error : null;
@@ -19290,85 +19789,450 @@ var parseOpencodeStructuredLine = createStructuredLineParser(
   "opencode_cli",
   handleOpencodeStructuredEvent
 );
-var AUTONOMOUS_OPENCODE_CONFIG_CONTENT = JSON.stringify({
-  $schema: "https://opencode.ai/config.json",
-  permission: "allow"
-});
-function buildAutonomousOpenCodeConfigContent(existing) {
-  if (!existing?.trim()) return AUTONOMOUS_OPENCODE_CONFIG_CONTENT;
+function buildOpencodeEffortArgs(selectedEffortLevel) {
+  const trimmed = selectedEffortLevel?.trim().toLowerCase();
+  if (!trimmed || !isEffortLevel(trimmed)) return [];
+  return ["--variant", trimmed];
+}
+function createOpencodeCliBackend(command = "opencode", defaultArgs = []) {
+  return {
+    kind: "opencode_cli",
+    supportTier: "structured",
+    async run(context) {
+      const { paths: imagePaths, cleanup } = writeImagesToTempFiles(
+        context.config.images,
+        context.cwd
+      );
+      const { paths: filePaths, cleanup: cleanupFiles } = writeFilesToTempFiles(
+        context.config.files,
+        context.cwd
+      );
+      try {
+        const runContext = withAutonomousOpenCodePermissions(context);
+        return await createGenericCliBackend({
+          kind: "opencode_cli",
+          supportTier: "structured",
+          command,
+          args: [],
+          buildArgs: (ctx, prompt) => {
+            const args = ["run", "--format", "json", "--thinking"];
+            if (!shouldUseReadOnlyRuntimePermissions(ctx.config)) {
+              args.push("--dangerously-skip-permissions");
+            }
+            const resumeId = ctx.config.runtimeSessionId?.trim() || ctx.config.providerSessionId?.trim();
+            if (resumeId) args.push("--session", resumeId);
+            const model = ctx.config.selectedModel?.trim();
+            if (model?.includes("/")) args.push("--model", model);
+            args.push(...buildOpencodeEffortArgs(ctx.config.selectedEffortLevel));
+            const attachmentPaths = [...imagePaths, ...filePaths];
+            const fileArgs = attachmentPaths.flatMap((p) => ["--file", p]);
+            if (fileArgs.length > 0) {
+              return [...args, ...fileArgs, ...defaultArgs, "--", prompt];
+            }
+            return [...args, ...defaultArgs, prompt];
+          },
+          augmentPrompt: (ctx) => {
+            const base = buildPromptWithSystem(ctx.config, ctx.promptText);
+            return ctx.config.mode === "plan" ? buildPlanModePrefix(base) : base;
+          },
+          parseStructuredLine: parseOpencodeStructuredLine
+        }).run(runContext);
+      } finally {
+        cleanup();
+        cleanupFiles();
+      }
+    }
+  };
+}
+function parseSseEventBlock(block) {
+  const dataLines = block.split("\n").map((line) => line.endsWith("\r") ? line.slice(0, -1) : line).filter((line) => line.startsWith("data:")).map((line) => line.slice("data:".length).replace(/^ /, ""));
+  if (dataLines.length === 0) return null;
   try {
-    const parsed = JSON.parse(existing);
-    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-      return JSON.stringify({
-        ...parsed,
-        permission: "allow"
-      });
+    const parsed = JSON.parse(dataLines.join("\n"));
+    if (parsed && typeof parsed === "object" && typeof parsed.type === "string") {
+      const record = parsed;
+      return {
+        id: typeof record.id === "string" ? record.id : void 0,
+        type: record.type,
+        properties: typeof record.properties === "object" && record.properties !== null ? record.properties : {}
+      };
     }
   } catch {
   }
-  return AUTONOMOUS_OPENCODE_CONFIG_CONTENT;
+  return null;
+}
+async function connectOpenCodeSse(url2, signal) {
+  const response = await fetch(url2, {
+    signal,
+    headers: { Accept: "text/event-stream" }
+  });
+  if (!response.ok || !response.body) {
+    throw new Error(`OpenCode SSE connection failed: HTTP ${response.status}`);
+  }
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let closed = false;
+  async function* generate() {
+    let buffer = "";
+    try {
+      while (!closed) {
+        const { value: value2, done } = await reader.read();
+        if (done) return;
+        buffer += decoder.decode(value2, { stream: true });
+        let separatorIndex = buffer.indexOf("\n\n");
+        while (separatorIndex !== -1) {
+          const block = buffer.slice(0, separatorIndex);
+          buffer = buffer.slice(separatorIndex + 2);
+          const event = parseSseEventBlock(block);
+          if (event) yield event;
+          separatorIndex = buffer.indexOf("\n\n");
+        }
+      }
+    } finally {
+      try {
+        reader.releaseLock();
+      } catch {
+      }
+    }
+  }
+  return {
+    events: generate(),
+    close: () => {
+      if (closed) return;
+      closed = true;
+      reader.cancel().catch(() => {
+      });
+    }
+  };
+}
+var SERVER_LISTENING_PATTERN = /listening on (https?:\/\/\S+)/i;
+var STARTUP_TIMEOUT_MS = 2e4;
+var HEALTH_POLL_INTERVAL_MS = 200;
+var HEALTH_POLL_MAX_ATTEMPTS = 50;
+function startOpenCodeServer(command, context) {
+  const child = spawnCli(command, ["serve", "--port", "0", "--hostname", "127.0.0.1"], context);
+  const ready = new Promise((resolve22, reject) => {
+    let settled = false;
+    const timeout = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      reject(
+        new Error(`opencode serve did not report a listening URL within ${STARTUP_TIMEOUT_MS}ms`)
+      );
+    }, STARTUP_TIMEOUT_MS);
+    const stdoutRl = (0, import_readline2.createInterface)({ input: child.stdout });
+    const stderrRl = (0, import_readline2.createInterface)({ input: child.stderr });
+    const stderrLines = [];
+    const checkLine = (line) => {
+      if (settled) return;
+      const match = line.match(SERVER_LISTENING_PATTERN);
+      if (!match) return;
+      settled = true;
+      clearTimeout(timeout);
+      resolve22({ baseUrl: match[1].replace(/\/$/, "") });
+    };
+    stdoutRl.on("line", checkLine);
+    stderrRl.on("line", (line) => {
+      stderrLines.push(line);
+      checkLine(line);
+    });
+    child.once("error", (error) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+      reject(error);
+    });
+    child.once("exit", (code) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+      reject(
+        new Error(
+          `opencode serve exited (code ${code}) before reporting a listening URL. stderr: ${stderrLines.slice(-5).join("\n")}`
+        )
+      );
+    });
+  });
+  return { child, ready };
+}
+async function waitForHealthy(baseUrl, signal) {
+  for (let attempt = 0; attempt < HEALTH_POLL_MAX_ATTEMPTS; attempt++) {
+    if (signal.aborted)
+      throw new Error("Aborted while waiting for opencode server to become healthy");
+    try {
+      const response = await fetch(`${baseUrl}/global/health`, { signal });
+      if (response.ok) {
+        const body = await response.json().catch(() => null);
+        if (body?.healthy) return;
+      }
+    } catch {
+    }
+    await new Promise((resolve22) => setTimeout(resolve22, HEALTH_POLL_INTERVAL_MS));
+  }
+  throw new Error(`opencode server at ${baseUrl} did not become healthy in time`);
+}
+var NON_INTERACTIVE_DENY_RULES = [
+  { permission: "question", pattern: "*", action: "deny" },
+  { permission: "plan_enter", pattern: "*", action: "deny" },
+  { permission: "plan_exit", pattern: "*", action: "deny" }
+];
+async function resolveSession(baseUrl, context, signal) {
+  const resumeId = context.config.runtimeSessionId?.trim() || context.config.providerSessionId?.trim();
+  if (resumeId) {
+    const existing = await fetch(`${baseUrl}/session/${encodeURIComponent(resumeId)}`, {
+      signal
+    }).catch(() => null);
+    if (existing?.ok) return { id: resumeId };
+  }
+  const title = context.promptText.slice(0, 50) + (context.promptText.length > 50 ? "..." : "");
+  const response = await fetch(`${baseUrl}/session`, {
+    method: "POST",
+    signal,
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ title, permission: NON_INTERACTIVE_DENY_RULES })
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to create OpenCode session: HTTP ${response.status}`);
+  }
+  const info = await response.json();
+  if (!info.id) throw new Error("OpenCode session create response had no id");
+  return { id: info.id };
+}
+function buildPromptParts(promptText, imageFiles, attachmentFiles) {
+  const attachments = [...imageFiles, ...attachmentFiles].map(
+    (file) => ({
+      type: "file",
+      mime: file.mimeType,
+      filename: file.filename,
+      url: (0, import_url2.pathToFileURL)(file.path).href
+    })
+  );
+  return [...attachments, { type: "text", text: promptText }];
+}
+async function sendPrompt(baseUrl, sessionId, context, parts2, signal) {
+  const model = context.config.selectedModel?.trim();
+  const modelBody = model && model.includes("/") ? (() => {
+    const slashIndex = model.indexOf("/");
+    return { providerID: model.slice(0, slashIndex), modelID: model.slice(slashIndex + 1) };
+  })() : void 0;
+  const variant = context.config.selectedEffortLevel?.trim().toLowerCase();
+  const response = await fetch(`${baseUrl}/session/${encodeURIComponent(sessionId)}/message`, {
+    method: "POST",
+    signal,
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      parts: parts2,
+      ...modelBody ? { model: modelBody } : {},
+      ...variant && isEffortLevel(variant) ? { variant } : {}
+    })
+  });
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`OpenCode prompt request failed: HTTP ${response.status} ${text}`.trim());
+  }
 }
-function withAutonomousOpenCodePermissions(context) {
-  if (shouldUseReadOnlyRuntimePermissions(context.config)) return context;
+async function replyToPermission(baseUrl, requestId, reply, signal) {
+  await fetch(`${baseUrl}/permission/${encodeURIComponent(requestId)}/reply`, {
+    method: "POST",
+    signal,
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ reply })
+  }).catch((error) => {
+    console.warn("[opencode_serve] Failed to reply to permission request", requestId, error);
+  });
+}
+function buildAgentResult(state, sessionId, aborted2) {
+  if (aborted2) {
+    return {
+      success: false,
+      summary: "Interrupted by user",
+      filesModified: [],
+      planFilesCreated: [],
+      iterations: Math.max(state.iterations, 1),
+      error: "Interrupted by user",
+      providerSessionId: sessionId,
+      runtimeSessionId: sessionId,
+      backendKind: "opencode_serve",
+      supportTier: "structured",
+      usage: state.usage
+    };
+  }
+  const failed = Boolean(state.error?.trim());
+  const summary = state.summary.trim() || state.error?.trim() || (failed ? "Task failed" : "Task completed");
   return {
-    ...context,
-    env: {
-      ...context.env,
-      OPENCODE_CONFIG_CONTENT: buildAutonomousOpenCodeConfigContent(
-        context.env.OPENCODE_CONFIG_CONTENT
-      )
-    }
+    success: !failed,
+    summary,
+    filesModified: [],
+    planFilesCreated: [],
+    iterations: Math.max(state.iterations, 1),
+    ...state.error?.trim() ? { error: state.error.trim() } : {},
+    providerSessionId: sessionId,
+    runtimeSessionId: sessionId,
+    backendKind: "opencode_serve",
+    supportTier: "structured",
+    usage: state.usage
   };
 }
-function createOpencodeCliBackend(command = "opencode", defaultArgs = []) {
+function createOpencodeServeBackend(command = "opencode") {
   return {
-    kind: "opencode_cli",
+    kind: "opencode_serve",
     supportTier: "structured",
     async run(context) {
-      const { paths: imagePaths, cleanup } = writeImagesToTempFiles(
+      const { files: imageFiles, cleanup: cleanupImages } = writeImagesToTempFiles(
         context.config.images,
         context.cwd
       );
-      const { paths: filePaths, cleanup: cleanupFiles } = writeFilesToTempFiles(
+      const { files: attachmentFiles, cleanup: cleanupFiles } = writeFilesToTempFiles(
         context.config.files,
         context.cwd
       );
+      const runContext = withAutonomousOpenCodePermissions(context);
+      const readOnly = shouldUseReadOnlyRuntimePermissions(context.config);
+      const { child, ready } = startOpenCodeServer(command, runContext);
+      const state = { process: child, iterations: 0, summary: "" };
+      context.onProcessSpawned?.(child);
+      context.registerLivenessProbe?.(() => ({
+        providerAlive: child.exitCode === null,
+        lastRawOutputAgoMs: typeof state.lastRawOutputAtMs === "number" ? Date.now() - state.lastRawOutputAtMs : null
+      }));
+      let sseClose = null;
+      let sessionId = "";
+      let aborted2 = false;
+      const onAbort = () => {
+        aborted2 = true;
+        sseClose?.();
+        killProcessTree(child.pid, { signal: "SIGTERM", child });
+      };
+      context.abortController.signal.addEventListener("abort", onAbort, { once: true });
       try {
-        const runContext = withAutonomousOpenCodePermissions(context);
-        return await createGenericCliBackend({
-          kind: "opencode_cli",
-          supportTier: "structured",
-          command,
-          args: [],
-          buildArgs: (ctx, prompt) => {
-            const args = ["run", "--format", "json"];
-            if (!shouldUseReadOnlyRuntimePermissions(ctx.config)) {
-              args.push("--dangerously-skip-permissions");
-            }
-            const resumeId = ctx.config.runtimeSessionId?.trim() || ctx.config.providerSessionId?.trim();
-            if (resumeId) args.push("--session", resumeId);
-            const model = ctx.config.selectedModel?.trim();
-            if (model?.includes("/")) args.push("--model", model);
-            const attachmentPaths = [...imagePaths, ...filePaths];
-            const fileArgs = attachmentPaths.flatMap((p) => ["--file", p]);
-            if (fileArgs.length > 0) {
-              return [...args, ...fileArgs, ...defaultArgs, "--", prompt];
-            }
-            return [...args, ...defaultArgs, prompt];
-          },
-          augmentPrompt: (ctx) => {
-            const base = buildPromptWithSystem(ctx.config, ctx.promptText);
-            return ctx.config.mode === "plan" ? buildPlanModePrefix(base) : base;
-          },
-          parseStructuredLine: parseOpencodeStructuredLine
-        }).run(runContext);
+        const server = await ready;
+        state.lastRawOutputAtMs = Date.now();
+        await waitForHealthy(server.baseUrl, context.abortController.signal);
+        const session = await resolveSession(
+          server.baseUrl,
+          runContext,
+          context.abortController.signal
+        );
+        sessionId = session.id;
+        state.runtimeSessionId = sessionId;
+        const prompt = context.config.mode === "plan" ? buildPlanModePrefix(buildPromptWithSystem(context.config, context.promptText)) : buildPromptWithSystem(context.config, context.promptText);
+        const parts2 = buildPromptParts(prompt, imageFiles, attachmentFiles);
+        const connection = await connectOpenCodeSse(
+          `${server.baseUrl}/event`,
+          context.abortController.signal
+        );
+        sseClose = connection.close;
+        const promptError = await sendPrompt(
+          server.baseUrl,
+          sessionId,
+          runContext,
+          parts2,
+          context.abortController.signal
+        ).then(() => null).catch((error) => ({
+          message: error instanceof Error ? error.message : String(error)
+        }));
+        if (context.abortController.signal.aborted) {
+        } else if (promptError) {
+          state.error = promptError.message;
+          void context.presenter.onError(promptError.message);
+        } else {
+          for await (const event of connection.events) {
+            if (aborted2) break;
+            const done = handleOpenCodeServeEvent(
+              event,
+              sessionId,
+              runContext,
+              state,
+              readOnly,
+              server.baseUrl
+            );
+            if (done) break;
+          }
+        }
+        return buildAgentResult(state, sessionId, aborted2);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (!aborted2 && !context.abortController.signal.aborted) {
+          console.error("[opencode_serve] Run failed:", message);
+          state.error = message;
+          void context.presenter.onError(message);
+        }
+        return buildAgentResult(
+          state,
+          sessionId,
+          aborted2 || context.abortController.signal.aborted
+        );
       } finally {
-        cleanup();
+        context.abortController.signal.removeEventListener("abort", onAbort);
+        sseClose?.();
+        killProcessTree(child.pid, { signal: "SIGTERM", child });
+        cleanupImages();
         cleanupFiles();
       }
     }
   };
 }
+function handleOpenCodeServeEvent(event, sessionId, context, state, readOnly, baseUrl) {
+  const properties = event.properties;
+  const eventSessionId = getString(properties.sessionID);
+  if (eventSessionId && eventSessionId !== sessionId) return false;
+  switch (event.type) {
+    // Live-verified: the SSE bus emits a message.updated (and matching
+    // message.part.updated) for the USER's own message too, not just the
+    // assistant's — track user message ids so their echoed text is never
+    // mistaken for assistant output below.
+    case "message.updated": {
+      const info = getRecord(properties.info);
+      if (getString(info?.role) === "user") {
+        const messageId = getString(info?.id);
+        if (messageId) {
+          state.opencodeUserMessageIds ??= /* @__PURE__ */ new Set();
+          state.opencodeUserMessageIds.add(messageId);
+        }
+      }
+      return false;
+    }
+    case "message.part.updated": {
+      const part = getRecord(properties.part);
+      if (!part) return false;
+      const messageId = getString(part.messageID);
+      if (messageId && state.opencodeUserMessageIds?.has(messageId)) return false;
+      mapOpencodePart(part, context, state);
+      return false;
+    }
+    // Live token-by-token streaming is explicitly out of scope — only the
+    // start/complete snapshots from message.part.updated are consumed.
+    case "message.part.delta":
+      return false;
+    case "permission.asked": {
+      const requestId = getString(properties.id);
+      if (requestId) {
+        void replyToPermission(
+          baseUrl,
+          requestId,
+          readOnly ? "reject" : "once",
+          context.abortController.signal
+        );
+      }
+      return false;
+    }
+    case "session.error": {
+      const errorRecord = getRecord(properties.error);
+      const message = getString(errorRecord?.message) || getString(properties.error) || "OpenCode session error.";
+      if (!state.error) {
+        state.error = message;
+        void context.presenter.onError(message);
+      }
+      return false;
+    }
+    case "session.status": {
+      const status = getRecord(properties.status);
+      return getString(status?.type) === "idle";
+    }
+    default:
+      return false;
+  }
+}
 function createGenericCliPassthroughBackend(command, defaultArgs = []) {
   return {
     kind: "generic_cli",
@@ -19473,7 +20337,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 });
           }
@@ -19597,6 +20461,7 @@ function defaultSelectedModelForBackend(backendKind) {
     case "grok_cli":
       return firstCatalogModelId(backendKind) ?? "grok-4.5";
     case "opencode_cli":
+    case "opencode_serve":
       return void 0;
     case "antigravity_cli":
       return void 0;
@@ -19658,6 +20523,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;
@@ -19714,7 +20581,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;
@@ -19733,9 +20645,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);
     }
   }
@@ -19758,6 +20678,7 @@ var BaseMachineAgent = class _BaseMachineAgent {
       case "cursor_agent_cli":
       case "droid_cli":
       case "opencode_cli":
+      case "opencode_serve":
       case "copilot_cli":
       case "supatest_cli":
       case "kimi_cli":
@@ -19825,7 +20746,7 @@ Prefer relative paths and keep your work scoped to this project.`
     const promptText = this.buildPromptText(runtimeConfig);
     const runtimeCommand = runtimeConfig.runtimeCommand || this.runtime.runtimeCommand;
     const runtimeArgs = runtimeConfig.runtimeArgs || this.runtime.runtimeArgs || [];
-    const backend = backendKind === "claude_cli" ? createClaudeCliBackend(runtimeCommand || "claude", runtimeArgs) : backendKind === "codex_app_server" ? createCodexRuntimeBackend(runtimeCommand || "codex", runtimeArgs) : backendKind === "copilot_cli" ? createCopilotCliBackend(runtimeCommand || "copilot", runtimeArgs) : backendKind === "cursor_agent_cli" ? createCursorAgentCliBackend(runtimeCommand || "cursor-agent", runtimeArgs) : backendKind === "antigravity_cli" ? createAntigravityCliBackend(runtimeCommand || "agy", runtimeArgs) : backendKind === "droid_cli" ? createDroidCliBackend(runtimeCommand || "droid", runtimeArgs) : backendKind === "opencode_cli" ? createOpencodeCliBackend(runtimeCommand || "opencode", runtimeArgs) : backendKind === "kimi_cli" ? createKimiCliBackend(runtimeCommand || "kimi-cli", runtimeArgs) : backendKind === "grok_cli" ? createGrokCliBackend(runtimeCommand || "grok", runtimeArgs) : backendKind === "supatest_cli" ? createSupatestCliBackend(runtimeCommand || "supatest", runtimeArgs) : createGenericCliPassthroughBackend(
+    const backend = backendKind === "claude_cli" ? createClaudeCliBackend(runtimeCommand || "claude", runtimeArgs) : backendKind === "codex_app_server" ? createCodexRuntimeBackend(runtimeCommand || "codex", runtimeArgs) : backendKind === "copilot_cli" ? createCopilotCliBackend(runtimeCommand || "copilot", runtimeArgs) : backendKind === "cursor_agent_cli" ? createCursorAgentCliBackend(runtimeCommand || "cursor-agent", runtimeArgs) : backendKind === "antigravity_cli" ? createAntigravityCliBackend(runtimeCommand || "agy", runtimeArgs) : backendKind === "droid_cli" ? createDroidCliBackend(runtimeCommand || "droid", runtimeArgs) : backendKind === "opencode_cli" ? createOpencodeCliBackend(runtimeCommand || "opencode", runtimeArgs) : backendKind === "opencode_serve" ? createOpencodeServeBackend(runtimeCommand || "opencode") : backendKind === "kimi_cli" ? createKimiCliBackend(runtimeCommand || "kimi-cli", runtimeArgs) : backendKind === "grok_cli" ? createGrokCliBackend(runtimeCommand || "grok", runtimeArgs) : backendKind === "supatest_cli" ? createSupatestCliBackend(runtimeCommand || "supatest", runtimeArgs) : createGenericCliPassthroughBackend(
       runtimeCommand || "generic-cli",
       runtimeArgs
     );
@@ -19969,19 +20890,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) {
@@ -20550,13 +21459,20 @@ ${meta.description}`);
     }
     if (conversationId) artifactIds.push(`- conversationId: "${conversationId}"`);
     if (artifactIds.length > 0) {
+      const artifactTools = ["create_plan", "create_document_artifact", "create_test_report"];
+      if (taskId || isWorkflowSession) artifactTools.push("upsert_prototype_version");
       parts2.push(
         [
-          "When creating artifacts using MCP tools (create_plan, create_document_artifact, create_test_report, upsert_prototype_version), always pass these IDs:",
+          `When creating artifacts using MCP tools (${artifactTools.join(", ")}), always pass these IDs:`,
           ...artifactIds
         ].join("\n")
       );
     }
+    if (teamId && conversationId && !taskId && !isWorkflowSession) {
+      parts2.push(
+        "This is a standalone chat. For create_plan, create_document_artifact, and create_test_report, omit taskId and workflowId; conversationId is the artifact owner. Do not use create_document unless the user explicitly asks for a standalone team Document."
+      );
+    }
     if (workflowId && conversationId && teamId) {
       parts2.push(
         [
@@ -20669,7 +21585,7 @@ function encryptedFileSize(entries) {
   );
   return emptyEnvelopeBytes + base64UrlLength(plaintextBytes);
 }
-var EncryptedEventOutbox = class {
+var EncryptedEventOutbox = class _EncryptedEventOutbox {
   constructor(path, encodedKey, pushLog = () => {
   }, options = {}) {
     this.path = path;
@@ -20684,6 +21600,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();
   }
@@ -20693,6 +21614,17 @@ var EncryptedEventOutbox = class {
   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;
@@ -20895,20 +21827,28 @@ var EncryptedEventOutbox = class {
       throw new Error(`unable to decrypt durable event outbox: ${detail}`);
     }
   }
+  /** Serialize the current entries to their plaintext + content signature (once). */
+  serializeForPersist() {
+    if (this.entries.length === 0) {
+      return { plaintext: "", signature: _EncryptedEventOutbox.EMPTY_SIGNATURE };
+    }
+    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 {
       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(JSON.stringify({ entries: this.entries }), "utf8"),
-        cipher.final()
-      ]);
+      const ciphertext = Buffer.concat([cipher.update(plaintext, "utf8"), cipher.final()]);
       const envelope = {
         version: OUTBOX_VERSION,
         iv: iv.toString("base64url"),
@@ -20923,8 +21863,10 @@ var EncryptedEventOutbox = class {
       } 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);
@@ -21637,8 +22579,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);
@@ -21678,7 +22620,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,
     {
@@ -21771,9 +22736,7 @@ var CODEX_ALAN_TOML_SECTION = "mcp_servers.alan";
 function isCodexAlanTomlSection(section) {
   return section === CODEX_ALAN_TOML_SECTION || section.startsWith(`${CODEX_ALAN_TOML_SECTION}.`);
 }
-function mergeCodexAlanSection(path, existingContent, desiredContent) {
-  if (existingContent === null || existingContent.trim() === "") return desiredContent;
-  assertValidExistingToml(path, existingContent);
+function stripCodexAlanSection(existingContent) {
   const lines = existingContent.split("\n");
   const retained = [];
   let insideAlanSection = false;
@@ -21784,7 +22747,12 @@ function mergeCodexAlanSection(path, existingContent, desiredContent) {
     }
     if (!insideAlanSection) retained.push(line);
   }
-  const prefix = retained.join("\n").trimEnd();
+  return retained.join("\n").trimEnd();
+}
+function mergeCodexAlanSection(path, existingContent, desiredContent) {
+  if (existingContent === null || existingContent.trim() === "") return desiredContent;
+  assertValidExistingToml(path, existingContent);
+  const prefix = stripCodexAlanSection(existingContent);
   const merged = `${prefix}${prefix ? "\n\n" : ""}${desiredContent.trim()}
 `;
   try {
@@ -21870,6 +22838,45 @@ function verifyAlanMcpRegistered(backendKind, home = (0, import_node_os6.homedir
     verification: inspection.verification
   };
 }
+function removeAlanFromJsonConfig(path, existingContent) {
+  const config = parseJsonObject2(path, existingContent);
+  for (const containerKey of ["mcpServers", "mcp"]) {
+    const container = config[containerKey];
+    if (container && typeof container === "object" && !Array.isArray(container)) {
+      delete container.alan;
+    }
+  }
+  return JSON.stringify(config);
+}
+function unregisterAlanMcp(backendKind, home = (0, import_node_os6.homedir)()) {
+  const removedPaths = [];
+  const errors = [];
+  const files = alanMcpConfigFilesForBackend(backendKind, {}, home);
+  for (const file of files) {
+    if (!(0, import_node_fs7.existsSync)(file.path)) continue;
+    const releaseLock = waitForConfigLock(`${file.path}.alan-lock`);
+    try {
+      const current = (0, import_node_fs7.readFileSync)(file.path, "utf8");
+      let next;
+      if (file.path.endsWith(".toml")) {
+        const stripped = stripCodexAlanSection(current);
+        next = stripped ? `${stripped}
+` : "";
+      } else {
+        next = removeAlanFromJsonConfig(file.path, current);
+      }
+      if (next !== current) {
+        atomicWriteManagedConfig(file.path, next);
+        removedPaths.push(file.path);
+      }
+    } catch (err) {
+      errors.push(err instanceof Error ? err.message : String(err));
+    } finally {
+      releaseLock();
+    }
+  }
+  return { removedPaths, errors };
+}
 function isHttpUrl(value2) {
   if (typeof value2 !== "string") return false;
   try {
@@ -22216,6 +23223,88 @@ function extractCodexDiscoveredModelIdsFromDebugJson(value2) {
   }
   return [...new Set(ids)];
 }
+var OPENCODE_MODEL_ID_LINE_PATTERN = /^[a-z0-9][\w.-]*\/[\w.-]+$/i;
+var OPENCODE_KNOWN_VARIANT_KEYS = /* @__PURE__ */ new Set([
+  "minimal",
+  "none",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "extra-high",
+  "max",
+  "ultra"
+]);
+function parseOpenCodeVerboseModelOutput(text) {
+  const entries = [];
+  const lines = text.split(/\r?\n/);
+  let i = 0;
+  while (i < lines.length) {
+    const line = (lines[i] ?? "").trim();
+    i += 1;
+    if (!OPENCODE_MODEL_ID_LINE_PATTERN.test(line)) continue;
+    let jsonStart = i;
+    while (jsonStart < lines.length && (lines[jsonStart] ?? "").trim() === "") jsonStart += 1;
+    if (jsonStart >= lines.length || !(lines[jsonStart] ?? "").trim().startsWith("{")) continue;
+    let depth = 0;
+    let inString = false;
+    let escaped = false;
+    let endLineIdx = -1;
+    let buffer = "";
+    for (let j = jsonStart; j < lines.length; j += 1) {
+      const raw = lines[j] ?? "";
+      buffer += (buffer ? "\n" : "") + raw;
+      for (const ch of raw) {
+        if (escaped) {
+          escaped = false;
+          continue;
+        }
+        if (ch === "\\" && inString) {
+          escaped = true;
+          continue;
+        }
+        if (ch === '"') {
+          inString = !inString;
+          continue;
+        }
+        if (inString) continue;
+        if (ch === "{") depth += 1;
+        else if (ch === "}") depth -= 1;
+      }
+      if (depth === 0) {
+        endLineIdx = j;
+        break;
+      }
+    }
+    if (endLineIdx === -1) break;
+    try {
+      const obj = JSON.parse(buffer);
+      entries.push({
+        id: line,
+        reasoning: obj.capabilities?.reasoning === true,
+        variants: obj.variants ? Object.keys(obj.variants) : []
+      });
+    } catch {
+    }
+    i = endLineIdx + 1;
+  }
+  return entries;
+}
+function extractOpenCodeDiscoveredModelIdsFromVerboseOutput(text) {
+  const entries = parseOpenCodeVerboseModelOutput(text);
+  const ids = [];
+  for (const entry of entries) {
+    const knownVariants = entry.reasoning ? entry.variants.filter((variant) => OPENCODE_KNOWN_VARIANT_KEYS.has(variant)) : [];
+    if (knownVariants.length === 0) {
+      ids.push(entry.id);
+      continue;
+    }
+    for (const variant of knownVariants) {
+      ids.push(`${entry.id}-${variant}`);
+    }
+  }
+  return [...new Set(ids)];
+}
 function extractModelIdsFromText(value2) {
   const ansiPattern = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "g");
   const ignoredLinePattern = /^(available models|models|usage|error|flag provided|try |agy\b|warning:)/i;
@@ -22326,12 +23415,24 @@ async function probeJsonOrTextModels(executable, env, argSets, options) {
   return [];
 }
 async function discoverOpenCodeModels(executable, env) {
-  const probed = await probeJsonOrTextModels(executable, env, [
+  const verbose = await runCliProbeAsync(
+    executable,
+    withModelProbeEnv(env),
+    ["models", "--verbose"],
+    MODEL_DISCOVERY_TIMEOUT_MS
+  );
+  if (verbose && !verbose.error && verbose.status === 0 && verbose.stdout.trim()) {
+    const withEffort = extractOpenCodeDiscoveredModelIdsFromVerboseOutput(verbose.stdout);
+    if (withEffort.length > 0) return withEffort;
+  }
+  const plain = await probeJsonOrTextModels(executable, env, [["models"]]);
+  if (plain.length > 0) return plain;
+  const legacy = await probeJsonOrTextModels(executable, env, [
     ["models", "--json"],
     ["models", "list", "--json"],
     ["model", "list", "--json"]
   ]);
-  return probed.length > 0 ? probed : OPENCODE_ZEN_MODEL_IDS;
+  return legacy.length > 0 ? legacy : OPENCODE_ZEN_MODEL_IDS;
 }
 async function discoverAntigravityModels(executable, env) {
   return probeJsonOrTextModels(executable, env, [["models"]], {
@@ -22577,7 +23678,7 @@ var RunStartGate = class {
 };
 
 // src/version.ts
-var AGENT_VERSION = "0.1.42";
+var AGENT_VERSION = "0.1.44";
 
 // src/workspace-relocation.ts
 var import_node_child_process3 = require("child_process");
@@ -22653,11 +23754,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;
@@ -22693,6 +23802,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) {
@@ -22740,6 +23856,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);
@@ -22769,6 +23936,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";
@@ -24087,9 +25288,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" });
@@ -24618,6 +25822,21 @@ async function startDaemon(args) {
     recentLogs.push(`${(/* @__PURE__ */ new Date()).toISOString()} ${message}`);
     if (recentLogs.length > 200) recentLogs.splice(0, recentLogs.length - 200);
   };
+  const alanMcpRegisteredRuns = /* @__PURE__ */ new Set();
+  const alanMcpRegisteredBackends = /* @__PURE__ */ new Set();
+  const finalizeAlanMcpForRun = (runId) => {
+    if (!alanMcpRegisteredRuns.delete(runId)) return;
+    if (alanMcpRegisteredRuns.size > 0) return;
+    for (const backend of alanMcpRegisteredBackends) {
+      try {
+        const { removedPaths } = unregisterAlanMcp(backend);
+        if (removedPaths.length > 0) pushLog(`mcp-unregistered backend=${backend} run=${runId}`);
+      } catch (err) {
+        pushLog(`mcp-unregister-failed backend=${backend} ${err.message}`);
+      }
+    }
+    alanMcpRegisteredBackends.clear();
+  };
   const workspaceAccessTracker = new WorkspaceAccessTracker();
   const recheckWorkspaceIssue = () => {
     const previousPath = workspaceAccessTracker.recoveryPath();
@@ -24830,6 +26049,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;
@@ -24837,15 +26060,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?.();
@@ -25322,7 +26569,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;
@@ -25372,6 +26619,10 @@ async function startDaemon(args) {
       workspaceLease: workspaceLeaseCapture.lease
     });
     pendingRunStarts.delete(payload.runId);
+    if (payload.alanMcp && backendKind) {
+      alanMcpRegisteredRuns.add(payload.runId);
+      alanMcpRegisteredBackends.add(backendKind);
+    }
     void agent.run({
       task: payload.content,
       maxIterations: payload.maxIterations ?? 50,
@@ -25390,6 +26641,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,
@@ -25416,6 +26668,7 @@ async function startDaemon(args) {
       } catch {
         pushLog(`run-journal-remove-failed run=${payload.runId}`);
       }
+      finalizeAlanMcpForRun(payload.runId);
       releaseActiveRun();
     });
   });
@@ -25441,7 +26694,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) {
@@ -26208,6 +27461,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) {
@@ -26500,6 +27765,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);
   }
@@ -26619,7 +27885,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?.();
   }
@@ -26702,6 +27968,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,
@@ -26893,6 +28160,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;
@@ -26976,10 +28244,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,
@@ -27027,6 +28297,7 @@ async function runSandbox(config) {
         }
       }
       currentAgent = null;
+      resumeFallbackContext = void 0;
       lifecycle.info("sandbox_agent_run_complete", {
         success: result.success,
         iterations: result.iterations,
@@ -27053,6 +28324,7 @@ async function runSandbox(config) {
     currentFiles = nextPayload.files ?? [];
     if (nextPayload.providerSessionId) {
       lastProviderSessionId = nextPayload.providerSessionId;
+      resumeFallbackContext = nextPayload.resumeFallbackContext;
     }
     if (nextPayload.backendKind) {
       activeBackendKind = nextPayload.backendKind;
@@ -27383,7 +28655,7 @@ async function runSessionFromEnv() {
   const task = process.env.ALAN_TASK;
   const teamId = process.env.ALAN_TEAM_ID || void 0;
   const projectPath = process.env.ALAN_PROJECT_PATH || "/home/user/workspace";
-  const backendKind = process.env.ALAN_BACKEND_KIND || "claude_cli";
+  const backendKind = process.env.ALAN_BACKEND_KIND || "codex_app_server";
   const agentId = process.env.ALAN_AGENT_ID || void 0;
   const agentPrompt = process.env.ALAN_AGENT_PROMPT || void 0;
   const mode = process.env.ALAN_MODE || "agent";
@@ -27391,6 +28663,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;
@@ -27432,6 +28707,7 @@ async function runSessionFromEnv() {
     contextWindow,
     effortLevel,
     providerSessionId,
+    resumeFallbackContext,
     workflowId,
     workflowExecutionId,
     sandboxId,