@aiden-ade/sandbox-agent 0.1.37 → 0.1.39

package/dist/index.cjs

@@ -3404,7 +3404,7 @@ var require_websocket = __commonJS({
     var http2 = require("http");
     var net = require("net");
     var tls = require("tls");
-    var { randomBytes: randomBytes5, createHash: createHash6 } = require("crypto");
+    var { randomBytes: randomBytes5, createHash: createHash7 } = require("crypto");
     var { Duplex, Readable } = require("stream");
     var { URL: URL2 } = require("url");
     var PerMessageDeflate = require_permessage_deflate();
@@ -4061,7 +4061,7 @@ var require_websocket = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest = createHash6("sha1").update(key + GUID).digest("base64");
+        const digest = createHash7("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -4428,7 +4428,7 @@ var require_websocket_server = __commonJS({
     var EventEmitter = require("events");
     var http2 = require("http");
     var { Duplex } = require("stream");
-    var { createHash: createHash6 } = require("crypto");
+    var { createHash: createHash7 } = require("crypto");
     var extension = require_extension();
     var PerMessageDeflate = require_permessage_deflate();
     var subprotocol = require_subprotocol();
@@ -4725,7 +4725,7 @@ var require_websocket_server = __commonJS({
           );
         }
         if (this._state > RUNNING) return abortHandshake(socket, 503);
-        const digest = createHash6("sha1").update(key + GUID).digest("base64");
+        const digest = createHash7("sha1").update(key + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -4867,19 +4867,18 @@ var import_node_os7 = require("os");
 var import_node_path10 = require("path");
 
 // ../shared/dist/constants/agent.js
-var INTERACTIVE_TOOL_NAMES = /* @__PURE__ */ new Set(["askuserquestion", "exitplanmode", "enterplanmode"]);
+var INTERACTIVE_TOOL_NAMES = /* @__PURE__ */ new Set([
+  "askuserquestion",
+  "askquestion",
+  "exitplanmode",
+  "enterplanmode"
+]);
+var HARNESS_ASK_TOOL_NAMES = /* @__PURE__ */ new Set(["askuserquestion", "askquestion"]);
 function normalizeToolName(name) {
   const lower = name.toLowerCase();
   const mcp = lower.match(/^mcp__[a-z0-9-]+__(.+)$/);
-  let bare = mcp ? mcp[1] : lower;
-  bare = bare.replace(/[_\s-]/g, "");
-  for (const vendor of ["alan", "alan"]) {
-    if (bare.startsWith(vendor) && bare.length > vendor.length) {
-      bare = bare.slice(vendor.length);
-      break;
-    }
-  }
-  return bare;
+  const bare = mcp ? mcp[1] : lower;
+  return bare.replace(/[_\s-]/g, "");
 }
 function toolNameFromInput(input) {
   if (!input || typeof input !== "object")
@@ -4899,16 +4898,13 @@ function inputLooksLikeAskUserQuestion(input) {
   return Array.isArray(args.questions) && args.questions.length > 0;
 }
 function isAskUserQuestionTool(name, input) {
-  if (normalizeToolName(name) === "askuserquestion")
+  if (HARNESS_ASK_TOOL_NAMES.has(normalizeToolName(name)))
     return true;
   const nested = toolNameFromInput(input);
-  if (nested && nested !== name && normalizeToolName(nested) === "askuserquestion") {
-    return true;
-  }
-  if (normalizeToolName(name) === "mcp" && inputLooksLikeAskUserQuestion(input)) {
+  if (nested && nested !== name && HARNESS_ASK_TOOL_NAMES.has(normalizeToolName(nested))) {
     return true;
   }
-  return false;
+  return inputLooksLikeAskUserQuestion(input);
 }
 function isInteractiveToolName(name, input) {
   const normalized = normalizeToolName(name);
@@ -9574,6 +9570,11 @@ var RUNNER_STATUS_PROTOCOL_VERSION = 2;
 var RUNNER_STATUS_MIN_SUPPORTED_PROTOCOL_VERSION = Math.max(1, RUNNER_STATUS_PROTOCOL_VERSION - 1);
 var RUNNER_STATUS_MAX_SUPPORTED_PROTOCOL_VERSION = RUNNER_STATUS_PROTOCOL_VERSION;
 var RUNNER_RECOVERY_GRACE_MS = 2 * 60 * 1e3;
+var SYSTEM_ABORT_RUN_ERRORS = {
+  watchdog_timeout: "Agent run was stopped by the server after a period of no stream activity",
+  provider_exited: "Agent process exited unexpectedly",
+  runner_stalled: "Agent run stalled with no recent activity and was recovered"
+};
 function resolveAgentConfigFileName(profile) {
   switch (profile) {
     case "production":
@@ -14510,33 +14511,6 @@ Deliverables persist as Alan artifacts and documents \u2014 not as chat. Plans,
 For non-trivial tasks, log high-signal events as they happen: decisions, changed assumptions, validation results, known-good IDs, blockers, risks, and direction changes. Keep one current task-state summary updated with current state, known-good IDs, open risks, and next action. Do not log routine commands or file reads. Before stopping, ensure the timeline and current state are enough for a human to understand progress and for another agent to resume. If a prior decision is stale, write a newer event that supersedes it.
 
 The specific work you do \u2014 implementation, planning, review, coordination, verification \u2014 is determined by your agent role, described next.`;
-var ALAN_CURSOR_ASK_USER_OVERLAY = `### Cursor runtime note
-Cursor native \`AskQuestion\` does not block stdin for Alan yet. When you need clickable question cards on Cursor, use \`mcp__alan__ask_user_question\` (server tool: \`ask_user_question\`) instead of native AskQuestion.`;
-var ALAN_ASK_USER_PROMPT = `## Asking the user
-
-When you need a decision or information only the user can provide, do not guess \u2014 ask with an interactive ask tool so Alan can render clickable question cards.
-
-### Tool preference (required)
-1. Prefer the **native** ask tool when it appears in your tool list (\`AskUserQuestion\`, or the backend's equivalent built-in ask tool).
-2. Only if native ask is missing, call \`mcp__alan__ask_user_question\` (server tool name: \`ask_user_question\`).
-
-Required arguments (both native and MCP forms):
-- \`questions\`: non-empty array. Each item needs a clear \`question\` string.
-- Prefer 2\u20135 selectable \`options\` per question (\`label\` required; optional \`value\` / \`description\`). Free-text-only questions are allowed when options do not fit.
-- Do NOT include an "Other" option \u2014 the UI always adds a freeform Other\u2026 field.
-- Set \`multiSelect: true\` on a question when the user may pick more than one option; omit or set false for single-select (default).
-- Optional \`header\` per question and optional \`title\` for the card header.
-
-If neither native ask nor the MCP ask tool is available, ask ONE short plain-text question \u2014 do not invent cards or pretend the UI exists.
-
-### Never do this
-- Do NOT paste multiple-choice lists, A/B/C tables, or "reply with 1A / 1B" in chat.
-- Do NOT say "answer in the UI", "see the cards", "questions are above", or similar unless you just successfully called an ask tool with real \`questions\` in this turn.
-- Do NOT call the tool with empty \`questions\`, placeholder text, or missing options when choices exist.
-- Do NOT invent defaults when the user skips. If the next user message says they skipped, continue without those answers (or re-ask only if truly required).
-
-### After the tool call
-The ask tool returns an empty/ack result and does NOT wait. Immediately end your turn. At most one short line like "Please pick an option above." \u2014 no restating the full questions in markdown. The user's answer (or skip) arrives as the next user message; continue from there.`;
 function buildAlanTeamScopePrompt(teamId) {
   return [
     `You are operating within team \`${teamId}\`.`,
@@ -15228,20 +15202,23 @@ var import_path3 = require("path");
 var import_readline = require("readline");
 var import_child_process2 = require("child_process");
 var import_crypto2 = require("crypto");
-var import_child_process3 = require("child_process");
-var import_util10 = require("util");
 var import_fs4 = require("fs");
 var import_os4 = require("os");
 var import_path4 = require("path");
+var import_child_process3 = require("child_process");
+var import_util10 = require("util");
 var import_fs5 = require("fs");
 var import_os5 = require("os");
 var import_path5 = require("path");
 var import_fs6 = require("fs");
 var import_os6 = require("os");
 var import_path6 = require("path");
-var import_crypto3 = require("crypto");
 var import_fs7 = require("fs");
+var import_os7 = require("os");
 var import_path7 = require("path");
+var import_crypto3 = require("crypto");
+var import_fs8 = require("fs");
+var import_path8 = require("path");
 var MANAGED_ALAN_MCP_SERVER_NAMES = [
   "alan",
   "alan-prod",
@@ -15736,10 +15713,111 @@ function getClaudePermissionMode(config) {
 function getClaudeDisallowedTools(config) {
   return isReadOnlyAgent(config.agentId) ? ["Edit", "Write", "MultiEdit", "NotebookEdit"] : [];
 }
+function getCodexPermissionArgs(config) {
+  const sandbox = shouldUseReadOnlyRuntimePermissions(config) ? "read-only" : "danger-full-access";
+  return ["--ask-for-approval", "never", "--sandbox", sandbox];
+}
+var ERROR_SPECS = {
+  model_mismatch: {
+    message: "The selected model isn't available, or you don't have access to it. Pick a different model, then send your message again.",
+    recoveryClass: "user_fixable"
+  },
+  auth_invalid: {
+    message: "API key invalid or expired. Check your provider settings, then retry.",
+    recoveryClass: "user_fixable"
+  },
+  not_logged_in: {
+    message: "Not logged in to this provider. Sign in from provider settings, then retry.",
+    recoveryClass: "user_fixable"
+  },
+  not_authenticated: {
+    message: "The agent CLI isn't signed in on this runtime. Authenticate it there, then retry.",
+    recoveryClass: "needs_env"
+  },
+  auth_expired: {
+    message: "The provider connection expired. Reconnect it in Cloud settings, then restart or recreate the machine.",
+    recoveryClass: "user_fixable"
+  },
+  subscription_required: {
+    message: "This model requires a paid subscription. Switch to a supported model or upgrade your plan.",
+    recoveryClass: "user_fixable"
+  },
+  quota_exceeded: {
+    message: "API quota exceeded. Wait for it to reset or check your billing, then retry.",
+    recoveryClass: "user_fixable"
+  },
+  usage_limit: {
+    message: "Provider usage limit reached. Switch model or wait for the limit to reset, then retry.",
+    recoveryClass: "user_fixable"
+  },
+  context_length: {
+    message: "Context window exceeded \u2014 the conversation is too long. Start a new session or send a shorter message.",
+    recoveryClass: "user_fixable"
+  },
+  rate_limited: {
+    message: "Rate limited by the provider. Retrying automatically shortly.",
+    recoveryClass: "auto_recovering"
+  },
+  overloaded: {
+    message: "The provider is overloaded. Retrying automatically.",
+    recoveryClass: "auto_recovering"
+  },
+  network: {
+    message: "Network connection failed. Check your internet connection \u2014 retrying automatically.",
+    recoveryClass: "auto_recovering"
+  },
+  provider_timeout: {
+    message: "The provider timed out while continuing the turn. Send your message again; if it repeats, check network/API latency or reduce slow tool calls.",
+    recoveryClass: "retry"
+  },
+  resume_failed: {
+    message: "The previous session could not be resumed \u2014 its stored session was missing or expired. The next message starts a fresh session without earlier context.",
+    recoveryClass: "retry"
+  },
+  permission_denied: {
+    message: "Permission denied. Check file or command permissions on the runtime.",
+    recoveryClass: "needs_env"
+  },
+  out_of_memory: {
+    message: "Out of memory on the runtime. Close other work or use a larger machine, then retry.",
+    recoveryClass: "needs_env"
+  },
+  provider_error: {
+    message: "The provider returned an error. Send your message again to retry.",
+    recoveryClass: "retry"
+  },
+  unknown_cli_error: {
+    message: "The agent stopped unexpectedly. Send your message again to retry.",
+    recoveryClass: "retry"
+  }
+};
+function specForErrorKind(errorKind) {
+  const spec = ERROR_SPECS[errorKind];
+  return { message: spec.message, errorKind, recoveryClass: spec.recoveryClass };
+}
 function isLikelyProviderAuthError(stderr) {
   const lower = stderr.toLowerCase();
   return lower.includes("api key") || lower.includes("api_key") || lower.includes("invalid api key") || lower.includes("api key invalid") || lower.includes("unauthorized") || lower.includes("authentication failed") || lower.includes("authentication error") || lower.includes("provider settings") || lower.includes("invalid token") || lower.includes("token expired");
 }
+function mapProviderApiError(errorCode, apiStatus) {
+  const code = errorCode?.trim().toLowerCase();
+  if (code) {
+    if (code.includes("model_not_found") || code.includes("model_not_available")) {
+      return "model_mismatch";
+    }
+    if (code.includes("authentication") || code.includes("permission_error")) return "auth_invalid";
+    if (code.includes("rate_limit")) return "rate_limited";
+    if (code.includes("overloaded")) return "overloaded";
+    if (code.includes("insufficient_quota") || code.includes("billing")) return "quota_exceeded";
+  }
+  if (typeof apiStatus === "number") {
+    if (apiStatus === 404) return "model_mismatch";
+    if (apiStatus === 401 || apiStatus === 403) return "auth_invalid";
+    if (apiStatus === 429) return "rate_limited";
+    if (apiStatus >= 500) return "overloaded";
+  }
+  return null;
+}
 function normalizeCodexCliErrorMessage(message) {
   const lower = message.toLowerCase();
   if (lower.includes("reconnecting") && lower.includes("request timed out")) {
@@ -15750,40 +15828,73 @@ function normalizeCodexCliErrorMessage(message) {
   }
   return message;
 }
-function classifyCliError(stderr, exitCode) {
+function classifyCliErrorDetailed(stderr, _exitCode, opts) {
   const normalizedCodexError = normalizeCodexCliErrorMessage(stderr);
-  if (normalizedCodexError !== stderr) return normalizedCodexError;
-  const lower = stderr.toLowerCase();
-  if (lower.includes("authentication required") || lower.includes("not authenticated"))
-    return "Cursor Agent is not authenticated. Log in with `cursor-agent login` on this machine, then retry.";
-  if (lower.includes("out of usage") || lower.includes("increase your limit"))
-    return "Provider usage limit reached. Switch model/plan or wait for the limit to reset, then retry.";
-  if (lower.includes("no chat found") || lower.includes("chat not found") || lower.includes("session not found") || lower.includes("could not resume"))
-    return "The previous session could not be resumed \u2014 the CLI's stored session was missing or expired. The next message starts a fresh session without earlier context.";
-  if (lower.includes("rate_limit") || lower.includes("rate limit") || lower.includes("429"))
-    return "Rate limited by API. Try again shortly.";
-  if (isLikelyProviderAuthError(stderr))
-    return "API key invalid or expired. Check your provider settings.";
-  if (lower.includes("not logged in") || lower.includes("login required") || lower.includes("please sign in") || lower.includes("please log in") || lower.includes("sign in to") || lower.includes("log in to"))
-    return "Not logged in. Please authenticate with this provider first.";
-  if (lower.includes("model not supported") || lower.includes("unsupported model") || lower.includes("model not found") || lower.includes("model not available") || lower.includes("model is not available") || lower.includes("invalid model") || lower.includes("unknown model") || lower.includes("no such model") || lower.includes("llm not set"))
-    return "Model not supported by this provider. Check your provider's model list.";
-  if (lower.includes("subscription") || lower.includes("paid plan") || lower.includes("plan required") || lower.includes("upgrade your plan") || lower.includes("only supports free") || lower.includes("not available on your") || lower.includes("requires a paid"))
-    return "This model requires a paid subscription. Switch to a supported model or upgrade your plan.";
-  if (lower.includes("quota exceeded") || lower.includes("quota limit") || lower.includes("daily limit") || lower.includes("monthly limit") || lower.includes("usage limit"))
-    return "API quota exceeded. Wait for it to reset or check your billing.";
-  if (lower.includes("overloaded") || lower.includes("503") || lower.includes("service unavailable"))
-    return "API is overloaded. Will retry automatically.";
-  if (lower.includes("context_length") || lower.includes("too long") || lower.includes("max tokens") || lower.includes("context window"))
-    return "Context window exceeded. Try a shorter prompt or start a new session.";
-  if (lower.includes("econnrefused") || lower.includes("network") || lower.includes("enotfound") || lower.includes("timeout") || lower.includes("etimedout"))
-    return "Network connection failed. Check your internet connection.";
-  if (lower.includes("permission denied") || lower.includes("eacces"))
-    return "Permission denied. Check file or command permissions.";
-  if (lower.includes("out of memory") || lower.includes("enomem"))
-    return "Out of memory. Close other applications and try again.";
+  if (normalizedCodexError !== stderr) {
+    const kind = /timed out/i.test(normalizedCodexError) ? "provider_timeout" : "auth_expired";
+    return {
+      message: normalizedCodexError,
+      errorKind: kind,
+      recoveryClass: ERROR_SPECS[kind].recoveryClass
+    };
+  }
+  const haystack = [stderr, ...opts?.extraSignals ?? []].join("\n").toLowerCase();
+  const has = (...needles) => needles.some((n) => haystack.includes(n));
+  if (has("authentication required", "not authenticated"))
+    return specForErrorKind("not_authenticated");
+  if (has("out of usage", "increase your limit")) return specForErrorKind("usage_limit");
+  if (has("no chat found", "chat not found", "session not found", "could not resume"))
+    return specForErrorKind("resume_failed");
+  if (has("rate_limit", "rate limit", "429")) return specForErrorKind("rate_limited");
+  if (isLikelyProviderAuthError(haystack)) return specForErrorKind("auth_invalid");
+  if (has(
+    "not logged in",
+    "login required",
+    "please sign in",
+    "please log in",
+    "sign in to",
+    "log in to"
+  ))
+    return specForErrorKind("not_logged_in");
+  if (has(
+    "model not supported",
+    "unsupported model",
+    "model not found",
+    "model not available",
+    "model is not available",
+    "invalid model",
+    "unknown model",
+    "no such model",
+    "llm not set",
+    // Claude Code phrasings (safety net; the structured decoder catches these first).
+    "issue with the selected model",
+    "may not exist or you may not have access"
+  ))
+    return specForErrorKind("model_mismatch");
+  if (has(
+    "subscription",
+    "paid plan",
+    "plan required",
+    "upgrade your plan",
+    "only supports free",
+    "not available on your",
+    "requires a paid"
+  ))
+    return specForErrorKind("subscription_required");
+  if (has("quota exceeded", "quota limit", "daily limit", "monthly limit", "usage limit"))
+    return specForErrorKind("quota_exceeded");
+  if (has("overloaded", "503", "service unavailable")) return specForErrorKind("overloaded");
+  if (has("context_length", "too long", "max tokens", "context window"))
+    return specForErrorKind("context_length");
+  if (has("econnrefused", "network", "enotfound", "timeout", "etimedout"))
+    return specForErrorKind("network");
+  if (has("permission denied", "eacces")) return specForErrorKind("permission_denied");
+  if (has("out of memory", "enomem")) return specForErrorKind("out_of_memory");
   const raw = stderr.trim().slice(0, 200);
-  return raw || `Process exited with code ${exitCode}`;
+  if (raw) {
+    return { message: raw, errorKind: "unknown_cli_error", recoveryClass: "unknown" };
+  }
+  return specForErrorKind("unknown_cli_error");
 }
 function isTransientError(errorMessage) {
   const lower = errorMessage.toLowerCase();
@@ -15832,6 +15943,16 @@ function spawnCli(command, args, context) {
     detached: process.platform !== "win32"
   });
 }
+function emitSessionNotice(presenter, kind, message) {
+  if (presenter.onNotice) {
+    void presenter.onNotice(kind, message);
+    return;
+  }
+  presenter.onLog(`[session_notice:${kind}] ${message}`);
+}
+function logResumeObservability(event, fields) {
+  console.info(`[agent-resume] ${event}`, { event, ...fields });
+}
 function structuredEventKey(event) {
   const type = typeof event.type === "string" && event.type ? event.type : "";
   const role = typeof event.role === "string" && event.role ? event.role : "";
@@ -15901,7 +16022,12 @@ function createGenericCliBackend(options) {
       const args = options.buildArgs?.(context, prompt) ?? options.args.map((arg) => arg === "{{prompt}}" ? prompt : arg);
       const child = spawnCli(options.command, args, context);
       state.process = child;
+      state.lastRawOutputAtMs = Date.now();
       context.onProcessSpawned?.(child);
+      context.registerLivenessProbe?.(() => ({
+        providerAlive: child.exitCode === null,
+        lastRawOutputAgoMs: typeof state.lastRawOutputAtMs === "number" ? Date.now() - state.lastRawOutputAtMs : null
+      }));
       const safeArgs = args.map(
         (a, i) => i > 0 && args[i - 1] === "--system-prompt" ? `"<system-prompt ${a.length} chars>"` : a
       );
@@ -15950,6 +16076,7 @@ function createGenericCliBackend(options) {
       }
       stdoutRl.on("line", (line) => {
         sawStdoutLine = true;
+        state.lastRawOutputAtMs = Date.now();
         presenter.recordRawTranscript?.("stdout", line);
         if (options.parseStructuredLine) {
           options.parseStructuredLine(line, context, state);
@@ -15967,6 +16094,7 @@ function createGenericCliBackend(options) {
         }
       });
       stderrRl.on("line", (line) => {
+        state.lastRawOutputAtMs = Date.now();
         presenter.recordRawTranscript?.("stderr", line);
         if (options.parseStderrLine) {
           options.parseStderrLine(line, context, state);
@@ -16013,7 +16141,7 @@ function createGenericCliBackend(options) {
                 if (presenter.pendingAskUserToolIds?.size) {
                   idleTimeoutReason = "pending_user_answer";
                   resolve22("idle_timeout");
-                } else if (state.activeBackgroundTaskIds?.size) {
+                } else if (state.resultDeferredOnBackgroundWork && state.activeBackgroundTaskIds?.size) {
                   idleTimeoutReason = "background_task";
                   resolve22("idle_timeout");
                 } else {
@@ -16076,10 +16204,26 @@ function createGenericCliBackend(options) {
         logUnhandledStructuredEventSummary(options.kind, state);
       }
       const requestedResumeId = context.config.runtimeSessionId?.trim() || context.config.providerSessionId?.trim();
+      let cursorResumeSilentlyFailed = false;
       if (requestedResumeId && state.runtimeSessionId && state.runtimeSessionId !== requestedResumeId) {
         console.warn(
           `[${options.kind}] CLI reported session id ${state.runtimeSessionId} after resume was requested with ${requestedResumeId} \u2014 expected for claude session forks, a failed-resume signal for cursor-agent`
         );
+        if (options.kind === "cursor_agent_cli") {
+          cursorResumeSilentlyFailed = true;
+          logResumeObservability("agent_resume_failed", {
+            backendKind: options.kind,
+            reason: "cli_forked_fresh_session",
+            requestedResumeId,
+            runtimeSessionId: state.runtimeSessionId,
+            hadFallbackContext: Boolean(context.config.resumeFallbackContext?.trim())
+          });
+          emitSessionNotice(
+            context.presenter,
+            "session_resume_failed",
+            "The previous session could not be resumed, so this reply was generated without earlier conversation context. Retrying with the recent history re-included."
+          );
+        }
       }
       if (context.abortController.signal.aborted) {
         return {
@@ -16173,14 +16317,51 @@ function createGenericCliBackend(options) {
       const stderrText = stderrLines.join("\n").trim();
       const hasStructuredError = exitCode === 0 && !!state.error?.trim();
       const failed = exitCode !== 0 || hasStructuredError;
+      if (cursorResumeSilentlyFailed && !failed) {
+        return {
+          success: false,
+          summary: state.summary.trim() || "Session resume failed",
+          filesModified: [],
+          planFilesCreated: [],
+          iterations: Math.max(state.iterations, 1),
+          error: SESSION_RESUME_FAILED_MESSAGE,
+          errorKind: "resume_failed",
+          providerSessionId: state.runtimeSessionId,
+          runtimeSessionId: state.runtimeSessionId,
+          backendKind: options.kind,
+          supportTier: options.supportTier,
+          usage: state.usage
+        };
+      }
       const summary = state.summary.trim() || state.error?.trim() || (failed ? "Task failed" : "Task completed");
+      let classifiedError;
+      let classifiedErrorKind;
+      let classifiedRecoveryClass;
+      if (failed) {
+        if (state.errorKind && state.error?.trim()) {
+          classifiedError = state.error.trim();
+          classifiedErrorKind = state.errorKind;
+          classifiedRecoveryClass = state.recoveryClass;
+        } else {
+          const detailed = classifyCliErrorDetailed(
+            state.error?.trim() || stderrText || "",
+            exitCode,
+            { extraSignals: state.summary ? [state.summary] : void 0 }
+          );
+          classifiedError = detailed.message;
+          classifiedErrorKind = detailed.errorKind;
+          classifiedRecoveryClass = detailed.recoveryClass;
+        }
+      }
       return {
         success: !failed,
         summary,
         filesModified: [],
         planFilesCreated: [],
         iterations: Math.max(state.iterations, 1),
-        error: failed ? classifyCliError(state.error?.trim() || stderrText || "", exitCode) : void 0,
+        error: classifiedError,
+        ...classifiedErrorKind ? { errorKind: classifiedErrorKind } : {},
+        ...classifiedRecoveryClass ? { recoveryClass: classifiedRecoveryClass } : {},
         providerSessionId: state.runtimeSessionId,
         runtimeSessionId: state.runtimeSessionId,
         backendKind: options.kind,
@@ -16622,6 +16803,21 @@ function createAntigravityCliBackend(command = "agy", defaultArgs = []) {
     }
   };
 }
+function resolveClaudeHome(env, variant = "claude") {
+  if (variant === "supatest") {
+    return (0, import_path4.join)((0, import_os4.homedir)(), ".supatest", "claude-internal");
+  }
+  return env.CLAUDE_CONFIG_DIR || process.env.CLAUDE_CONFIG_DIR || (0, import_path4.join)((0, import_os4.homedir)(), ".claude");
+}
+function encodeClaudeProjectDir(cwd) {
+  return cwd.replace(/[^a-zA-Z0-9]/g, "-");
+}
+function claudeSessionLogExists(input) {
+  if (!input.sessionId || !input.cwd) return false;
+  const projectDir = (0, import_path4.join)(input.home, "projects", encodeClaudeProjectDir(input.cwd));
+  if (!(0, import_fs4.existsSync)(projectDir)) return false;
+  return (0, import_fs4.existsSync)((0, import_path4.join)(projectDir, `${input.sessionId}.jsonl`));
+}
 var execFileAsync = (0, import_util10.promisify)(import_child_process3.execFile);
 var flagSupportCache = /* @__PURE__ */ new Map();
 function helpAdvertisesFlag(helpText, flag) {
@@ -16672,15 +16868,38 @@ function registerBackgroundTaskIds(state, keys) {
     state.activeBackgroundTaskIds.add(key);
   }
 }
-function registerBackgroundTaskRecord(state, record) {
+function registerBackgroundLauncher(state, toolUseId) {
+  registerBackgroundTaskIds(state, [toolUseId]);
+  if (!state.pendingLauncherToolIds) state.pendingLauncherToolIds = [];
+  if (!state.pendingLauncherToolIds.includes(toolUseId)) {
+    state.pendingLauncherToolIds.push(toolUseId);
+  }
+}
+function drainNextUnlinkedBackgroundLauncher(state) {
+  const launcherId = state.pendingLauncherToolIds?.shift();
+  if (state.pendingLauncherToolIds?.length === 0) state.pendingLauncherToolIds = void 0;
+  if (launcherId) clearBackgroundTaskIds(state, [launcherId]);
+  return launcherId;
+}
+function registerBackgroundTaskRecord(state, record, launcherToolUseId) {
   const taskId = backgroundTaskId(record);
-  let toolUseId = backgroundToolUseId(record);
-  if (!toolUseId && taskId && state.activeBackgroundTaskIds?.size === 1) {
-    const [candidate] = state.activeBackgroundTaskIds;
-    if (candidate && candidate !== taskId) toolUseId = candidate;
+  let toolUseId = backgroundToolUseId(record) ?? launcherToolUseId ?? void 0;
+  if (!toolUseId && taskId) {
+    const nextLauncher = state.pendingLauncherToolIds?.[0];
+    if (nextLauncher) {
+      toolUseId = nextLauncher;
+    } else if (state.activeBackgroundTaskIds?.size === 1) {
+      const [candidate] = state.activeBackgroundTaskIds;
+      if (candidate && candidate !== taskId) toolUseId = candidate;
+    }
   }
   registerBackgroundTaskIds(state, backgroundTaskKeys(record));
   if (!taskId || !toolUseId) return;
+  if (state.pendingLauncherToolIds) {
+    const idx = state.pendingLauncherToolIds.indexOf(toolUseId);
+    if (idx >= 0) state.pendingLauncherToolIds.splice(idx, 1);
+    if (state.pendingLauncherToolIds.length === 0) state.pendingLauncherToolIds = void 0;
+  }
   if (!state.backgroundToolIdByTaskId) state.backgroundToolIdByTaskId = /* @__PURE__ */ new Map();
   if (!state.backgroundTaskIdsByToolId) state.backgroundTaskIdsByToolId = /* @__PURE__ */ new Map();
   state.backgroundToolIdByTaskId.set(taskId, toolUseId);
@@ -16711,6 +16930,10 @@ function clearBackgroundTaskIds(state, keys) {
       state.backgroundTaskIdsByToolId?.delete(key);
     }
   }
+  if (state.pendingLauncherToolIds) {
+    state.pendingLauncherToolIds = state.pendingLauncherToolIds.filter((id) => activeIds.has(id));
+    if (state.pendingLauncherToolIds.length === 0) state.pendingLauncherToolIds = void 0;
+  }
   if (activeIds.size === 0) state.activeBackgroundTaskIds = void 0;
 }
 function resolveBackgroundTaskToolUseId(state, record) {
@@ -16733,6 +16956,7 @@ function deferOrFinalizeStructuredResult(kind, context, state) {
     console.info(
       `[${kind}] Keeping stdin open \u2014 ${pendingAsks} interactive question(s) awaiting user response`
     );
+    state.resultDeferredOnPendingAnswer = true;
     return "deferred_pending_answer";
   }
   const activeBackgroundTasks = state.activeBackgroundTaskIds?.size ?? 0;
@@ -16747,9 +16971,10 @@ function deferOrFinalizeStructuredResult(kind, context, state) {
   return "finalized";
 }
 function maybeFinalizeDeferredResult(kind, context, state) {
-  if (!state.resultDeferredOnBackgroundWork) return;
+  if (!state.resultDeferredOnBackgroundWork && !state.resultDeferredOnPendingAnswer) return;
   if (context.presenter.pendingAskUserToolIds?.size || state.activeBackgroundTaskIds?.size) return;
   state.resultDeferredOnBackgroundWork = false;
+  state.resultDeferredOnPendingAnswer = false;
   finalizeStructuredResult(kind, state);
 }
 var DEBUG_ASK = process.env.ALAN_DEBUG_ASK === "1" || process.env.ALAN_DEBUG === "1";
@@ -16810,6 +17035,9 @@ function handleClaudeStructuredEvent(parsed, context, state) {
   if (typeof parsed.session_id === "string") {
     state.runtimeSessionId = parsed.session_id;
   }
+  if (typeof parsed.error === "string" && parsed.error.trim()) {
+    state.providerErrorCode = parsed.error.trim();
+  }
   const parentToolUseId = typeof parsed.parent_tool_use_id === "string" ? parsed.parent_tool_use_id : null;
   switch (type) {
     case "system": {
@@ -16819,21 +17047,44 @@ function handleClaudeStructuredEvent(parsed, context, state) {
         return true;
       }
       if (parsed.subtype === "task_started") {
-        registerBackgroundTaskRecord(state, parsed);
+        registerBackgroundTaskRecord(state, parsed, parentToolUseId);
+        return true;
+      }
+      if (parsed.subtype === "compact_boundary") {
+        const compactMetadata = typeof parsed.compact_metadata === "object" && parsed.compact_metadata !== null ? parsed.compact_metadata : {};
+        const trigger = typeof compactMetadata.trigger === "string" ? compactMetadata.trigger : typeof parsed.trigger === "string" ? parsed.trigger : "auto";
+        const preTokens = typeof compactMetadata.pre_tokens === "number" ? compactMetadata.pre_tokens : typeof parsed.pre_tokens === "number" ? parsed.pre_tokens : void 0;
+        const tokensPart = typeof preTokens === "number" && preTokens > 0 ? ` (${Math.round(preTokens / 1e3)}k tokens summarized)` : "";
+        emitSessionNotice(
+          presenter,
+          "context_compacted",
+          trigger === "manual" ? `Conversation context was compacted${tokensPart} \u2014 earlier detail was replaced with a summary.` : `Conversation context was automatically compacted${tokensPart} to stay within the model's limit \u2014 earlier detail was replaced with a summary.`
+        );
         return true;
       }
       if (parsed.subtype === "task_notification") {
         if (isTerminalTaskNotification(parsed)) {
           const toolUseId = resolveBackgroundTaskToolUseId(state, parsed);
           const wasActive = !!toolUseId && state.activeBackgroundTaskIds?.has(toolUseId) ? true : backgroundTaskKeys(parsed).some((key) => state.activeBackgroundTaskIds?.has(key));
+          const isFailed = isFailedTaskNotification(parsed) ? true : void 0;
           if (toolUseId && wasActive) {
             void presenter.onToolResult?.(
               toolUseId,
               formatClaudeTaskNotificationResult(parsed),
-              isFailedTaskNotification(parsed) ? true : void 0
+              isFailed
             );
+            clearBackgroundTaskIds(state, backgroundTaskKeys(parsed));
+          } else {
+            clearBackgroundTaskIds(state, backgroundTaskKeys(parsed));
+            const drainedLauncher = drainNextUnlinkedBackgroundLauncher(state);
+            if (drainedLauncher) {
+              void presenter.onToolResult?.(
+                drainedLauncher,
+                formatClaudeTaskNotificationResult(parsed),
+                isFailed
+              );
+            }
           }
-          clearBackgroundTaskIds(state, backgroundTaskKeys(parsed));
           maybeFinalizeDeferredResult("claude_cli", context, state);
         }
         return true;
@@ -16841,9 +17092,10 @@ function handleClaudeStructuredEvent(parsed, context, state) {
       return false;
     }
     case "assistant": {
-      if (presenter.pendingAskUserToolIds?.size) {
+      if (state.awaitingAskDenialFallback) {
+        state.awaitingAskDenialFallback = false;
         console.info(
-          `[claude_cli] Suppressing fallback assistant turn \u2014 ${presenter.pendingAskUserToolIds.size} AskUserQuestion(s) still pending`
+          "[claude_cli] Suppressing auto-denial fallback assistant turn after native AskUserQuestion"
         );
         return true;
       }
@@ -16872,7 +17124,7 @@ function handleClaudeStructuredEvent(parsed, context, state) {
             parentToolUseId
           );
           if (CLAUDE_SUBAGENT_TOOL_NAMES.has(toolBlock.name.toLowerCase())) {
-            registerBackgroundTaskIds(state, [toolBlock.id]);
+            registerBackgroundLauncher(state, toolBlock.id);
           }
           const normalizedName = normalizeToolName(toolBlock.name);
           if (isInteractiveToolName(toolBlock.name) || INTERACTIVE_TOOL_NAMES.has(normalizedName)) {
@@ -16883,6 +17135,10 @@ function handleClaudeStructuredEvent(parsed, context, state) {
           if (isAskUserQuestionTool(toolBlock.name)) {
             if (!presenter.pendingAskUserToolIds) presenter.pendingAskUserToolIds = /* @__PURE__ */ new Set();
             presenter.pendingAskUserToolIds.add(toolBlock.id);
+            if (!toolBlock.name.toLowerCase().startsWith("mcp__")) {
+              if (!state.nativeAskToolIds) state.nativeAskToolIds = /* @__PURE__ */ new Set();
+              state.nativeAskToolIds.add(toolBlock.id);
+            }
             debugAskLog(
               `[claude_cli] AskUserQuestion tool_use detected \u2014 id=${toolBlock.id}, name=${toolBlock.name}, pendingSize=${presenter.pendingAskUserToolIds.size}, presenterHasProp=${Object.hasOwn(presenter, "pendingAskUserToolIds")}`
             );
@@ -16907,6 +17163,22 @@ function handleClaudeStructuredEvent(parsed, context, state) {
       for (const block of content) {
         if (typeof block === "object" && block !== null && "type" in block && block.type === "tool_result" && "tool_use_id" in block && typeof block.tool_use_id === "string") {
           if (state.suppressedToolResultIds?.has(block.tool_use_id)) {
+            const isSuppressedError = "is_error" in block && block.is_error === true;
+            const isNativeAsk = state.nativeAskToolIds?.has(block.tool_use_id) === true;
+            if (isSuppressedError && !isNativeAsk && presenter.pendingAskUserToolIds?.has(block.tool_use_id)) {
+              presenter.pendingAskUserToolIds.delete(block.tool_use_id);
+              state.suppressedToolResultIds.delete(block.tool_use_id);
+              const resultText2 = extractToolResultContent(block.content);
+              console.info(
+                `[claude_cli] Ask tool ${block.tool_use_id} returned an error \u2014 clearing pending ask so the run can finish`
+              );
+              void presenter.onToolResult?.(block.tool_use_id, resultText2, true, parentToolUseId);
+              maybeFinalizeDeferredResult("claude_cli", context, state);
+              continue;
+            }
+            if (isNativeAsk) {
+              state.awaitingAskDenialFallback = true;
+            }
             console.info(
               `[claude_cli] Suppressed auto-generated tool_result for ${block.tool_use_id}`
             );
@@ -16978,6 +17250,27 @@ function handleClaudeStructuredEvent(parsed, context, state) {
           })
         );
       }
+      const isApiError = parsed.is_error === true || parsed.terminal_reason === "api_error" || typeof parsed.api_error_status === "number";
+      if (isApiError && !state.error) {
+        const apiStatus = typeof parsed.api_error_status === "number" ? parsed.api_error_status : void 0;
+        state.apiErrorStatus = apiStatus;
+        const mappedKind = mapProviderApiError(state.providerErrorCode, apiStatus);
+        const spec = mappedKind ? specForErrorKind(mappedKind) : specForErrorKind("provider_error");
+        state.error = mappedKind || typeof parsed.result !== "string" || !parsed.result.trim() ? spec.message : parsed.result.trim();
+        state.errorKind = spec.errorKind;
+        state.recoveryClass = spec.recoveryClass;
+        console.error(
+          "[claude_cli] result flagged API error:",
+          JSON.stringify({
+            is_error: parsed.is_error,
+            terminal_reason: parsed.terminal_reason,
+            api_error_status: parsed.api_error_status,
+            providerErrorCode: state.providerErrorCode,
+            mappedKind,
+            result: typeof parsed.result === "string" ? parsed.result.slice(0, 200) : void 0
+          })
+        );
+      }
       debugAskLog(
         `[claude_cli] result event \u2014 pendingAskUserToolIds size=${presenter.pendingAskUserToolIds?.size ?? "undefined"}, hasOwnProp=${Object.hasOwn(presenter, "pendingAskUserToolIds")}`
       );
@@ -17014,7 +17307,31 @@ function createClaudeCliBackend(command = "claude", defaultArgs = []) {
       if (disallowedTools.length > 0) {
         args.push("--disallowedTools", disallowedTools.join(","));
       }
-      const resumeId = context.config.runtimeSessionId?.trim() || context.config.providerSessionId?.trim();
+      const requestedResumeId = context.config.runtimeSessionId?.trim() || context.config.providerSessionId?.trim();
+      let resumeId = requestedResumeId;
+      let resumeContextPrefix;
+      if (requestedResumeId && !claudeSessionLogExists({
+        sessionId: requestedResumeId,
+        cwd: context.cwd,
+        home: resolveClaudeHome(context.env)
+      })) {
+        resumeId = void 0;
+        resumeContextPrefix = context.config.resumeFallbackContext?.trim() || void 0;
+        console.warn(
+          `[claude_cli] No session log for ${requestedResumeId} under cwd ${context.cwd}; starting a fresh session instead of resuming`
+        );
+        logResumeObservability("agent_resume_fallback_used", {
+          backendKind: "claude_cli",
+          reason: "session_log_missing_for_cwd",
+          requestedResumeId,
+          hadFallbackContext: Boolean(resumeContextPrefix)
+        });
+        emitSessionNotice(
+          context.presenter,
+          "session_resume_failed",
+          resumeContextPrefix ? "The previous Claude session was created in a different working directory and could not be resumed here, so a fresh session was started with the recent conversation history re-included." : "The previous Claude session was created in a different working directory and could not be resumed here, so a fresh session was started. Earlier conversation context may be missing from this reply."
+        );
+      }
       if (!resumeId && context.config.systemPrompt?.trim()) {
         args.push("--system-prompt", context.config.systemPrompt.trim());
       } else if (resumeId && context.config.systemPromptAppend?.trim()) {
@@ -17034,6 +17351,10 @@ function createClaudeCliBackend(command = "claude", defaultArgs = []) {
       if (resumeId) {
         args.push("--resume", resumeId);
         console.info("[claude_cli] Resuming session", { resumeId });
+        logResumeObservability("agent_resume_requested", {
+          backendKind: "claude_cli",
+          requestedResumeId: resumeId
+        });
       }
       args.push("--chrome");
       console.info("[claude_cli] Chrome flag added \u2014 final args:", args.join(" "));
@@ -17054,7 +17375,10 @@ function createClaudeCliBackend(command = "claude", defaultArgs = []) {
               });
             }
           }
-          const promptText = ctx.config.mode === "plan" ? buildPlanModePrefix(buildPromptWithSystem(ctx.config, ctx.promptText)) : buildPromptWithSystem(ctx.config, ctx.promptText);
+          const basePromptText = resumeContextPrefix ? `${resumeContextPrefix}
+
+${ctx.promptText}` : ctx.promptText;
+          const promptText = ctx.config.mode === "plan" ? buildPlanModePrefix(buildPromptWithSystem(ctx.config, basePromptText)) : buildPromptWithSystem(ctx.config, basePromptText);
           if (promptText.trim()) {
             contentBlocks.push({ type: "text", text: promptText });
           }
@@ -17105,27 +17429,30 @@ function normalizeCodexMcpToolResult(output) {
   }
   return raw;
 }
+function resolveCodexHome(env) {
+  return env.CODEX_HOME || process.env.CODEX_HOME || (0, import_path5.join)((0, import_os5.homedir)(), ".codex");
+}
 function findCodexSessionLog(runtimeSessionId, codexHome) {
-  if (!runtimeSessionId || !(0, import_fs4.existsSync)(codexHome)) return null;
-  const root = (0, import_path4.join)(codexHome, "sessions");
-  if (!(0, import_fs4.existsSync)(root)) return null;
+  if (!runtimeSessionId || !(0, import_fs5.existsSync)(codexHome)) return null;
+  const root = (0, import_path5.join)(codexHome, "sessions");
+  if (!(0, import_fs5.existsSync)(root)) return null;
   const matches = [];
   const stack = [root];
   while (stack.length > 0) {
     const dir = stack.pop();
     let entries;
     try {
-      entries = (0, import_fs4.readdirSync)(dir, { withFileTypes: true });
+      entries = (0, import_fs5.readdirSync)(dir, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const entry of entries) {
-      const path = (0, import_path4.join)(dir, entry.name);
+      const path = (0, import_path5.join)(dir, entry.name);
       if (entry.isDirectory()) {
         stack.push(path);
       } else if (entry.isFile() && entry.name.includes(runtimeSessionId) && entry.name.endsWith(".jsonl")) {
         try {
-          matches.push({ path, mtimeMs: (0, import_fs4.statSync)(path).mtimeMs });
+          matches.push({ path, mtimeMs: (0, import_fs5.statSync)(path).mtimeMs });
         } catch {
           matches.push({ path, mtimeMs: 0 });
         }
@@ -17158,12 +17485,14 @@ function latestUserMessageLineIndex(lines) {
 async function replayCodexMcpToolEventsFromSessionLog(context, state) {
   const runtimeSessionId = state.runtimeSessionId;
   if (!runtimeSessionId) return;
-  const codexHome = context.env.CODEX_HOME || process.env.CODEX_HOME || (0, import_path4.join)((0, import_os4.homedir)(), ".codex");
+  if (!state.iterations || state.iterations <= 0) return;
+  const codexHome = resolveCodexHome(context.env);
   const logPath = findCodexSessionLog(runtimeSessionId, codexHome);
   if (!logPath) return;
-  const allLines = (0, import_fs4.readFileSync)(logPath, "utf8").split(/\r?\n/).filter(Boolean);
+  const allLines = (0, import_fs5.readFileSync)(logPath, "utf8").split(/\r?\n/).filter(Boolean);
   const latestUserLineIndex = latestUserMessageLineIndex(allLines);
   const lines = latestUserLineIndex >= 0 ? allLines.slice(latestUserLineIndex + 1) : allLines;
+  const streamedToolIds = state.codexStreamedToolIds ?? /* @__PURE__ */ new Set();
   const emittedToolIds = /* @__PURE__ */ new Set();
   for (const line of lines) {
     const entry = parseJsonObject(line);
@@ -17174,6 +17503,7 @@ async function replayCodexMcpToolEventsFromSessionLog(context, state) {
       const name = typeof payload.name === "string" ? payload.name : "";
       const namespace = typeof payload.namespace === "string" ? payload.namespace : "";
       if (!callId || !name || !namespace.startsWith("mcp__")) continue;
+      if (streamedToolIds.has(callId)) continue;
       const toolName = `${namespace.replace(/_+$/, "")}__${name}`;
       context.presenter.onToolUse(toolName, parseMaybeJson(payload.arguments), callId);
       emittedToolIds.add(callId);
@@ -17182,6 +17512,7 @@ async function replayCodexMcpToolEventsFromSessionLog(context, state) {
     if (payload.type === "tool_search_call") {
       const callId = typeof payload.call_id === "string" ? payload.call_id : "";
       if (!callId) continue;
+      if (streamedToolIds.has(callId)) continue;
       context.presenter.onToolUse("tool_search", payload.arguments ?? {}, callId);
       emittedToolIds.add(callId);
       continue;
@@ -17208,6 +17539,63 @@ async function replayCodexMcpToolEventsFromSessionLog(context, state) {
     }
   }
 }
+var CODEX_EXIT_GRACE_MS = 3e4;
+function armCodexExitGraceKill(state) {
+  if (state.exitGraceKillTimer) return;
+  const child = state.process;
+  if (!child) return;
+  const timer = setTimeout(() => {
+    if (child.exitCode !== null || child.killed) return;
+    console.warn(
+      "[codex_app_server] Process did not exit after turn completion; killing process group"
+    );
+    const pid = child.pid;
+    if (pid) {
+      try {
+        process.kill(-pid, "SIGTERM");
+        return;
+      } catch {
+      }
+    }
+    try {
+      child.kill("SIGTERM");
+    } catch {
+    }
+  }, CODEX_EXIT_GRACE_MS);
+  timer.unref?.();
+  state.exitGraceKillTimer = timer;
+}
+function disarmCodexExitGraceKill(state) {
+  if (!state.exitGraceKillTimer) return;
+  clearTimeout(state.exitGraceKillTimer);
+  state.exitGraceKillTimer = void 0;
+}
+function trackCodexStreamedToolId(state, toolId) {
+  if (!state.codexStreamedToolIds) state.codexStreamedToolIds = /* @__PURE__ */ new Set();
+  if (state.codexStreamedToolIds.has(toolId)) return false;
+  state.codexStreamedToolIds.add(toolId);
+  return true;
+}
+function buildCodexMcpToolName(item) {
+  const server = typeof item.server === "string" ? item.server.replace(/_+$/, "") : "";
+  const tool = typeof item.tool === "string" ? item.tool : typeof item.tool_name === "string" ? item.tool_name : "";
+  if (server && tool) return `mcp__${server}__${tool}`;
+  return tool || "MCP Tool";
+}
+function emitCodexFileChanges(context, state, itemId, changes) {
+  changes.forEach((change, index) => {
+    if (!change || typeof change !== "object") return;
+    const record = change;
+    const filePath = typeof record.path === "string" ? record.path : "";
+    if (!filePath) return;
+    const kind = typeof record.kind === "string" ? record.kind : "update";
+    const toolName = kind === "add" ? "write_file" : "edit_file";
+    const toolId = changes.length > 1 ? `${itemId}:${index}` : itemId;
+    trackCodexStreamedToolId(state, toolId);
+    void context.presenter.onToolUse(toolName, { file_path: filePath, kind }, toolId);
+    void context.presenter.onToolResult?.(toolId, `${kind} ${filePath}`);
+  });
+}
 function handleCodexStructuredEvent(parsed, context, state) {
   const presenter = context.presenter;
   const type = typeof parsed.type === "string" ? parsed.type : "";
@@ -17235,6 +17623,7 @@ function handleCodexStructuredEvent(parsed, context, state) {
     case "thread.started":
       return true;
     case "turn.started":
+      disarmCodexExitGraceKill(state);
       state.iterations += 1;
       return true;
     case "session_configured":
@@ -17243,36 +17632,112 @@ function handleCodexStructuredEvent(parsed, context, state) {
       }
       return true;
     case "task_started":
+      disarmCodexExitGraceKill(state);
       state.iterations += 1;
       return true;
     case "item.started": {
       const item = typeof parsed.item === "object" && parsed.item !== null ? parsed.item : null;
-      if (!item || item.type !== "command_execution" || typeof item.id !== "string") return true;
-      const command = typeof item.command === "string" ? item.command : "";
-      void presenter.onToolUse("Bash", { command, cwd: context.cwd }, item.id);
-      return true;
+      if (!item || typeof item.type !== "string" || typeof item.id !== "string") return true;
+      switch (item.type) {
+        case "command_execution": {
+          if (trackCodexStreamedToolId(state, item.id)) {
+            const command = typeof item.command === "string" ? item.command : "";
+            void presenter.onToolUse("Bash", { command, cwd: context.cwd }, item.id);
+          }
+          return true;
+        }
+        case "mcp_tool_call": {
+          if (trackCodexStreamedToolId(state, item.id)) {
+            const input = typeof item.arguments === "object" && item.arguments !== null ? item.arguments : {};
+            void presenter.onToolUse(buildCodexMcpToolName(item), input, item.id);
+          }
+          return true;
+        }
+        case "web_search": {
+          if (trackCodexStreamedToolId(state, item.id)) {
+            const query = typeof item.query === "string" ? item.query : "";
+            void presenter.onToolUse("web_search", { query }, item.id);
+          }
+          return true;
+        }
+        // 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":
+        case "agent_message":
+        case "file_change":
+        case "todo_list":
+          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;
-      if (item.type === "reasoning" && typeof item.text === "string") {
-        void presenter.onThinking(item.text);
-        return true;
-      }
-      if (item.type === "agent_message" && typeof item.text === "string") {
-        state.summary += `${item.text}
+      switch (item.type) {
+        case "reasoning": {
+          if (typeof item.text === "string") void presenter.onThinking(item.text);
+          return true;
+        }
+        case "agent_message": {
+          if (typeof item.text === "string") {
+            state.summary += `${item.text}
 `;
-        void presenter.onAssistantText(item.text);
-        return true;
-      }
-      if (item.type === "command_execution" && typeof item.id === "string") {
-        const output = typeof item.aggregated_output === "string" ? item.aggregated_output : "";
-        const itemExitCode = typeof item.exit_code === "number" ? item.exit_code : null;
-        const resultText = output.trim().length > 0 ? output : itemExitCode === null ? "" : `Exit code: ${itemExitCode}`;
-        void presenter.onToolResult?.(item.id, resultText);
-        return true;
+            void presenter.onAssistantText(item.text);
+          }
+          return true;
+        }
+        case "command_execution": {
+          if (typeof item.id !== "string") return true;
+          if (trackCodexStreamedToolId(state, item.id)) {
+            const command = typeof item.command === "string" ? item.command : "";
+            void presenter.onToolUse("Bash", { command, cwd: context.cwd }, item.id);
+          }
+          const output = typeof item.aggregated_output === "string" ? item.aggregated_output : "";
+          const itemExitCode = typeof item.exit_code === "number" ? item.exit_code : null;
+          const resultText = output.trim().length > 0 ? output : itemExitCode === null ? "" : `Exit code: ${itemExitCode}`;
+          void presenter.onToolResult?.(
+            item.id,
+            resultText,
+            itemExitCode != null && itemExitCode !== 0
+          );
+          return true;
+        }
+        case "mcp_tool_call": {
+          if (typeof item.id !== "string") return true;
+          if (trackCodexStreamedToolId(state, item.id)) {
+            const input = typeof item.arguments === "object" && item.arguments !== null ? item.arguments : {};
+            void presenter.onToolUse(buildCodexMcpToolName(item), input, item.id);
+          }
+          const isError = item.status === "failed" || item.error != null;
+          const payload = item.result ?? item.output ?? item.error ?? {};
+          const resultText = typeof payload === "string" ? payload : JSON.stringify(payload ?? {}, null, 2);
+          void presenter.onToolResult?.(item.id, resultText, isError);
+          return true;
+        }
+        case "file_change": {
+          if (typeof item.id !== "string") return true;
+          const changes = Array.isArray(item.changes) ? item.changes : [];
+          emitCodexFileChanges(context, state, item.id, changes);
+          return true;
+        }
+        case "web_search": {
+          if (typeof item.id !== "string") return true;
+          const query = typeof item.query === "string" ? item.query : "";
+          if (trackCodexStreamedToolId(state, item.id)) {
+            void presenter.onToolUse("web_search", { query }, item.id);
+          }
+          void presenter.onToolResult?.(item.id, query ? `Searched: ${query}` : "");
+          return true;
+        }
+        case "todo_list": {
+          const todos = Array.isArray(item.items) ? item.items : [];
+          void presenter.onTodoWrite?.(todos);
+          return true;
+        }
+        default:
+          return false;
       }
-      return true;
     }
     case "agent_message_delta":
     case "agent_message_content_delta": {
@@ -17294,6 +17759,7 @@ function handleCodexStructuredEvent(parsed, context, state) {
       const toolId = typeof parsed.call_id === "string" ? parsed.call_id : `exec-${Date.now()}`;
       const command = Array.isArray(parsed.command) ? parsed.command.join(" ") : "";
       const cwd = typeof parsed.cwd === "string" ? parsed.cwd : context.cwd;
+      trackCodexStreamedToolId(state, toolId);
       void presenter.onToolUse("Bash", { command, cwd }, toolId);
       return true;
     }
@@ -17307,6 +17773,7 @@ function handleCodexStructuredEvent(parsed, context, state) {
       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);
       return true;
     }
@@ -17344,6 +17811,8 @@ function handleCodexStructuredEvent(parsed, context, state) {
     case "task_complete": {
       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);
       return true;
     }
     case "turn.completed": {
@@ -17365,6 +17834,8 @@ function handleCodexStructuredEvent(parsed, context, state) {
         cacheReadTokens: state.usage.cacheReadTokens,
         cacheCreationTokens: state.usage.cacheCreationTokens
       });
+      state.error = void 0;
+      armCodexExitGraceKill(state);
       return true;
     }
     case "error": {
@@ -17409,6 +17880,33 @@ function createCodexRuntimeBackend(command = "codex", defaultArgs = []) {
         context.config.images,
         context.cwd
       );
+      const requestedResumeId = context.config.runtimeSessionId?.trim() || context.config.providerSessionId?.trim();
+      let resumableSessionId = requestedResumeId;
+      let resumeContextPrefix;
+      if (requestedResumeId && !findCodexSessionLog(requestedResumeId, resolveCodexHome(context.env))) {
+        resumableSessionId = void 0;
+        resumeContextPrefix = context.config.resumeFallbackContext?.trim() || void 0;
+        console.warn(
+          `[codex_app_server] No rollout log found for session ${requestedResumeId}; starting a fresh session instead of resuming`
+        );
+        logResumeObservability("agent_resume_fallback_used", {
+          backendKind: "codex_app_server",
+          reason: "rollout_log_missing",
+          requestedResumeId,
+          hadFallbackContext: Boolean(resumeContextPrefix)
+        });
+        emitSessionNotice(
+          context.presenter,
+          "session_resume_failed",
+          resumeContextPrefix ? "The previous Codex session log was not found on this machine, so a fresh session was started with the recent conversation history re-included." : "The previous Codex session log was not found on this machine, so a fresh session was started. Earlier conversation context may be missing from this reply."
+        );
+      }
+      if (resumableSessionId) {
+        logResumeObservability("agent_resume_requested", {
+          backendKind: "codex_app_server",
+          requestedResumeId: resumableSessionId
+        });
+      }
       try {
         return await createGenericCliBackend({
           kind: "codex_app_server",
@@ -17417,15 +17915,10 @@ function createCodexRuntimeBackend(command = "codex", defaultArgs = []) {
           args: [],
           startupTimeoutMs: CODEX_STARTUP_TIMEOUT_MS,
           buildArgs: (ctx) => {
-            const resumeId = ctx.config.runtimeSessionId?.trim() || ctx.config.providerSessionId?.trim();
+            const resumeId = resumableSessionId;
             const modelArgs = ctx.config.selectedModel?.trim() ? ["--model", ctx.config.selectedModel.trim()] : [];
             const effortArgs = buildCodexEffortArgs(ctx.config.selectedEffortLevel);
-            const permissionArgs = [
-              "--ask-for-approval",
-              "never",
-              "--sandbox",
-              "danger-full-access"
-            ];
+            const permissionArgs = getCodexPermissionArgs(ctx.config);
             const imageArgs = imagePaths.flatMap((p) => ["--image", p]);
             const baseArgs = resumeId ? [
               ...permissionArgs,
@@ -17452,7 +17945,10 @@ function createCodexRuntimeBackend(command = "codex", defaultArgs = []) {
           },
           promptViaStdin: true,
           augmentPrompt: (ctx) => {
-            const basePrompt = buildPromptWithSystem(ctx.config, ctx.promptText);
+            const promptWithContext = resumeContextPrefix ? `${resumeContextPrefix}
+
+${ctx.promptText}` : ctx.promptText;
+            const basePrompt = buildPromptWithSystem(ctx.config, promptWithContext);
             return ctx.config.mode === "plan" ? buildPlanModePrefix(basePrompt) : basePrompt;
           },
           parseStructuredLine: parseCodexStructuredLine,
@@ -17779,7 +18275,10 @@ function buildCursorAgentModelArg(modelId, options) {
   return `${parsed.baseId}[${overrides.join(",")}]`;
 }
 function isCursorAgentCliModelId(model) {
-  return model === "auto" || /^composer-/.test(model) || /^gpt-\d/.test(model) || /^claude-\d/.test(model) || /^gemini-\d/.test(model) || /^grok-\d/.test(model) || /^kimi-/.test(model);
+  return model === "auto" || /^composer-/.test(model) || /^gpt-/.test(model) || /^claude-/.test(model) || /^gemini-/.test(model) || /^grok-/.test(model) || /^kimi-/.test(model);
+}
+function isDispatchableCursorModel(model) {
+  return isCursorAgentCliModelId(model) || Boolean(findModelDef("cursor_agent_cli", model));
 }
 function shouldForceCursorAgent(config) {
   if (shouldUseReadOnlyRuntimePermissions(config)) return false;
@@ -17797,6 +18296,21 @@ function createCursorAgentCliBackend(command = "cursor-agent", defaultArgs = [])
     kind: "cursor_agent_cli",
     supportTier: "structured",
     async run(context) {
+      const selectedModel = context.config.selectedModel?.trim();
+      if (selectedModel && !isDispatchableCursorModel(selectedModel)) {
+        const message = `Model "${selectedModel}" is not supported by cursor-agent. Pick a cursor-agent model (or "auto") and send your message again.`;
+        return {
+          success: false,
+          summary: message,
+          filesModified: [],
+          planFilesCreated: [],
+          iterations: 0,
+          error: message,
+          errorKind: "model_mismatch",
+          backendKind: "cursor_agent_cli",
+          supportTier: "structured"
+        };
+      }
       const { files: imageFiles, cleanup } = writeImagesToTempFiles(
         context.config.images,
         context.cwd
@@ -17826,10 +18340,18 @@ function createCursorAgentCliBackend(command = "cursor-agent", defaultArgs = [])
               args.push("--mode", "plan");
             } else if (ctx.config.mode === "ask") {
               args.push("--mode", "ask");
+            } else if (shouldUseReadOnlyRuntimePermissions(ctx.config)) {
+              args.push("--mode", "plan");
+            }
+            if (resumeId) {
+              args.push("--resume", resumeId);
+              logResumeObservability("agent_resume_requested", {
+                backendKind: "cursor_agent_cli",
+                requestedResumeId: resumeId
+              });
             }
-            if (resumeId) args.push("--resume", resumeId);
             const model = ctx.config.selectedModel?.trim();
-            if (model && isCursorAgentCliModelId(model)) {
+            if (model && isDispatchableCursorModel(model)) {
               const modelDef = findModelDef("cursor_agent_cli", model);
               args.push(
                 "--model",
@@ -18292,9 +18814,9 @@ function buildGrokAgentArgs(config, defaultArgs = []) {
   return args;
 }
 var DEFAULT_SKILL_ROOTS = [
-  (0, import_path5.join)((0, import_os5.homedir)(), ".agents", "skills"),
-  (0, import_path5.join)((0, import_os5.homedir)(), ".claude", "skills"),
-  (0, import_path5.join)((0, import_os5.homedir)(), ".config", "opencode", "skills")
+  (0, import_path6.join)((0, import_os6.homedir)(), ".agents", "skills"),
+  (0, import_path6.join)((0, import_os6.homedir)(), ".claude", "skills"),
+  (0, import_path6.join)((0, import_os6.homedir)(), ".config", "opencode", "skills")
 ];
 function parseFrontmatter(content) {
   if (!content.startsWith("---\n")) return {};
@@ -18310,12 +18832,12 @@ function parseFrontmatter(content) {
   return result;
 }
 function listSkillFiles(root) {
-  if (!(0, import_fs5.existsSync)(root)) return [];
+  if (!(0, import_fs6.existsSync)(root)) return [];
   const files = [];
-  for (const entry of (0, import_fs5.readdirSync)(root, { withFileTypes: true })) {
+  for (const entry of (0, import_fs6.readdirSync)(root, { withFileTypes: true })) {
     if (!entry.isDirectory()) continue;
-    const skillPath = (0, import_path5.join)(root, entry.name, "SKILL.md");
-    if ((0, import_fs5.existsSync)(skillPath)) files.push(skillPath);
+    const skillPath = (0, import_path6.join)(root, entry.name, "SKILL.md");
+    if ((0, import_fs6.existsSync)(skillPath)) files.push(skillPath);
   }
   return files;
 }
@@ -18324,7 +18846,7 @@ function loadInstalledSkills(roots = DEFAULT_SKILL_ROOTS) {
   for (const root of roots) {
     for (const skillPath of listSkillFiles(root)) {
       try {
-        const frontmatter = parseFrontmatter((0, import_fs5.readFileSync)(skillPath, "utf8"));
+        const frontmatter = parseFrontmatter((0, import_fs6.readFileSync)(skillPath, "utf8"));
         const name = frontmatter.name;
         const description = frontmatter.description;
         if (!name || !description || skills.has(name)) continue;
@@ -18757,7 +19279,31 @@ function createSupatestCliBackend(command = "supatest", defaultArgs = []) {
         "--permission-mode",
         getClaudePermissionMode(context.config)
       ];
-      const resumeId = context.config.runtimeSessionId?.trim() || context.config.providerSessionId?.trim();
+      const requestedResumeId = context.config.runtimeSessionId?.trim() || context.config.providerSessionId?.trim();
+      let resumeId = requestedResumeId;
+      let resumeContextPrefix;
+      if (requestedResumeId && !claudeSessionLogExists({
+        sessionId: requestedResumeId,
+        cwd: context.cwd,
+        home: resolveClaudeHome(context.env, "supatest")
+      })) {
+        resumeId = void 0;
+        resumeContextPrefix = context.config.resumeFallbackContext?.trim() || void 0;
+        console.warn(
+          `[supatest_cli] No session log for ${requestedResumeId} under cwd ${context.cwd}; starting a fresh session instead of resuming`
+        );
+        logResumeObservability("agent_resume_fallback_used", {
+          backendKind: "supatest_cli",
+          reason: "session_log_missing_for_cwd",
+          requestedResumeId,
+          hadFallbackContext: Boolean(resumeContextPrefix)
+        });
+        emitSessionNotice(
+          context.presenter,
+          "session_resume_failed",
+          resumeContextPrefix ? "The previous session was created in a different working directory and could not be resumed here, so a fresh session was started with the recent conversation history re-included." : "The previous session was created in a different working directory and could not be resumed here, so a fresh session was started. Earlier conversation context may be missing from this reply."
+        );
+      }
       if (!resumeId) {
         if (context.config.systemPrompt?.trim()) {
           args.push("--system-prompt", context.config.systemPrompt.trim());
@@ -18773,6 +19319,10 @@ function createSupatestCliBackend(command = "supatest", defaultArgs = []) {
       if (resumeId) {
         args.push("--resume", resumeId);
         console.info("[supatest_cli] Resuming session", { resumeId });
+        logResumeObservability("agent_resume_requested", {
+          backendKind: "supatest_cli",
+          requestedResumeId: resumeId
+        });
       }
       args.push(...defaultArgs);
       return createGenericCliBackend({
@@ -18791,7 +19341,10 @@ function createSupatestCliBackend(command = "supatest", defaultArgs = []) {
               });
             }
           }
-          const promptText = ctx.config.mode === "plan" ? buildPlanModePrefix(buildPromptWithSystem(ctx.config, ctx.promptText)) : buildPromptWithSystem(ctx.config, ctx.promptText);
+          const basePromptText = resumeContextPrefix ? `${resumeContextPrefix}
+
+${ctx.promptText}` : ctx.promptText;
+          const promptText = ctx.config.mode === "plan" ? buildPlanModePrefix(buildPromptWithSystem(ctx.config, basePromptText)) : buildPromptWithSystem(ctx.config, basePromptText);
           if (promptText.trim()) {
             contentBlocks.push({ type: "text", text: promptText });
           }
@@ -18821,40 +19374,40 @@ function parseSkillInvocation(text) {
 function candidateRoots(cwd) {
   const roots = [];
   if (cwd) {
-    roots.push((0, import_path6.join)(cwd, ".agents", "skills"));
-    roots.push((0, import_path6.join)(cwd, ".claude", "skills"));
-    roots.push((0, import_path6.join)(cwd, ".codex", "skills"));
-    if ((0, import_fs6.existsSync)(cwd)) {
+    roots.push((0, import_path7.join)(cwd, ".agents", "skills"));
+    roots.push((0, import_path7.join)(cwd, ".claude", "skills"));
+    roots.push((0, import_path7.join)(cwd, ".codex", "skills"));
+    if ((0, import_fs7.existsSync)(cwd)) {
       let entries = [];
       try {
-        entries = (0, import_fs6.readdirSync)(cwd, { withFileTypes: true });
+        entries = (0, import_fs7.readdirSync)(cwd, { withFileTypes: true });
       } catch {
       }
       for (const entry of entries) {
         if (!entry.isDirectory()) continue;
         if (entry.name.startsWith(".")) continue;
-        const child = (0, import_path6.join)(cwd, entry.name);
-        roots.push((0, import_path6.join)(child, ".agents", "skills"));
-        roots.push((0, import_path6.join)(child, ".claude", "skills"));
-        roots.push((0, import_path6.join)(child, ".codex", "skills"));
+        const child = (0, import_path7.join)(cwd, entry.name);
+        roots.push((0, import_path7.join)(child, ".agents", "skills"));
+        roots.push((0, import_path7.join)(child, ".claude", "skills"));
+        roots.push((0, import_path7.join)(child, ".codex", "skills"));
       }
     }
   }
-  const home = (0, import_os6.homedir)();
-  roots.push((0, import_path6.join)(home, ".agents", "skills"));
-  roots.push((0, import_path6.join)(home, ".claude", "skills"));
-  roots.push((0, import_path6.join)(home, ".codex", "skills"));
+  const home = (0, import_os7.homedir)();
+  roots.push((0, import_path7.join)(home, ".agents", "skills"));
+  roots.push((0, import_path7.join)(home, ".claude", "skills"));
+  roots.push((0, import_path7.join)(home, ".codex", "skills"));
   return Array.from(new Set(roots));
 }
 function resolveSkillInvocation(text, cwd) {
   const parsed = parseSkillInvocation(text);
   if (!parsed) return null;
   for (const root of candidateRoots(cwd)) {
-    const skillPath = (0, import_path6.join)(root, parsed.command, "SKILL.md");
-    if (!(0, import_fs6.existsSync)(skillPath)) continue;
+    const skillPath = (0, import_path7.join)(root, parsed.command, "SKILL.md");
+    if (!(0, import_fs7.existsSync)(skillPath)) continue;
     let content;
     try {
-      content = (0, import_fs6.readFileSync)(skillPath, "utf-8");
+      content = (0, import_fs7.readFileSync)(skillPath, "utf-8");
     } catch {
       continue;
     }
@@ -19035,11 +19588,19 @@ var BaseMachineAgent = class _BaseMachineAgent {
   async runBackendWithActivityHeartbeat(backend, context) {
     const intervalMs = this.getActivityHeartbeatIntervalMs();
     let heartbeat = null;
+    let livenessProbe = null;
+    context.registerLivenessProbe = (probe) => {
+      livenessProbe = probe;
+    };
+    const emitHeartbeat = () => {
+      const evidence = livenessProbe?.();
+      void this.presenter.onActivity?.("background_work", evidence);
+    };
     if (this.presenter.onActivity && intervalMs > 0) {
-      void this.presenter.onActivity("background_work");
+      emitHeartbeat();
       heartbeat = setInterval(() => {
         if (!context.abortController.signal.aborted) {
-          void this.presenter.onActivity?.("background_work");
+          emitHeartbeat();
         }
       }, intervalMs);
     }
@@ -19088,10 +19649,6 @@ var BaseMachineAgent = class _BaseMachineAgent {
     if (agentPrompt) systemPromptParts.push(agentPrompt);
     const modeHint = getAlanModePrompt(config.mode);
     if (modeHint) systemPromptParts.push(modeHint);
-    systemPromptParts.push(ALAN_ASK_USER_PROMPT);
-    if (backendKind === "cursor_agent_cli") {
-      systemPromptParts.push(ALAN_CURSOR_ASK_USER_OVERLAY);
-    }
     const operatorSystemPrompt = config.systemPrompt?.trim();
     if (operatorSystemPrompt) systemPromptParts.push(operatorSystemPrompt);
     const workingDir = config.worktreePath || safeProjectPath;
@@ -19164,6 +19721,7 @@ Prefer relative paths and keep your work scoped to this project.`
       };
       if (lastResult.success || !lastResult.error) break;
       if (this.abortController?.signal.aborted) break;
+      if (lastResult.errorKind === "model_mismatch") break;
       const hadResumeId = runtimeConfig.runtimeSessionId || runtimeConfig.providerSessionId;
       if (hadResumeId && !isTransientError(lastResult.error)) {
         const overrideResult = await this.onSessionResumeFailure(runtimeConfig, lastResult);
@@ -19175,10 +19733,25 @@ Prefer relative paths and keep your work scoped to this project.`
           "[base-machine-agent] Resume failed, retrying without session ID:",
           lastResult.error
         );
+        const fallbackContext = runtimeConfig.resumeFallbackContext?.trim();
+        logResumeObservability("agent_resume_fallback_used", {
+          backendKind: backend.kind,
+          reason: "retry_fresh_after_resume_failure",
+          errorKind: lastResult.errorKind,
+          hadFallbackContext: Boolean(fallbackContext)
+        });
+        emitSessionNotice(
+          this.presenter,
+          "session_resume_failed",
+          fallbackContext ? "Could not resume the previous session; started a fresh session with the recent conversation history re-included." : "Could not resume the previous session; retrying with a fresh session. Earlier conversation context may be missing from this reply."
+        );
         runtimeConfig = {
           ...runtimeConfig,
           runtimeSessionId: void 0,
-          providerSessionId: void 0
+          providerSessionId: void 0,
+          ...fallbackContext ? { task: `${fallbackContext}
+
+${runtimeConfig.task}` } : {}
         };
         const retryResult = await this.runBackendWithActivityHeartbeat(backend, {
           presenter: this.presenter,
@@ -19186,7 +19759,7 @@ Prefer relative paths and keep your work scoped to this project.`
           abortController: this.abortController,
           cwd,
           env,
-          promptText,
+          promptText: fallbackContext ? this.buildPromptText(runtimeConfig) : promptText,
           onProcessSpawned: this.getOnProcessSpawned()
         });
         lastResult = {
@@ -19382,14 +19955,14 @@ function normalizePath(candidate, cwd) {
   } catch {
   }
   if (path.startsWith("~/")) return null;
-  if ((0, import_path7.isAbsolute)(path)) return path;
-  return cwd ? (0, import_path7.join)(cwd, path) : null;
+  if ((0, import_path8.isAbsolute)(path)) return path;
+  return cwd ? (0, import_path8.join)(cwd, path) : null;
 }
 function resolveToolCwd(cwd, toolInput) {
   if (!isRecord(toolInput)) return cwd;
   const raw = typeof toolInput.cwd === "string" ? toolInput.cwd : typeof toolInput.workdir === "string" ? toolInput.workdir : typeof toolInput.workingDirectory === "string" ? toolInput.workingDirectory : null;
   if (!raw) return cwd;
-  return (0, import_path7.isAbsolute)(raw) || !cwd ? raw : (0, import_path7.join)(cwd, raw);
+  return (0, import_path8.isAbsolute)(raw) || !cwd ? raw : (0, import_path8.join)(cwd, raw);
 }
 function extractBrowserMediaPathHints(content, cwd, toolName, options = {}, kind = "video") {
   if (!isAgentBrowserMediaInvocation(toolName, content, options.toolInput, kind)) return [];
@@ -19432,19 +20005,19 @@ function extractGeneratedImagesFromToolResult(toolId, content, cwd, toolName, op
   const effectiveCwd = resolveToolCwd(cwd, options.toolInput);
   for (const candidate of extractPathCandidates(content, options)) {
     const path = normalizePath(candidate, effectiveCwd);
-    if (!path || seen.has(path) || !(0, import_fs7.existsSync)(path)) continue;
+    if (!path || seen.has(path) || !(0, import_fs8.existsSync)(path)) continue;
     seen.add(path);
-    const ext = (0, import_path7.extname)(path).toLowerCase();
+    const ext = (0, import_path8.extname)(path).toLowerCase();
     const mimeType = IMAGE_MIME_BY_EXT[ext];
     if (!mimeType) continue;
-    const stat = (0, import_fs7.statSync)(path);
+    const stat = (0, import_fs8.statSync)(path);
     if (!stat.isFile() || stat.size <= 0 || stat.size > MAX_GENERATED_IMAGE_BYTES) continue;
-    const buffer = (0, import_fs7.readFileSync)(path);
+    const buffer = (0, import_fs8.readFileSync)(path);
     const { width, height } = readImageDimensions2(buffer, mimeType);
     images.push({
       type: "generated_image",
       id: (0, import_crypto3.randomUUID)(),
-      filename: (0, import_path7.basename)(path),
+      filename: (0, import_path8.basename)(path),
       mimeType,
       size: buffer.length,
       width,
@@ -19471,20 +20044,20 @@ function extractSessionMediaFromToolResult(toolId, content, cwd, toolName, optio
   const mimeByExt = kind === "video" ? VIDEO_MIME_BY_EXT : IMAGE_MIME_BY_EXT;
   for (const candidate of extractPathCandidates(content, options, extensionsPattern)) {
     const path = normalizePath(candidate, effectiveCwd);
-    if (!path || seen.has(path) || !(0, import_fs7.existsSync)(path)) continue;
+    if (!path || seen.has(path) || !(0, import_fs8.existsSync)(path)) continue;
     seen.add(path);
-    const ext = (0, import_path7.extname)(path).toLowerCase();
+    const ext = (0, import_path8.extname)(path).toLowerCase();
     const mimeType = mimeByExt[ext];
     if (!mimeType) continue;
-    const stat = (0, import_fs7.statSync)(path);
+    const stat = (0, import_fs8.statSync)(path);
     if (!stat.isFile() || stat.size <= 0 || stat.size > maxBytes) continue;
-    const buffer = (0, import_fs7.readFileSync)(path);
+    const buffer = (0, import_fs8.readFileSync)(path);
     const dimensions = kind === "image" ? readImageDimensions2(buffer, mimeType) : null;
     media.push({
       type: "session_media",
       kind,
       id: (0, import_crypto3.randomUUID)(),
-      filename: (0, import_path7.basename)(path),
+      filename: (0, import_path8.basename)(path),
       mimeType,
       size: buffer.length,
       width: dimensions?.width,
@@ -19648,6 +20221,10 @@ var CoreAgent = class _CoreAgent extends BaseMachineAgent {
     if (!this.childProcess) return false;
     const stdin = this.childProcess.stdin;
     if (!stdin || stdin.destroyed) return false;
+    if (this.presenter.hasKnownToolUse && !this.presenter.hasKnownToolUse(toolId)) {
+      console.warn(`[CoreAgent] Ignoring tool_response for unknown tool ${toolId}`);
+      return false;
+    }
     try {
       let message;
       if (this.presenter.pendingAskUserToolIds?.has(toolId)) {
@@ -19902,6 +20479,9 @@ function decodeKey(encodedKey) {
 function isTerminal(event) {
   return TERMINAL_EVENT_TYPES.has(event.type);
 }
+function isBackgroundHeartbeat(event) {
+  return event.type === "activity" && event.status === "background_work";
+}
 function truncateUtf8(value2, maxBytes) {
   const encoded = Buffer.from(value2, "utf8");
   if (encoded.length <= maxBytes) return value2;
@@ -20050,6 +20630,23 @@ var EncryptedEventOutbox = class {
   isDroppable(entry) {
     return entry.eventId !== this.inFlightEventId && entry.kind !== "condensation_marker" && !isTerminal(entry.event);
   }
+  /**
+   * Pick the next droppable entry to evict. Heartbeats are always evicted
+   * first (oldest heartbeat first) since they carry no transcript content;
+   * only once none remain do we fall back to the oldest droppable entry of
+   * any kind. Without this, oldest-first eviction treats a background_work
+   * heartbeat exactly like real transcript content, so a long offline stretch
+   * (heartbeats every 10s, never removed by an ack since nothing is
+   * connected) evicts genuine early events — including `start` — ahead of
+   * the heartbeats that caused the overflow.
+   */
+  pickDropCandidate(matches) {
+    const heartbeat = this.entries.find(
+      (entry) => matches(entry) && this.isDroppable(entry) && isBackgroundHeartbeat(entry.event)
+    );
+    if (heartbeat) return heartbeat;
+    return this.entries.find((entry) => matches(entry) && this.isDroppable(entry));
+  }
   ensureCondensationMarker(runId, conversationId) {
     if (this.entries.some((entry) => entry.runId === runId && entry.kind === "condensation_marker")) {
       return;
@@ -20077,7 +20674,7 @@ var EncryptedEventOutbox = class {
     const runIds = preferredRunId ? [preferredRunId] : [...new Set(this.entries.map((entry) => entry.runId))];
     for (const runId of runIds) {
       while (this.entries.filter((entry) => entry.runId === runId && this.isDroppable(entry)).length > this.maxIntermediateEventsPerRun) {
-        const drop = this.entries.find((entry) => entry.runId === runId && this.isDroppable(entry));
+        const drop = this.pickDropCandidate((entry) => entry.runId === runId);
         if (!drop) break;
         this.entries = this.entries.filter((entry) => entry.eventId !== drop.eventId);
         lossCountByRunId.set(runId, (lossCountByRunId.get(runId) ?? 0) + 1);
@@ -20085,7 +20682,7 @@ var EncryptedEventOutbox = class {
       }
     }
     while (encryptedFileSize(this.entries) > this.maxEncryptedBytes) {
-      const drop = this.entries.find((entry) => this.isDroppable(entry));
+      const drop = this.pickDropCandidate(() => true);
       if (drop) {
         this.entries = this.entries.filter((entry) => entry.eventId !== drop.eventId);
         lossCountByRunId.set(drop.runId, (lossCountByRunId.get(drop.runId) ?? 0) + 1);
@@ -20104,7 +20701,7 @@ var EncryptedEventOutbox = class {
       this.ensureCondensationMarker(runId, lossConversationByRunId.get(runId));
     }
     while (encryptedFileSize(this.entries) > this.maxEncryptedBytes) {
-      const drop = this.entries.find((entry) => this.isDroppable(entry));
+      const drop = this.pickDropCandidate(() => true);
       if (!drop) break;
       this.entries = this.entries.filter((entry) => entry.eventId !== drop.eventId);
       lossCountByRunId.set(drop.runId, (lossCountByRunId.get(drop.runId) ?? 0) + 1);
@@ -21029,6 +21626,10 @@ function assertValidExistingToml(path, content) {
     `Existing config is malformed; no changes were applied. Review the backup at ${backupPath}`
   );
 }
+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);
@@ -21038,7 +21639,7 @@ function mergeCodexAlanSection(path, existingContent, desiredContent) {
   for (const line of lines) {
     const section = line.trim().match(/^\[([^\]]+)]$/)?.[1];
     if (section) {
-      insideAlanSection = section === "mcp_servers.alan";
+      insideAlanSection = isCodexAlanTomlSection(section);
     }
     if (!insideAlanSection) retained.push(line);
   }
@@ -21403,6 +22004,10 @@ var ANTIGRAVITY_MODEL_DISCOVERY_TIMEOUT_MS = 12e3;
 var OPENCODE_ZEN_MODEL_IDS = OPENCODE_ZEN_MODELS.map((model) => model.id);
 var CLAUDE_MODEL_ID_PATTERN = /claude-(?:sonnet|opus|haiku|fable)-[a-z0-9][a-z0-9-]*/g;
 var CLAUDE_MODEL_ALIASES = ["sonnet", "opus", "haiku", "fable"];
+var CLAUDE_MODEL_QUALIFIER_SEGMENTS = /* @__PURE__ */ new Set(["fast", "thinking", "latest", "preview"]);
+var PROTECTED_CATALOG_MODEL_IDS = new Set(
+  AVAILABLE_MODELS.map((model) => model.id).filter((id) => id.length > 0)
+);
 var CATALOG_MODEL_IDS_BY_PROVIDER = Object.fromEntries(
   Object.entries(PROVIDER_MODELS).map(([provider, models]) => [
     provider,
@@ -21493,15 +22098,22 @@ function extractModelIdsFromLabeledList(value2) {
 }
 function isValidClaudeModelId(id) {
   if (CLAUDE_MODEL_ALIASES.includes(id)) return true;
-  if (!/^claude-(sonnet|opus|haiku|fable)-[a-z0-9][a-z0-9-]*$/.test(id)) return false;
+  const match = id.match(/^claude-(sonnet|opus|haiku|fable)-([a-z0-9][a-z0-9-]*)$/);
+  if (!match) return false;
   if (id.includes(".")) return false;
   if (/-\d{8}$/.test(id)) return false;
   if (/-v\d+$/.test(id)) return false;
+  for (const segment of match[2].split("-")) {
+    if (/^\d+$/.test(segment)) continue;
+    if (CLAUDE_MODEL_QUALIFIER_SEGMENTS.has(segment)) continue;
+    return false;
+  }
   return true;
 }
 function filterClaudePrefixModelIds(ids) {
   const set = new Set(ids);
   return ids.filter((id) => {
+    if (PROTECTED_CATALOG_MODEL_IDS.has(id)) return true;
     for (const other of set) {
       if (other !== id && other.startsWith(`${id}-`)) return false;
     }
@@ -21824,7 +22436,7 @@ var RunStartGate = class {
 };
 
 // src/version.ts
-var AGENT_VERSION = "0.1.37";
+var AGENT_VERSION = "0.1.39";
 
 // src/workspace-relocation.ts
 var import_node_child_process3 = require("child_process");
@@ -23180,14 +23792,29 @@ var USER_INTERRUPTED_RESULT = {
   filesModified: [],
   planFilesCreated: [],
   iterations: 0,
-  error: "Interrupted by user"
+  error: "Interrupted by user",
+  errorKind: "user"
 };
+function buildAbortResult(reason) {
+  if (reason === "user") return USER_INTERRUPTED_RESULT;
+  const message = SYSTEM_ABORT_RUN_ERRORS[reason];
+  return {
+    success: false,
+    summary: message,
+    filesModified: [],
+    planFilesCreated: [],
+    iterations: 0,
+    error: message,
+    errorKind: reason
+  };
+}
 function abortActiveAgent(entry, options) {
   const awaitingAsk = (entry.presenter.pendingAskUserToolIds?.size ?? 0) > 0;
   if (awaitingAsk && !options?.userInitiated) {
     return;
   }
-  entry.presenter.onComplete(USER_INTERRUPTED_RESULT);
+  const reason = options?.reason ?? (options?.userInitiated ? "user" : "runner_stalled");
+  entry.presenter.onComplete(buildAbortResult(reason));
   entry.agent.kill();
 }
 function isProviderProcessAlive(pid) {
@@ -23296,7 +23923,11 @@ function flushPendingDeliveryLostEvents(input) {
   if (input.pending.length === 0) return;
   for (const item of input.pending) {
     if (input.eventOutbox.hasTerminalEvent(item.runId)) continue;
-    if (!input.activeAgents.has(item.runId)) continue;
+    const activeEntry = input.activeAgents.get(item.runId);
+    if (activeEntry) {
+      if (activeEntry.stage === "delivery_lost") activeEntry.stage = "running";
+      continue;
+    }
     input.eventOutbox.enqueue(item.conversationId, item.runId, {
       type: "session_error",
       error: DELIVERY_LOST_ERROR
@@ -23320,7 +23951,7 @@ function reconcileActiveRuns(input) {
       input.pushLog?.(`reconciled dead provider pid run=${runId} (awaiting ask, no interrupt)`);
       continue;
     }
-    abortActiveAgent(entry);
+    abortActiveAgent(entry, { reason: staleByDeadPid ? "provider_exited" : "runner_stalled" });
     input.activeAgents.delete(runId);
     if (staleByDeadPid) {
       input.pushLog?.(`reconciled dead provider pid run=${runId}`);
@@ -23384,6 +24015,7 @@ var RuntimePresenter = class {
   emitEvent(event) {
     if (this.terminalFenced) return;
     this.touchRunnerActivity?.();
+    if (isBackgroundHeartbeat(event) && !this.socket.connected) return;
     this.eventOutbox.enqueue(this.conversationId, this.runId, event);
     this.eventOutbox.flush(this.socket);
   }
@@ -23411,6 +24043,9 @@ var RuntimePresenter = class {
   onLog(message) {
     console.error(message);
   }
+  onNotice(kind, message) {
+    this.emitEvent({ type: "session_notice", kind, message, ts: Date.now() });
+  }
   onAssistantText(text) {
     this.emitEvent({ type: "text", text, ts: Date.now() });
   }
@@ -23510,8 +24145,8 @@ var RuntimePresenter = class {
   onCheckpoint(id) {
     this.emitEvent({ type: "checkpoint", id });
   }
-  onActivity(status) {
-    this.emitEvent({ type: "activity", status, ts: Date.now() });
+  onActivity(status, evidence) {
+    this.emitEvent({ type: "activity", status, ts: Date.now(), ...evidence ? { evidence } : {} });
   }
   onOpenBrowserTab(browserId, url2) {
     this.emitEvent({ type: "open_browser_tab", browserId, ...url2 ? { url: url2 } : {} });
@@ -24297,16 +24932,22 @@ async function startDaemon(args) {
         flushWorkspaceRelocations();
       }
     }
-    if (workspaceReadiness.ready && expectedRepoUrls.length > 0 && !isAlanDefaultWorkspace(cwd) && !workspaceMatchesExpectedRepositories({
-      workspacePath: cwd,
-      expectedRepoUrls
-    })) {
-      socket.emit("agent.rejected", {
-        runId: payload.runId,
-        message: "This folder belongs to a different repository. Choose the correct project folder and try again.",
-        code: "workspace_repository_mismatch"
-      });
-      return;
+    if (workspaceReadiness.ready && expectedRepoUrls.length > 0 && !isAlanDefaultWorkspace(cwd)) {
+      const worktreePaths = payload.worktreeInfo?.allWorktrees?.map((worktree) => worktree.worktreePath).filter((worktreePath) => Boolean(worktreePath));
+      const repositoryMismatch = worktreePaths && worktreePaths.length > 0 ? worktreePaths.some(
+        (worktreePath) => !workspaceMatchesExpectedRepositories({
+          workspacePath: worktreePath,
+          expectedRepoUrls
+        })
+      ) : !workspaceMatchesExpectedRepositories({ workspacePath: cwd, expectedRepoUrls });
+      if (repositoryMismatch) {
+        socket.emit("agent.rejected", {
+          runId: payload.runId,
+          message: "This folder belongs to a different repository. Choose the correct project folder and try again.",
+          code: "workspace_repository_mismatch"
+        });
+        return;
+      }
     }
     if (workspaceRequired) workspaceAccessTracker.track(cwd, workspaceReadiness);
     const runnerSummary = summarizeRunnerStatus({
@@ -24604,6 +25245,7 @@ async function startDaemon(args) {
       selectedContextWindow: payload.selectedContextWindow ?? null,
       selectedEffortLevel: payload.selectedEffortLevel ?? null,
       providerSessionId: payload.providerSessionId,
+      resumeFallbackContext: payload.resumeFallbackContext,
       taskMeta: payload.taskMeta,
       prMeta: payload.prMeta,
       conversationId: payload.conversationId,
@@ -24640,11 +25282,13 @@ async function startDaemon(args) {
     if (!payload?.runId) return;
     const entry = activeAgents.get(payload.runId);
     if (!entry) return;
-    abortActiveAgent(entry, { userInitiated: true });
+    const reason = payload.reason === "watchdog_timeout" ? "watchdog_timeout" : "user";
+    abortActiveAgent(entry, { userInitiated: true, reason });
     activeAgents.delete(payload.runId);
-    pushLog(`aborted run=${payload.runId}`);
+    pushLog(`aborted run=${payload.runId} reason=${reason}`);
     console.info("[alan-agent] Agent run aborted", {
       runId: payload.runId,
+      reason,
       agentVersion: AGENT_VERSION
     });
   });
@@ -24652,7 +25296,9 @@ async function startDaemon(args) {
     "agent.tool_response",
     (payload) => {
       if (!payload?.toolId || typeof payload.response !== "string") return;
-      const entries = payload.runId ? [[payload.runId, activeAgents.get(payload.runId)]] : [...activeAgents.entries()];
+      const entries = payload.runId ? [[payload.runId, activeAgents.get(payload.runId)]] : payload.conversationId ? [...activeAgents.entries()].filter(
+        ([, entry]) => entry.conversationId === payload.conversationId
+      ) : [...activeAgents.entries()];
       const delivered = entries.some(([runId, entry]) => {
         if (!entry || !verifyActiveWorkspaceLease(runId, entry)) return false;
         return entry.agent.sendToolResponse(payload.toolId, payload.response) === true;
@@ -24660,8 +25306,8 @@ async function startDaemon(args) {
       if (!delivered) {
         pushLog(`tool_response missed tool=${payload.toolId}`);
         const fallbackRun = [...activeAgents.entries()][0];
-        const resolvedRunId = payload.runId ?? fallbackRun?.[0];
-        const conversationId = (payload.runId ? activeAgents.get(payload.runId)?.conversationId : void 0) ?? fallbackRun?.[1].conversationId;
+        const resolvedRunId = payload.runId ?? entries[0]?.[0] ?? fallbackRun?.[0];
+        const conversationId = payload.conversationId ?? (payload.runId ? activeAgents.get(payload.runId)?.conversationId : void 0) ?? fallbackRun?.[1].conversationId;
         if (conversationId && resolvedRunId) {
           eventOutbox.enqueue(conversationId, resolvedRunId, {
             type: "error",
@@ -25444,12 +26090,18 @@ var WebPresenter = class {
   onLog(message) {
     console.error(message);
   }
+  onNotice(kind, message) {
+    this.wsClient.emitEvent({ type: "session_notice", kind, message, ts: Date.now() });
+  }
   onAssistantText(text) {
     this.wsClient.emitEvent({ type: "text", text, ts: Date.now() });
   }
   onThinking(text) {
     this.wsClient.emitEvent({ type: "thinking", text, ts: Date.now() });
   }
+  hasKnownToolUse(toolId) {
+    return this.toolNamesById.has(toolId);
+  }
   onToolUse(tool, input, toolId, parentToolUseId) {
     this.toolNamesById.set(toolId, tool);
     this.toolInputsById.set(toolId, input);
@@ -25541,8 +26193,13 @@ var WebPresenter = class {
   onCheckpoint(id) {
     this.wsClient.emitEvent({ type: "checkpoint", id });
   }
-  onActivity(status) {
-    this.wsClient.emitEvent({ type: "activity", status, ts: Date.now() });
+  onActivity(status, evidence) {
+    this.wsClient.emitEvent({
+      type: "activity",
+      status,
+      ts: Date.now(),
+      ...evidence ? { evidence } : {}
+    });
   }
   onOpenBrowserTab(browserId, url2) {
     this.wsClient.emitEvent({ type: "open_browser_tab", browserId, ...url2 ? { url: url2 } : {} });
@@ -25583,7 +26240,7 @@ var WebPresenter = class {
 };
 
 // src/ws-client.ts
-var import_node_crypto4 = require("crypto");
+var import_node_crypto5 = require("crypto");
 
 // ../shared/dist/agent-liveness.js
 var AGENT_LIVENESS_PROTOCOL_VERSION = 1;
@@ -25610,7 +26267,117 @@ var agentProbeAckSchema = external_exports.object({
   protocolVersion: external_exports.number().int().positive().optional()
 });
 
+// src/sandbox-outbox.ts
+var import_node_crypto4 = require("crypto");
+var import_node_fs13 = require("fs");
+var SANDBOX_EVENT_OUTBOX_ENV = "ALAN_EVENT_OUTBOX_ENABLED";
+function isSandboxEventOutboxEnabled(env = process.env) {
+  return env[SANDBOX_EVENT_OUTBOX_ENV] === "true";
+}
+function deriveSandboxOutboxKey(sessionToken) {
+  if (!sessionToken) {
+    throw new Error("sandbox event outbox requires ALAN_SESSION_TOKEN for key derivation");
+  }
+  return (0, import_node_crypto4.createHash)("sha256").update(sessionToken, "utf8").digest("base64url");
+}
+function sandboxOutboxSpoolPath(conversationId) {
+  return `/tmp/alan-agent-outbox-${conversationId}.enc`;
+}
+function createSandboxEventOutbox(input) {
+  const path = input.spoolPath ?? sandboxOutboxSpoolPath(input.conversationId);
+  const key = deriveSandboxOutboxKey(input.sessionToken);
+  try {
+    return new EncryptedEventOutbox(path, key, input.pushLog, input.options);
+  } catch (error) {
+    input.pushLog?.(
+      `sandbox_outbox_spool_reset ${error instanceof Error ? error.message : String(error)}`
+    );
+    (0, import_node_fs13.rmSync)(path, { force: true });
+    return new EncryptedEventOutbox(path, key, input.pushLog, input.options);
+  }
+}
+var SandboxOutboxSocket = class {
+  constructor(socket) {
+    this.socket = socket;
+  }
+  seqByEventId = /* @__PURE__ */ new Map();
+  seqCounter = 0;
+  get connected() {
+    return this.socket.connected;
+  }
+  emit(_event, payload, acknowledge) {
+    let seq = this.seqByEventId.get(payload.eventId);
+    if (seq === void 0) {
+      this.seqCounter += 1;
+      seq = this.seqCounter;
+      this.seqByEventId.set(payload.eventId, seq);
+    }
+    const wirePayload = { ...payload.event, eventId: payload.eventId, seq };
+    this.socket.emit("agent_event", wirePayload, (result) => {
+      if (result?.ok) this.seqByEventId.delete(payload.eventId);
+      acknowledge({ ok: Boolean(result?.ok), retryable: result?.retryable });
+    });
+  }
+};
+var SandboxEventDispatcher = class {
+  conversationId;
+  outbox;
+  outboxSocket;
+  currentRunId;
+  constructor(input) {
+    this.conversationId = input.conversationId;
+    if (!input.enabled) return;
+    try {
+      this.outbox = createSandboxEventOutbox({
+        conversationId: input.conversationId,
+        sessionToken: input.sessionToken,
+        pushLog: input.pushLog,
+        options: input.options,
+        spoolPath: input.spoolPath
+      });
+      this.outboxSocket = new SandboxOutboxSocket(input.socket);
+    } catch (error) {
+      input.onInitError?.(error);
+      this.outbox = void 0;
+      this.outboxSocket = void 0;
+    }
+  }
+  /** True when events are being durably queued rather than fired-and-forgotten. */
+  get active() {
+    return this.outbox !== void 0 && this.outboxSocket !== void 0;
+  }
+  /** Set the run id used to bucket per-run caps / terminal condensation. */
+  setRunId(runId) {
+    this.currentRunId = runId;
+  }
+  /**
+   * Durably deliver one event (enqueue-before-send, remove-on-ack). When the
+   * outbox is inactive, defers to `fireAndForget` so behaviour is unchanged.
+   */
+  emit(event, fireAndForget) {
+    if (!this.outbox || !this.outboxSocket) {
+      fireAndForget(event);
+      return;
+    }
+    this.outbox.enqueue(this.conversationId, this.currentRunId ?? this.conversationId, event);
+    this.outbox.flush(this.outboxSocket);
+  }
+  /** Replay un-acked events in order — called on (re)connect before new events. */
+  flush() {
+    if (this.outbox && this.outboxSocket) this.outbox.flush(this.outboxSocket);
+  }
+  /** Reset in-flight state on disconnect so the next flush replays from the head. */
+  disconnect() {
+    this.outbox?.disconnect();
+  }
+  /** Diagnostics: number of events still awaiting a server ack. */
+  pendingCount() {
+    return this.outbox?.pendingCount() ?? 0;
+  }
+};
+
 // src/ws-client.ts
+var ACCEPTED_MESSAGE_ID_CACHE_SIZE = 200;
 var WSClient = class {
   constructor(wsUrl, sessionId, taskId, token, callbacks, agentVersion, lifecycle) {
     this.lifecycle = lifecycle;
@@ -25629,16 +26396,63 @@ var WSClient = class {
       upgrade: false,
       extraHeaders: { "ngrok-skip-browser-warning": "1" }
     });
+    const outboxEnabled = isSandboxEventOutboxEnabled();
+    this.eventDispatcher = new SandboxEventDispatcher({
+      conversationId: sessionId,
+      sessionToken: token,
+      enabled: outboxEnabled,
+      socket: this.socket,
+      pushLog: (message) => this.lifecycle?.info("sandbox_agent_event_outbox", { detail: message }),
+      onInitError: (error) => this.lifecycle?.warn("sandbox_agent_event_outbox_init_failed", {
+        error: error instanceof Error ? error : new Error(String(error))
+      })
+    });
+    if (this.eventDispatcher.active) {
+      this.lifecycle?.info("sandbox_agent_event_outbox_enabled", { conversationId: sessionId });
+    }
     this.setupListeners(callbacks);
   }
   socket;
   /** Stable id for this agent process; fences stale heartbeats server-side. */
-  agentSessionId = (0, import_node_crypto4.randomUUID)();
+  agentSessionId = (0, import_node_crypto5.randomUUID)();
   /** Monotonic heartbeat sequence — advances on every hello + heartbeat. */
   heartbeatSeq = 0;
   heartbeatTimer = null;
   agentVersion;
   getRunState;
+  /**
+   * Durable at-least-once delivery for stream events. Active only when
+   * `ALAN_EVENT_OUTBOX_ENABLED === "true"`; otherwise events are fired-and-
+   * forgotten exactly as before (see {@link SandboxEventDispatcher}).
+   */
+  eventDispatcher;
+  /**
+   * Bounded record of `messageId`s whose handoff to `onUserMessage` already
+   * completed successfully. A redelivered `user_message` for one of these ids
+   * (e.g. the original `ok:true` ack was lost in transit and the server's
+   * ≤5-attempt redelivery re-armed the run) is re-acked `{ ok: true }`
+   * without invoking the handler again, so the message is never processed
+   * twice. A `Set`'s insertion order doubles as recency, so eviction is just
+   * "drop the oldest key" — a minimal LRU without extra bookkeeping.
+   */
+  acceptedMessageIds = /* @__PURE__ */ new Set();
+  /** Record a successfully-handed-off messageId, evicting the oldest entry past the cap. */
+  rememberAcceptedMessageId(messageId) {
+    this.acceptedMessageIds.delete(messageId);
+    this.acceptedMessageIds.add(messageId);
+    if (this.acceptedMessageIds.size > ACCEPTED_MESSAGE_ID_CACHE_SIZE) {
+      const oldest = this.acceptedMessageIds.keys().next().value;
+      if (oldest !== void 0) this.acceptedMessageIds.delete(oldest);
+    }
+  }
+  /**
+   * Record the run id for events emitted from here on, so the durable outbox can
+   * bucket per-run caps and terminal-event condensation correctly. No-op when the
+   * outbox is disabled.
+   */
+  setCurrentRunId(runId) {
+    this.eventDispatcher.setRunId(runId);
+  }
   currentRunState() {
     try {
       return this.getRunState?.() ?? { idle: true, activeRunIds: [] };
@@ -25675,7 +26489,9 @@ var WSClient = class {
     }
   }
   emitEvent(event) {
-    this.socket.emit("agent_event", event);
+    this.eventDispatcher.emit(event, (payload) => {
+      this.socket.emit("agent_event", payload);
+    });
   }
   waitForConnection(timeoutMs = 15e3) {
     return new Promise((resolve6, reject) => {
@@ -25712,11 +26528,13 @@ var WSClient = class {
     this.socket.on("connect", () => {
       this.lifecycle?.info("sandbox_agent_ws_socket_connected", { socketId: this.socket.id });
       this.startHeartbeat();
+      this.eventDispatcher.flush();
       callbacks.onConnect?.();
     });
     this.socket.on("disconnect", (reason) => {
       this.lifecycle?.info("sandbox_agent_ws_socket_disconnected", { reason });
       this.stopHeartbeat();
+      this.eventDispatcher.disconnect();
       callbacks.onDisconnect?.(reason);
     });
     this.socket.on("agent.probe", (_data, ack) => {
@@ -25734,8 +26552,11 @@ var WSClient = class {
     this.socket.on(
       "user_message",
       (data, ack) => {
-        ack?.({ ok: true });
-        callbacks.onUserMessage({
+        if (data.messageId && this.acceptedMessageIds.has(data.messageId)) {
+          ack?.({ ok: true });
+          return;
+        }
+        const payload = {
           text: data.text,
           images: data.images,
           files: data.files,
@@ -25759,7 +26580,24 @@ var WSClient = class {
           conversationId: data.conversationId,
           teamId: data.teamId,
           currentUser: data.currentUser
-        });
+        };
+        const acceptDelivery = () => {
+          if (data.messageId) this.rememberAcceptedMessageId(data.messageId);
+          ack?.({ ok: true });
+        };
+        const rejectDelivery = (error) => {
+          ack?.({ ok: false, message: error instanceof Error ? error.message : String(error) });
+        };
+        try {
+          const result = callbacks.onUserMessage(payload);
+          if (result instanceof Promise) {
+            result.then(acceptDelivery, rejectDelivery);
+          } else {
+            acceptDelivery();
+          }
+        } catch (error) {
+          rejectDelivery(error);
+        }
       }
     );
     this.socket.on("stop", () => {
@@ -25928,6 +26766,7 @@ async function runSandbox(config) {
         backendKind: activeBackendKind
       });
       currentAgent = agent;
+      wsClient.setCurrentRunId(currentRunId ?? config.runId);
       const correlation = correlationLogFields2({
         taskId: currentTaskId,
         conversationId: currentConversationId,
@@ -26145,7 +26984,7 @@ async function runSandbox(config) {
 
 // src/service-manager.ts
 var import_node_child_process6 = require("child_process");
-var import_node_fs13 = require("fs");
+var import_node_fs14 = require("fs");
 var import_node_os8 = require("os");
 var import_node_path11 = require("path");
 var SERVICE_LABEL = "ai.tryalan.agent";
@@ -26344,14 +27183,14 @@ function currentServicePlan(args) {
   });
 }
 function writeManifest(path, contents) {
-  (0, import_node_fs13.mkdirSync)((0, import_node_path11.dirname)(path), { recursive: true, mode: 448 });
+  (0, import_node_fs14.mkdirSync)((0, import_node_path11.dirname)(path), { recursive: true, mode: 448 });
   const pendingPath = `${path}.pending-${process.pid}`;
   try {
-    (0, import_node_fs13.writeFileSync)(pendingPath, contents, { mode: 384 });
-    (0, import_node_fs13.chmodSync)(pendingPath, 384);
-    (0, import_node_fs13.renameSync)(pendingPath, path);
+    (0, import_node_fs14.writeFileSync)(pendingPath, contents, { mode: 384 });
+    (0, import_node_fs14.chmodSync)(pendingPath, 384);
+    (0, import_node_fs14.renameSync)(pendingPath, path);
   } finally {
-    (0, import_node_fs13.rmSync)(pendingPath, { force: true });
+    (0, import_node_fs14.rmSync)(pendingPath, { force: true });
   }
 }
 function runServiceCommand(command) {
@@ -26374,7 +27213,7 @@ function installDaemonService(args = []) {
   const plan = currentServicePlan(args);
   if (plan.manifestPath && plan.manifest) {
     if ((0, import_node_os8.platform)() === "darwin") {
-      (0, import_node_fs13.mkdirSync)((0, import_node_path11.join)((0, import_node_os8.homedir)(), ".alan", "agent", "logs"), { recursive: true, mode: 448 });
+      (0, import_node_fs14.mkdirSync)((0, import_node_path11.join)((0, import_node_os8.homedir)(), ".alan", "agent", "logs"), { recursive: true, mode: 448 });
     }
     writeManifest(plan.manifestPath, plan.manifest);
   }
@@ -26384,7 +27223,7 @@ function installDaemonService(args = []) {
 function uninstallDaemonService(args = []) {
   const plan = currentServicePlan(args);
   for (const command of plan.uninstallCommands) runServiceCommand(command);
-  if (plan.manifestPath) (0, import_node_fs13.rmSync)(plan.manifestPath, { force: true });
+  if (plan.manifestPath) (0, import_node_fs14.rmSync)(plan.manifestPath, { force: true });
   console.info("[alan-agent] Per-user daemon service removed");
 }
 function printDaemonServiceStatus(args = []) {