@aiden-ade/sandbox-agent 0.1.40 → 0.1.42

package/dist/index.cjs

@@ -13514,6 +13514,16 @@ function resolveBackendRuntimeCommand(backendKind, env = getDaemonCliEnvironment
   cacheResolvedCli(command, resolved);
   return resolved ?? void 0;
 }
+function revalidateBackendRuntimeCommand(backendKind, env = getDaemonCliEnvironment()) {
+  if (!backendKind) return void 0;
+  const command = BACKEND_CLI_COMMANDS[backendKind];
+  if (!command) return void 0;
+  resolvedCliCache.delete(command);
+  const spec = Object.values(PROVIDER_CLI_COMMANDS).find((entry) => entry.command === command);
+  const envOverride = spec ? spec.envVars.map((name) => env[name]?.trim()).find(Boolean) : void 0;
+  if (envOverride) resolvedCliCache.delete(envOverride);
+  return resolveBackendRuntimeCommand(backendKind, env);
+}
 
 // src/computer-readiness.ts
 var import_node_fs5 = require("fs");
@@ -14590,9 +14600,9 @@ function getAlanAgentPrompt(agentId) {
   return getAgentSystemPrompt(agentId);
 }
 
-// ../shared/dist/types/frontend.js
+// ../shared/dist/effort.js
 var EFFORT_LEVELS = ["minimal", "low", "medium", "high", "xhigh", "max", "ultra"];
-var CLAUDE_48_EFFORT_LEVELS = [
+var CLAUDE_EFFORT_LEVELS = [
   "minimal",
   "low",
   "medium",
@@ -14600,20 +14610,144 @@ var CLAUDE_48_EFFORT_LEVELS = [
   "xhigh",
   "max"
 ];
-var CLAUDE_5_EFFORT_LEVELS = [
+var CODEX_5X_EFFORT_LEVELS = ["low", "medium", "high", "xhigh"];
+var GPT_5_5_EFFORT_LEVELS = [
   "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh"
+];
+var GPT_5_4_EFFORT_LEVELS = ["low", "medium", "high"];
+var GPT_5_6_EFFORT_LEVELS = [
   "low",
   "medium",
   "high",
   "xhigh",
   "max"
 ];
-var CODEX_5X_EFFORT_LEVELS = [
+var GPT_5_6_ULTRA_EFFORT_LEVELS = [
   "low",
   "medium",
   "high",
-  "xhigh"
+  "xhigh",
+  "max",
+  "ultra"
+];
+var ATOMIC_MODEL_IDS = /* @__PURE__ */ new Set([
+  "gpt-5.1-codex-max",
+  "opencode/gpt-5.1-codex-max"
+]);
+var EFFORT_SUFFIXES = [
+  { suffix: "-extra-high", level: "xhigh" },
+  { suffix: "-xhigh", level: "xhigh" },
+  { suffix: "-ultra", level: "ultra" },
+  { suffix: "-max", level: "max" },
+  { suffix: "-high", level: "high" },
+  { suffix: "-medium", level: "medium" },
+  { suffix: "-low", level: "low" },
+  { suffix: "-none", level: "minimal" },
+  { suffix: "-minimal", level: "minimal" }
 ];
+function isAtomicModelId(modelId) {
+  return ATOMIC_MODEL_IDS.has(modelId.trim());
+}
+function isEffortLevel(value2) {
+  return EFFORT_LEVELS.includes(value2);
+}
+var EFFORT_RANK = {
+  minimal: 0,
+  low: 1,
+  medium: 2,
+  high: 3,
+  xhigh: 4,
+  max: 5,
+  ultra: 6
+};
+function clampEffortToSupported(requested, allowed) {
+  if (!requested?.trim() || allowed.length === 0)
+    return null;
+  const normalized = requested.trim().toLowerCase();
+  if (!isEffortLevel(normalized))
+    return null;
+  if (allowed.includes(normalized))
+    return normalized;
+  const targetRank = EFFORT_RANK[normalized];
+  let best = null;
+  for (const level of allowed) {
+    if (EFFORT_RANK[level] <= targetRank) {
+      if (!best || EFFORT_RANK[level] > EFFORT_RANK[best])
+        best = level;
+    }
+  }
+  return best ?? allowed[0] ?? null;
+}
+function inferEffortLevelsForModel(harness, modelId) {
+  const id = collapseModelIdToBase(modelId);
+  if (harness === "claude_cli" || id.startsWith("claude-") || id === "sonnet" || id === "opus") {
+    if (id === "haiku" || id.startsWith("claude-haiku-"))
+      return [];
+    return CLAUDE_EFFORT_LEVELS;
+  }
+  if (id === "gpt-5.5")
+    return GPT_5_5_EFFORT_LEVELS;
+  if (id === "gpt-5.4" || id === "gpt-5.4-mini")
+    return GPT_5_4_EFFORT_LEVELS;
+  if (/^gpt-5\.6-/.test(id)) {
+    const hasUltra = id.includes("-sol") || id.includes("-terra");
+    return hasUltra ? GPT_5_6_ULTRA_EFFORT_LEVELS : GPT_5_6_EFFORT_LEVELS;
+  }
+  if (id.includes("codex") || /^gpt-5\.[0-3]/.test(id))
+    return CODEX_5X_EFFORT_LEVELS;
+  return [];
+}
+function resolveWireEffort(input) {
+  const allowed = input.effortLevels && input.effortLevels.length > 0 ? input.effortLevels : inferEffortLevelsForModel(input.harness, input.modelId);
+  const clamped = clampEffortToSupported(input.selectedEffortLevel, allowed);
+  if (!clamped)
+    return null;
+  if (input.harness === "cursor_agent_cli" && clamped === "minimal")
+    return "none";
+  if (input.harness === "claude_cli" && clamped === "minimal")
+    return "low";
+  return clamped;
+}
+function parseModelEffortSuffix(modelId) {
+  const trimmed = modelId.trim();
+  if (!trimmed)
+    return { baseId: "", effort: null, fast: false };
+  if (isAtomicModelId(trimmed)) {
+    return { baseId: trimmed, effort: null, fast: false };
+  }
+  let id = trimmed;
+  let fast = false;
+  if (id.endsWith("-fast")) {
+    const withoutFast = id.slice(0, -"-fast".length);
+    if (isAtomicModelId(withoutFast)) {
+      return { baseId: withoutFast, effort: null, fast: true };
+    }
+    fast = true;
+    id = withoutFast;
+  }
+  if (isAtomicModelId(id)) {
+    return { baseId: id, effort: null, fast };
+  }
+  for (const { suffix, level } of EFFORT_SUFFIXES) {
+    if (id.endsWith(suffix)) {
+      return { baseId: id.slice(0, -suffix.length), effort: level, fast };
+    }
+  }
+  return { baseId: id, effort: null, fast };
+}
+function collapseModelIdToBase(modelId) {
+  const parsed = parseModelEffortSuffix(modelId);
+  if (parsed.fast && !parsed.effort)
+    return modelId.trim();
+  return parsed.baseId;
+}
+
+// ../shared/dist/types/frontend.js
+var CLAUDE_5_EFFORT_LEVELS = CLAUDE_EFFORT_LEVELS;
 var AVAILABLE_MODELS = [
   {
     id: "",
@@ -14628,7 +14762,7 @@ var AVAILABLE_MODELS = [
   {
     id: "claude-opus-4-8",
     name: "Opus 4.8",
-    capabilities: { contextWindows: ["200k", "1m"], effortLevels: CLAUDE_48_EFFORT_LEVELS }
+    capabilities: { contextWindows: ["200k", "1m"], effortLevels: CLAUDE_5_EFFORT_LEVELS }
   },
   {
     id: "claude-haiku-4-5",
@@ -14867,51 +15001,8 @@ function findModelDef(providerKind, modelId) {
 }
 
 // ../shared/dist/cursor-agent-models.js
-var CLAUDE_5_EFFORT_LEVELS2 = [
-  "minimal",
-  "low",
-  "medium",
-  "high",
-  "xhigh",
-  "max"
-];
-var CODEX_5X_EFFORT_LEVELS2 = ["low", "medium", "high", "xhigh"];
-var GPT_5_5_EFFORT_LEVELS = ["minimal", "low", "medium", "high", "xhigh"];
-var GPT_5_4_EFFORT_LEVELS = ["low", "medium", "high"];
-var GPT_5_6_EFFORT_LEVELS = [
-  "low",
-  "medium",
-  "high",
-  "xhigh",
-  "max",
-  "ultra"
-];
-var CURSOR_EFFORT_SUFFIXES = [
-  { suffix: "-extra-high", level: "xhigh" },
-  { suffix: "-xhigh", level: "xhigh" },
-  { suffix: "-ultra", level: "ultra" },
-  { suffix: "-max", level: "max" },
-  { suffix: "-high", level: "high" },
-  { suffix: "-medium", level: "medium" },
-  { suffix: "-low", level: "low" },
-  { suffix: "-none", level: "minimal" }
-];
-function parseCursorModelId(modelId) {
-  let id = modelId.trim();
-  let fast = false;
-  if (id.endsWith("-fast")) {
-    fast = true;
-    id = id.slice(0, -"-fast".length);
-  }
-  for (const { suffix, level } of CURSOR_EFFORT_SUFFIXES) {
-    if (id.endsWith(suffix)) {
-      return { baseId: id.slice(0, -suffix.length), effort: level, fast };
-    }
-  }
-  return { baseId: id, effort: null, fast };
-}
 function getCursorModelCollapseKey(modelId) {
-  const parsed = parseCursorModelId(modelId);
+  const parsed = parseModelEffortSuffix(modelId);
   if (parsed.fast && !parsed.effort)
     return modelId.trim();
   return parsed.baseId;
@@ -15017,11 +15108,11 @@ function inferSlugModelCapabilities(providerKind, modelId) {
       const hasUltra = id.includes("-sol") || id.includes("-terra");
       return {
         contextWindows: [],
-        effortLevels: hasUltra ? GPT_5_6_EFFORT_LEVELS : GPT_5_6_EFFORT_LEVELS.filter((level) => level !== "ultra")
+        effortLevels: hasUltra ? GPT_5_6_ULTRA_EFFORT_LEVELS : GPT_5_6_EFFORT_LEVELS
       };
     }
     if (id.includes("codex") || /^gpt-5\.[0-3]/.test(id)) {
-      return { contextWindows: [], effortLevels: CODEX_5X_EFFORT_LEVELS2 };
+      return { contextWindows: [], effortLevels: CODEX_5X_EFFORT_LEVELS };
     }
     return void 0;
   }
@@ -15030,10 +15121,10 @@ function inferSlugModelCapabilities(providerKind, modelId) {
       return { contextWindows: ["200k"], effortLevels: [] };
     }
     if (id === "claude-opus-4-8") {
-      return { contextWindows: ["200k", "1m"], effortLevels: CLAUDE_5_EFFORT_LEVELS2 };
+      return { contextWindows: ["200k", "1m"], effortLevels: CLAUDE_EFFORT_LEVELS };
     }
     if (id === "sonnet" || id === "opus" || id === "fable" || /^claude-(sonnet|opus|fable)-/.test(id)) {
-      return { contextWindows: ["200k", "1m"], effortLevels: CLAUDE_5_EFFORT_LEVELS2 };
+      return { contextWindows: ["200k", "1m"], effortLevels: CLAUDE_EFFORT_LEVELS };
     }
     return void 0;
   }
@@ -15201,11 +15292,12 @@ var import_os3 = require("os");
 var import_path3 = require("path");
 var import_readline = require("readline");
 var import_child_process2 = require("child_process");
+var import_child_process3 = require("child_process");
 var import_crypto2 = require("crypto");
 var import_fs4 = require("fs");
 var import_os4 = require("os");
 var import_path4 = require("path");
-var import_child_process3 = require("child_process");
+var import_child_process4 = require("child_process");
 var import_util10 = require("util");
 var import_fs5 = require("fs");
 var import_os5 = require("os");
@@ -15795,6 +15887,7 @@ function specForErrorKind(errorKind) {
   const spec = ERROR_SPECS[errorKind];
   return { message: spec.message, errorKind, recoveryClass: spec.recoveryClass };
 }
+var RESUME_SESSION_UNAVAILABLE_MESSAGE = ERROR_SPECS.resume_failed.message;
 function isLikelyProviderAuthError(stderr) {
   const lower = stderr.toLowerCase();
   return lower.includes("api key") || lower.includes("api_key") || lower.includes("invalid api key") || lower.includes("api key invalid") || lower.includes("unauthorized") || lower.includes("authentication failed") || lower.includes("authentication error") || lower.includes("provider settings") || lower.includes("invalid token") || lower.includes("token expired");
@@ -15950,6 +16043,54 @@ function spawnCli(command, args, context) {
     detached: process.platform !== "win32"
   });
 }
+function isAlreadyDead(error) {
+  return error?.code === "ESRCH";
+}
+function killProcessTree(pid, options = {}) {
+  const { signal = "SIGTERM", child, onError } = options;
+  if (typeof pid !== "number" || !Number.isInteger(pid) || pid <= 0) {
+    if (child) {
+      try {
+        child.kill(signal);
+      } catch (err) {
+        if (!isAlreadyDead(err)) onError?.("fallback", err);
+      }
+    }
+    return;
+  }
+  if (process.platform === "win32") {
+    try {
+      const killer = (0, import_child_process3.spawn)("taskkill", ["/pid", String(pid), "/t", "/f"], {
+        stdio: "ignore",
+        windowsHide: true
+      });
+      killer.once("error", (err) => {
+        if (child) {
+          try {
+            child.kill();
+          } catch {
+          }
+        }
+        onError?.("taskkill", err);
+      });
+    } catch (err) {
+      onError?.("taskkill", err);
+    }
+    return;
+  }
+  try {
+    process.kill(-pid, signal);
+  } catch (groupErr) {
+    if (!isAlreadyDead(groupErr)) onError?.("group", groupErr);
+    if (child) {
+      try {
+        child.kill(signal);
+      } catch (fallbackErr) {
+        if (!isAlreadyDead(fallbackErr)) onError?.("fallback", fallbackErr);
+      }
+    }
+  }
+}
 function emitSessionNotice(presenter, kind, message) {
   if (presenter.onNotice) {
     void presenter.onNotice(kind, message);
@@ -16014,6 +16155,12 @@ function formatCliSpawnError(command, error) {
   }
   return error;
 }
+function waitForSpawnOutcome(child) {
+  return new Promise((resolve22) => {
+    child.once("spawn", () => resolve22(null));
+    child.once("error", (error) => resolve22(error));
+  });
+}
 function createGenericCliBackend(options) {
   return {
     kind: options.kind,
@@ -16027,7 +16174,23 @@ function createGenericCliBackend(options) {
       };
       const prompt = options.augmentPrompt?.(context) ?? (context.config.mode === "plan" ? buildPlanModePrefix(buildPromptWithSystem(context.config, context.promptText)) : buildPromptWithSystem(context.config, context.promptText));
       const args = options.buildArgs?.(context, prompt) ?? options.args.map((arg) => arg === "{{prompt}}" ? prompt : arg);
-      const child = spawnCli(options.command, args, context);
+      let command = options.command;
+      let child = spawnCli(command, args, context);
+      if (context.revalidateCommand) {
+        const spawnError = await waitForSpawnOutcome(child);
+        if (spawnError) {
+          const fresh = spawnError.code === "ENOENT" ? context.revalidateCommand()?.trim() || null : null;
+          if (fresh && fresh !== command) {
+            console.warn(
+              `[${options.kind}] Spawn failed ENOENT for "${command}" \u2014 re-resolved to "${fresh}", retrying once`
+            );
+            command = fresh;
+            child = spawnCli(command, args, context);
+          } else {
+            throw formatCliSpawnError(command, spawnError);
+          }
+        }
+      }
       state.process = child;
       state.lastRawOutputAtMs = Date.now();
       context.onProcessSpawned?.(child);
@@ -16038,8 +16201,8 @@ function createGenericCliBackend(options) {
       const safeArgs = args.map(
         (a, i) => i > 0 && args[i - 1] === "--system-prompt" ? `"<system-prompt ${a.length} chars>"` : a
       );
-      console.info(`[${options.kind}] Spawning: ${options.command} ${safeArgs.join(" ")}`);
-      presenter.recordRawTranscript?.("system", `${options.command} ${args.join(" ")}`, {
+      console.info(`[${options.kind}] Spawning: ${command} ${safeArgs.join(" ")}`);
+      presenter.recordRawTranscript?.("system", `${command} ${args.join(" ")}`, {
         backendKind: options.kind
       });
       child.stdin.on("error", (err) => {
@@ -16071,14 +16234,7 @@ function createGenericCliBackend(options) {
           console.warn(
             `[${options.kind}] No stdout within ${options.startupTimeoutMs}ms of spawn \u2014 killing hung process`
           );
-          try {
-            if (process.platform === "win32") {
-              child.kill("SIGKILL");
-            } else if (child.pid) {
-              process.kill(-child.pid, "SIGKILL");
-            }
-          } catch {
-          }
+          killProcessTree(child.pid, { signal: "SIGKILL", child });
         }, options.startupTimeoutMs);
       }
       stdoutRl.on("line", (line) => {
@@ -16121,16 +16277,7 @@ function createGenericCliBackend(options) {
           });
           child.on("exit", (code) => resolve22(code ?? 0));
           const onAbort = () => {
-            const pid = child.pid;
-            if (!pid) return;
-            try {
-              process.kill(-pid, "SIGTERM");
-            } catch {
-              try {
-                child.kill("SIGTERM");
-              } catch {
-              }
-            }
+            killProcessTree(child.pid, { signal: "SIGTERM", child });
           };
           context.abortController.signal.addEventListener("abort", onAbort, { once: true });
         });
@@ -16166,14 +16313,7 @@ function createGenericCliBackend(options) {
             console.warn(
               `[${options.kind}] Idle timeout (${IDLE_MS}ms) waiting for ${idleTimeoutReason === "background_task" ? "a background task terminal event" : "a pending user answer"} \u2014 force-killing orphaned process`
             );
-            try {
-              if (process.platform === "win32") {
-                child.kill("SIGKILL");
-              } else if (child.pid) {
-                process.kill(-child.pid, "SIGKILL");
-              }
-            } catch {
-            }
+            killProcessTree(child.pid, { signal: "SIGKILL", child });
             exitCode = await Promise.race([
               exitPromise,
               new Promise((resolve22) => setTimeout(() => resolve22(1), 5e3))
@@ -16189,14 +16329,7 @@ function createGenericCliBackend(options) {
               console.warn(
                 `[${options.kind}] Process still alive ${GRACE_MS}ms after result event, killing`
               );
-              try {
-                if (process.platform === "win32") {
-                  child.kill("SIGKILL");
-                } else if (child.pid) {
-                  process.kill(-child.pid, "SIGKILL");
-                }
-              } catch {
-              }
+              killProcessTree(child.pid, { signal: "SIGKILL", child });
             }
           } else {
             exitCode = raceResult;
@@ -16359,6 +16492,9 @@ function createGenericCliBackend(options) {
           classifiedErrorKind = detailed.errorKind;
           classifiedRecoveryClass = detailed.recoveryClass;
         }
+        if (classifiedErrorKind === "resume_failed" && !requestedResumeId) {
+          classifiedErrorKind = void 0;
+        }
       }
       return {
         success: !failed,
@@ -16367,7 +16503,11 @@ function createGenericCliBackend(options) {
         planFilesCreated: [],
         iterations: Math.max(state.iterations, 1),
         error: classifiedError,
-        ...classifiedErrorKind ? { errorKind: classifiedErrorKind } : {},
+        // Surface every recognized, machine-actionable kind (model_mismatch,
+        // resume_failed, auth_*, …). The catch-all unknown_cli_error carries no routing
+        // signal — nothing downstream keys on it — so leave errorKind absent for it,
+        // keeping an unrelated failure untagged even when a resume id was set.
+        ...classifiedErrorKind && classifiedErrorKind !== "unknown_cli_error" ? { errorKind: classifiedErrorKind } : {},
         ...classifiedRecoveryClass ? { recoveryClass: classifiedRecoveryClass } : {},
         providerSessionId: state.runtimeSessionId,
         runtimeSessionId: state.runtimeSessionId,
@@ -16825,7 +16965,7 @@ function claudeSessionLogExists(input) {
   if (!(0, import_fs4.existsSync)(projectDir)) return false;
   return (0, import_fs4.existsSync)((0, import_path4.join)(projectDir, `${input.sessionId}.jsonl`));
 }
-var execFileAsync = (0, import_util10.promisify)(import_child_process3.execFile);
+var execFileAsync = (0, import_util10.promisify)(import_child_process4.execFile);
 var flagSupportCache = /* @__PURE__ */ new Map();
 function helpAdvertisesFlag(helpText, flag) {
   return helpText.includes(flag);
@@ -17347,11 +17487,15 @@ function createClaudeCliBackend(command = "claude", defaultArgs = []) {
       if (context.config.teamId?.trim() && await cliSupportsFlag(command, "--approve-mcps", context.env)) {
         args.push("--approve-mcps");
       }
-      const baseModel = context.config.selectedModel?.trim();
+      const baseModel = collapseModelIdToBase(context.config.selectedModel?.trim() || "");
       if (baseModel) {
         args.push("--model", buildClaudeModelArg(baseModel, context.config.selectedContextWindow));
       }
-      const claudeEffort = context.config.selectedEffortLevel?.trim();
+      const claudeEffort = resolveWireEffort({
+        harness: "claude_cli",
+        modelId: baseModel,
+        selectedEffortLevel: context.config.selectedEffortLevel
+      });
       if (claudeEffort) {
         args.push("--effort", claudeEffort);
       }
@@ -17556,18 +17700,7 @@ function armCodexExitGraceKill(state) {
     console.warn(
       "[codex_app_server] Process did not exit after turn completion; killing process group"
     );
-    const pid = child.pid;
-    if (pid) {
-      try {
-        process.kill(-pid, "SIGTERM");
-        return;
-      } catch {
-      }
-    }
-    try {
-      child.kill("SIGTERM");
-    } catch {
-    }
+    killProcessTree(child.pid, { signal: "SIGTERM", child });
   }, CODEX_EXIT_GRACE_MS);
   timer.unref?.();
   state.exitGraceKillTimer = timer;
@@ -17872,8 +18005,14 @@ var parseCodexStructuredLine = createStructuredLineParser(
   "codex_app_server",
   handleCodexStructuredEvent
 );
-function buildCodexEffortArgs(selectedEffortLevel) {
-  const level = selectedEffortLevel?.trim();
+function buildCodexEffortArgs(selectedEffortLevel, options) {
+  const modelId = collapseModelIdToBase(options?.modelId?.trim() || "");
+  const level = resolveWireEffort({
+    harness: "codex_app_server",
+    modelId,
+    selectedEffortLevel,
+    effortLevels: options?.effortLevels
+  });
   if (!level) return [];
   return ["-c", `model_reasoning_effort=${level}`];
 }
@@ -17923,8 +18062,11 @@ function createCodexRuntimeBackend(command = "codex", defaultArgs = []) {
           startupTimeoutMs: CODEX_STARTUP_TIMEOUT_MS,
           buildArgs: (ctx) => {
             const resumeId = resumableSessionId;
-            const modelArgs = ctx.config.selectedModel?.trim() ? ["--model", ctx.config.selectedModel.trim()] : [];
-            const effortArgs = buildCodexEffortArgs(ctx.config.selectedEffortLevel);
+            const selectedModel = collapseModelIdToBase(ctx.config.selectedModel?.trim() || "");
+            const modelArgs = selectedModel ? ["--model", selectedModel] : [];
+            const effortArgs = buildCodexEffortArgs(ctx.config.selectedEffortLevel, {
+              modelId: selectedModel
+            });
             const permissionArgs = getCodexPermissionArgs(ctx.config);
             const imageArgs = imagePaths.flatMap((p) => ["--image", p]);
             const baseArgs = resumeId ? [
@@ -18228,58 +18370,48 @@ var parseCursorStructuredLine = createStructuredLineParser(
   "cursor_agent_cli",
   handleCursorStructuredEvent
 );
-var CURSOR_EFFORT_SUFFIXES2 = [
-  { suffix: "-extra-high", level: "xhigh" },
-  { suffix: "-xhigh", level: "xhigh" },
-  { suffix: "-max", level: "max" },
-  { suffix: "-high", level: "high" },
-  { suffix: "-medium", level: "medium" },
-  { suffix: "-low", level: "low" },
-  { suffix: "-none", level: "minimal" }
-];
-function parseCursorModelId2(modelId) {
-  let id = modelId.trim();
-  let fast = false;
-  if (id.endsWith("-fast")) {
-    fast = true;
-    id = id.slice(0, -"-fast".length);
-  }
-  for (const { suffix, level } of CURSOR_EFFORT_SUFFIXES2) {
-    if (id.endsWith(suffix)) {
-      return { baseId: id.slice(0, -suffix.length), effort: level, fast };
-    }
-  }
-  return { baseId: id, effort: null, fast };
-}
-function cursorEffortForBracket(level) {
-  if (level === "minimal") return "none";
-  return level;
-}
-function asEffortLevel(value2, allowed) {
-  if (!value2) return null;
-  return allowed.includes(value2) ? value2 : null;
-}
 function asContextWindow(value2) {
   if (value2 === "1m" || value2 === "200k") return value2;
   return null;
 }
+function cursorEffortSuffix(level, baseId) {
+  if (level === "minimal") return "-none";
+  if (level === "xhigh") {
+    if (/^gpt-5\.5(?:-|$)/.test(baseId)) return "-extra-high";
+    return "-xhigh";
+  }
+  if (level === "ultra") return "-max";
+  return `-${level}`;
+}
 function buildCursorAgentModelArg(modelId, options) {
   const trimmed = modelId.trim();
   if (!trimmed) return trimmed;
-  const parsed = parseCursorModelId2(trimmed);
+  const parsed = parseModelEffortSuffix(trimmed);
   if (parsed.fast && !parsed.effort) return trimmed;
+  const baseId = collapseModelIdToBase(trimmed);
   const effortLevels = options?.effortLevels ?? [];
-  const overrides = [];
-  const contextWindow = asContextWindow(options?.selectedContextWindow);
-  if (contextWindow === "1m") {
-    overrides.push("context=1m");
+  const wireEffort = resolveWireEffort({
+    harness: "cursor_agent_cli",
+    modelId: baseId,
+    selectedEffortLevel: options?.selectedEffortLevel,
+    effortLevels
+  });
+  let id = baseId;
+  if (wireEffort) {
+    const alanLevel = wireEffort === "none" ? "minimal" : wireEffort;
+    if (isEffortLevel(alanLevel)) {
+      const allowed = effortLevels.length === 0 || effortLevels.includes(alanLevel) || alanLevel === "minimal" && effortLevels.includes("minimal");
+      if (allowed) {
+        id = `${baseId}${cursorEffortSuffix(alanLevel, baseId)}`;
+      }
+    }
   }
-  const effort = asEffortLevel(options?.selectedEffortLevel, effortLevels);
-  if (effort) {
-    overrides.push(`effort=${cursorEffortForBracket(effort)}`);
+  const contextWindow = asContextWindow(options?.selectedContextWindow);
+  if (contextWindow === "1m" && id === baseId) {
+    return `${baseId}[context=1m]`;
   }
-  if (overrides.length === 0) return parsed.baseId;
-  return `${parsed.baseId}[${overrides.join(",")}]`;
+  if (parsed.fast) return `${id}-fast`;
+  return id;
 }
 function isCursorAgentCliModelId(model) {
   return model === "auto" || /^composer-/.test(model) || /^gpt-/.test(model) || /^claude-/.test(model) || /^gemini-/.test(model) || /^grok-/.test(model) || /^kimi-/.test(model);
@@ -18359,7 +18491,7 @@ function createCursorAgentCliBackend(command = "cursor-agent", defaultArgs = [])
             }
             const model = ctx.config.selectedModel?.trim();
             if (model && isDispatchableCursorModel(model)) {
-              const modelDef = findModelDef("cursor_agent_cli", model);
+              const modelDef = findModelDef("cursor_agent_cli", model) ?? findModelDef("cursor_agent_cli", model.replace(/-fast$/, ""));
               args.push(
                 "--model",
                 buildCursorAgentModelArg(model, {
@@ -19147,17 +19279,7 @@ function handleOpencodeStructuredEvent(parsed, context, state) {
         void presenter.onError(message);
         state.error = message;
       }
-      const pid = state.process?.pid;
-      if (pid) {
-        try {
-          process.kill(-pid, "SIGTERM");
-        } catch {
-          try {
-            state.process?.kill("SIGTERM");
-          } catch {
-          }
-        }
-      }
+      killProcessTree(state.process?.pid, { signal: "SIGTERM", child: state.process });
       return true;
     }
     default:
@@ -19707,6 +19829,8 @@ Prefer relative paths and keep your work scoped to this project.`
       runtimeCommand || "generic-cli",
       runtimeArgs
     );
+    const revalidateRuntimeCommand = this.revalidateRuntimeCommand;
+    const revalidateCommand = revalidateRuntimeCommand ? () => revalidateRuntimeCommand.call(this) : void 0;
     let lastResult = null;
     for (let attempt = 0; attempt <= _BaseMachineAgent.MAX_RETRIES; attempt++) {
       if (this.abortController?.signal.aborted) break;
@@ -19717,7 +19841,8 @@ Prefer relative paths and keep your work scoped to this project.`
         cwd,
         env,
         promptText,
-        onProcessSpawned: this.getOnProcessSpawned()
+        onProcessSpawned: this.getOnProcessSpawned(),
+        revalidateCommand
       });
       lastResult = {
         ...result,
@@ -19767,7 +19892,8 @@ ${runtimeConfig.task}` } : {}
           cwd,
           env,
           promptText: fallbackContext ? this.buildPromptText(runtimeConfig) : promptText,
-          onProcessSpawned: this.getOnProcessSpawned()
+          onProcessSpawned: this.getOnProcessSpawned(),
+          revalidateCommand
         });
         lastResult = {
           ...retryResult,
@@ -20187,38 +20313,32 @@ var CoreAgent = class _CoreAgent extends BaseMachineAgent {
     const pid = child.pid;
     if (!pid) return false;
     console.info("[CoreAgent] Killing agent process", { pid });
-    try {
-      if (process.platform === "win32") {
-        child.kill("SIGTERM");
-      } else {
-        process.kill(-pid, "SIGTERM");
-      }
-    } catch (err) {
-      if (err.code !== "ESRCH") {
-        console.warn("[CoreAgent] SIGTERM failed", { pid, err });
-      }
-      try {
-        child.kill("SIGTERM");
-      } catch {
-      }
-    }
+    killProcessTree(pid, {
+      signal: "SIGTERM",
+      child,
+      onError: (stage, err) => console.warn(`[CoreAgent] SIGTERM failed (${stage})`, { pid, err })
+    });
     setTimeout(() => {
       if (child.killed || child.exitCode !== null) return;
       console.warn("[CoreAgent] Escalating to SIGKILL", { pid });
-      try {
-        if (process.platform === "win32") {
-          child.kill("SIGKILL");
-        } else {
-          process.kill(-pid, "SIGKILL");
-        }
-      } catch (err) {
-        if (err.code !== "ESRCH") {
-          console.warn("[CoreAgent] SIGKILL failed", { pid, err });
-        }
-      }
+      killProcessTree(pid, {
+        signal: "SIGKILL",
+        child,
+        onError: (stage, err) => console.warn(`[CoreAgent] SIGKILL failed (${stage})`, { pid, err })
+      });
     }, _CoreAgent.SIGKILL_DELAY_MS);
     return true;
   }
+  /**
+   * Re-resolve this agent's CLI executable from scratch when a spawn fails
+   * ENOENT. The daemon caches resolved CLI paths, so a provider binary that was
+   * moved or reinstalled mid-session would otherwise fail every turn with
+   * "CLI command not found" until the daemon restarts. Invalidating the cache
+   * and re-resolving once lets the current run recover against the new location.
+   */
+  revalidateRuntimeCommand() {
+    return revalidateBackendRuntimeCommand(this.runtime.backendKind) ?? null;
+  }
   // ── Interactive tool response (WS relay → stdin) ───────────────────────
   /**
    * Send a tool_result to the CLI's stdin (stream-json format).
@@ -20571,6 +20691,8 @@ var EncryptedEventOutbox = class {
   inFlightEventId = null;
   ackTimer = null;
   retryTimer = null;
+  /** Latch so a persistent disk failure logs once per streak, not per event. */
+  persistFailureLogged = false;
   key;
   maxEncryptedBytes;
   maxIntermediateEventsPerRun;
@@ -20774,30 +20896,42 @@ var EncryptedEventOutbox = class {
     }
   }
   persist() {
-    if (this.entries.length === 0) {
-      (0, import_node_fs6.rmSync)(this.path, { force: true });
-      return;
-    }
-    (0, import_node_fs6.mkdirSync)((0, import_node_path5.dirname)(this.path), { recursive: true, mode: 448 });
-    const iv = (0, import_node_crypto.randomBytes)(12);
-    const cipher = (0, import_node_crypto.createCipheriv)("aes-256-gcm", this.key, iv);
-    const ciphertext = Buffer.concat([
-      cipher.update(JSON.stringify({ entries: this.entries }), "utf8"),
-      cipher.final()
-    ]);
-    const envelope = {
-      version: OUTBOX_VERSION,
-      iv: iv.toString("base64url"),
-      authTag: cipher.getAuthTag().toString("base64url"),
-      ciphertext: ciphertext.toString("base64url")
-    };
-    const pendingPath = `${this.path}.pending-${process.pid}-${(0, import_node_crypto.randomBytes)(6).toString("hex")}`;
     try {
-      (0, import_node_fs6.writeFileSync)(pendingPath, JSON.stringify(envelope), { mode: 384 });
-      (0, import_node_fs6.chmodSync)(pendingPath, 384);
-      (0, import_node_fs6.renameSync)(pendingPath, this.path);
-    } finally {
-      (0, import_node_fs6.rmSync)(pendingPath, { force: true });
+      if (this.entries.length === 0) {
+        (0, import_node_fs6.rmSync)(this.path, { force: true });
+        this.persistFailureLogged = false;
+        return;
+      }
+      (0, import_node_fs6.mkdirSync)((0, import_node_path5.dirname)(this.path), { recursive: true, mode: 448 });
+      const iv = (0, import_node_crypto.randomBytes)(12);
+      const cipher = (0, import_node_crypto.createCipheriv)("aes-256-gcm", this.key, iv);
+      const ciphertext = Buffer.concat([
+        cipher.update(JSON.stringify({ entries: this.entries }), "utf8"),
+        cipher.final()
+      ]);
+      const envelope = {
+        version: OUTBOX_VERSION,
+        iv: iv.toString("base64url"),
+        authTag: cipher.getAuthTag().toString("base64url"),
+        ciphertext: ciphertext.toString("base64url")
+      };
+      const pendingPath = `${this.path}.pending-${process.pid}-${(0, import_node_crypto.randomBytes)(6).toString("hex")}`;
+      try {
+        (0, import_node_fs6.writeFileSync)(pendingPath, JSON.stringify(envelope), { mode: 384 });
+        (0, import_node_fs6.chmodSync)(pendingPath, 384);
+        (0, import_node_fs6.renameSync)(pendingPath, this.path);
+      } finally {
+        (0, import_node_fs6.rmSync)(pendingPath, { force: true });
+      }
+      this.persistFailureLogged = false;
+    } catch (error) {
+      if (!this.persistFailureLogged) {
+        this.persistFailureLogged = true;
+        const detail = error instanceof Error ? error.message : String(error);
+        this.pushLog(
+          `event_outbox_persist_failed error=${detail} pending_entries=${this.entries.length}`
+        );
+      }
     }
   }
 };
@@ -22443,7 +22577,7 @@ var RunStartGate = class {
 };
 
 // src/version.ts
-var AGENT_VERSION = "0.1.40";
+var AGENT_VERSION = "0.1.42";
 
 // src/workspace-relocation.ts
 var import_node_child_process3 = require("child_process");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiden-ade/sandbox-agent",
-  "version": "0.1.40",
+  "version": "0.1.42",
   "type": "module",
   "description": "Alan agent runtime — cloud sandbox and local daemon (alan-agent CLI)",
   "bin": {