@alan-ai-hq/agent-manager 0.1.123 → 0.1.124

package/dist/index.cjs

@@ -14312,7 +14312,7 @@ var require_extract = __commonJS({
 var require_constants2 = __commonJS({
   "../../node_modules/tar-stream/constants.js"(exports2, module2) {
     "use strict";
-    var constants5 = {
+    var constants6 = {
       // just for envs without fs
       S_IFMT: 61440,
       S_IFDIR: 16384,
@@ -14322,9 +14322,9 @@ var require_constants2 = __commonJS({
       S_IFLNK: 40960
     };
     try {
-      module2.exports = require("fs").constants || constants5;
+      module2.exports = require("fs").constants || constants6;
     } catch {
-      module2.exports = constants5;
+      module2.exports = constants6;
     }
   }
 });
@@ -14335,7 +14335,7 @@ var require_pack = __commonJS({
     "use strict";
     var { Readable: Readable2, Writable, getStreamError } = require_streamx();
     var b4a = require_b4a();
-    var constants5 = require_constants2();
+    var constants6 = require_constants2();
     var headers = require_headers();
     var DMODE = 493;
     var FMODE = 420;
@@ -14538,16 +14538,16 @@ var require_pack = __commonJS({
       return new Pack(opts);
     };
     function modeToType(mode) {
-      switch (mode & constants5.S_IFMT) {
-        case constants5.S_IFBLK:
+      switch (mode & constants6.S_IFMT) {
+        case constants6.S_IFBLK:
           return "block-device";
-        case constants5.S_IFCHR:
+        case constants6.S_IFCHR:
           return "character-device";
-        case constants5.S_IFDIR:
+        case constants6.S_IFDIR:
           return "directory";
-        case constants5.S_IFIFO:
+        case constants6.S_IFIFO:
           return "fifo";
-        case constants5.S_IFLNK:
+        case constants6.S_IFLNK:
           return "symlink";
       }
       return "file";
@@ -14643,12 +14643,12 @@ function resolveCommand(args, env) {
 // src/cli/hook.ts
 var import_node_fs9 = require("fs");
 var import_node_http = require("http");
-var import_node_path10 = require("path");
+var import_node_path12 = require("path");
 
 // src/daemon/control.ts
-var import_node_crypto = require("crypto");
+var import_node_crypto2 = require("crypto");
 var import_node_fs8 = require("fs");
-var import_node_path7 = require("path");
+var import_node_path9 = require("path");
 
 // src/runtime-config.ts
 var import_node_fs = require("fs");
@@ -33437,9 +33437,9 @@ var transcriptSyncPendingRunSchema = external_exports.object({
   problemPermanent: external_exports.boolean().optional()
 });
 var RUNNER_CAPACITY_SOURCES = ["default", "config", "provider_limit"];
-var DEFAULT_MAX_ACTIVE_RUNS = 4;
 var MIN_MAX_ACTIVE_RUNS = 1;
 var MAX_MAX_ACTIVE_RUNS = 32;
+var DEFAULT_MAX_ACTIVE_RUNS = MAX_MAX_ACTIVE_RUNS;
 var runnerCapacitySourceSchema = external_exports.enum(RUNNER_CAPACITY_SOURCES);
 var runtimeRunnerStatusSchema = external_exports.object({
   daemonSessionId: external_exports.uuid(),
@@ -33707,14 +33707,153 @@ function bindAgentConfigPathFromArgs(args) {
 
 // src/daemon/status.ts
 var import_node_fs7 = require("fs");
-var import_node_os5 = require("os");
-var import_node_path6 = require("path");
+var import_node_os6 = require("os");
+var import_node_path8 = require("path");
 
 // ../shared/dist/node/provider-limits.js
 var import_node_child_process = require("child_process");
-var import_node_fs2 = require("fs");
+var import_node_fs3 = require("fs");
+var import_node_os3 = require("os");
+var import_node_path4 = require("path");
+
+// ../shared/dist/node/shell-path.js
 var import_node_os2 = require("os");
+var import_node_path3 = require("path");
+
+// ../shared/dist/node/version-manager-paths.js
+var import_node_fs2 = require("fs");
 var import_node_path2 = require("path");
+function compareNodeVersionsDesc(a, b) {
+  const parse8 = (value2) => value2.replace(/^v/, "").split(".").map((part) => Number.parseInt(part, 10) || 0);
+  const left = parse8(a);
+  const right = parse8(b);
+  for (let i = 0; i < 3; i += 1) {
+    const diff = (right[i] ?? 0) - (left[i] ?? 0);
+    if (diff !== 0)
+      return diff;
+  }
+  return 0;
+}
+function resolveNvmDefaultBin(home) {
+  const versionsDir = (0, import_node_path2.join)(home, ".nvm", "versions", "node");
+  if (!(0, import_node_fs2.existsSync)(versionsDir))
+    return null;
+  let alias = null;
+  try {
+    const aliasFile = (0, import_node_path2.join)(home, ".nvm", "alias", "default");
+    if ((0, import_node_fs2.existsSync)(aliasFile))
+      alias = (0, import_node_fs2.readFileSync)(aliasFile, "utf8").trim();
+  } catch {
+    alias = null;
+  }
+  let installed;
+  try {
+    installed = (0, import_node_fs2.readdirSync)(versionsDir).filter((entry) => entry.startsWith("v"));
+  } catch {
+    return null;
+  }
+  if (installed.length === 0)
+    return null;
+  const matching = alias ? installed.filter((entry) => entry === alias || entry === `v${alias}` || entry.startsWith(`v${alias}.`)) : [];
+  const chosen = (matching.length > 0 ? matching : installed).sort(compareNodeVersionsDesc)[0];
+  if (!chosen)
+    return null;
+  const bin = (0, import_node_path2.join)(versionsDir, chosen, "bin");
+  return (0, import_node_fs2.existsSync)(bin) ? bin : null;
+}
+function resolveVersionManagerBinDirs(home, platform7 = process.platform) {
+  if (platform7 === "win32")
+    return [];
+  const candidates = [
+    resolveNvmDefaultBin(home),
+    (0, import_node_path2.join)(home, ".volta", "bin"),
+    (0, import_node_path2.join)(home, ".fnm", "aliases", "default", "bin"),
+    (0, import_node_path2.join)(home, "Library", "Application Support", "fnm", "aliases", "default", "bin"),
+    (0, import_node_path2.join)(home, ".asdf", "shims"),
+    (0, import_node_path2.join)(home, ".local", "share", "mise", "shims")
+  ];
+  const seen = /* @__PURE__ */ new Set();
+  const resolved = [];
+  for (const dir of candidates) {
+    if (!dir || seen.has(dir))
+      continue;
+    seen.add(dir);
+    if ((0, import_node_fs2.existsSync)(dir))
+      resolved.push(dir);
+  }
+  return resolved;
+}
+
+// ../shared/dist/node/shell-path.js
+function splitPath(value2) {
+  const separator = (0, import_node_os2.platform)() === "win32" ? ";" : ":";
+  return (value2 ?? "").split(separator).filter(Boolean);
+}
+function joinPath(segments) {
+  return segments.join((0, import_node_os2.platform)() === "win32" ? ";" : ":");
+}
+function dedupePath(value2) {
+  const seen = /* @__PURE__ */ new Set();
+  const kept2 = [];
+  for (const dir of splitPath(value2)) {
+    if (seen.has(dir))
+      continue;
+    seen.add(dir);
+    kept2.push(dir);
+  }
+  return joinPath(kept2);
+}
+function promoteAheadOfVersionManagers(path2, promoted, versionManagerDirs) {
+  const managed = new Set(versionManagerDirs);
+  const firstManaged = path2.findIndex((dir) => managed.has(dir));
+  if (firstManaged === -1)
+    return path2;
+  const before = path2.slice(0, firstManaged);
+  const tail = path2.slice(firstManaged);
+  const moved = tail.filter((dir) => promoted.has(dir));
+  if (moved.length === 0)
+    return path2;
+  return [...before, ...moved, ...tail.filter((dir) => !promoted.has(dir))];
+}
+function promotedUserBinDirs(home) {
+  return /* @__PURE__ */ new Set([
+    (0, import_node_path3.join)(home, ".local", "bin"),
+    (0, import_node_path3.join)(home, ".bun", "bin"),
+    (0, import_node_path3.join)(home, ".cargo", "bin")
+  ]);
+}
+function augmentCliPath(env, includeSystemPaths = true) {
+  const source2 = {};
+  for (const [key, value2] of Object.entries(env)) {
+    if (value2 !== void 0)
+      source2[key] = value2;
+  }
+  const home = source2.HOME || source2.USERPROFILE || (0, import_node_os2.homedir)();
+  const isWin = (0, import_node_os2.platform)() === "win32";
+  const windowsLocalAppData = source2.LOCALAPPDATA || (0, import_node_path3.join)(home, "AppData", "Local");
+  const versionManagerDirs = isWin ? [] : resolveVersionManagerBinDirs(home);
+  const userPaths = isWin ? [
+    (0, import_node_path3.join)(home, "AppData", "Roaming", "npm"),
+    (0, import_node_path3.join)(windowsLocalAppData, "Programs", "OpenAI", "Codex", "bin"),
+    (0, import_node_path3.join)(windowsLocalAppData, "Programs", "Microsoft", "WindowsApps"),
+    (0, import_node_path3.join)(home, ".local", "bin")
+  ] : [
+    (0, import_node_path3.join)(home, ".local", "bin"),
+    (0, import_node_path3.join)(home, ".local", "node", "bin"),
+    (0, import_node_path3.join)(home, ".bun", "bin"),
+    (0, import_node_path3.join)(home, ".cargo", "bin"),
+    ...versionManagerDirs
+  ];
+  const systemPaths = isWin ? ["C:\\Program Files\\nodejs", "C:\\Program Files\\Git\\cmd"] : ["/opt/homebrew/bin", "/usr/local/bin"];
+  const extraPaths = includeSystemPaths ? [...userPaths, ...systemPaths] : userPaths;
+  const existing = new Set(splitPath(source2.PATH));
+  const missing = extraPaths.filter((dir) => !existing.has(dir));
+  const combined = [...missing, ...splitPath(source2.PATH)];
+  const ordered = isWin ? combined : promoteAheadOfVersionManagers(combined, promotedUserBinDirs(home), versionManagerDirs);
+  return { ...source2, PATH: dedupePath(joinPath(ordered)) };
+}
+
+// ../shared/dist/node/provider-limits.js
 var CACHE_TTL_MS = 6e4;
 var cachedLimits = null;
 function numericValue(value2) {
@@ -33725,42 +33864,23 @@ function numericValue(value2) {
   }
   return null;
 }
-function splitPath(value2) {
-  return (value2 ?? "").split(import_node_path2.delimiter).filter(Boolean);
+function splitPath2(value2) {
+  return (value2 ?? "").split(import_node_path4.delimiter).filter(Boolean);
 }
 function isExecutableFile(path2) {
   try {
-    (0, import_node_fs2.accessSync)(path2, import_node_fs2.constants.X_OK);
+    (0, import_node_fs3.accessSync)(path2, import_node_fs3.constants.X_OK);
     return true;
   } catch {
     return false;
   }
 }
-function augmentCliPath(env) {
-  const home = env.HOME || (0, import_node_os2.homedir)();
-  const extraPaths = [
-    (0, import_node_path2.join)(home, ".local", "bin"),
-    (0, import_node_path2.join)(home, ".local", "node", "bin"),
-    (0, import_node_path2.join)(home, ".bun", "bin"),
-    (0, import_node_path2.join)(home, ".cargo", "bin"),
-    "/opt/homebrew/bin",
-    "/usr/local/bin"
-  ];
-  const existing = new Set(splitPath(env.PATH));
-  const missing = extraPaths.filter((path2) => !existing.has(path2));
-  if (missing.length === 0)
-    return env;
-  return {
-    ...env,
-    PATH: `${missing.join(import_node_path2.delimiter)}${import_node_path2.delimiter}${env.PATH ?? ""}`
-  };
-}
 function resolveExecutable(command, env, overrideEnvVar) {
   const override = env[overrideEnvVar]?.trim();
   if (override && isExecutableFile(override))
     return override;
-  for (const dir of splitPath(env.PATH)) {
-    const candidate = (0, import_node_path2.join)(dir, command);
+  for (const dir of splitPath2(env.PATH)) {
+    const candidate = (0, import_node_path4.join)(dir, command);
     if (isExecutableFile(candidate))
       return candidate;
   }
@@ -33904,10 +34024,10 @@ async function collectCodexLimits(env) {
   }), 4e3, []);
 }
 function readClaudeCredentialsPayload() {
-  const path2 = (0, import_node_path2.join)((0, import_node_os2.homedir)(), ".claude", ".credentials.json");
-  if ((0, import_node_fs2.existsSync)(path2)) {
+  const path2 = (0, import_node_path4.join)((0, import_node_os3.homedir)(), ".claude", ".credentials.json");
+  if ((0, import_node_fs3.existsSync)(path2)) {
     try {
-      return JSON.parse((0, import_node_fs2.readFileSync)(path2, "utf8"));
+      return JSON.parse((0, import_node_fs3.readFileSync)(path2, "utf8"));
     } catch {
       return null;
     }
@@ -34043,11 +34163,11 @@ async function collectAntigravityLimits(env) {
 var CURSOR_USAGE_URL = "https://api2.cursor.sh/aiserver.v1.DashboardService/GetCurrentPeriodUsage";
 function cursorAuthFilePath(platform7, env, home) {
   if (platform7 === "win32") {
-    return (0, import_node_path2.join)(env.APPDATA || (0, import_node_path2.join)(home, "AppData", "Roaming"), "Cursor", "auth.json");
+    return (0, import_node_path4.join)(env.APPDATA || (0, import_node_path4.join)(home, "AppData", "Roaming"), "Cursor", "auth.json");
   }
   if (platform7 === "darwin")
-    return (0, import_node_path2.join)(home, ".cursor", "auth.json");
-  return (0, import_node_path2.join)(env.XDG_CONFIG_HOME || (0, import_node_path2.join)(home, ".config"), "cursor", "auth.json");
+    return (0, import_node_path4.join)(home, ".cursor", "auth.json");
+  return (0, import_node_path4.join)(env.XDG_CONFIG_HOME || (0, import_node_path4.join)(home, ".config"), "cursor", "auth.json");
 }
 function readCursorKeychainToken() {
   if (process.platform !== "darwin")
@@ -34061,8 +34181,8 @@ function readCursorKeychainToken() {
 }
 function readCursorAuthFileToken() {
   try {
-    const path2 = cursorAuthFilePath(process.platform, process.env, (0, import_node_os2.homedir)());
-    const parsed = JSON.parse((0, import_node_fs2.readFileSync)(path2, "utf8"));
+    const path2 = cursorAuthFilePath(process.platform, process.env, (0, import_node_os3.homedir)());
+    const parsed = JSON.parse((0, import_node_fs3.readFileSync)(path2, "utf8"));
     return typeof parsed.accessToken === "string" && parsed.accessToken.trim() ? parsed.accessToken.trim() : null;
   } catch {
     return null;
@@ -34168,8 +34288,8 @@ async function collectLocalAgentProviderLimits(env = process.env) {
 var import_node_child_process3 = require("child_process");
 var import_node_fs5 = require("fs");
 var import_node_module = require("module");
-var import_node_os4 = require("os");
-var import_node_path5 = require("path");
+var import_node_os5 = require("os");
+var import_node_path7 = require("path");
 
 // ../sandbox-runtime-spec/dist/index.js
 function quote(value2) {
@@ -34569,141 +34689,208 @@ function canRepairSandboxRuntime(runtime, platform7, sandboxProvider) {
 }
 
 // src/shell-environment.ts
+var import_node_path6 = require("path");
+
+// ../shared/dist/node/shell-environment.js
 var import_node_child_process2 = require("child_process");
+var import_node_crypto = require("crypto");
 var import_node_fs4 = require("fs");
-var import_node_os3 = require("os");
-var import_node_path4 = require("path");
-
-// src/version-manager-paths.ts
-var import_node_fs3 = require("fs");
-var import_node_path3 = require("path");
-function compareNodeVersionsDesc(a, b) {
-  const parse8 = (value2) => value2.replace(/^v/, "").split(".").map((part) => Number.parseInt(part, 10) || 0);
-  const left = parse8(a);
-  const right = parse8(b);
-  for (let i = 0; i < 3; i += 1) {
-    const diff = (right[i] ?? 0) - (left[i] ?? 0);
-    if (diff !== 0) return diff;
-  }
-  return 0;
+var import_node_os4 = require("os");
+var import_node_path5 = require("path");
+var PROBE_TIMEOUT_MS = 2e4;
+var DEGRADED_RETRY_BACKOFF_MS = 3e4;
+var SNAPSHOT_FILE_VERSION = 1;
+var SELF_GUARD_ENV = "ALAN_RESOLVING_ENVIRONMENT";
+var config2 = { snapshotFile: null, timeoutMs: PROBE_TIMEOUT_MS };
+var cachedState = null;
+var nextRetryAtMs = 0;
+var lastProbeError = null;
+function configureShellEnvironment(next) {
+  if (next.snapshotFile !== void 0)
+    config2.snapshotFile = next.snapshotFile;
+  if (next.timeoutMs !== void 0)
+    config2.timeoutMs = next.timeoutMs;
 }
-function resolveNvmDefaultBin(home) {
-  const versionsDir = (0, import_node_path3.join)(home, ".nvm", "versions", "node");
-  if (!(0, import_node_fs3.existsSync)(versionsDir)) return null;
-  let alias = null;
+function isExecutableFile2(path2) {
   try {
-    const aliasFile = (0, import_node_path3.join)(home, ".nvm", "alias", "default");
-    if ((0, import_node_fs3.existsSync)(aliasFile)) alias = (0, import_node_fs3.readFileSync)(aliasFile, "utf8").trim();
+    (0, import_node_fs4.accessSync)(path2, import_node_fs4.constants.X_OK);
+    return true;
   } catch {
-    alias = null;
+    return false;
   }
-  let installed;
+}
+function resolveLoginShell(env = process.env) {
+  if ((0, import_node_os4.platform)() === "win32")
+    return null;
+  const explicit = env.SHELL?.trim();
+  if (explicit && (0, import_node_path5.isAbsolute)(explicit) && isExecutableFile2(explicit))
+    return explicit;
   try {
-    installed = (0, import_node_fs3.readdirSync)(versionsDir).filter((entry) => entry.startsWith("v"));
+    const accountShell = (0, import_node_os4.userInfo)().shell?.trim();
+    if (accountShell && (0, import_node_path5.isAbsolute)(accountShell) && isExecutableFile2(accountShell)) {
+      return accountShell;
+    }
   } catch {
-    return null;
   }
-  if (installed.length === 0) return null;
-  const matching = alias ? installed.filter(
-    (entry) => entry === alias || entry === `v${alias}` || entry.startsWith(`v${alias}.`)
-  ) : [];
-  const chosen = (matching.length > 0 ? matching : installed).sort(compareNodeVersionsDesc)[0];
-  if (!chosen) return null;
-  const bin = (0, import_node_path3.join)(versionsDir, chosen, "bin");
-  return (0, import_node_fs3.existsSync)(bin) ? bin : null;
+  const fallback = (0, import_node_os4.platform)() === "darwin" ? "/bin/zsh" : "/bin/bash";
+  return isExecutableFile2(fallback) ? fallback : null;
 }
-function resolveVersionManagerBinDirs(home, platform7 = process.platform) {
-  if (platform7 === "win32") return [];
-  const candidates = [
-    resolveNvmDefaultBin(home),
-    (0, import_node_path3.join)(home, ".volta", "bin"),
-    (0, import_node_path3.join)(home, ".fnm", "aliases", "default", "bin"),
-    (0, import_node_path3.join)(home, "Library", "Application Support", "fnm", "aliases", "default", "bin"),
-    (0, import_node_path3.join)(home, ".asdf", "shims"),
-    (0, import_node_path3.join)(home, ".local", "share", "mise", "shims")
-  ];
-  const seen = /* @__PURE__ */ new Set();
-  const resolved = [];
-  for (const dir of candidates) {
-    if (!dir || seen.has(dir)) continue;
-    seen.add(dir);
-    if ((0, import_node_fs3.existsSync)(dir)) resolved.push(dir);
+function buildProbeEnvironment() {
+  const env = {};
+  for (const [key, value2] of Object.entries(process.env)) {
+    if (value2 !== void 0)
+      env[key] = value2;
+  }
+  if (!env.HOME || !(0, import_node_fs4.existsSync)(env.HOME))
+    env.HOME = (0, import_node_os4.homedir)();
+  env[SELF_GUARD_ENV] = "1";
+  if (process.versions.electron)
+    env.ELECTRON_RUN_AS_NODE = "1";
+  return env;
+}
+function escapeForSingleQuotes(value2) {
+  return value2.replace(/'/g, "'\\''");
+}
+function buildProbeCommand(execPath, mark) {
+  return `'${escapeForSingleQuotes(execPath)}' -p '"${mark}" + JSON.stringify(process.env) + "${mark}"'`;
+}
+function extractProbePayload(stdout, mark) {
+  const first = stdout.indexOf(mark);
+  if (first === -1)
+    return null;
+  const second = stdout.indexOf(mark, first + mark.length);
+  if (second === -1)
+    return null;
+  try {
+    const parsed = JSON.parse(stdout.slice(first + mark.length, second).trim());
+    if (!parsed || typeof parsed !== "object")
+      return null;
+    const env = {};
+    for (const [key, value2] of Object.entries(parsed)) {
+      if (typeof value2 === "string")
+        env[key] = value2;
+    }
+    return env;
+  } catch {
+    return null;
   }
-  return resolved;
 }
-
-// src/shell-environment.ts
-var LOGIN_SHELL_PROBE_TIMEOUT_MS = 2e4;
-var DEGRADED_RETRY_BACKOFF_MS = 3e4;
-var SHELL_PATH_SNAPSHOT_FILE = "shell-path.json";
-var SHELL_PATH_SNAPSHOT_VERSION = 1;
-var cachedState = null;
-var nextRetryAtMs = 0;
-var lastProbeError = null;
-function parseEnvOutput(output2) {
-  const loginEnv = {};
+function parseShellEnvLines(output2) {
+  const env = {};
   for (const line of output2.split("\n")) {
-    if (!line.trim()) continue;
+    if (!line.trim())
+      continue;
     const eqIdx = line.indexOf("=");
-    if (eqIdx <= 0) continue;
+    if (eqIdx <= 0)
+      continue;
     const key = line.slice(0, eqIdx);
-    if (/\s/.test(key)) continue;
-    loginEnv[key] = line.slice(eqIdx + 1);
+    if (/\s/.test(key) || key.endsWith("%%"))
+      continue;
+    env[key] = line.slice(eqIdx + 1);
+  }
+  return env;
+}
+function newMark() {
+  return (0, import_node_crypto.randomUUID)().replace(/-/g, "").slice(0, 12);
+}
+function isTimeout(error61) {
+  if (!error61 || typeof error61 !== "object")
+    return false;
+  const candidate = error61;
+  return candidate.killed === true || candidate.signal === "SIGTERM" || candidate.code === "ETIMEDOUT";
+}
+function isUsableProbe(env) {
+  return env !== null && Boolean(env.PATH?.trim());
+}
+function probeArgs(shell, execPath, mark) {
+  const name = (0, import_node_path5.basename)(shell);
+  if (name === "csh" || name === "tcsh") {
+    return ["-ic", buildProbeCommand(execPath, mark)];
   }
-  if (!loginEnv.HOME) loginEnv.HOME = process.env.HOME ?? (0, import_node_os3.homedir)();
-  if (!loginEnv.SHELL) loginEnv.SHELL = process.env.SHELL ?? "/bin/zsh";
-  return loginEnv;
+  return ["-i", "-l", "-c", buildProbeCommand(execPath, mark)];
 }
-function probeLoginShell() {
-  const shell = process.env.SHELL || "/bin/bash";
+function probeLoginShellBlocking() {
+  const shell = resolveLoginShell();
+  if (!shell) {
+    lastProbeError = "no executable login shell found";
+    return null;
+  }
+  const env = buildProbeEnvironment();
+  const mark = newMark();
   try {
-    const envOutput = (0, import_node_child_process2.execFileSync)(shell, ["-lc", "env"], {
+    const stdout = (0, import_node_child_process2.execFileSync)(shell, probeArgs(shell, process.execPath, mark), {
+      env,
+      timeout: config2.timeoutMs,
       encoding: "utf8",
-      stdio: ["pipe", "pipe", "pipe"],
-      timeout: LOGIN_SHELL_PROBE_TIMEOUT_MS
+      stdio: ["ignore", "pipe", "pipe"],
+      maxBuffer: 8 * 1024 * 1024
     });
-    const parsed = parseEnvOutput(envOutput);
-    if (!parsed.PATH?.trim()) {
-      lastProbeError = "login shell returned no PATH";
+    const payload = extractProbePayload(stdout, mark);
+    if (isUsableProbe(payload))
+      return payload;
+    lastProbeError = "interactive probe returned no PATH";
+  } catch (error61) {
+    if (isTimeout(error61)) {
+      lastProbeError = "interactive probe timed out";
       return null;
     }
-    lastProbeError = null;
-    return parsed;
+    lastProbeError = error61 instanceof Error ? error61.message : String(error61);
+  }
+  try {
+    const stdout = (0, import_node_child_process2.execFileSync)(shell, ["-lc", "env"], {
+      env,
+      timeout: config2.timeoutMs,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"],
+      maxBuffer: 8 * 1024 * 1024
+    });
+    const parsed = parseShellEnvLines(stdout);
+    if (isUsableProbe(parsed))
+      return parsed;
+    lastProbeError = "login shell returned no PATH";
   } catch (error61) {
     lastProbeError = error61 instanceof Error ? error61.message : String(error61);
-    return null;
   }
+  return null;
 }
-function shellPathSnapshotFile() {
-  const explicit = process.env.ALAN_AGENT_CONFIG_PATH?.trim();
-  const dir = explicit ? (0, import_node_path4.dirname)(explicit) : resolveAgentConfigDirectory();
-  return (0, import_node_path4.join)(dir, SHELL_PATH_SNAPSHOT_FILE);
+function normalizeHydratedEnv(env) {
+  const normalized2 = augmentCliPath(env);
+  if (!normalized2.HOME)
+    normalized2.HOME = (0, import_node_os4.homedir)();
+  if (!normalized2.SHELL)
+    normalized2.SHELL = resolveLoginShell() ?? "";
+  return normalized2;
+}
+function snapshotFile() {
+  const configured = config2.snapshotFile;
+  if (!configured)
+    return null;
+  return typeof configured === "function" ? configured() ?? null : configured;
 }
 function persistLastKnownGoodPath(path2) {
+  const file2 = snapshotFile();
+  if (!file2)
+    return;
   try {
-    const file2 = shellPathSnapshotFile();
-    (0, import_node_fs4.mkdirSync)((0, import_node_path4.dirname)(file2), { recursive: true });
-    (0, import_node_fs4.writeFileSync)(
-      file2,
-      `${JSON.stringify(
-        { version: SHELL_PATH_SNAPSHOT_VERSION, path: path2, capturedAt: (/* @__PURE__ */ new Date()).toISOString() },
-        null,
-        2
-      )}
-`,
-      { mode: 384 }
-    );
+    (0, import_node_fs4.mkdirSync)((0, import_node_path5.dirname)(file2), { recursive: true });
+    (0, import_node_fs4.writeFileSync)(file2, `${JSON.stringify({ version: SNAPSHOT_FILE_VERSION, path: path2, capturedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2)}
+`, { mode: 384 });
   } catch {
   }
 }
 function readLastKnownGoodPath() {
+  const file2 = snapshotFile();
+  if (!file2)
+    return null;
   try {
-    const file2 = shellPathSnapshotFile();
-    if (!(0, import_node_fs4.existsSync)(file2)) return null;
+    if (!(0, import_node_fs4.existsSync)(file2))
+      return null;
     const parsed = JSON.parse((0, import_node_fs4.readFileSync)(file2, "utf8"));
-    if (!parsed || typeof parsed !== "object") return null;
+    if (!parsed || typeof parsed !== "object")
+      return null;
     const record4 = parsed;
-    if (record4.version !== SHELL_PATH_SNAPSHOT_VERSION) return null;
+    if (record4.version !== SNAPSHOT_FILE_VERSION)
+      return null;
     return typeof record4.path === "string" && record4.path.trim() ? record4.path : null;
   } catch {
     return null;
@@ -34712,38 +34899,60 @@ function readLastKnownGoodPath() {
 function buildDegradedState() {
   const base = { ...process.env };
   const lastKnownGood = readLastKnownGoodPath();
-  if (!lastKnownGood) return { env: base, source: "process_env" };
-  const existing = new Set(splitPath2(base.PATH ?? ""));
-  const restored = splitPath2(lastKnownGood).filter((dir) => !existing.has(dir));
-  if (restored.length === 0) return { env: base, source: "process_env" };
-  return {
-    env: { ...base, PATH: [...restored, ...splitPath2(base.PATH ?? "")].join(":") },
-    source: "last_known_good_path"
-  };
+  if (lastKnownGood) {
+    const existing = new Set(splitPath(base.PATH));
+    const restored = splitPath(lastKnownGood).filter((dir) => !existing.has(dir));
+    if (restored.length > 0) {
+      return {
+        env: { ...base, PATH: dedupePath(joinPath2([...restored, ...splitPath(base.PATH)])) },
+        source: "last_known_good_path"
+      };
+    }
+  }
+  return { env: normalizeHydratedEnv(base), source: "process_env" };
 }
-function splitPath2(value2) {
-  const separator = (0, import_node_os3.platform)() === "win32" ? ";" : ":";
-  return value2.split(separator).filter(Boolean);
+function joinPath2(segments) {
+  return segments.join((0, import_node_os4.platform)() === "win32" ? ";" : ":");
 }
-function loadLoginShellEnvironment() {
-  if ((0, import_node_os3.platform)() === "win32") {
+function acceptProbedEnv(probed) {
+  const env = normalizeHydratedEnv(probed);
+  nextRetryAtMs = 0;
+  persistLastKnownGoodPath(env.PATH ?? "");
+  return { env, source: "login_shell" };
+}
+function degrade() {
+  if (!lastProbeError)
+    lastProbeError = "login shell probe failed";
+  nextRetryAtMs = Date.now() + DEGRADED_RETRY_BACKOFF_MS;
+  return buildDegradedState();
+}
+function loadShellEnvironmentSync() {
+  if ((0, import_node_os4.platform)() === "win32") {
     cachedState ??= { env: process.env, source: "process_env" };
     return cachedState.env;
   }
-  if (cachedState?.source === "login_shell") return cachedState.env;
-  if (cachedState && Date.now() < nextRetryAtMs) return cachedState.env;
-  const probed = probeLoginShell();
-  if (probed) {
-    cachedState = { env: probed, source: "login_shell" };
-    nextRetryAtMs = 0;
-    persistLastKnownGoodPath(probed.PATH ?? "");
-    return probed;
-  }
-  nextRetryAtMs = Date.now() + DEGRADED_RETRY_BACKOFF_MS;
-  cachedState = buildDegradedState();
+  if (cachedState?.source === "login_shell")
+    return cachedState.env;
+  if (cachedState && Date.now() < nextRetryAtMs)
+    return cachedState.env;
+  const probed = probeLoginShellBlocking();
+  cachedState = isUsableProbe(probed) ? acceptProbedEnv(probed) : degrade();
   return cachedState.env;
 }
 
+// src/shell-environment.ts
+var SNAPSHOT_FILE = "shell-path.json";
+configureShellEnvironment({
+  snapshotFile: () => {
+    const explicit = process.env.ALAN_AGENT_CONFIG_PATH?.trim();
+    const dir = explicit ? (0, import_node_path6.dirname)(explicit) : resolveAgentConfigDirectory();
+    return (0, import_node_path6.join)(dir, SNAPSHOT_FILE);
+  }
+});
+function loadLoginShellEnvironment() {
+  return loadShellEnvironmentSync();
+}
+
 // src/cli-executable.ts
 var ALAN_CODE_PROVIDER_KIND = "alan_code";
 var DISCOVERABLE_PROVIDER_KINDS = [
@@ -34764,8 +34973,8 @@ function appendCliProbeOutput(current, chunk, limit) {
   return current + chunk.slice(0, limit - current.length);
 }
 function getDaemonCliEnvironment() {
-  const base = (0, import_node_os4.platform)() === "win32" ? process.env : loadLoginShellEnvironment();
-  return augmentCliPath2(base);
+  const base = (0, import_node_os5.platform)() === "win32" ? process.env : loadLoginShellEnvironment();
+  return augmentCliPath(base);
 }
 function cacheResolvedCli(command, resolvedPath) {
   resolvedCliCache.set(command, resolvedPath);
@@ -34791,8 +35000,8 @@ function getCachedResolvedCli(command) {
   return cached2;
 }
 function resolveViaWhere(command, env) {
-  if ((0, import_node_os4.platform)() !== "win32") return null;
-  const whereExe = (0, import_node_path5.join)(
+  if ((0, import_node_os5.platform)() !== "win32") return null;
+  const whereExe = (0, import_node_path7.join)(
     env.SystemRoot ?? process.env.SystemRoot ?? "C:\\Windows",
     "System32",
     "where.exe"
@@ -34814,7 +35023,7 @@ function resolveViaWhere(command, env) {
 }
 function runCliProbeAsync(executable, env, args = ["--version"], timeoutMs = 3e3, spawnOptions) {
   return new Promise((resolve16) => {
-    const isWin = (0, import_node_os4.platform)() === "win32";
+    const isWin = (0, import_node_os5.platform)() === "win32";
     let command = executable;
     let commandArgs = args;
     if (isWin && /\.(cmd|bat)$/i.test(executable)) {
@@ -34859,7 +35068,7 @@ function runCliVersionProbeAsync(executable, env, args = ["--version"], timeoutM
   return runCliProbeAsync(executable, env, args, timeoutMs);
 }
 function pathSeparator() {
-  return (0, import_node_os4.platform)() === "win32" ? ";" : ":";
+  return (0, import_node_os5.platform)() === "win32" ? ";" : ":";
 }
 function splitPath3(pathValue) {
   if (!pathValue) return [];
@@ -34867,7 +35076,7 @@ function splitPath3(pathValue) {
 }
 function isRunnableFile(path2) {
   if (!(0, import_node_fs5.existsSync)(path2)) return false;
-  if ((0, import_node_os4.platform)() === "win32") return true;
+  if ((0, import_node_os5.platform)() === "win32") return true;
   try {
     (0, import_node_fs5.accessSync)(path2, import_node_fs5.constants.X_OK);
     return true;
@@ -34894,15 +35103,15 @@ var WINDOWS_CODEX_NATIVE_TARGETS = {
   }
 };
 function resolveWindowsCodexNativeExecutable(executable) {
-  if ((0, import_node_os4.platform)() !== "win32" || /\.exe$/i.test(executable) || (0, import_node_path5.basename)(executable).toLowerCase() !== "codex.cmd") {
+  if ((0, import_node_os5.platform)() !== "win32" || /\.exe$/i.test(executable) || (0, import_node_path7.basename)(executable).toLowerCase() !== "codex.cmd") {
     return executable;
   }
-  const target = WINDOWS_CODEX_NATIVE_TARGETS[(0, import_node_os4.arch)()];
+  const target = WINDOWS_CODEX_NATIVE_TARGETS[(0, import_node_os5.arch)()];
   if (!target) return executable;
-  const shimDir = (0, import_node_path5.dirname)(executable);
+  const shimDir = (0, import_node_path7.dirname)(executable);
   const entrypoints = [
-    (0, import_node_path5.join)(shimDir, "node_modules", "@openai", "codex", "bin", "codex.js"),
-    (0, import_node_path5.join)(shimDir, "..", "@openai", "codex", "bin", "codex.js")
+    (0, import_node_path7.join)(shimDir, "node_modules", "@openai", "codex", "bin", "codex.js"),
+    (0, import_node_path7.join)(shimDir, "..", "@openai", "codex", "bin", "codex.js")
   ];
   for (const entrypoint of entrypoints) {
     if (!(0, import_node_fs5.existsSync)(entrypoint)) continue;
@@ -34910,69 +35119,22 @@ function resolveWindowsCodexNativeExecutable(executable) {
     try {
       const packageJson = (0, import_node_module.createRequire)(entrypoint).resolve(`${target.packageName}/package.json`);
       nativeCandidates.push(
-        (0, import_node_path5.join)((0, import_node_path5.dirname)(packageJson), "vendor", target.targetTriple, "bin", "codex.exe")
+        (0, import_node_path7.join)((0, import_node_path7.dirname)(packageJson), "vendor", target.targetTriple, "bin", "codex.exe")
       );
     } catch {
     }
     nativeCandidates.push(
-      (0, import_node_path5.join)((0, import_node_path5.dirname)(entrypoint), "..", "vendor", target.targetTriple, "bin", "codex.exe")
+      (0, import_node_path7.join)((0, import_node_path7.dirname)(entrypoint), "..", "vendor", target.targetTriple, "bin", "codex.exe")
     );
     const nativeExecutable = nativeCandidates.find(isRunnableFile);
     if (nativeExecutable) return nativeExecutable;
   }
   return executable;
 }
-function promoteAheadOfVersionManagers(path2, promoted, versionManagerDirs) {
-  const managed = new Set(versionManagerDirs);
-  const firstManaged = path2.findIndex((dir) => managed.has(dir));
-  if (firstManaged === -1) return path2;
-  const before = path2.slice(0, firstManaged);
-  const tail = path2.slice(firstManaged);
-  const moved = tail.filter((dir) => promoted.has(dir));
-  if (moved.length === 0) return path2;
-  return [...before, ...moved, ...tail.filter((dir) => !promoted.has(dir))];
-}
-function promotedUserBinDirs(home) {
-  return /* @__PURE__ */ new Set([
-    (0, import_node_path5.join)(home, ".local", "bin"),
-    (0, import_node_path5.join)(home, ".bun", "bin"),
-    (0, import_node_path5.join)(home, ".cargo", "bin")
-  ]);
-}
-function augmentCliPath2(env, includeSystemPaths = true) {
-  const home = env.HOME || env.USERPROFILE || (0, import_node_os4.homedir)();
-  const isWin = (0, import_node_os4.platform)() === "win32";
-  const windowsLocalAppData = env.LOCALAPPDATA || (0, import_node_path5.join)(home, "AppData", "Local");
-  const versionManagerDirs = isWin ? [] : resolveVersionManagerBinDirs(home);
-  const userPaths = isWin ? [
-    (0, import_node_path5.join)(home, "AppData", "Roaming", "npm"),
-    (0, import_node_path5.join)(windowsLocalAppData, "Programs", "OpenAI", "Codex", "bin"),
-    (0, import_node_path5.join)(windowsLocalAppData, "Programs", "Microsoft", "WindowsApps"),
-    (0, import_node_path5.join)(home, ".local", "bin")
-  ] : [
-    (0, import_node_path5.join)(home, ".local", "bin"),
-    (0, import_node_path5.join)(home, ".local", "node", "bin"),
-    (0, import_node_path5.join)(home, ".bun", "bin"),
-    (0, import_node_path5.join)(home, ".cargo", "bin"),
-    // nvm/fnm/volta/asdf/mise live behind shell functions and leave nothing
-    // on a non-interactive PATH, so resolve them from disk. Without this a
-    // degraded shell probe hides node entirely and `env node` hooks die 127.
-    ...versionManagerDirs
-  ];
-  const systemPaths = isWin ? ["C:\\Program Files\\nodejs", "C:\\Program Files\\Git\\cmd"] : ["/opt/homebrew/bin", "/usr/local/bin"];
-  const extraPaths = includeSystemPaths ? [...userPaths, ...systemPaths] : userPaths;
-  const basePath = env.PATH ?? "";
-  const existing = new Set(splitPath3(basePath));
-  const missing = extraPaths.filter((dir) => !existing.has(dir));
-  const combined = missing.length > 0 ? [...missing, ...splitPath3(basePath)] : splitPath3(basePath);
-  const ordered = isWin ? combined : promoteAheadOfVersionManagers(combined, promotedUserBinDirs(home), versionManagerDirs);
-  if (ordered === combined && missing.length === 0) return env;
-  return { ...env, PATH: ordered.join(pathSeparator()) };
-}
 function resolveCliExecutable(command, env) {
   const trimmed4 = command.trim();
   if (!trimmed4) return null;
-  const enriched = augmentCliPath2(env ?? getDaemonCliEnvironment(), env === void 0);
+  const enriched = augmentCliPath(env ?? getDaemonCliEnvironment(), env === void 0);
   const cacheKey = cliResolutionCacheKey(trimmed4, enriched);
   const cached2 = getCachedResolvedCli(cacheKey);
   if (cached2 === null) return null;
@@ -34981,7 +35143,7 @@ function resolveCliExecutable(command, env) {
     cacheResolvedCli(cacheKey, trimmed4);
     return trimmed4;
   }
-  const isWin = (0, import_node_os4.platform)() === "win32";
+  const isWin = (0, import_node_os5.platform)() === "win32";
   const pathExt = enriched.PATHEXT ?? (isWin ? ".EXE;.CMD;.BAT;.COM" : "");
   const commandNames = [trimmed4, ...CLI_COMMAND_ALIASES[trimmed4] ?? []];
   const names = commandNames.flatMap(
@@ -34994,7 +35156,7 @@ function resolveCliExecutable(command, env) {
       continue;
     }
     for (const dir of splitPath3(enriched.PATH)) {
-      candidates.push((0, import_node_path5.join)(dir, name));
+      candidates.push((0, import_node_path7.join)(dir, name));
     }
   }
   const seen = /* @__PURE__ */ new Set();
@@ -35014,7 +35176,15 @@ function resolveCliExecutable(command, env) {
   cacheResolvedCli(cacheKey, null);
   return null;
 }
+var ALAN_CODE_ENGINE_PATH_ENV = "ALAN_CODE_ENGINE_PATH";
+function bundledAlanCodeEngine(backendKind, env) {
+  if (backendKind !== ALAN_CODE_PROVIDER_KIND) return null;
+  const path2 = env[ALAN_CODE_ENGINE_PATH_ENV]?.trim() || process.env[ALAN_CODE_ENGINE_PATH_ENV]?.trim();
+  return path2 && isRunnableFile(path2) ? path2 : null;
+}
 function resolveProviderCliCommand(provider, env) {
+  const bundled = bundledAlanCodeEngine(provider, env ?? getDaemonCliEnvironment());
+  if (bundled) return bundled;
   const spec = findSandboxRuntimeDefinition(provider);
   if (!spec) return null;
   const cliEnv = env ?? getDaemonCliEnvironment();
@@ -35031,6 +35201,8 @@ function resolveBackendRuntimeCommand(backendKind, env) {
   const spec = findSandboxRuntimeDefinition(backendKind);
   if (!spec) return void 0;
   const cliEnv = env ?? getDaemonCliEnvironment();
+  const bundled = bundledAlanCodeEngine(backendKind, cliEnv);
+  if (bundled) return bundled;
   const envOverride = spec.envVars.map((name) => cliEnv[name]?.trim()).find(Boolean);
   const resolved = resolveCliExecutable(envOverride?.trim() || spec.command, cliEnv);
   if (!resolved) return void 0;
@@ -35271,7 +35443,7 @@ function buildComputerReadiness(input2) {
 }
 
 // src/version.ts
-var AGENT_VERSION = "0.1.123";
+var AGENT_VERSION = "0.1.124";
 
 // src/daemon/status.ts
 var PENDING_RUN_START_TTL_MS = 10 * 6e4;
@@ -35329,7 +35501,7 @@ var DurablePendingRunStarts = class extends Map {
       return;
     }
     const pendingPath = `${this.path}.pending`;
-    (0, import_node_fs7.mkdirSync)((0, import_node_path6.dirname)(this.path), { recursive: true, mode: 448 });
+    (0, import_node_fs7.mkdirSync)((0, import_node_path8.dirname)(this.path), { recursive: true, mode: 448 });
     try {
       (0, import_node_fs7.writeFileSync)(
         pendingPath,
@@ -35559,21 +35731,21 @@ function reconcileActiveRuns(input2) {
   }
 }
 function collectRuntimeMetadata() {
-  const cpuList = (0, import_node_os5.cpus)();
+  const cpuList = (0, import_node_os6.cpus)();
   const metadata = {
-    platform: (0, import_node_os5.platform)(),
-    arch: (0, import_node_os5.arch)(),
-    osVersion: (0, import_node_os5.release)(),
+    platform: (0, import_node_os6.platform)(),
+    arch: (0, import_node_os6.arch)(),
+    osVersion: (0, import_node_os6.release)(),
     agentVersion: AGENT_VERSION,
-    memoryBytes: (0, import_node_os5.totalmem)(),
-    memoryFreeBytes: (0, import_node_os5.freemem)()
+    memoryBytes: (0, import_node_os6.totalmem)(),
+    memoryFreeBytes: (0, import_node_os6.freemem)()
   };
   if (cpuList.length > 0) {
     metadata.cpuModel = cpuList[0]?.model;
     metadata.cpuCores = cpuList.length;
   }
   try {
-    const disk = (0, import_node_fs7.statfsSync)((0, import_node_os5.homedir)());
+    const disk = (0, import_node_fs7.statfsSync)((0, import_node_os6.homedir)());
     metadata.diskFreeBytes = disk.bavail * disk.bsize;
     metadata.diskTotalBytes = disk.blocks * disk.bsize;
   } catch {
@@ -35622,14 +35794,14 @@ function localServiceOwnerPayload(owner) {
   ].join("\0");
 }
 function signLocalServiceOwner(secret, owner) {
-  return (0, import_node_crypto.createHmac)("sha256", secret).update(localServiceOwnerPayload(owner)).digest("hex");
+  return (0, import_node_crypto2.createHmac)("sha256", secret).update(localServiceOwnerPayload(owner)).digest("hex");
 }
 function signLocalServiceAdoption(secret, serviceId, challenge) {
-  return (0, import_node_crypto.createHmac)("sha256", secret).update(["adopt", serviceId, challenge].join("\0")).digest("hex");
+  return (0, import_node_crypto2.createHmac)("sha256", secret).update(["adopt", serviceId, challenge].join("\0")).digest("hex");
 }
 function equalHexDigest(actual, expected) {
   if (!/^[a-f0-9]{64}$/i.test(actual) || !/^[a-f0-9]{64}$/i.test(expected)) return false;
-  return (0, import_node_crypto.timingSafeEqual)(Buffer.from(actual, "hex"), Buffer.from(expected, "hex"));
+  return (0, import_node_crypto2.timingSafeEqual)(Buffer.from(actual, "hex"), Buffer.from(expected, "hex"));
 }
 function parseLocalServiceOwner(value2) {
   if (!value2 || typeof value2 !== "object") return null;
@@ -35791,7 +35963,7 @@ function getConfigPath() {
   return boundAgentConfigPath ?? process.env.ALAN_AGENT_CONFIG_PATH ?? resolveAgentConfigPath({ profile: "production" });
 }
 function getEndpointDefaultsPath() {
-  return process.env.ALAN_AGENT_ENDPOINTS_PATH ?? (0, import_node_path7.join)((0, import_node_path7.dirname)(getConfigPath()), "endpoints.json");
+  return process.env.ALAN_AGENT_ENDPOINTS_PATH ?? (0, import_node_path9.join)((0, import_node_path9.dirname)(getConfigPath()), "endpoints.json");
 }
 function readConfig() {
   const configPath = getConfigPath();
@@ -35821,8 +35993,8 @@ function readEndpointDefaults() {
 }
 function writeConfig(config4) {
   const configPath = getConfigPath();
-  (0, import_node_fs8.mkdirSync)((0, import_node_path7.dirname)(configPath), { recursive: true, mode: 448 });
-  const pendingPath = `${configPath}.pending-${process.pid}-${(0, import_node_crypto.randomBytes)(6).toString("hex")}`;
+  (0, import_node_fs8.mkdirSync)((0, import_node_path9.dirname)(configPath), { recursive: true, mode: 448 });
+  const pendingPath = `${configPath}.pending-${process.pid}-${(0, import_node_crypto2.randomBytes)(6).toString("hex")}`;
   try {
     (0, import_node_fs8.writeFileSync)(pendingPath, JSON.stringify(sanitizeAgentConfig({ ...config4 }), null, 2), {
       mode: 384
@@ -35869,12 +36041,12 @@ function acquireLocalDaemonMaintenanceLease(configPath, reason, ttlMs = 5e3) {
   if (existing) return { acquired: false, lease: existing };
   const lease = {
     version: 1,
-    id: (0, import_node_crypto.randomUUID)(),
+    id: (0, import_node_crypto2.randomUUID)(),
     reason,
     expiresAtMs: reason === "credential_cleanup" ? null : Date.now() + Math.max(1e3, Math.min(ttlMs, 6e4))
   };
   const path2 = maintenanceLeasePath(configPath);
-  (0, import_node_fs8.mkdirSync)((0, import_node_path7.dirname)(path2), { recursive: true, mode: 448 });
+  (0, import_node_fs8.mkdirSync)((0, import_node_path9.dirname)(path2), { recursive: true, mode: 448 });
   try {
     (0, import_node_fs8.writeFileSync)(path2, JSON.stringify(lease), { mode: 384, flag: "wx" });
     (0, import_node_fs8.chmodSync)(path2, 384);
@@ -35940,7 +36112,7 @@ async function acquireLocalDaemonOwnerLease(input2) {
   }
   const lease = {
     version: 1,
-    id: (0, import_node_crypto.randomUUID)(),
+    id: (0, import_node_crypto2.randomUUID)(),
     daemonSessionId: input2.daemonSessionId,
     pid: process.pid,
     startedAtMs: Date.now(),
@@ -35950,7 +36122,7 @@ async function acquireLocalDaemonOwnerLease(input2) {
     localApiToken: input2.localApiToken
   };
   const path2 = daemonOwnerLeasePath(input2.configPath);
-  (0, import_node_fs8.mkdirSync)((0, import_node_path7.dirname)(path2), { recursive: true, mode: 448 });
+  (0, import_node_fs8.mkdirSync)((0, import_node_path9.dirname)(path2), { recursive: true, mode: 448 });
   try {
     (0, import_node_fs8.writeFileSync)(path2, JSON.stringify(lease), { mode: 384, flag: "wx" });
     (0, import_node_fs8.chmodSync)(path2, 384);
@@ -35980,7 +36152,7 @@ function releaseLocalDaemonOwnerLease(configPath, leaseId) {
   releaseOwnedJsonFile(daemonOwnerLeasePath(configPath), leaseId);
 }
 function releaseOwnedJsonFile(path2, ownerId, ownerField = "id") {
-  const releasePath = `${path2}.release-${process.pid}-${(0, import_node_crypto.randomBytes)(6).toString("hex")}`;
+  const releasePath = `${path2}.release-${process.pid}-${(0, import_node_crypto2.randomBytes)(6).toString("hex")}`;
   try {
     (0, import_node_fs8.renameSync)(path2, releasePath);
   } catch (error61) {
@@ -36055,7 +36227,7 @@ function pendingSetupIntentPath() {
   return `${getConfigPath()}.setup-pending`;
 }
 function setupTokenHash(setupToken) {
-  return (0, import_node_crypto.createHash)("sha256").update(setupToken).digest("hex");
+  return (0, import_node_crypto2.createHash)("sha256").update(setupToken).digest("hex");
 }
 function getOrCreateSetupAttemptId(setupToken) {
   const intentPath = pendingSetupIntentPath();
@@ -36069,9 +36241,9 @@ function getOrCreateSetupAttemptId(setupToken) {
     } catch {
     }
   }
-  const registrationAttemptId = (0, import_node_crypto.randomUUID)();
-  (0, import_node_fs8.mkdirSync)((0, import_node_path7.dirname)(intentPath), { recursive: true, mode: 448 });
-  const writePath = `${intentPath}.pending-${process.pid}-${(0, import_node_crypto.randomBytes)(6).toString("hex")}`;
+  const registrationAttemptId = (0, import_node_crypto2.randomUUID)();
+  (0, import_node_fs8.mkdirSync)((0, import_node_path9.dirname)(intentPath), { recursive: true, mode: 448 });
+  const writePath = `${intentPath}.pending-${process.pid}-${(0, import_node_crypto2.randomBytes)(6).toString("hex")}`;
   try {
     (0, import_node_fs8.writeFileSync)(
       writePath,
@@ -36114,7 +36286,7 @@ function restoreCapturedFileUnlessReplaced(path2, content) {
   }
 }
 function quarantineCorruptDeviceAuthorizationOperation(path2) {
-  const quarantinePath = `${path2}.corrupt-${process.pid}-${(0, import_node_crypto.randomBytes)(6).toString("hex")}`;
+  const quarantinePath = `${path2}.corrupt-${process.pid}-${(0, import_node_crypto2.randomBytes)(6).toString("hex")}`;
   try {
     (0, import_node_fs8.renameSync)(path2, quarantinePath);
   } catch (error61) {
@@ -36149,11 +36321,11 @@ function acquireDeviceAuthorizationOperation() {
   if (existing) return null;
   const lease = {
     version: 1,
-    id: (0, import_node_crypto.randomUUID)(),
+    id: (0, import_node_crypto2.randomUUID)(),
     expiresAtMs: Date.now() + 6e4
   };
   const path2 = deviceAuthorizationOperationPath();
-  (0, import_node_fs8.mkdirSync)((0, import_node_path7.dirname)(path2), { recursive: true, mode: 448 });
+  (0, import_node_fs8.mkdirSync)((0, import_node_path9.dirname)(path2), { recursive: true, mode: 448 });
   try {
     (0, import_node_fs8.writeFileSync)(path2, JSON.stringify(lease), { mode: 384, flag: "wx" });
     (0, import_node_fs8.chmodSync)(path2, 384);
@@ -36169,7 +36341,7 @@ function extendDeviceAuthorizationOperation(operationId, expiresAtMs) {
     throw new Error("browser authorization operation ownership was lost");
   }
   const path2 = deviceAuthorizationOperationPath();
-  const pendingPath = `${path2}.pending-${process.pid}-${(0, import_node_crypto.randomBytes)(6).toString("hex")}`;
+  const pendingPath = `${path2}.pending-${process.pid}-${(0, import_node_crypto2.randomBytes)(6).toString("hex")}`;
   try {
     (0, import_node_fs8.writeFileSync)(
       pendingPath,
@@ -36218,8 +36390,8 @@ function readPendingDeviceAuthorization(apiUrl) {
 }
 function writePendingDeviceAuthorization(pending) {
   const path2 = pendingDeviceAuthorizationPath();
-  (0, import_node_fs8.mkdirSync)((0, import_node_path7.dirname)(path2), { recursive: true, mode: 448 });
-  const writePath = `${path2}.pending-${process.pid}-${(0, import_node_crypto.randomBytes)(6).toString("hex")}`;
+  (0, import_node_fs8.mkdirSync)((0, import_node_path9.dirname)(path2), { recursive: true, mode: 448 });
+  const writePath = `${path2}.pending-${process.pid}-${(0, import_node_crypto2.randomBytes)(6).toString("hex")}`;
   try {
     (0, import_node_fs8.writeFileSync)(writePath, JSON.stringify(pending, null, 2), { mode: 384 });
     (0, import_node_fs8.chmodSync)(writePath, 384);
@@ -36230,8 +36402,8 @@ function writePendingDeviceAuthorization(pending) {
 }
 function removeAlanOwnedLocalArtifacts() {
   const configPath = getConfigPath();
-  const directory = (0, import_node_path7.dirname)(configPath);
-  const configName = (0, import_node_path7.basename)(configPath).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const directory = (0, import_node_path9.dirname)(configPath);
+  const configName = (0, import_node_path9.basename)(configPath).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
   const alanAtomicSidecarPattern = new RegExp(
     `^${configName}(?:|\\.setup-pending|\\.device-auth-pending|\\.device-auth-operation\\.json|\\.maintenance-lease\\.json|\\.event-outbox\\.enc)\\.(?:pending|release|corrupt)-\\d+-[a-f0-9]{12}$`
   );
@@ -36250,14 +36422,14 @@ function removeAlanOwnedLocalArtifacts() {
   ]);
   if ((0, import_node_fs8.existsSync)(directory)) {
     for (const entry of (0, import_node_fs8.readdirSync)(directory)) {
-      if (alanAtomicSidecarPattern.test(entry)) artifacts.add((0, import_node_path7.join)(directory, entry));
+      if (alanAtomicSidecarPattern.test(entry)) artifacts.add((0, import_node_path9.join)(directory, entry));
     }
   }
   for (const artifact of artifacts) (0, import_node_fs8.rmSync)(artifact, { force: true });
   for (const staleSpool of [
     `${configPath}.event-outbox.enc.journal`,
     `${configPath}.native-streams`,
-    (0, import_node_path7.join)(directory, "native-hook-inbox")
+    (0, import_node_path9.join)(directory, "native-hook-inbox")
   ]) {
     (0, import_node_fs8.rmSync)(staleSpool, { recursive: true, force: true });
   }
@@ -36306,25 +36478,25 @@ function isNativeAssistantFingerprint(value2) {
 }
 
 // src/native/provider-paths.ts
-var import_node_os6 = require("os");
-var import_node_path8 = require("path");
+var import_node_os7 = require("os");
+var import_node_path10 = require("path");
 function providerConfigDir(provider, options) {
   const env = options.env ?? process.env;
-  const home = options.homeDir ?? (0, import_node_os6.homedir)();
-  if (provider === "claude") return env.CLAUDE_CONFIG_DIR?.trim() || (0, import_node_path8.join)(home, ".claude");
-  return env.CODEX_HOME?.trim() || (0, import_node_path8.join)(home, ".codex");
+  const home = options.homeDir ?? (0, import_node_os7.homedir)();
+  if (provider === "claude") return env.CLAUDE_CONFIG_DIR?.trim() || (0, import_node_path10.join)(home, ".claude");
+  return env.CODEX_HOME?.trim() || (0, import_node_path10.join)(home, ".codex");
 }
 function providerHookSettingsPath(provider, options = {}) {
   const file2 = provider === "claude" ? "settings.json" : "hooks.json";
-  return (0, import_node_path8.join)(providerConfigDir(provider, options), file2);
+  return (0, import_node_path10.join)(providerConfigDir(provider, options), file2);
 }
 function providerTranscriptRoot(provider, options = {}) {
   const directory = provider === "claude" ? "projects" : "sessions";
-  return (0, import_node_path8.join)(providerConfigDir(provider, options), directory);
+  return (0, import_node_path10.join)(providerConfigDir(provider, options), directory);
 }
 
 // src/native/signal.ts
-var import_node_path9 = require("path");
+var import_node_path11 = require("path");
 
 // ../shared/dist/types/native-agent-session.js
 var nativeAgentProviderBackendKinds = {
@@ -36386,7 +36558,7 @@ function isNativeIngestionHookSignal(value2) {
   if (keys.length !== SIGNAL_KEYS.size || !keys.every((key) => SIGNAL_KEYS.has(key))) {
     return false;
   }
-  return isNativeIngestionProvider(value2.provider) && isNativeIngestionHookEvent(value2.event) && isNonEmptyString(value2.externalSessionId) && isNonEmptyString(value2.transcriptPath) && (0, import_node_path9.isAbsolute)(value2.transcriptPath) && isNullableString(value2.cwd) && isNullableString(value2.providerTurnId) && (value2.assistantFingerprint === null || isNativeAssistantFingerprint(value2.assistantFingerprint)) && isIsoTimestamp(value2.observedAt);
+  return isNativeIngestionProvider(value2.provider) && isNativeIngestionHookEvent(value2.event) && isNonEmptyString(value2.externalSessionId) && isNonEmptyString(value2.transcriptPath) && (0, import_node_path11.isAbsolute)(value2.transcriptPath) && isNullableString(value2.cwd) && isNullableString(value2.providerTurnId) && (value2.assistantFingerprint === null || isNativeAssistantFingerprint(value2.assistantFingerprint)) && isIsoTimestamp(value2.observedAt);
 }
 
 // src/cli/hook.ts
@@ -36420,7 +36592,7 @@ function stringField(payload, ...names) {
 }
 function codexSessionIdFromTranscriptPath(transcriptPath2) {
   const match = /^rollout-.*-([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/i.exec(
-    (0, import_node_path10.basename)(transcriptPath2)
+    (0, import_node_path12.basename)(transcriptPath2)
   );
   return match?.[1] ?? null;
 }
@@ -36489,14 +36661,14 @@ function realpathOrSelf(path2) {
   }
 }
 function isWithinDirectory(path2, directory) {
-  const offset2 = (0, import_node_path10.relative)(realpathOrSelf(directory), realpathOrSelf(path2));
-  return offset2 !== "" && !offset2.startsWith("..") && !(0, import_node_path10.isAbsolute)(offset2);
+  const offset2 = (0, import_node_path12.relative)(realpathOrSelf(directory), realpathOrSelf(path2));
+  return offset2 !== "" && !offset2.startsWith("..") && !(0, import_node_path12.isAbsolute)(offset2);
 }
 function parseHookSignal(input2) {
   const { payload } = input2;
   const rawTranscriptPath = stringField(payload, "transcript_path", "transcriptPath");
   if (!rawTranscriptPath) return null;
-  const transcriptPath2 = (0, import_node_path10.resolve)(rawTranscriptPath);
+  const transcriptPath2 = (0, import_node_path12.resolve)(rawTranscriptPath);
   const externalSessionId = stringField(payload, "session_id", "sessionId") ?? (input2.provider === "codex" ? codexSessionIdFromTranscriptPath(transcriptPath2) : null);
   if (!externalSessionId) return null;
   const cwd = stringField(payload, "cwd");
@@ -36505,7 +36677,7 @@ function parseHookSignal(input2) {
     event: input2.event,
     externalSessionId,
     transcriptPath: transcriptPath2,
-    cwd: cwd ? (0, import_node_path10.resolve)(cwd) : null,
+    cwd: cwd ? (0, import_node_path12.resolve)(cwd) : null,
     providerTurnId: stringField(payload, "prompt_id", "turn_id"),
     assistantFingerprint: typeof payload.last_assistant_message === "string" ? assistantFingerprint(payload.last_assistant_message) : null,
     observedAt: input2.observedAt.toISOString()
@@ -36840,21 +37012,21 @@ function describeError(error61) {
 }
 
 // src/cli/login.ts
-var import_node_crypto3 = require("crypto");
-var import_node_os11 = require("os");
+var import_node_crypto4 = require("crypto");
+var import_node_os12 = require("os");
 
 // src/cli/setup.ts
-var import_node_crypto2 = require("crypto");
-var import_node_os10 = require("os");
+var import_node_crypto3 = require("crypto");
+var import_node_os11 = require("os");
 
 // src/runtime-registration.ts
-var import_node_os9 = require("os");
+var import_node_os10 = require("os");
 
 // src/cli-ensure-install.ts
 var import_node_child_process5 = require("child_process");
 var import_node_fs10 = require("fs");
-var import_node_os7 = require("os");
-var import_node_path11 = require("path");
+var import_node_os8 = require("os");
+var import_node_path13 = require("path");
 var CLI_RUNTIME_VERSIONS_ENV = "ALAN_CLI_RUNTIME_VERSIONS";
 var installOutcomes = /* @__PURE__ */ new Map();
 function canInstallProviderCli(backendKind) {
@@ -36867,23 +37039,23 @@ function canInstallProviderCli(backendKind) {
 function usesStagedSandboxInstall(backendKind) {
   const runtime = findSandboxRuntimeDefinition(backendKind);
   return Boolean(
-    runtime?.installer.kind === "npm" && (0, import_node_os7.platform)() === "linux" && process.env.ALAN_SANDBOX_PROVIDER && canInstallProviderCli(backendKind)
+    runtime?.installer.kind === "npm" && (0, import_node_os8.platform)() === "linux" && process.env.ALAN_SANDBOX_PROVIDER && canInstallProviderCli(backendKind)
   );
 }
 function currentRuntimePlatform() {
-  const current = (0, import_node_os7.platform)();
+  const current = (0, import_node_os8.platform)();
   if (current === "linux" || current === "darwin" || current === "win32") return current;
   return null;
 }
 function resolveWindowsNpmInvocation(env, npmArgs) {
   const searchPath = env.PATH ?? env.Path ?? "";
-  for (const rawDirectory of searchPath.split(import_node_path11.delimiter)) {
+  for (const rawDirectory of searchPath.split(import_node_path13.delimiter)) {
     const directory = rawDirectory.trim().replace(/^"|"$/g, "");
     if (!directory) continue;
-    const executable = (0, import_node_path11.join)(directory, "npm.exe");
+    const executable = (0, import_node_path13.join)(directory, "npm.exe");
     if ((0, import_node_fs10.existsSync)(executable)) return { command: executable, args: npmArgs };
-    const commandShim = (0, import_node_path11.join)(directory, "npm.cmd");
-    const cliScript = (0, import_node_path11.join)(directory, "node_modules", "npm", "bin", "npm-cli.js");
+    const commandShim = (0, import_node_path13.join)(directory, "npm.cmd");
+    const cliScript = (0, import_node_path13.join)(directory, "node_modules", "npm", "bin", "npm-cli.js");
     if ((0, import_node_fs10.existsSync)(commandShim) && (0, import_node_fs10.existsSync)(cliScript)) {
       return { command: process.execPath, args: [cliScript, ...npmArgs] };
     }
@@ -36896,7 +37068,7 @@ function runCliInstallCommand(command, args, env, timeoutMs) {
     try {
       child = (0, import_node_child_process5.spawn)(command, args, {
         env,
-        windowsHide: (0, import_node_os7.platform)() === "win32" ? true : void 0,
+        windowsHide: (0, import_node_os8.platform)() === "win32" ? true : void 0,
         timeout: timeoutMs,
         stdio: ["ignore", "pipe", "pipe"]
       });
@@ -36928,7 +37100,7 @@ function runCliInstallCommand(command, args, env, timeoutMs) {
 }
 function runNpmInstall(installSpec, env, timeoutMs) {
   const npmArgs = ["install", "-g", installSpec];
-  const invocation = (0, import_node_os7.platform)() === "win32" ? resolveWindowsNpmInvocation(env, npmArgs) : { command: "npm", args: npmArgs };
+  const invocation = (0, import_node_os8.platform)() === "win32" ? resolveWindowsNpmInvocation(env, npmArgs) : { command: "npm", args: npmArgs };
   if (!invocation) {
     return Promise.resolve({
       status: null,
@@ -37086,8 +37258,8 @@ ${result.stderr}`.trim();
 
 // src/provider-model-discovery.ts
 var import_node_fs11 = require("fs");
-var import_node_os8 = require("os");
-var import_node_path12 = require("path");
+var import_node_os9 = require("os");
+var import_node_path14 = require("path");
 
 // ../shared/dist/utils/workflow-tools-filter.js
 var WORKFLOW_ALWAYS_ALLOWED_BUILTIN_TOOLS = [
@@ -39831,9 +40003,9 @@ function readOpenCodeZenCredential(env) {
 function readOpenCodeAuthDocument(env) {
   const injected = env.OPENCODE_AUTH_CONTENT?.trim();
   if (injected) return injected;
-  const dataHome = env.XDG_DATA_HOME?.trim() || (0, import_node_path12.join)((0, import_node_os8.homedir)(), ".local", "share");
+  const dataHome = env.XDG_DATA_HOME?.trim() || (0, import_node_path14.join)((0, import_node_os9.homedir)(), ".local", "share");
   try {
-    return (0, import_node_fs11.readFileSync)((0, import_node_path12.join)(dataHome, "opencode", "auth.json"), "utf8");
+    return (0, import_node_fs11.readFileSync)((0, import_node_path14.join)(dataHome, "opencode", "auth.json"), "utf8");
   } catch {
     return null;
   }
@@ -39891,10 +40063,10 @@ var OPENCODE_CACHE_PROVIDER_KEYS = ["opencode", "opencode-go"];
 var OPENCODE_CATALOGUE_URL = "https://models.dev/api.json";
 var OPENCODE_CATALOGUE_TIMEOUT_MS = 1e4;
 function readOpenCodeCatalogueCache(env) {
-  const cacheHome = env.XDG_CACHE_HOME?.trim() || (0, import_node_path12.join)((0, import_node_os8.homedir)(), ".cache");
+  const cacheHome = env.XDG_CACHE_HOME?.trim() || (0, import_node_path14.join)((0, import_node_os9.homedir)(), ".cache");
   try {
     return openCodeMetadataFromCatalogue(
-      JSON.parse((0, import_node_fs11.readFileSync)((0, import_node_path12.join)(cacheHome, ...OPENCODE_CATALOGUE_CACHE_SEGMENTS), "utf8"))
+      JSON.parse((0, import_node_fs11.readFileSync)((0, import_node_path14.join)(cacheHome, ...OPENCODE_CATALOGUE_CACHE_SEGMENTS), "utf8"))
     );
   } catch {
     return null;
@@ -40403,7 +40575,7 @@ async function exchangeRuntimeSetupGrant(input2, setupSignal) {
       setupToken: input2.setupToken,
       registrationAttemptId,
       displayName: input2.displayName,
-      hostname: (0, import_node_os9.hostname)(),
+      hostname: (0, import_node_os10.hostname)(),
       runtimeKind: "machine",
       managementKind: "user_managed",
       hostKind: "daemon",
@@ -40491,9 +40663,9 @@ function writeRegisteredRuntimeConfig(args, previousConfig, registered) {
   writeConfig({
     ...registered,
     localApiPort: getLocalApiPort(args, {}),
-    localApiToken: previousConfig.localApiToken ?? (0, import_node_crypto2.randomBytes)(24).toString("hex"),
-    localServiceId: previousConfig.localServiceId ?? (0, import_node_crypto2.randomUUID)(),
-    localServiceSecret: previousConfig.localServiceSecret ?? (0, import_node_crypto2.randomBytes)(32).toString("base64url"),
+    localApiToken: previousConfig.localApiToken ?? (0, import_node_crypto3.randomBytes)(24).toString("hex"),
+    localServiceId: previousConfig.localServiceId ?? (0, import_node_crypto3.randomUUID)(),
+    localServiceSecret: previousConfig.localServiceSecret ?? (0, import_node_crypto3.randomBytes)(32).toString("base64url"),
     daemonEpoch: previousConfig.daemonEpoch,
     nativeIngestion: previousConfig.nativeIngestion
   });
@@ -40507,9 +40679,9 @@ async function setupDaemon(args, options = {}) {
   const teamId = argValue(args, "--team") ?? process.env.ALAN_TEAM_ID;
   const setupToken = argValue(args, "--setup-token") ?? process.env.ALAN_RUNTIME_SETUP_TOKEN;
   const token = argValue(args, "--token") ?? process.env.ALAN_SETUP_TOKEN;
-  const displayName = argValue(args, "--name") ?? (0, import_node_os10.hostname)();
+  const displayName = argValue(args, "--name") ?? (0, import_node_os11.hostname)();
   const scope = argValue(args, "--scope") ?? process.env.ALAN_RUNTIME_SCOPE ?? (setupToken ? "team" : "user");
-  const installationId = argValue(args, "--installation-id") ?? previousConfig.installationId ?? (0, import_node_crypto2.randomUUID)();
+  const installationId = argValue(args, "--installation-id") ?? previousConfig.installationId ?? (0, import_node_crypto3.randomUUID)();
   if (scope !== "team" && scope !== "user") {
     throw new Error("setup --scope must be either 'team' or 'user'");
   }
@@ -40627,10 +40799,10 @@ async function loginWithDeviceCode(args) {
     }
     const previousConfig = readConfigForRegistration();
     const { apiUrl, wsUrl, endpointProfile } = resolveEndpoints(args);
-    const displayName = argValue(args, "--name") ?? (0, import_node_os11.hostname)();
+    const displayName = argValue(args, "--name") ?? (0, import_node_os12.hostname)();
     const maxPolls = Number.parseInt(argValue(args, "--max-polls") ?? "300", 10);
     const resumed = readPendingDeviceAuthorization(apiUrl);
-    const installationId = resumed?.installationId ?? previousConfig.installationId ?? (0, import_node_crypto3.randomUUID)();
+    const installationId = resumed?.installationId ?? previousConfig.installationId ?? (0, import_node_crypto4.randomUUID)();
     let authorization = resumed ? { ...resumed, operationId: operation.id } : null;
     if (!authorization) {
       clearPendingDeviceAuthorization();
@@ -40639,7 +40811,7 @@ async function loginWithDeviceCode(args) {
         headers: { "content-type": "application/json" },
         body: JSON.stringify({
           displayName,
-          hostname: (0, import_node_os11.hostname)(),
+          hostname: (0, import_node_os12.hostname)(),
           capabilities: discoverCapabilities(),
           metadata: {
             ...await collectRuntimeMetadataWithProviderLimits(),
@@ -41148,15 +41320,15 @@ async function revokeRuntimeToken(args) {
 
 // src/skills/local-skill-source.ts
 var import_node_buffer2 = require("buffer");
-var import_node_crypto5 = require("crypto");
+var import_node_crypto6 = require("crypto");
 var import_promises2 = require("fs/promises");
-var import_node_path14 = __toESM(require("path"), 1);
+var import_node_path16 = __toESM(require("path"), 1);
 
 // ../shared/dist/node/skill-package.js
 var import_node_buffer = require("buffer");
-var import_node_crypto4 = require("crypto");
+var import_node_crypto5 = require("crypto");
 var import_promises = require("fs/promises");
-var import_node_path13 = require("path");
+var import_node_path15 = require("path");
 var import_yaml = __toESM(require_dist(), 1);
 
 // ../shared/dist/skills/domain.js
@@ -41638,7 +41810,7 @@ async function inspectSkillPackage(packageRoot, options = {}) {
   }
   const inspectedFiles = await Promise.all(files.map(readPackageFile));
   inspectedFiles.sort(comparePackageFiles);
-  const parsedMetadata = parseSkillMetadata(inspectedFiles.find((file2) => file2.manifest.path === "SKILL.md")?.bytes, options.expectedName === void 0 ? (0, import_node_path13.basename)(root) : options.expectedName);
+  const parsedMetadata = parseSkillMetadata(inspectedFiles.find((file2) => file2.manifest.path === "SKILL.md")?.bytes, options.expectedName === void 0 ? (0, import_node_path15.basename)(root) : options.expectedName);
   const manifestFiles = inspectedFiles.map((file2) => file2.manifest);
   const diagnostics = [
     ...parsedMetadata.conformance,
@@ -41662,7 +41834,7 @@ async function readSkillPackageFile(packageRoot, path2, expectedSha256) {
   if (!normalizedPath || normalizedPath !== path2 || normalizedPath.includes("\\") || components.some((component) => !component || component === "." || component === "..")) {
     throw new SkillPackageError("INVALID_PATH", `Invalid Skill package path: ${path2}`, path2);
   }
-  const absolutePath = await (0, import_promises.realpath)((0, import_node_path13.resolve)(root, ...components)).catch(() => null);
+  const absolutePath = await (0, import_promises.realpath)((0, import_node_path15.resolve)(root, ...components)).catch(() => null);
   if (!absolutePath || normalizeRelativePath(root, absolutePath) !== normalizedPath) {
     throw new SkillPackageError("INVALID_PATH", `Skill package file was not found: ${path2}`, path2);
   }
@@ -41683,7 +41855,7 @@ async function readSkillPackageFile(packageRoot, path2, expectedSha256) {
   return { file: read.manifest, bytes: read.bytes };
 }
 async function requirePackageRoot(packageRoot) {
-  const root = await (0, import_promises.realpath)((0, import_node_path13.resolve)(packageRoot)).catch(() => null);
+  const root = await (0, import_promises.realpath)((0, import_node_path15.resolve)(packageRoot)).catch(() => null);
   if (!root) {
     throw new SkillPackageError("INVALID_PACKAGE_ROOT", "Skill package directory does not exist");
   }
@@ -41709,7 +41881,7 @@ async function walkPackage(root, ignoredPaths) {
   async function walkDirectory(directory) {
     const entries = await (0, import_promises.readdir)(directory, { withFileTypes: true });
     for (const entry of entries) {
-      const absolutePath = (0, import_node_path13.resolve)(directory, entry.name);
+      const absolutePath = (0, import_node_path15.resolve)(directory, entry.name);
       const normalizedPath = normalizeRelativePath(root, absolutePath);
       if (isIgnored(normalizedPath, entry.name, entry.isDirectory(), ignored2))
         continue;
@@ -41746,10 +41918,10 @@ function createIgnoreMatcher(path2) {
   const expression = globToRegExp(pattern);
   return (candidate) => expression.test(candidate) || expression.test(`${candidate}/`);
 }
-function isIgnored(normalizedPath, basename7, isDirectory2, configured) {
-  if (isDirectory2 && ALWAYS_IGNORED_DIRECTORIES.has(basename7))
+function isIgnored(normalizedPath, basename8, isDirectory2, configured) {
+  if (isDirectory2 && ALWAYS_IGNORED_DIRECTORIES.has(basename8))
     return true;
-  if (!isDirectory2 && ALWAYS_IGNORED_FILES.has(basename7))
+  if (!isDirectory2 && ALWAYS_IGNORED_FILES.has(basename8))
     return true;
   return configured.some((matches) => matches(normalizedPath));
 }
@@ -41776,12 +41948,12 @@ function globToRegExp(pattern) {
   return new RegExp(`${source2}(?:/.*)?$`);
 }
 function normalizeRelativePath(root, absolutePath) {
-  const nativeRelativePath = (0, import_node_path13.relative)(root, absolutePath);
-  if (!nativeRelativePath || nativeRelativePath.startsWith(`..${import_node_path13.sep}`) || nativeRelativePath === "..") {
+  const nativeRelativePath = (0, import_node_path15.relative)(root, absolutePath);
+  if (!nativeRelativePath || nativeRelativePath.startsWith(`..${import_node_path15.sep}`) || nativeRelativePath === "..") {
     throw new SkillPackageError("INVALID_PATH", "Skill package path escapes its root");
   }
-  const normalized2 = nativeRelativePath.split(import_node_path13.sep).join("/").normalize("NFC");
-  if (normalized2.includes("\0") || normalized2.includes("\uFFFD") || import_node_path13.posix.isAbsolute(normalized2)) {
+  const normalized2 = nativeRelativePath.split(import_node_path15.sep).join("/").normalize("NFC");
+  if (normalized2.includes("\0") || normalized2.includes("\uFFFD") || import_node_path15.posix.isAbsolute(normalized2)) {
     throw new SkillPackageError("INVALID_PATH", `Invalid Skill package path: ${normalized2}`);
   }
   return normalized2;
@@ -41816,7 +41988,7 @@ function requireSafeFile(path2, size, normalizedPaths) {
   }
 }
 function isSecretPath(path2) {
-  const name = import_node_path13.posix.basename(path2).toLowerCase();
+  const name = import_node_path15.posix.basename(path2).toLowerCase();
   if (SECRET_BASENAMES.has(name) || name.startsWith(".env."))
     return true;
   return name.endsWith(".private-key.pem") || name.endsWith(".private-key.key");
@@ -41844,12 +42016,12 @@ function classifyFileKind(path2) {
     return "reference";
   if (path2.startsWith("assets/"))
     return "asset";
-  if (/^(?:licen[cs]e|copying|notice)(?:\.|$)/i.test(import_node_path13.posix.basename(path2)))
+  if (/^(?:licen[cs]e|copying|notice)(?:\.|$)/i.test(import_node_path15.posix.basename(path2)))
     return "license";
   return "other";
 }
 function classifyPreview(path2, bytes) {
-  const extension = import_node_path13.posix.extname(path2).toLowerCase();
+  const extension = import_node_path15.posix.extname(path2).toLowerCase();
   if (IMAGE_EXTENSIONS.has(extension))
     return "image";
   if (bytes.includes(0))
@@ -41953,7 +42125,7 @@ function normalizePackageReference(value2) {
   const withoutSuffix = trimmed4.split(/[?#]/, 1)[0];
   if (!withoutSuffix)
     return null;
-  const normalized2 = import_node_path13.posix.normalize(withoutSuffix).replace(/^\.\//, "").normalize("NFC");
+  const normalized2 = import_node_path15.posix.normalize(withoutSuffix).replace(/^\.\//, "").normalize("NFC");
   if (normalized2 === ".." || normalized2.startsWith("../"))
     return null;
   return normalized2;
@@ -41965,7 +42137,7 @@ function comparePackageFiles(left, right) {
   return import_node_buffer.Buffer.compare(import_node_buffer.Buffer.from(left.manifest.path, "utf8"), import_node_buffer.Buffer.from(right.manifest.path, "utf8"));
 }
 function hashPackageTree(files) {
-  const hash2 = (0, import_node_crypto4.createHash)("sha256");
+  const hash2 = (0, import_node_crypto5.createHash)("sha256");
   hash2.update(TREE_HASH_PREFIX);
   for (const file2 of files) {
     const path2 = import_node_buffer.Buffer.from(file2.path, "utf8");
@@ -41978,7 +42150,7 @@ function hashPackageTree(files) {
   return `sha256:${hash2.digest("hex")}`;
 }
 function sha256(bytes) {
-  return `sha256:${(0, import_node_crypto4.createHash)("sha256").update(bytes).digest("hex")}`;
+  return `sha256:${(0, import_node_crypto5.createHash)("sha256").update(bytes).digest("hex")}`;
 }
 function uint322(value2) {
   const buffer = import_node_buffer.Buffer.allocUnsafe(4);
@@ -42928,7 +43100,7 @@ var LocalSkillSource = class {
   locations = /* @__PURE__ */ new Map();
   inspectionCache = /* @__PURE__ */ new Map();
   async scan(input2) {
-    const attemptId = (0, import_node_crypto5.randomUUID)();
+    const attemptId = (0, import_node_crypto6.randomUUID)();
     const diagnostics = [];
     const candidates = [];
     const visitedDirectories = /* @__PURE__ */ new Set();
@@ -43005,9 +43177,9 @@ var LocalSkillSource = class {
    */
   async scanRootAsPackage(resolvedRoot, ignoredPaths, mode) {
     const directory = resolvedRoot.directory;
-    if (!await pathExists((0, import_node_path14.join)(directory, "SKILL.md"))) return null;
+    if (!await pathExists((0, import_node_path16.join)(directory, "SKILL.md"))) return null;
     const canonicalRoot = await (0, import_promises2.realpath)(directory).catch(() => directory);
-    const name = import_node_path14.default.basename(canonicalRoot);
+    const name = import_node_path16.default.basename(canonicalRoot);
     try {
       const fingerprint = await fingerprintPackage(canonicalRoot);
       const ignoreSignature = JSON.stringify(ignoredPaths);
@@ -43077,7 +43249,7 @@ var LocalSkillSource = class {
     );
     for (const entry of entries) {
       if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
-      const candidatePath = (0, import_node_path14.join)(resolvedRoot.directory, entry.name);
+      const candidatePath = (0, import_node_path16.join)(resolvedRoot.directory, entry.name);
       const canonicalPath = await (0, import_promises2.realpath)(candidatePath).catch(() => null);
       if (!canonicalPath) {
         diagnostics.push({
@@ -43135,7 +43307,7 @@ var LocalSkillSource = class {
   }
 };
 async function fingerprintPackage(root) {
-  const hash2 = (0, import_node_crypto5.createHash)("sha256").update("alan-skill-stat-fingerprint-v1\0");
+  const hash2 = (0, import_node_crypto6.createHash)("sha256").update("alan-skill-stat-fingerprint-v1\0");
   await visit2(root, "");
   return `sha256:${hash2.digest("hex")}`;
   async function visit2(directory, relativeDirectory) {
@@ -43143,7 +43315,7 @@ async function fingerprintPackage(root) {
     entries.sort((left, right) => import_node_buffer2.Buffer.compare(import_node_buffer2.Buffer.from(left.name), import_node_buffer2.Buffer.from(right.name)));
     for (const entry of entries) {
       const path2 = relativeDirectory ? `${relativeDirectory}/${entry.name}` : entry.name;
-      const absolutePath = (0, import_node_path14.join)(directory, entry.name);
+      const absolutePath = (0, import_node_path16.join)(directory, entry.name);
       const metadata = await (0, import_promises2.lstat)(absolutePath);
       hash2.update(path2.normalize("NFC")).update("\0").update(
         entry.isDirectory() ? "d" : entry.isFile() ? "f" : entry.isSymbolicLink() ? "l" : "o"
@@ -43168,12 +43340,12 @@ async function canonicalDirectories(directories) {
   return [...new Set(canonical)];
 }
 function isWithinDirectory2(parent, candidate) {
-  const path2 = (0, import_node_path14.relative)(parent, candidate);
-  return path2 !== ".." && !path2.startsWith(`..${import_node_path14.sep}`) && !(0, import_node_path14.isAbsolute)(path2);
+  const path2 = (0, import_node_path16.relative)(parent, candidate);
+  return path2 !== ".." && !path2.startsWith(`..${import_node_path16.sep}`) && !(0, import_node_path16.isAbsolute)(path2);
 }
 async function loadSkillSourceConfig(homeDirectory2) {
-  const configDirectory = (0, import_node_path14.join)(homeDirectory2, ".alan");
-  const configPath = (0, import_node_path14.join)(configDirectory, "config.toml");
+  const configDirectory = (0, import_node_path16.join)(homeDirectory2, ".alan");
+  const configPath = (0, import_node_path16.join)(configDirectory, "config.toml");
   await (0, import_promises2.mkdir)(configDirectory, { recursive: true, mode: 448 });
   let created = false;
   try {
@@ -43207,7 +43379,7 @@ async function resolveSkillScanInput(homeDirectory2, declared) {
   }
   const { config: config4 } = loaded;
   if (!config4.enabled) return { ...declared, roots: [], ignoredPaths: config4.ignoredPaths };
-  const draftsPath = (0, import_node_path14.resolve)((0, import_node_path14.join)(homeDirectory2, ".alan", "skill-sources"));
+  const draftsPath = (0, import_node_path16.resolve)((0, import_node_path16.join)(homeDirectory2, ".alan", "skill-sources"));
   const enabledProviders = new Set(declared.enabledProviderKinds ?? []);
   const configured = [];
   for (const source2 of config4.sources) {
@@ -43215,7 +43387,7 @@ async function resolveSkillScanInput(homeDirectory2, declared) {
       continue;
     }
     configured.push(
-      (0, import_node_path14.resolve)(source2.path) === draftsPath ? { kind: "drafts", path: source2.path, label: "Alan drafts" } : {
+      (0, import_node_path16.resolve)(source2.path) === draftsPath ? { kind: "drafts", path: source2.path, label: "Alan drafts" } : {
         kind: "configured",
         declarationId: source2.declarationId,
         path: source2.path,
@@ -43261,7 +43433,7 @@ function parseSkillSourceConfig(content, homeDirectory2) {
       value2.providers,
       `skills.sources[${index}].providers`
     );
-    const relativeDirectory = import_node_path14.default.relative(homeDirectory2, sourcePath);
+    const relativeDirectory = import_node_path16.default.relative(homeDirectory2, sourcePath);
     const inferredProviders = providerKindsForUserDirectory(relativeDirectory);
     const declaredProviders = value2.providers === void 0 ? inferredProviders : [...new Set(explicitProviders.map((provider) => provider.trim()).filter(Boolean))];
     const stale = staleCodexDeclaration(relativeDirectory, label, declaredProviders);
@@ -43282,7 +43454,7 @@ function parseSkillSourceConfig(content, homeDirectory2) {
   return { enabled, discoverRepositorySkills, ignoredPaths, sources };
 }
 function stableSourceDeclarationId(sourcePath) {
-  const digest = (0, import_node_crypto5.createHash)("sha256").update("alan-skill-source-v1\0").update(sourcePath.normalize("NFC")).digest("hex").slice(0, 24);
+  const digest = (0, import_node_crypto6.createHash)("sha256").update("alan-skill-source-v1\0").update(sourcePath.normalize("NFC")).digest("hex").slice(0, 24);
   return `source-${digest}`;
 }
 function requiredSourceId(value2, field) {
@@ -43291,7 +43463,7 @@ function requiredSourceId(value2, field) {
   }
   return value2;
 }
-function resolveSkillSourcePath(sourcePath, homeDirectory2, pathApi = import_node_path14.default) {
+function resolveSkillSourcePath(sourcePath, homeDirectory2, pathApi = import_node_path16.default) {
   const trimmed4 = sourcePath.trim();
   if (trimmed4 === "~") return pathApi.resolve(homeDirectory2);
   if (trimmed4.startsWith("~/") || trimmed4.startsWith("~\\")) {
@@ -43321,7 +43493,7 @@ function resolveScanRoots(roots, enabledProviderKinds) {
       ).entries()) {
         resolved.push({
           root,
-          directory: (0, import_node_path14.join)(root.path, relativeDirectory),
+          directory: (0, import_node_path16.join)(root.path, relativeDirectory),
           order: `1:${root.repositoryId}:${String(index).padStart(2, "0")}`
         });
       }
@@ -43343,11 +43515,11 @@ function candidateOrigin(root) {
 }
 function createLocalKey(root, skillName) {
   const rootIdentity = root.kind === "configured" ? `configured:${root.declarationId}` : root.kind === "repository" ? `repository:${root.repositoryId}` : "drafts";
-  const digest = (0, import_node_crypto5.createHash)("sha256").update("alan-local-skill-v1\0").update(rootIdentity).update("\0").update(skillName.normalize("NFC")).digest("hex");
+  const digest = (0, import_node_crypto6.createHash)("sha256").update("alan-local-skill-v1\0").update(rootIdentity).update("\0").update(skillName.normalize("NFC")).digest("hex");
   return `local:${digest}`;
 }
 function hashInventory(candidates) {
-  const hash2 = (0, import_node_crypto5.createHash)("sha256");
+  const hash2 = (0, import_node_crypto6.createHash)("sha256");
   hash2.update("alan-skill-inventory-v1\0");
   for (const candidate of candidates) {
     hash2.update(candidate.localKey);
@@ -43380,7 +43552,7 @@ async function pathExists(candidate) {
 }
 async function hasManagedMarker(directory) {
   try {
-    await (0, import_promises2.access)((0, import_node_path14.join)(directory, ".alan-managed.json"));
+    await (0, import_promises2.access)((0, import_node_path16.join)(directory, ".alan-managed.json"));
     return true;
   } catch {
     return false;
@@ -43401,7 +43573,7 @@ function isAlreadyPresent(error61) {
 }
 
 // src/ws/host.ts
-var import_node_crypto6 = require("crypto");
+var import_node_crypto7 = require("crypto");
 
 // ../agent-core/dist/index.js
 var import_crypto = require("crypto");
@@ -43425,12 +43597,12 @@ var TRANSCRIPT_LIVE_DELIVERY_HEADER = "x-alan-transcript-delivery";
 
 // ../shared/dist/node/local-workspace.js
 var import_node_fs12 = require("fs");
-var import_node_os12 = require("os");
-var import_node_path15 = require("path");
-function resolveAlanDefaultWorkspacePath(homeDirectory2 = (0, import_node_os12.homedir)()) {
-  return (0, import_node_path15.join)(homeDirectory2, ".alan", "workspace");
+var import_node_os13 = require("os");
+var import_node_path17 = require("path");
+function resolveAlanDefaultWorkspacePath(homeDirectory2 = (0, import_node_os13.homedir)()) {
+  return (0, import_node_path17.join)(homeDirectory2, ".alan", "workspace");
 }
-function ensureAlanDefaultWorkspace(homeDirectory2 = (0, import_node_os12.homedir)()) {
+function ensureAlanDefaultWorkspace(homeDirectory2 = (0, import_node_os13.homedir)()) {
   const workspacePath = resolveAlanDefaultWorkspacePath(homeDirectory2);
   (0, import_node_fs12.mkdirSync)(workspacePath, { recursive: true });
   return workspacePath;
@@ -43500,13 +43672,21 @@ var import_path14 = require("path");
 var import_fs15 = require("fs");
 var import_os7 = require("os");
 var import_path15 = require("path");
+var import_crypto8 = require("crypto");
 var import_fs16 = require("fs");
 var import_os8 = require("os");
 var import_path16 = require("path");
-var import_child_process7 = require("child_process");
 var import_fs17 = require("fs");
 var import_os9 = require("os");
 var import_path17 = require("path");
+var import_crypto9 = require("crypto");
+var import_fs18 = require("fs");
+var import_os10 = require("os");
+var import_path18 = require("path");
+var import_child_process7 = require("child_process");
+var import_fs19 = require("fs");
+var import_os11 = require("os");
+var import_path19 = require("path");
 function createGrammarState() {
   return { seenToolCallIds: /* @__PURE__ */ new Set(), counter: 0, scratch: {} };
 }
@@ -43958,6 +44138,7 @@ var CLI_PROBLEM_CODE_BY_ERROR_KIND = {
   provider_error: "cli.unknown",
   subagent_parent_exited: "cli.process.nonzero_exit",
   tool_call_invalid: "cli.tool.failed",
+  turn_limit: "cli.process.nonzero_exit",
   unknown_cli_error: "cli.unknown"
 };
 function createCliProblem(classified, options) {
@@ -44028,15 +44209,15 @@ var ERROR_SPECS = {
     recoveryClass: "user_fixable"
   },
   rate_limited: {
-    message: "Rate limited by the provider. Retrying automatically shortly.",
+    message: "Rate limited by the provider. Wait a moment, then send your message again.",
     recoveryClass: "auto_recovering"
   },
   overloaded: {
-    message: "The provider is overloaded. Retrying automatically.",
+    message: "The provider is overloaded right now. Wait a moment or pick a different model, then send your message again.",
     recoveryClass: "auto_recovering"
   },
   network: {
-    message: "Network connection failed. Check your internet connection \u2014 retrying automatically.",
+    message: "Network connection failed. Check your internet connection, then send your message again.",
     recoveryClass: "auto_recovering"
   },
   provider_timeout: {
@@ -44075,6 +44256,10 @@ var ERROR_SPECS = {
     message: "The agent made an invalid tool call (for example, referencing a file that doesn't exist) and the run stopped. Send your message again \u2014 it usually succeeds on retry.",
     recoveryClass: "retry"
   },
+  turn_limit: {
+    message: "The agent reached its turn limit and stopped before finishing. Send Continue to pick up where it left off.",
+    recoveryClass: "retry"
+  },
   unknown_cli_error: {
     message: "The agent stopped unexpectedly. Send your message again to retry.",
     recoveryClass: "retry"
@@ -44125,6 +44310,13 @@ function normalizeCodexCliErrorMessage(message) {
   }
   return message;
 }
+function lineContaining(text2, pattern) {
+  return text2.split("\n").map((line) => line.trim()).find((line) => pattern.test(line));
+}
+function lastMeaningfulLine(text2) {
+  const lines = text2.split("\n").map((line) => line.trim()).filter((line) => line.length > 0 && !/^at\s/.test(line));
+  return lines.at(-1) ?? "";
+}
 var NAMED_SESSION_NOT_FOUND = /\b(?:session|chat|conversation)\s+(?:"[^"\n]{1,160}"|'[^'\n]{1,160}'|[\w-]{6,})\s+not found\b/;
 function classifyCliErrorDetailed(stderr, exitCode, opts) {
   const normalizedCodexError = normalizeCodexCliErrorMessage(stderr);
@@ -44141,6 +44333,8 @@ function classifyCliErrorDetailed(stderr, exitCode, opts) {
   if (has("codex cli connection expired", "reconnect openai codex"))
     return specForErrorKind("auth_expired");
   if (has("codex connection to openai timed out")) return specForErrorKind("provider_timeout");
+  if (has("reached maximum conversation turns", "reached maximum number of turns", "error_max_turns"))
+    return specForErrorKind("turn_limit");
   if (has("authentication required", "not authenticated"))
     return specForErrorKind("not_authenticated");
   if (has(
@@ -44216,10 +44410,17 @@ function classifyCliErrorDetailed(stderr, exitCode, opts) {
     "requires a paid"
   ))
     return specForErrorKind("subscription_required");
-  if (has("quota exceeded", "quota limit", "daily limit", "monthly limit", "usage limit"))
+  if (has("usage limit", "usage_limit_exceeded"))
+    return {
+      ...specForErrorKind("usage_limit"),
+      message: lineContaining(stderr, /usage limit/i) ?? ERROR_SPECS.usage_limit.message
+    };
+  if (has("quota exceeded", "quota limit", "daily limit", "monthly limit"))
     return specForErrorKind("quota_exceeded");
   if (has(
     "overloaded",
+    "at capacity",
+    "server_overloaded",
     "http 500",
     "[500]",
     "status 500",
@@ -44257,7 +44458,7 @@ function classifyCliErrorDetailed(stderr, exitCode, opts) {
   if (has("out of memory", "enomem")) return specForErrorKind("out_of_memory");
   if (has("invalid tool call error", "declaring permissions:"))
     return specForErrorKind("tool_call_invalid");
-  const raw = stderr.trim().slice(0, 200);
+  const raw = lastMeaningfulLine(stderr).slice(0, 200);
   if (raw) {
     return { message: raw, errorKind: "unknown_cli_error", recoveryClass: "unknown" };
   }
@@ -44860,15 +45061,19 @@ function timeoutProblem(closing, message, phase) {
     }
   );
 }
+var FRESH_SESSION_ON_RESUME_MISS = /* @__PURE__ */ new Set([
+  "cursor_agent_cli",
+  "antigravity_cli"
+]);
 function detectSilentResumeFork(closing) {
   const { options, context, state } = closing;
   const requestedResumeId = context.config.runtimeSessionId?.trim() || context.config.providerSessionId?.trim();
   if (!requestedResumeId || !state.runtimeSessionId) return false;
   if (state.runtimeSessionId === requestedResumeId) return false;
   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`
+    `[${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 and antigravity`
   );
-  if (options.kind !== "cursor_agent_cli") return false;
+  if (!FRESH_SESSION_ON_RESUME_MISS.has(options.kind)) return false;
   logResumeObservability("agent_resume_failed", {
     backendKind: options.kind,
     reason: "cli_forked_fresh_session",
@@ -45080,6 +45285,7 @@ function resumeFailedResult(closing) {
     state
   );
 }
+var SUMMARY_ERROR_SIGNAL_MAX_CHARS = 300;
 function explainFailure(closing, verdict) {
   const { state, observed } = closing;
   if (state.errorKind && state.error?.trim()) {
@@ -45100,10 +45306,15 @@ function explainFailure(closing, verdict) {
       recoveryClass: "retry"
     };
   }
+  const summary = state.summary.trim();
   const detailed = classifyCliErrorDetailed(
     state.error?.trim() || observed.stderrTail.trim() || "",
     observed.exit.exitCode ?? 1,
-    { extraSignals: state.summary ? [state.summary] : void 0 }
+    // A provider error echoed as assistant text is one short line; a partial answer that says
+    // "network" or "API key" in passing must not decide the failure kind.
+    {
+      extraSignals: summary && summary.length <= SUMMARY_ERROR_SIGNAL_MAX_CHARS ? [summary] : void 0
+    }
   );
   return {
     error: detailed.message,
@@ -45875,7 +46086,8 @@ function createCliBackend(options) {
         process: null,
         iterations: 0,
         summary: "",
-        runStartedAtMs: Date.now()
+        runStartedAtMs: Date.now(),
+        ...options.initialSessionId ? { runtimeSessionId: options.initialSessionId } : {}
       };
       const prompt = resolvePrompt(options, context);
       const supervisor = new CliProcessSupervisor(options, context, state);
@@ -48370,7 +48582,7 @@ function formatResults(results) {
 }
 
 /** Mirrors the harness CLI: say what the agent can do next instead of just failing. */
-function describeRefusal(refusal, status, text) {
+function describeRefusalAction(refusal, status, text) {
   const code = refusal && typeof refusal.error === "string" ? refusal.error : "";
   const message = refusal && typeof refusal.message === "string" ? refusal.message : truncate(text, 300);
   const reset = refusal && typeof refusal.resetsAt === "string" ? refusal.resetsAt.slice(0, 10) : "";
@@ -48389,12 +48601,26 @@ function describeRefusal(refusal, status, text) {
   return "Web search failed (" + status + "): " + message;
 }
 
+/** The correlation id turns "something went wrong" into a log line an operator can open. */
+function describeRefusal(refusal, status, text) {
+  const described = describeRefusalAction(refusal, status, text);
+  const ref =
+    refusal && typeof refusal.requestId === "string" && refusal.requestId
+      ? " [ref: " + refusal.requestId + "]"
+      : "";
+  return described + ref;
+}
+
 async function callWebSearch(query, signal) {
   const apiKey = process.env[API_KEY_ENV];
   if (!apiKey) {
     return { title: "web_search unavailable", output: "Web search is unavailable: this run has no Alan credential." };
   }
-  const headers = { Authorization: "Bearer " + apiKey, "Content-Type": "application/json" };
+  const headers = {
+    Authorization: "Bearer " + apiKey,
+    "Content-Type": "application/json",
+    "x-request-id": crypto.randomUUID(),
+  };
   if (process.env[RUN_ID_ENV]) headers["x-alan-run-id"] = process.env[RUN_ID_ENV];
 
   for (let attempt = 0; ; attempt += 1) {
@@ -49006,15 +49232,15 @@ var antigravityTextGrammar = {
 `)];
   }
 };
-var config2 = (input2) => input2.context.config;
+var config3 = (input2) => input2.context.config;
 var settings = (input2) => input2.context.config.antigravity;
-var selectedModel = (input2) => trimmedOrUndefined(config2(input2).selectedModel);
+var selectedModel = (input2) => trimmedOrUndefined(config3(input2).selectedModel);
 var selectedEffort = (input2) => {
-  const level = trimmedOrUndefined(config2(input2).selectedEffortLevel)?.toLowerCase();
+  const level = trimmedOrUndefined(config3(input2).selectedEffortLevel)?.toLowerCase();
   if (!selectedModel(input2) || !level || !isEffortLevel(level)) return void 0;
   return level;
 };
-var resumeId = (input2) => trimmedOrUndefined(config2(input2).runtimeSessionId) ?? trimmedOrUndefined(config2(input2).providerSessionId);
+var resumeId = (input2) => trimmedOrUndefined(config3(input2).runtimeSessionId) ?? trimmedOrUndefined(config3(input2).providerSessionId);
 var workspacePaths = (input2) => [
   ...new Set(
     (settings(input2)?.additionalWorkspacePaths ?? []).map((p) => p.trim()).filter(Boolean)
@@ -52260,7 +52486,9 @@ var turnCompleted = (event) => {
 };
 var taskComplete = (event) => {
   const last = asString(event.last_agent_message);
+  const error61 = asRecord(event.error);
   return [
+    ...errorNotice3(errorMessage(error61?.message)),
     {
       sessionUpdate: "state_update",
       state: "idle",
@@ -52947,8 +53175,8 @@ var CODEX_EVENTS = /* @__PURE__ */ new Map([
   ],
   [
     "task_complete",
-    (_event, _context, state) => {
-      clearRecoveredCodexError(state);
+    (event, _context, state) => {
+      if (!recordFailedCodexTurn(event, state)) clearRecoveredCodexError(state);
       completeCodexTurnRespectingWorkers(state);
     }
   ],
@@ -53003,6 +53231,24 @@ function beginCodexTurn(state, family) {
 function clearRecoveredCodexError(state) {
   state.error = void 0;
 }
+var ERROR_KIND_BY_CODEX_ERROR_INFO = /* @__PURE__ */ new Map([
+  ["server_overloaded", "overloaded"],
+  ["usage_limit_exceeded", "usage_limit"],
+  ["context_window_exceeded", "context_length"]
+]);
+function recordFailedCodexTurn(event, state) {
+  const error61 = asRecord(event.error);
+  const message = normalizeCodexCliErrorMessage(asString(error61?.message).trim());
+  if (!error61 || !message) return false;
+  const info = asString(error61.codex_error_info).trim();
+  const knownKind = ERROR_KIND_BY_CODEX_ERROR_INFO.get(info);
+  const classified = knownKind ? { ...specForErrorKind(knownKind), message } : classifyCliErrorDetailed(message, 1);
+  state.error = classified.message;
+  state.errorKind = classified.errorKind;
+  state.recoveryClass = classified.recoveryClass;
+  if (info) state.providerErrorCode = info;
+  return true;
+}
 function handleCollabToolCall(context, state, item, completed, updates) {
   const itemId = asString(item.id);
   const tool = asString(item.tool);
@@ -53115,11 +53361,11 @@ function buildCodexExternalMcpArgs(servers) {
     ([name, server]) => server.type === "stdio" ? codexStdioServerArgs(`mcp_servers.${name}`, server) : codexRemoteServerArgs(`mcp_servers.${name}`, server)
   );
 }
-var config3 = (input2) => input2.context.config;
-var permissions = (input2) => getCodexPermissionArgs(config3(input2));
-var baseModel2 = (input2) => collapseModelIdToBase(trimmedOrUndefined(config3(input2).selectedModel) ?? "");
+var config32 = (input2) => input2.context.config;
+var permissions = (input2) => getCodexPermissionArgs(config32(input2));
+var baseModel2 = (input2) => collapseModelIdToBase(trimmedOrUndefined(config32(input2).selectedModel) ?? "");
 var model = (input2) => baseModel2(input2) || void 0;
-var effort2 = (input2) => buildCodexEffortArgs(config3(input2).selectedEffortLevel, { modelId: baseModel2(input2) });
+var effort2 = (input2) => buildCodexEffortArgs(config32(input2).selectedEffortLevel, { modelId: baseModel2(input2) });
 var overrides = (input2) => input2.configOverrides;
 var resuming = (input2) => Boolean(input2.resumeId);
 var resumeTarget = (input2) => input2.resumeId ? [input2.resumeId] : [];
@@ -53689,6 +53935,7 @@ function usageModel(context, state) {
   const selected = context.config.selectedModel;
   return state.activeModel || (typeof selected === "string" && selected.trim() ? selected : "command-code");
 }
+var COMMAND_CODE_MAX_TURNS = 1e4;
 function commandCodePermissionArgs(config4) {
   if (shouldUseReadOnlyRuntimePermissions(config4)) {
     if (config4.mode === "plan" || config4.mode === "review") return ["--plan"];
@@ -53727,6 +53974,8 @@ function createCommandCodeCliBackend(command = "command-code", defaultArgs = [])
             "--skip-onboarding",
             "--trust",
             "--no-auto-update",
+            "--max-turns",
+            String(COMMAND_CODE_MAX_TURNS),
             ...commandCodePermissionArgs(ctx.config),
             ...defaultArgs
           ];
@@ -54253,6 +54502,55 @@ function writeCopilotMcpConfig(registration) {
   );
   return { path: path2, cleanup: () => (0, import_fs15.rmSync)(dir, { recursive: true, force: true }) };
 }
+function resolveCopilotHome(env) {
+  return env.COPILOT_HOME || (0, import_path16.join)(env.HOME || (0, import_os8.homedir)(), ".copilot");
+}
+function copilotSessionPresence(sessionId, home) {
+  const stateRoot = (0, import_path16.join)(home, "session-state");
+  if (!(0, import_fs16.existsSync)(stateRoot)) return "unknown";
+  return (0, import_fs16.existsSync)((0, import_path16.join)(stateRoot, sessionId, "events.jsonl")) ? "present" : "missing";
+}
+function freshSession(contextPrefix) {
+  const sessionId = (0, import_crypto8.randomUUID)();
+  return {
+    sessionId,
+    sessionArgs: [`--session-id=${sessionId}`],
+    resumed: false,
+    ...contextPrefix ? { contextPrefix } : {}
+  };
+}
+function planCopilotSession(context) {
+  const requestedResumeId = context.config.runtimeSessionId?.trim() || context.config.providerSessionId?.trim();
+  if (!requestedResumeId) return freshSession();
+  const presence = copilotSessionPresence(requestedResumeId, resolveCopilotHome(context.env));
+  if (presence !== "missing") {
+    logResumeObservability("agent_resume_requested", {
+      backendKind: "copilot_cli",
+      requestedResumeId
+    });
+    return {
+      sessionId: requestedResumeId,
+      sessionArgs: [`--resume=${requestedResumeId}`],
+      resumed: true
+    };
+  }
+  const contextPrefix = context.config.resumeFallbackContext?.trim() || void 0;
+  logResumeObservability("agent_resume_fallback_used", {
+    backendKind: "copilot_cli",
+    reason: "session_state_missing",
+    requestedResumeId,
+    hadFallbackContext: Boolean(contextPrefix)
+  });
+  emitSessionUpdate(
+    noticeUpdate(
+      "warning",
+      "session_resume_failed",
+      contextPrefix ? "The previous Copilot session was not found on this machine, so a fresh session was started with the recent conversation history re-included." : "The previous Copilot session was not found on this machine, so a fresh session was started. Earlier conversation context may be missing from this reply."
+    ),
+    context
+  );
+  return freshSession(contextPrefix);
+}
 function buildCopilotCliArgs(context, prompt, defaultArgs = [], options = {}) {
   const args = [
     "--yolo",
@@ -54284,6 +54582,7 @@ function buildCopilotCliArgs(context, prompt, defaultArgs = [], options = {}) {
   if (options.additionalMcpConfigPath) {
     args.push("--additional-mcp-config", `@${options.additionalMcpConfigPath}`);
   }
+  if (options.sessionArgs) args.push(...options.sessionArgs);
   args.push("-p", prompt);
   return [...args, ...defaultArgs];
 }
@@ -54297,20 +54596,36 @@ function createCopilotCliBackend(command = "copilot", defaultArgs = []) {
         context.cwd
       );
       const mcpConfig = writeCopilotMcpConfig(context.config.alanMcp);
+      const session = planCopilotSession(context);
+      const runContext = session.resumed ? context : {
+        ...context,
+        config: {
+          ...context.config,
+          runtimeSessionId: void 0,
+          providerSessionId: void 0
+        }
+      };
       try {
         return await createCliBackend({
           kind: "copilot_cli",
           supportTier: "structured",
           command,
           args: [],
+          initialSessionId: session.sessionId,
           buildArgs: (ctx, prompt) => buildCopilotCliArgs(ctx, prompt, defaultArgs, {
-            additionalMcpConfigPath: mcpConfig?.path
+            additionalMcpConfigPath: mcpConfig?.path,
+            sessionArgs: session.sessionArgs
           }),
-          augmentPrompt: (ctx) => buildPromptWithImagePathReferences(ctx, imageFiles),
+          augmentPrompt: (ctx) => {
+            const prompt = buildPromptWithImagePathReferences(ctx, imageFiles);
+            return session.contextPrefix ? `${session.contextPrefix}
+
+${prompt}` : prompt;
+          },
           parseStructuredLine: grammarAsStructuredLineParser(copilotGrammar, copilotEffects),
           // Held open so a deferred `result` can wait for background work to drain.
           keepStdinOpen: true
-        }).run(context);
+        }).run(runContext);
       } finally {
         mcpConfig?.cleanup();
         cleanup();
@@ -54859,11 +55174,11 @@ function cursorConversationStepText(steps) {
 }
 function cursorTranscriptsRoot(context) {
   const projectKey = context.cwd.replace(/^[/\\]+/, "").replace(/[/\\]+/g, "-");
-  const home = context.env.HOME || process.env.HOME || (0, import_os8.homedir)();
-  return (0, import_path16.join)(home, ".cursor", "projects", projectKey, "agent-transcripts");
+  const home = context.env.HOME || process.env.HOME || (0, import_os9.homedir)();
+  return (0, import_path17.join)(home, ".cursor", "projects", projectKey, "agent-transcripts");
 }
 function cursorTranscriptPathForAgent(context, agentId) {
-  return (0, import_path16.join)(cursorTranscriptsRoot(context), agentId, `${agentId}.jsonl`);
+  return (0, import_path17.join)(cursorTranscriptsRoot(context), agentId, `${agentId}.jsonl`);
 }
 function resolveCursorSubagentTranscriptPath(success2, context) {
   const explicit = success2?.transcriptPath ?? success2?.transcript_path;
@@ -54888,13 +55203,13 @@ function cursorTranscriptUserText(transcriptPath2) {
 }
 function discoverCursorSubagentTranscript(context, state, task) {
   const root = cursorTranscriptsRoot(context);
-  if (!(0, import_fs16.existsSync)(root)) return void 0;
+  if (!(0, import_fs17.existsSync)(root)) return void 0;
   const prompt = task.prompt?.trim();
   const description = task.description?.trim().toLowerCase();
   const candidates = [];
   let entries;
   try {
-    entries = (0, import_fs16.readdirSync)(root, { withFileTypes: true });
+    entries = (0, import_fs17.readdirSync)(root, { withFileTypes: true });
   } catch {
     return void 0;
   }
@@ -54903,7 +55218,7 @@ function discoverCursorSubagentTranscript(context, state, task) {
     const path2 = cursorTranscriptPathForAgent(context, entry.name);
     let mtimeMs;
     try {
-      mtimeMs = (0, import_fs16.statSync)(path2).mtimeMs;
+      mtimeMs = (0, import_fs17.statSync)(path2).mtimeMs;
     } catch {
       continue;
     }
@@ -55220,6 +55535,52 @@ function buildCursorAgentModelArg(modelId, options) {
   if (parsed.fast) return `${id}-fast`;
   return id;
 }
+function realPathOr(cwd) {
+  try {
+    return (0, import_fs18.realpathSync)(cwd);
+  } catch {
+    return cwd;
+  }
+}
+function workspaceKeys(cwd) {
+  return [.../* @__PURE__ */ new Set([realPathOr(cwd), cwd])].map(
+    (path2) => (0, import_crypto9.createHash)("md5").update(path2).digest("hex")
+  );
+}
+function cursorChatPresence(query) {
+  const chatsRoot = (0, import_path18.join)(query.home, ".cursor", "chats");
+  if (!(0, import_fs18.existsSync)(chatsRoot)) return "unknown";
+  const found = workspaceKeys(query.cwd).some(
+    (key) => (0, import_fs18.existsSync)((0, import_path18.join)(chatsRoot, key, query.chatId, "store.db"))
+  );
+  return found ? "present" : "missing";
+}
+function planCursorResume(context) {
+  const requestedResumeId = context.config.runtimeSessionId?.trim() || context.config.providerSessionId?.trim();
+  if (!requestedResumeId) return {};
+  const presence = cursorChatPresence({
+    chatId: requestedResumeId,
+    cwd: context.cwd,
+    home: context.env.HOME || (0, import_os10.homedir)()
+  });
+  if (presence !== "missing") return { resumeId: requestedResumeId };
+  const contextPrefix = context.config.resumeFallbackContext?.trim() || void 0;
+  logResumeObservability("agent_resume_fallback_used", {
+    backendKind: "cursor_agent_cli",
+    reason: "chat_store_missing",
+    requestedResumeId,
+    hadFallbackContext: Boolean(contextPrefix)
+  });
+  emitSessionUpdate(
+    noticeUpdate(
+      "warning",
+      "session_resume_failed",
+      contextPrefix ? "The previous Cursor chat was not found on this machine, so a fresh chat was started with the recent conversation history re-included." : "The previous Cursor chat was not found on this machine, so a fresh chat was started. Earlier conversation context may be missing from this reply."
+    ),
+    context
+  );
+  return contextPrefix ? { contextPrefix } : {};
+}
 function isCursorAgentCliModelId(model2) {
   return model2 === "auto" || /^composer-/.test(model2) || /^gpt-/.test(model2) || /^claude-/.test(model2) || /^gemini-/.test(model2) || /^grok-/.test(model2) || /^kimi-/.test(model2);
 }
@@ -55265,14 +55626,23 @@ function createCursorAgentCliBackend(command = "cursor-agent", defaultArgs = [])
         context.config.alanMcp ? cliSupportsFlag(command, "--approve-mcps", context.env) : Promise.resolve(false),
         cliSupportsFlag(command, "--stream-partial-output", context.env)
       ]);
-      const runContext = context.config.alanMcp ? {
+      const resume = planCursorResume(context);
+      const resumeContext = resume.resumeId ? context : {
         ...context,
+        config: {
+          ...context.config,
+          runtimeSessionId: void 0,
+          providerSessionId: void 0
+        }
+      };
+      const runContext = context.config.alanMcp ? {
+        ...resumeContext,
         env: {
-          ...context.env,
+          ...resumeContext.env,
           [ALAN_MCP_AUTHORIZATION_ENV]: requireManagedAuthorization(context.config.alanMcp),
           [ALAN_RUN_ID_ENV]: requireManagedRunId(context.config.alanMcp)
         }
-      } : context;
+      } : resumeContext;
       const runBackend = () => createCliBackend({
         kind: "cursor_agent_cli",
         supportTier: "structured",
@@ -55293,7 +55663,7 @@ function createCursorAgentCliBackend(command = "cursor-agent", defaultArgs = [])
           if (approveMcps) {
             args.push("--approve-mcps");
           }
-          const resumeId3 = ctx.config.runtimeSessionId?.trim() || ctx.config.providerSessionId?.trim();
+          const resumeId3 = resume.resumeId;
           if (shouldForceCursorAgent(ctx.config)) args.push("--force");
           if (ctx.config.mode === "plan" || ctx.config.mode === "review") {
             args.push("--mode", "plan");
@@ -55332,10 +55702,12 @@ function createCursorAgentCliBackend(command = "cursor-agent", defaultArgs = [])
         // cursor-agent headless can hang at startup with zero output.
         startupTimeoutMs: 18e4,
         augmentPrompt: (ctx) => {
-          const isResume = Boolean(
-            ctx.config.runtimeSessionId?.trim() || ctx.config.providerSessionId?.trim()
-          );
-          const base = buildResumeAwarePrompt(ctx.config, ctx.promptText, { isResume });
+          const promptText = resume.contextPrefix ? `${resume.contextPrefix}
+
+${ctx.promptText}` : ctx.promptText;
+          const base = buildResumeAwarePrompt(ctx.config, promptText, {
+            isResume: Boolean(resume.resumeId)
+          });
           const prompt = ctx.config.mode === "plan" ? buildPlanModePrefix(base) : base;
           return appendImagePathReferences(prompt, imageFiles);
         },
@@ -57192,10 +57564,10 @@ function createKimiCliBackend(command = "kimi", defaultArgs = []) {
     async run(context) {
       const dialect = await detectKimiCliDialect(command, context);
       const registration = dialect === "kimi-cli" ? context.config.alanMcp : void 0;
-      const mcpDirectory = registration ? (0, import_fs17.mkdtempSync)((0, import_path17.join)((0, import_os9.tmpdir)(), "alan-kimi-mcp-")) : null;
-      const mcpConfigPath = mcpDirectory ? (0, import_path17.join)(mcpDirectory, "mcp.json") : null;
+      const mcpDirectory = registration ? (0, import_fs19.mkdtempSync)((0, import_path19.join)((0, import_os11.tmpdir)(), "alan-kimi-mcp-")) : null;
+      const mcpConfigPath = mcpDirectory ? (0, import_path19.join)(mcpDirectory, "mcp.json") : null;
       if (registration && mcpConfigPath) {
-        (0, import_fs17.writeFileSync)(
+        (0, import_fs19.writeFileSync)(
           mcpConfigPath,
           JSON.stringify(
             buildKimiMcpConfig(registration, selectExternalMcpServers(context.config))
@@ -57230,7 +57602,7 @@ function createKimiCliBackend(command = "kimi", defaultArgs = []) {
         }).run(context);
       } finally {
         cleanup();
-        if (mcpDirectory) (0, import_fs17.rmSync)(mcpDirectory, { recursive: true, force: true });
+        if (mcpDirectory) (0, import_fs19.rmSync)(mcpDirectory, { recursive: true, force: true });
       }
     }
   };
@@ -57465,9 +57837,12 @@ var AgentRunner = class {
   /** Provider attempts and runner commentary share one sequence for the run. */
   agentEventSeq = 0;
   foregroundState = "idle";
+  /** Notice titles already in this run's transcript, so a failure is not reported twice. */
+  noticeTitles = /* @__PURE__ */ new Set();
   publishEvent(event) {
     if (isUpdate(event.update, "state_update") && typeof event.update._meta?.["alan.dev/parentToolCallId"] !== "string")
       this.foregroundState = event.update.state;
+    if (isUpdate(event.update, "notice")) this.noticeTitles.add(event.update.title.trim());
     this.agentEventSeq += 1;
     this.host.onSessionEvent({ ...event, seq: this.agentEventSeq });
   }
@@ -57475,6 +57850,8 @@ var AgentRunner = class {
     this.publishEvent({ at: Date.now(), update });
   }
   complete(result) {
+    const unreported = this.unreportedFailure(result);
+    if (unreported) this.failure(unreported);
     if (this.foregroundState === "running")
       this.emit({
         sessionUpdate: "state_update",
@@ -57511,6 +57888,16 @@ var AgentRunner = class {
       _meta: { "alan.dev/noticeKind": kind }
     });
   }
+  /**
+   * The chat renders only the transcript, and `result.error` never reaches it on its own:
+   * a failed run whose reason was not already narrated would end with no explanation.
+   */
+  unreportedFailure(result) {
+    const error61 = result.error?.trim();
+    if (result.success || !error61) return null;
+    if (this.abortController?.signal.aborted && this.abortReason === "user") return null;
+    return this.noticeTitles.has(error61) ? null : error61;
+  }
   /** A failure the run could not recover from. */
   failure(message) {
     this.emit({
@@ -57775,6 +58162,7 @@ ${runtimeConfig.task}` } : {}
   }
   async run(config4) {
     this.agentEventSeq = 0;
+    this.noticeTitles = /* @__PURE__ */ new Set();
     this.abortReason = "user";
     this.abortController = new AbortController();
     const backendKind = this.resolveBackendKind(config4);
@@ -59193,7 +59581,7 @@ function buildApplicationRunFailure(input2) {
   const problem = createAlanProblem({
     domain: "application",
     code: input2.code,
-    id: (0, import_node_crypto6.randomUUID)(),
+    id: (0, import_node_crypto7.randomUUID)(),
     title: "Alan could not complete the agent run",
     detail: input2.detail,
     occurredAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -59398,7 +59786,7 @@ var RuntimeRunHost = class extends BaseRunHost {
       this.applicationProblem = createAlanProblem({
         domain: "application",
         code: /local path no longer exists/i.test(message) ? "app.workspace.missing" : "app.internal",
-        id: (0, import_node_crypto6.randomUUID)(),
+        id: (0, import_node_crypto7.randomUUID)(),
         title: "Alan could not start the agent run",
         detail: message,
         occurredAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -59638,10 +60026,10 @@ function scheduleRuntimeModelScan(getBaseMetadata, options) {
 }
 
 // src/daemon/start.ts
-var import_node_crypto16 = require("crypto");
+var import_node_crypto17 = require("crypto");
 var import_node_http2 = __toESM(require("http"), 1);
 var import_node_os16 = require("os");
-var import_node_path31 = require("path");
+var import_node_path33 = require("path");
 
 // ../../node_modules/engine.io-client/build/esm-debug/transports/polling-xhr.node.js
 var XMLHttpRequestModule = __toESM(require_XMLHttpRequest(), 1);
@@ -63199,8 +63587,8 @@ Object.assign(lookup, {
 
 // src/cleanup/hooks.ts
 var import_node_fs13 = require("fs");
-var import_node_os13 = require("os");
-var import_node_path16 = require("path");
+var import_node_os14 = require("os");
+var import_node_path18 = require("path");
 var ALAN_HOOK_MARKER = "# alan-native-session-hook";
 var ALAN_KIMI_HOOKS_START = "# alan-native-session-hooks:start";
 var ALAN_KIMI_HOOKS_END = "# alan-native-session-hooks:end";
@@ -63229,7 +63617,7 @@ function writeSettings(path2, settings2) {
   const serialized = `${JSON.stringify(settings2, null, 2)}
 `;
   if ((0, import_node_fs13.existsSync)(path2) && (0, import_node_fs13.readFileSync)(path2, "utf8") === serialized) return false;
-  (0, import_node_fs13.mkdirSync)((0, import_node_path16.dirname)(path2), { recursive: true, mode: 448 });
+  (0, import_node_fs13.mkdirSync)((0, import_node_path18.dirname)(path2), { recursive: true, mode: 448 });
   const temporary = `${path2}.${process.pid}.tmp`;
   (0, import_node_fs13.writeFileSync)(temporary, serialized, { mode: 384 });
   (0, import_node_fs13.renameSync)(temporary, path2);
@@ -63237,7 +63625,7 @@ function writeSettings(path2, settings2) {
 }
 function writeTextFile(path2, content) {
   if ((0, import_node_fs13.existsSync)(path2) && (0, import_node_fs13.readFileSync)(path2, "utf8") === content) return false;
-  (0, import_node_fs13.mkdirSync)((0, import_node_path16.dirname)(path2), { recursive: true, mode: 448 });
+  (0, import_node_fs13.mkdirSync)((0, import_node_path18.dirname)(path2), { recursive: true, mode: 448 });
   const temporary = `${path2}.${process.pid}.tmp`;
   (0, import_node_fs13.writeFileSync)(temporary, content, { mode: 384 });
   (0, import_node_fs13.renameSync)(temporary, path2);
@@ -63291,7 +63679,7 @@ function removeOwnedFile(path2, marker) {
   return true;
 }
 function removeKimiSection(homeDir) {
-  const path2 = (0, import_node_path16.join)(homeDir, ".kimi-code", "config.toml");
+  const path2 = (0, import_node_path18.join)(homeDir, ".kimi-code", "config.toml");
   if (!(0, import_node_fs13.existsSync)(path2)) return false;
   const current = (0, import_node_fs13.readFileSync)(path2, "utf8");
   const content = withoutMarkedSection(current, ALAN_KIMI_HOOKS_START, ALAN_KIMI_HOOKS_END);
@@ -63299,50 +63687,50 @@ function removeKimiSection(homeDir) {
   return writeTextFile(path2, content ? `${content.trimEnd()}
 ` : "");
 }
-function removeNativeHooks(homeDir = (0, import_node_os13.homedir)()) {
+function removeNativeHooks(homeDir = (0, import_node_os14.homedir)()) {
   const targets = [
     {
       provider: "Claude",
-      path: (0, import_node_path16.join)(homeDir, ".claude", "settings.json"),
-      remove: () => removeNestedCommandHooks((0, import_node_path16.join)(homeDir, ".claude", "settings.json"), "Claude")
+      path: (0, import_node_path18.join)(homeDir, ".claude", "settings.json"),
+      remove: () => removeNestedCommandHooks((0, import_node_path18.join)(homeDir, ".claude", "settings.json"), "Claude")
     },
     {
       provider: "Codex",
-      path: (0, import_node_path16.join)(homeDir, ".codex", "hooks.json"),
-      remove: () => removeNestedCommandHooks((0, import_node_path16.join)(homeDir, ".codex", "hooks.json"), "Codex")
+      path: (0, import_node_path18.join)(homeDir, ".codex", "hooks.json"),
+      remove: () => removeNestedCommandHooks((0, import_node_path18.join)(homeDir, ".codex", "hooks.json"), "Codex")
     },
     {
       provider: "Cursor",
-      path: (0, import_node_path16.join)(homeDir, ".cursor", "hooks.json"),
-      remove: () => removeFlatCommandHooks((0, import_node_path16.join)(homeDir, ".cursor", "hooks.json"), "Cursor")
+      path: (0, import_node_path18.join)(homeDir, ".cursor", "hooks.json"),
+      remove: () => removeFlatCommandHooks((0, import_node_path18.join)(homeDir, ".cursor", "hooks.json"), "Cursor")
     },
     {
       provider: "Copilot",
-      path: (0, import_node_path16.join)(homeDir, ".copilot", "hooks", "alan-native-session.json"),
+      path: (0, import_node_path18.join)(homeDir, ".copilot", "hooks", "alan-native-session.json"),
       remove: () => removeOwnedFile(
-        (0, import_node_path16.join)(homeDir, ".copilot", "hooks", "alan-native-session.json"),
+        (0, import_node_path18.join)(homeDir, ".copilot", "hooks", "alan-native-session.json"),
         ALAN_HOOK_MARKER
       )
     },
     {
       provider: "Grok",
-      path: (0, import_node_path16.join)(homeDir, ".grok", "hooks", "alan-native-session.json"),
+      path: (0, import_node_path18.join)(homeDir, ".grok", "hooks", "alan-native-session.json"),
       remove: () => removeOwnedFile(
-        (0, import_node_path16.join)(homeDir, ".grok", "hooks", "alan-native-session.json"),
+        (0, import_node_path18.join)(homeDir, ".grok", "hooks", "alan-native-session.json"),
         ALAN_HOOK_MARKER
       )
     },
     {
       provider: "opencode",
-      path: (0, import_node_path16.join)(homeDir, ".config", "opencode", "plugins", "alan-native-session.js"),
+      path: (0, import_node_path18.join)(homeDir, ".config", "opencode", "plugins", "alan-native-session.js"),
       remove: () => removeOwnedFile(
-        (0, import_node_path16.join)(homeDir, ".config", "opencode", "plugins", "alan-native-session.js"),
+        (0, import_node_path18.join)(homeDir, ".config", "opencode", "plugins", "alan-native-session.js"),
         ALAN_OPENCODE_PLUGIN_MARKER
       )
     },
     {
       provider: "Kimi",
-      path: (0, import_node_path16.join)(homeDir, ".kimi-code", "config.toml"),
+      path: (0, import_node_path18.join)(homeDir, ".kimi-code", "config.toml"),
       remove: () => removeKimiSection(homeDir)
     }
   ];
@@ -63400,7 +63788,7 @@ async function publishModelScanReply(reply, credentials) {
 var import_node_fs19 = require("fs");
 
 // src/events/live.ts
-var import_node_crypto8 = require("crypto");
+var import_node_crypto9 = require("crypto");
 var import_node_fs17 = require("fs");
 var import_promises8 = require("fs/promises");
 
@@ -63461,13 +63849,13 @@ function requestDeadline(timeoutMs, parent) {
 }
 
 // src/events/push.ts
-var import_node_crypto7 = require("crypto");
+var import_node_crypto8 = require("crypto");
 var import_node_fs16 = require("fs");
 var import_promises7 = require("fs/promises");
 
 // src/events/session.ts
 var import_node_fs15 = require("fs");
-var import_node_path18 = require("path");
+var import_node_path20 = require("path");
 
 // src/events/journal-notifications.ts
 var listeners2 = /* @__PURE__ */ new Map();
@@ -63493,21 +63881,21 @@ function subscribeJournalChanges(conversationId, listener) {
 
 // src/events/sync-state.ts
 var import_node_fs14 = require("fs");
-var import_node_path17 = require("path");
+var import_node_path19 = require("path");
 function sessionsDirectory(configPath) {
-  return (0, import_node_path17.join)((0, import_node_path17.dirname)(configPath), "sessions");
+  return (0, import_node_path19.join)((0, import_node_path19.dirname)(configPath), "sessions");
 }
 function conversationDirectory(configPath, conversationId) {
   if (!conversationId || conversationId === "." || conversationId === "..") {
     throw new Error("Invalid conversation storage identity");
   }
-  return (0, import_node_path17.join)(sessionsDirectory(configPath), encodeURIComponent(conversationId));
+  return (0, import_node_path19.join)(sessionsDirectory(configPath), encodeURIComponent(conversationId));
 }
 function transcriptPath(configPath, conversationId) {
-  return (0, import_node_path17.join)(conversationDirectory(configPath, conversationId), "transcript.jsonl");
+  return (0, import_node_path19.join)(conversationDirectory(configPath, conversationId), "transcript.jsonl");
 }
 function syncStatePath(configPath, conversationId) {
-  return (0, import_node_path17.join)(conversationDirectory(configPath, conversationId), "state.json");
+  return (0, import_node_path19.join)(conversationDirectory(configPath, conversationId), "state.json");
 }
 function record2(value2) {
   return typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
@@ -63594,16 +63982,16 @@ function contiguousOffset(state) {
 }
 function save(configPath, conversationId, state) {
   const path2 = syncStatePath(configPath, conversationId);
-  (0, import_node_fs14.mkdirSync)((0, import_node_path17.dirname)(path2), { recursive: true, mode: 448 });
+  (0, import_node_fs14.mkdirSync)((0, import_node_path19.dirname)(path2), { recursive: true, mode: 448 });
   (0, import_node_fs14.writeFileSync)(`${path2}.pending`, JSON.stringify(state), { mode: 384 });
   (0, import_node_fs14.renameSync)(`${path2}.pending`, path2);
 }
 function migrateConversationStorage(configPath, conversationId) {
   const root = sessionsDirectory(configPath);
   const name = encodeURIComponent(conversationId);
-  const oldTranscript = (0, import_node_path17.join)(root, `${name}.jsonl`);
-  const oldState = (0, import_node_path17.join)(root, `${name}.state.json`);
-  const oldRuns = (0, import_node_path17.join)(root, `${name}.runs`);
+  const oldTranscript = (0, import_node_path19.join)(root, `${name}.jsonl`);
+  const oldState = (0, import_node_path19.join)(root, `${name}.state.json`);
+  const oldRuns = (0, import_node_path19.join)(root, `${name}.runs`);
   if ((0, import_node_fs14.existsSync)(syncStatePath(configPath, conversationId))) {
     if ((0, import_node_fs14.existsSync)(oldTranscript)) {
       throw new Error("Both transcript layouts exist; refusing to overwrite history");
@@ -63621,11 +64009,11 @@ function migrateConversationStorage(configPath, conversationId) {
   if ((0, import_node_fs14.existsSync)(oldRuns)) {
     for (const file2 of (0, import_node_fs14.readdirSync)(oldRuns)) {
       if (!file2.endsWith(".json")) continue;
-      state.runs[decodeURIComponent(file2.slice(0, -5))] = runState(readJson((0, import_node_path17.join)(oldRuns, file2)));
+      state.runs[decodeURIComponent(file2.slice(0, -5))] = runState(readJson((0, import_node_path19.join)(oldRuns, file2)));
     }
   }
   const target = transcriptPath(configPath, conversationId);
-  (0, import_node_fs14.mkdirSync)((0, import_node_path17.dirname)(target), { recursive: true, mode: 448 });
+  (0, import_node_fs14.mkdirSync)((0, import_node_path19.dirname)(target), { recursive: true, mode: 448 });
   if ((0, import_node_fs14.existsSync)(oldTranscript)) {
     if ((0, import_node_fs14.existsSync)(target))
       throw new Error("Both transcript layouts exist; refusing to overwrite history");
@@ -63803,7 +64191,7 @@ function openSessionTranscript(input2) {
       if (getTranscriptBuffer(path2))
         throw new Error("Conversation has pending transcript bytes from another writer");
       migrateConversationStorage(input2.configPath, input2.conversationId);
-      (0, import_node_fs15.mkdirSync)((0, import_node_path18.dirname)(path2), { recursive: true, mode: 448 });
+      (0, import_node_fs15.mkdirSync)((0, import_node_path20.dirname)(path2), { recursive: true, mode: 448 });
       written = sizeOf(path2);
       const sync = readSyncState(input2.configPath, input2.conversationId);
       if (sync.lastRunId && sync.lastRunId !== input2.runId) {
@@ -64012,7 +64400,7 @@ var MAX_RECEIPT_POLL_MS = 15e3;
 var MAX_PUSH_BYTES = 512 * 1024;
 var MIN_PUSH_BYTES = 64 * 1024;
 var adaptivePushBytes = MAX_PUSH_BYTES;
-function isTimeout(error61) {
+function isTimeout2(error61) {
   return error61 instanceof Error && error61.name === "TimeoutError";
 }
 var REQUEST_TIMEOUT_MS = 1e4;
@@ -64044,7 +64432,7 @@ async function exchange(target, body, offset2, final = false) {
           "content-type": "application/octet-stream",
           "x-alan-offset": String(offset2),
           "x-alan-revision": "0",
-          "x-alan-sha256": (0, import_node_crypto7.createHash)("sha256").update(body).digest("hex"),
+          "x-alan-sha256": (0, import_node_crypto8.createHash)("sha256").update(body).digest("hex"),
           ...final ? { "x-alan-final": "1" } : {}
         } : {}
       },
@@ -64182,7 +64570,7 @@ function startTranscriptPush(target, onProblem) {
       }
     }).catch((error61) => {
       if (target.signal?.aborted) return;
-      if (isTimeout(error61)) adaptivePushBytes = Math.max(MIN_PUSH_BYTES, adaptivePushBytes / 2);
+      if (isTimeout2(error61)) adaptivePushBytes = Math.max(MIN_PUSH_BYTES, adaptivePushBytes / 2);
       failures += 1;
       pending = true;
       cached2 = void 0;
@@ -64334,7 +64722,7 @@ function startTranscriptLive(target, onProblem) {
             "content-type": "application/octet-stream",
             "x-alan-offset": String(offset2),
             "x-alan-revision": "0",
-            "x-alan-sha256": (0, import_node_crypto8.createHash)("sha256").update(body).digest("hex"),
+            "x-alan-sha256": (0, import_node_crypto9.createHash)("sha256").update(body).digest("hex"),
             "x-alan-live-epoch": epoch ?? ""
           } : {}
         },
@@ -64742,6 +65130,7 @@ var TERMINAL_EVENT_TYPES = /* @__PURE__ */ new Set([
   "session_error",
   "agent_run_finished"
 ]);
+var PROBLEM_EVENT_TYPES = /* @__PURE__ */ new Set(["error", "application_problem", "agent_problem_observed"]);
 var TERMINAL_RETRY_WINDOW_MS = 10 * 6e4;
 var RETRY_BACKOFF_CAP_MS = 3e4;
 function isRetryableStatus(status2) {
@@ -64819,7 +65208,7 @@ function createHttpRunEventSink(input2, url3, binding) {
     }
   }
   async function deliver(conversationId, runId, event) {
-    const terminal = TERMINAL_EVENT_TYPES.has(event.type);
+    const mustDeliver = TERMINAL_EVENT_TYPES.has(event.type) || PROBLEM_EVENT_TYPES.has(event.type);
     const giveUpAt = Date.now() + TERMINAL_RETRY_WINDOW_MS;
     for (let attempt = 0; ; attempt++) {
       if (shutdown.signal.aborted) return;
@@ -64848,7 +65237,7 @@ function createHttpRunEventSink(input2, url3, binding) {
         deadline.dispose();
       }
       const backoff = Math.min(1e3 * 2 ** attempt, RETRY_BACKOFF_CAP_MS);
-      if (!terminal || !retryable || Date.now() + backoff > giveUpAt) {
+      if (!mustDeliver || !retryable || Date.now() + backoff > giveUpAt) {
         input2.onFailure?.(failure2);
         return;
       }
@@ -65160,9 +65549,9 @@ async function pushNativeTurn(delivery, record4) {
 }
 
 // src/native/session-store.ts
-var import_node_crypto9 = require("crypto");
+var import_node_crypto10 = require("crypto");
 var import_node_fs20 = require("fs");
-var import_node_path19 = require("path");
+var import_node_path21 = require("path");
 var MAX_NATIVE_SESSION_ENTRIES = 500;
 var nativeRunFinishEvents = ["agent_run_finished", "query_complete"];
 function nativeSessionStorePath(configPath) {
@@ -65206,8 +65595,8 @@ function loadSessions(path2) {
   return parsed.sessions.filter(isSessionEntry);
 }
 function writeAtomically(path2, contents) {
-  (0, import_node_fs20.mkdirSync)((0, import_node_path19.dirname)(path2), { recursive: true, mode: 448 });
-  const pending = `${path2}.pending-${process.pid}-${(0, import_node_crypto9.randomBytes)(6).toString("hex")}`;
+  (0, import_node_fs20.mkdirSync)((0, import_node_path21.dirname)(path2), { recursive: true, mode: 448 });
+  const pending = `${path2}.pending-${process.pid}-${(0, import_node_crypto10.randomBytes)(6).toString("hex")}`;
   try {
     (0, import_node_fs20.writeFileSync)(pending, contents, { mode: 384 });
     (0, import_node_fs20.chmodSync)(pending, 384);
@@ -65260,7 +65649,7 @@ function reconcileTranscriptIdentity(entry, transcriptPath2, identity, size) {
 }
 
 // src/native/turns.ts
-var import_node_crypto10 = require("crypto");
+var import_node_crypto11 = require("crypto");
 var import_promises9 = require("fs/promises");
 var SCAN_BYTES = 1024 * 1024;
 var MIN_READ_BYTES = 64 * 1024;
@@ -65406,7 +65795,7 @@ function lastMatchingTurnIndex(turns, target) {
 function signalDigest(target) {
   const fingerprint = target.assistantFingerprint;
   const basis = target.providerTurnId ?? (fingerprint ? `${fingerprint.length}\0${fingerprint.head}\0${fingerprint.tail}` : null);
-  return basis ? (0, import_node_crypto10.createHash)("sha256").update(basis).digest("hex") : null;
+  return basis ? (0, import_node_crypto11.createHash)("sha256").update(basis).digest("hex") : null;
 }
 function lastForegroundStopReason(updates) {
   for (let index = updates.length - 1; index >= 0; index -= 1) {
@@ -66321,14 +66710,14 @@ var RuntimeSkillCoordinator = class {
 
 // src/skills/runtime-skill-manager.ts
 var import_node_buffer5 = require("buffer");
-var import_node_crypto13 = require("crypto");
+var import_node_crypto14 = require("crypto");
 var import_promises13 = require("fs/promises");
-var import_node_path22 = require("path");
+var import_node_path24 = require("path");
 
 // src/skills/managed-skill-store.ts
-var import_node_crypto11 = require("crypto");
+var import_node_crypto12 = require("crypto");
 var import_promises11 = require("fs/promises");
-var import_node_path20 = require("path");
+var import_node_path22 = require("path");
 var EMPTY_STATE = {
   version: 1,
   sources: {},
@@ -66345,7 +66734,7 @@ var ManagedSkillStore = class _ManagedSkillStore {
   static async open(baseDirectory) {
     await (0, import_promises11.mkdir)(baseDirectory, { recursive: true, mode: 448 });
     try {
-      const parsed = JSON.parse(await (0, import_promises11.readFile)((0, import_node_path20.join)(baseDirectory, "state.json"), "utf8"));
+      const parsed = JSON.parse(await (0, import_promises11.readFile)((0, import_node_path22.join)(baseDirectory, "state.json"), "utf8"));
       return new _ManagedSkillStore(baseDirectory, parseState(parsed), "verified");
     } catch (error61) {
       if (isMissingPath(error61)) {
@@ -66403,10 +66792,10 @@ var ManagedSkillStore = class _ManagedSkillStore {
     this.integrity = "verified";
   }
   async persist() {
-    const statePath = (0, import_node_path20.join)(this.baseDirectory, "state.json");
-    const pendingPath = (0, import_node_path20.join)(
+    const statePath = (0, import_node_path22.join)(this.baseDirectory, "state.json");
+    const pendingPath = (0, import_node_path22.join)(
       this.baseDirectory,
-      `.state.json.pending-${process.pid}-${(0, import_node_crypto11.randomBytes)(6).toString("hex")}`
+      `.state.json.pending-${process.pid}-${(0, import_node_crypto12.randomBytes)(6).toString("hex")}`
     );
     try {
       await (0, import_promises11.writeFile)(pendingPath, `${JSON.stringify(this.state, null, 2)}
@@ -66471,9 +66860,9 @@ function isMissingPath(error61) {
 
 // ../shared/dist/node/skill-bundle.js
 var import_node_buffer3 = require("buffer");
-var import_node_crypto12 = require("crypto");
+var import_node_crypto13 = require("crypto");
 var import_promises12 = require("fs/promises");
-var import_node_path21 = require("path");
+var import_node_path23 = require("path");
 var import_node_stream = require("stream");
 var import_node_zlib = require("zlib");
 var import_tar_stream = __toESM(require_tar_stream(), 1);
@@ -66482,7 +66871,7 @@ async function createSkillBundle(packageRoot, options = {}) {
   const archive = (0, import_tar_stream.pack)();
   const tarPromise = collectStream(archive);
   for (const file2 of before.files) {
-    const bytes2 = await (0, import_promises12.readFile)((0, import_node_path21.join)(packageRoot, ...file2.path.split("/")));
+    const bytes2 = await (0, import_promises12.readFile)((0, import_node_path23.join)(packageRoot, ...file2.path.split("/")));
     await addArchiveEntry(archive, {
       name: file2.path,
       type: "file",
@@ -66597,19 +66986,19 @@ async function extractEntry(header, stream, destination, limits) {
   if (bytes.byteLength !== declaredSize) {
     throw new Error(`Skill archive file size is invalid: ${path2}`);
   }
-  const outputPath = (0, import_node_path21.join)(destination, ...path2.split("/"));
-  await (0, import_promises12.mkdir)((0, import_node_path21.dirname)(outputPath), { recursive: true, mode: 448 });
+  const outputPath = (0, import_node_path23.join)(destination, ...path2.split("/"));
+  await (0, import_promises12.mkdir)((0, import_node_path23.dirname)(outputPath), { recursive: true, mode: 448 });
   await (0, import_promises12.writeFile)(outputPath, bytes, { mode: (header.mode ?? 420) & 73 ? 493 : 420 });
 }
 function requireSafeArchivePath(value2) {
   const normalized2 = value2.replaceAll("\\", "/").normalize("NFC");
-  if (!normalized2 || normalized2.startsWith("/") || normalized2.includes("\0") || import_node_path21.posix.normalize(normalized2) !== normalized2 || normalized2 === ".." || normalized2.startsWith("../")) {
+  if (!normalized2 || normalized2.startsWith("/") || normalized2.includes("\0") || import_node_path23.posix.normalize(normalized2) !== normalized2 || normalized2 === ".." || normalized2.startsWith("../")) {
     throw new Error(`Skill archive contains an unsafe path: ${value2}`);
   }
   return normalized2;
 }
 function sha2562(bytes) {
-  return `sha256:${(0, import_node_crypto12.createHash)("sha256").update(bytes).digest("hex")}`;
+  return `sha256:${(0, import_node_crypto13.createHash)("sha256").update(bytes).digest("hex")}`;
 }
 
 // src/skills/skill-control-client.ts
@@ -66687,14 +67076,14 @@ var RuntimeSkillManager = class _RuntimeSkillManager {
       options.endpointProfile,
       options.profileStorageIdentity
     );
-    const skillsStateDirectory = storageNamespace ? (0, import_node_path22.join)(options.homeDirectory, ".alan", "skills", "profiles", storageNamespace) : (0, import_node_path22.join)(options.homeDirectory, ".alan", "skills");
-    const managedSkillsDirectory = (0, import_node_path22.join)(options.homeDirectory, ".agents", "skills");
+    const skillsStateDirectory = storageNamespace ? (0, import_node_path24.join)(options.homeDirectory, ".alan", "skills", "profiles", storageNamespace) : (0, import_node_path24.join)(options.homeDirectory, ".alan", "skills");
+    const managedSkillsDirectory = (0, import_node_path24.join)(options.homeDirectory, ".agents", "skills");
     const store = await ManagedSkillStore.open(skillsStateDirectory);
     return new _RuntimeSkillManager(
       skillsStateDirectory,
       managedSkillsDirectory,
-      (0, import_node_path22.join)(options.homeDirectory, ".claude", "skills"),
-      (0, import_node_path22.join)(options.homeDirectory, ".alan", "sync-manifest.json"),
+      (0, import_node_path24.join)(options.homeDirectory, ".claude", "skills"),
+      (0, import_node_path24.join)(options.homeDirectory, ".alan", "sync-manifest.json"),
       storageNamespace,
       store,
       options.downloadBundle ?? downloadBundleWithFetch,
@@ -66860,11 +67249,11 @@ var RuntimeSkillManager = class _RuntimeSkillManager {
   async reconcileUnlocked(manifest) {
     const desired = desiredSkillManifestSchema.parse(manifest);
     await (0, import_promises13.mkdir)(this.managedSkillsDirectory, { recursive: true, mode: 448 });
-    await (0, import_promises13.mkdir)((0, import_node_path22.join)(this.skillsStateDirectory, "cache", "sha256"), {
+    await (0, import_promises13.mkdir)((0, import_node_path24.join)(this.skillsStateDirectory, "cache", "sha256"), {
       recursive: true,
       mode: 448
     });
-    await (0, import_promises13.mkdir)((0, import_node_path22.join)(this.skillsStateDirectory, "tmp"), { recursive: true, mode: 448 });
+    await (0, import_promises13.mkdir)((0, import_node_path24.join)(this.skillsStateDirectory, "tmp"), { recursive: true, mode: 448 });
     const results = [];
     const nextProjections = {};
     for (const entry of desired.skills) {
@@ -66908,7 +67297,7 @@ var RuntimeSkillManager = class _RuntimeSkillManager {
       await this.retireLegacySyncManifest();
     }
     return {
-      attemptId: (0, import_node_crypto13.randomUUID)(),
+      attemptId: (0, import_node_crypto14.randomUUID)(),
       desiredRevision: desired.revision,
       skills: results
     };
@@ -66967,7 +67356,7 @@ var RuntimeSkillManager = class _RuntimeSkillManager {
   }
   conflictDirectory(runtimeDirectory, kind) {
     requireSafeRuntimeDirectory(runtimeDirectory);
-    return (0, import_node_path22.join)(
+    return (0, import_node_path24.join)(
       kind === "managed_destination" ? this.managedSkillsDirectory : this.compatibilitySkillsDirectory,
       this.projectionDirectoryName(runtimeDirectory)
     );
@@ -66975,13 +67364,13 @@ var RuntimeSkillManager = class _RuntimeSkillManager {
   async renameLocalConflict(entry, conflict, name) {
     requirePortableSkillName(name);
     const source2 = this.conflictDirectory(entry.runtimeDirectory, conflict.kind);
-    const destination = (0, import_node_path22.join)((0, import_node_path22.dirname)(source2), name);
+    const destination = (0, import_node_path24.join)((0, import_node_path24.dirname)(source2), name);
     if (await pathExists2(destination)) {
       throw Object.assign(new Error(`A local Skill named ${name} already exists`), {
         code: "SKILL_LOCAL_NAME_CONFLICT"
       });
     }
-    const suffix = `${process.pid}-${(0, import_node_crypto13.randomBytes)(8).toString("hex")}`;
+    const suffix = `${process.pid}-${(0, import_node_crypto14.randomBytes)(8).toString("hex")}`;
     const backup = `${source2}.rename-backup-${suffix}`;
     const pending = `${source2}.rename-pending-${suffix}`;
     let sourceMoved = false;
@@ -66990,7 +67379,7 @@ var RuntimeSkillManager = class _RuntimeSkillManager {
       await (0, import_promises13.rename)(source2, backup);
       sourceMoved = true;
       await (0, import_promises13.cp)(backup, pending, { recursive: true, errorOnExist: true, force: false });
-      const skillMarkdown = (0, import_node_path22.join)(pending, "SKILL.md");
+      const skillMarkdown = (0, import_node_path24.join)(pending, "SKILL.md");
       await (0, import_promises13.writeFile)(
         skillMarkdown,
         rewriteSkillMarkdownName(await (0, import_promises13.readFile)(skillMarkdown, "utf8"), name),
@@ -67018,7 +67407,7 @@ var RuntimeSkillManager = class _RuntimeSkillManager {
   }
   async overwriteLocalConflict(input2, entry, conflict, manifest) {
     const source2 = this.conflictDirectory(entry.runtimeDirectory, conflict.kind);
-    const backup = `${source2}.overwrite-backup-${process.pid}-${(0, import_node_crypto13.randomBytes)(8).toString("hex")}`;
+    const backup = `${source2}.overwrite-backup-${process.pid}-${(0, import_node_crypto14.randomBytes)(8).toString("hex")}`;
     await (0, import_promises13.rename)(source2, backup);
     try {
       const reconciled = await this.reconcileUnlocked(manifest);
@@ -67070,14 +67459,14 @@ var RuntimeSkillManager = class _RuntimeSkillManager {
     const manifest = await readLegacyManifest(this.legacyManifestPath);
     const legacy = manifest?.skills[entry.slug];
     if (!legacy) return;
-    const source2 = (0, import_node_path22.join)(this.managedSkillsDirectory, entry.slug);
+    const source2 = (0, import_node_path24.join)(this.managedSkillsDirectory, entry.slug);
     if (!await legacyFileMatches(source2, legacy.hash) || !await packageMatches(source2, entry.contentHash)) {
       return;
     }
     await (0, import_promises13.rename)(source2, destination);
     try {
       await (0, import_promises13.writeFile)(
-        (0, import_node_path22.join)(destination, ".alan-managed.json"),
+        (0, import_node_path24.join)(destination, ".alan-managed.json"),
         `${JSON.stringify(markerFor(entry), null, 2)}
 `,
         { encoding: "utf8", flag: "wx", mode: 384 }
@@ -67086,20 +67475,20 @@ var RuntimeSkillManager = class _RuntimeSkillManager {
       await (0, import_promises13.rename)(destination, source2).catch(() => void 0);
       throw error61;
     }
-    await removeExactLegacySkill((0, import_node_path22.join)(this.compatibilitySkillsDirectory, entry.slug), legacy.hash);
+    await removeExactLegacySkill((0, import_node_path24.join)(this.compatibilitySkillsDirectory, entry.slug), legacy.hash);
   }
   async retireLegacySyncManifest() {
     if (this.storageNamespace) return;
     const manifest = await readLegacyManifest(this.legacyManifestPath);
     if (!manifest) return;
     for (const [command, entry] of Object.entries(manifest.skills)) {
-      await removeExactLegacySkill((0, import_node_path22.join)(this.managedSkillsDirectory, command), entry.hash);
-      await removeExactLegacySkill((0, import_node_path22.join)(this.compatibilitySkillsDirectory, command), entry.hash);
+      await removeExactLegacySkill((0, import_node_path24.join)(this.managedSkillsDirectory, command), entry.hash);
+      await removeExactLegacySkill((0, import_node_path24.join)(this.compatibilitySkillsDirectory, command), entry.hash);
     }
     await (0, import_promises13.rm)(this.legacyManifestPath, { force: true });
   }
   async ensureCached(entry) {
-    const cacheDirectory = (0, import_node_path22.join)(
+    const cacheDirectory = (0, import_node_path24.join)(
       this.skillsStateDirectory,
       "cache",
       "sha256",
@@ -67113,10 +67502,10 @@ var RuntimeSkillManager = class _RuntimeSkillManager {
         `Downloaded Skill bundle length ${bytes.byteLength} does not match ${entry.compressedBytes}`
       );
     }
-    const pendingDirectory = (0, import_node_path22.join)(
+    const pendingDirectory = (0, import_node_path24.join)(
       this.skillsStateDirectory,
       "tmp",
-      `cache-${process.pid}-${(0, import_node_crypto13.randomBytes)(8).toString("hex")}`
+      `cache-${process.pid}-${(0, import_node_crypto14.randomBytes)(8).toString("hex")}`
     );
     try {
       await extractSkillBundle(bytes, pendingDirectory, {
@@ -67140,16 +67529,16 @@ var RuntimeSkillManager = class _RuntimeSkillManager {
       await this.ensureCompatibilityProjection(entry, destination);
       return entry.contentHash;
     }
-    const suffix = `${process.pid}-${(0, import_node_crypto13.randomBytes)(8).toString("hex")}`;
-    const pending = (0, import_node_path22.join)(this.managedSkillsDirectory, `.pending-${suffix}`);
-    const backup = (0, import_node_path22.join)(this.managedSkillsDirectory, `.backup-${suffix}`);
+    const suffix = `${process.pid}-${(0, import_node_crypto14.randomBytes)(8).toString("hex")}`;
+    const pending = (0, import_node_path24.join)(this.managedSkillsDirectory, `.pending-${suffix}`);
+    const backup = (0, import_node_path24.join)(this.managedSkillsDirectory, `.backup-${suffix}`);
     let movedExisting = false;
     let installedPending = false;
     let completed = false;
     try {
       await (0, import_promises13.cp)(cacheDirectory, pending, { recursive: true, errorOnExist: true, force: false });
       await (0, import_promises13.writeFile)(
-        (0, import_node_path22.join)(pending, ".alan-managed.json"),
+        (0, import_node_path24.join)(pending, ".alan-managed.json"),
         `${JSON.stringify(markerFor(entry), null, 2)}
 `,
         { encoding: "utf8", flag: "wx", mode: 384 }
@@ -67223,7 +67612,7 @@ var RuntimeSkillManager = class _RuntimeSkillManager {
       const owned = splitProjectionName(entry);
       if (owned.namespace !== this.storageNamespace) continue;
       if (desired[owned.runtimeDirectory]) continue;
-      const destination = (0, import_node_path22.join)(this.managedSkillsDirectory, entry);
+      const destination = (0, import_node_path24.join)(this.managedSkillsDirectory, entry);
       const marker = await readMarker(destination);
       if (!marker) continue;
       const projection = {
@@ -67240,7 +67629,7 @@ var RuntimeSkillManager = class _RuntimeSkillManager {
         });
         continue;
       }
-      const compatibility = (0, import_node_path22.join)(this.compatibilitySkillsDirectory, entry);
+      const compatibility = (0, import_node_path24.join)(this.compatibilitySkillsDirectory, entry);
       if (!await removeCompatibilityProjection(compatibility, destination, projection)) {
         failures.push({
           ...projection,
@@ -67256,7 +67645,7 @@ var RuntimeSkillManager = class _RuntimeSkillManager {
   }
   async ensureCompatibilityProjection(entry, canonicalDirectory) {
     await (0, import_promises13.mkdir)(this.compatibilitySkillsDirectory, { recursive: true, mode: 448 });
-    const destination = (0, import_node_path22.join)(
+    const destination = (0, import_node_path24.join)(
       this.compatibilitySkillsDirectory,
       this.projectionDirectoryName(entry.runtimeDirectory)
     );
@@ -67270,11 +67659,11 @@ var RuntimeSkillManager = class _RuntimeSkillManager {
     } catch (error61) {
       if (!isSymlinkUnsupported(error61)) throw error61;
     }
-    const pending = `${destination}.pending-${process.pid}-${(0, import_node_crypto13.randomBytes)(6).toString("hex")}`;
+    const pending = `${destination}.pending-${process.pid}-${(0, import_node_crypto14.randomBytes)(6).toString("hex")}`;
     try {
       await (0, import_promises13.cp)(canonicalDirectory, pending, { recursive: true, errorOnExist: true, force: false });
       await (0, import_promises13.writeFile)(
-        (0, import_node_path22.join)(pending, ".alan-compatibility.json"),
+        (0, import_node_path24.join)(pending, ".alan-compatibility.json"),
         `${JSON.stringify({ ...markerFor(entry), canonicalDirectory }, null, 2)}
 `,
         { encoding: "utf8", flag: "wx", mode: 384 }
@@ -67298,7 +67687,7 @@ var RuntimeSkillManager = class _RuntimeSkillManager {
     }
   }
   projectionDirectory(runtimeDirectory) {
-    return (0, import_node_path22.join)(this.managedSkillsDirectory, this.projectionDirectoryName(runtimeDirectory));
+    return (0, import_node_path24.join)(this.managedSkillsDirectory, this.projectionDirectoryName(runtimeDirectory));
   }
   projectionDirectoryName(runtimeDirectory) {
     requireSafeRuntimeDirectory(runtimeDirectory);
@@ -67306,14 +67695,14 @@ var RuntimeSkillManager = class _RuntimeSkillManager {
   }
   async withMachineLock(work) {
     await (0, import_promises13.mkdir)(this.skillsStateDirectory, { recursive: true, mode: 448 });
-    const lockDirectory = (0, import_node_path22.join)(this.skillsStateDirectory, "manager.lock");
+    const lockDirectory = (0, import_node_path24.join)(this.skillsStateDirectory, "manager.lock");
     const deadline = Date.now() + 3e4;
     while (true) {
       try {
         await (0, import_promises13.mkdir)(lockDirectory, { mode: 448 });
         try {
           await (0, import_promises13.writeFile)(
-            (0, import_node_path22.join)(lockDirectory, "owner.json"),
+            (0, import_node_path24.join)(lockDirectory, "owner.json"),
             `${JSON.stringify({ pid: process.pid, acquiredAt: (/* @__PURE__ */ new Date()).toISOString() })}
 `,
             { encoding: "utf8", flag: "wx", mode: 384 }
@@ -67363,7 +67752,7 @@ async function packageMatches(directory, expectedHash) {
 async function readMarker(directory) {
   try {
     const value2 = JSON.parse(
-      await (0, import_promises13.readFile)((0, import_node_path22.join)(directory, ".alan-managed.json"), "utf8")
+      await (0, import_promises13.readFile)((0, import_node_path24.join)(directory, ".alan-managed.json"), "utf8")
     );
     if (typeof value2 !== "object" || value2 === null || !("protocolVersion" in value2) || value2.protocolVersion !== SKILLS_PROTOCOL_VERSION || !("skillId" in value2) || typeof value2.skillId !== "string" || !("versionId" in value2) || typeof value2.versionId !== "string" || !("contentHash" in value2) || typeof value2.contentHash !== "string" || !/^sha256:[a-f0-9]{64}$/.test(value2.contentHash)) {
       return null;
@@ -67377,7 +67766,7 @@ async function compatibilityProjectionMatches(destination, canonicalDirectory, e
   const metadata = await (0, import_promises13.lstat)(destination);
   if (metadata.isSymbolicLink()) {
     const target = await (0, import_promises13.readlink)(destination);
-    return (0, import_node_path22.resolve)((0, import_node_path22.dirname)(destination), target) === (0, import_node_path22.resolve)(canonicalDirectory);
+    return (0, import_node_path24.resolve)((0, import_node_path24.dirname)(destination), target) === (0, import_node_path24.resolve)(canonicalDirectory);
   }
   if (!metadata.isDirectory()) return false;
   const marker = await readCompatibilityMarker(destination);
@@ -67388,7 +67777,7 @@ async function removeCompatibilityProjection(destination, canonicalDirectory, pr
   const metadata = await (0, import_promises13.lstat)(destination);
   if (metadata.isSymbolicLink()) {
     const target = await (0, import_promises13.readlink)(destination);
-    if ((0, import_node_path22.resolve)((0, import_node_path22.dirname)(destination), target) !== (0, import_node_path22.resolve)(canonicalDirectory)) return false;
+    if ((0, import_node_path24.resolve)((0, import_node_path24.dirname)(destination), target) !== (0, import_node_path24.resolve)(canonicalDirectory)) return false;
     await (0, import_promises13.rm)(destination, { force: true });
     return true;
   }
@@ -67400,7 +67789,7 @@ async function removeCompatibilityProjection(destination, canonicalDirectory, pr
 async function readCompatibilityMarker(directory) {
   try {
     const value2 = JSON.parse(
-      await (0, import_promises13.readFile)((0, import_node_path22.join)(directory, ".alan-compatibility.json"), "utf8")
+      await (0, import_promises13.readFile)((0, import_node_path24.join)(directory, ".alan-compatibility.json"), "utf8")
     );
     if (value2.protocolVersion !== SKILLS_PROTOCOL_VERSION || typeof value2.skillId !== "string" || typeof value2.versionId !== "string" || !/^sha256:[a-f0-9]{64}$/.test(value2.contentHash) || typeof value2.canonicalDirectory !== "string") {
       return null;
@@ -67440,15 +67829,15 @@ async function legacyFileMatches(directory, expectedHash) {
   try {
     const metadata = await (0, import_promises13.lstat)(directory);
     if (!metadata.isDirectory() || metadata.isSymbolicLink()) return false;
-    const content = await (0, import_promises13.readFile)((0, import_node_path22.join)(directory, "SKILL.md"));
-    return (0, import_node_crypto13.createHash)("sha256").update(content).digest("hex").slice(0, 16) === expectedHash;
+    const content = await (0, import_promises13.readFile)((0, import_node_path24.join)(directory, "SKILL.md"));
+    return (0, import_node_crypto14.createHash)("sha256").update(content).digest("hex").slice(0, 16) === expectedHash;
   } catch {
     return false;
   }
 }
 async function removeExactLegacySkill(directory, expectedHash) {
   if (!await legacyFileMatches(directory, expectedHash)) return;
-  await (0, import_promises13.rm)((0, import_node_path22.join)(directory, "SKILL.md"), { force: true });
+  await (0, import_promises13.rm)((0, import_node_path24.join)(directory, "SKILL.md"), { force: true });
   const remaining = await (0, import_promises13.readdir)(directory);
   if (remaining.length === 0) await (0, import_promises13.rm)(directory, { recursive: true, force: true });
 }
@@ -67462,7 +67851,7 @@ function resolveStorageNamespace(endpointProfile, profileStorageIdentity) {
   }
   const identity = profileStorageIdentity?.trim();
   if (!identity) return endpointProfile;
-  const identityHash = (0, import_node_crypto13.createHash)("sha256").update(identity).digest("hex").slice(0, 12);
+  const identityHash = (0, import_node_crypto14.createHash)("sha256").update(identity).digest("hex").slice(0, 12);
   return `${endpointProfile}-${identityHash}`;
 }
 function splitProjectionName(name) {
@@ -67641,9 +68030,6 @@ var SuspensionDetector = class {
   }
 };
 
-// src/core-agent.ts
-var import_node_os14 = require("os");
-
 // src/prompt-context.ts
 function joinLines(lines) {
   return lines.join("\n");
@@ -67948,17 +68334,6 @@ var CoreAgent = class extends AgentRunner {
       delete augmented.GOOGLE_API_KEY;
     }
     Object.assign(augmented, buildProviderAuthEnv(backendKind, providerApiKey));
-    if ((0, import_node_os14.platform)() !== "win32") {
-      const home = augmented.HOME ?? "/home/user";
-      const extraPaths = [`${home}/.local/node/bin`, `${home}/.local/bin`];
-      const separator = ":";
-      const basePath = augmented.PATH ?? "";
-      const existingSegments = new Set(basePath.split(separator).filter(Boolean));
-      const missing = extraPaths.filter((p) => !existingSegments.has(p));
-      if (missing.length > 0) {
-        augmented.PATH = `${missing.join(separator)}${separator}${basePath}`;
-      }
-    }
     return augmented;
   }
   buildExtraSystemPromptParts(config4) {
@@ -68050,24 +68425,24 @@ ${input2.userRequest}
 
 // src/workspace-run-lease.ts
 var import_promises14 = require("fs/promises");
-var import_node_path23 = require("path");
+var import_node_path25 = require("path");
 var WORKSPACE_LEASE_CHECK_INTERVAL_MS = 1e3;
 async function hasGitWorkspaceMarker(workspacePath) {
   let directory;
   try {
-    directory = await (0, import_promises14.realpath)((0, import_node_path23.resolve)(workspacePath));
+    directory = await (0, import_promises14.realpath)((0, import_node_path25.resolve)(workspacePath));
   } catch {
     return true;
   }
   while (true) {
     try {
-      await (0, import_promises14.stat)((0, import_node_path23.join)(directory, ".git"));
+      await (0, import_promises14.stat)((0, import_node_path25.join)(directory, ".git"));
       return true;
     } catch (error61) {
       const code = error61.code;
       if (code !== "ENOENT" && code !== "ENOTDIR") return true;
     }
-    const parent = (0, import_node_path23.dirname)(directory);
+    const parent = (0, import_node_path25.dirname)(directory);
     if (parent === directory) return false;
     directory = parent;
   }
@@ -68078,19 +68453,19 @@ async function filesystemIdentity(path2) {
   return `${canonicalPath}:${metadata.dev}:${metadata.ino}`;
 }
 function resolveGitPath(workspacePath, value2) {
-  return (0, import_node_path23.isAbsolute)(value2) ? value2 : (0, import_node_path23.resolve)(workspacePath, value2);
+  return (0, import_node_path25.isAbsolute)(value2) ? value2 : (0, import_node_path25.resolve)(workspacePath, value2);
 }
 async function resolveGitIdentityPaths(canonicalWorkspacePath) {
   let directory = canonicalWorkspacePath;
   while (true) {
-    const marker = (0, import_node_path23.join)(directory, ".git");
+    const marker = (0, import_node_path25.join)(directory, ".git");
     let markerStats;
     try {
       markerStats = await (0, import_promises14.stat)(marker);
     } catch (error61) {
       const code = error61.code;
       if (code !== "ENOENT" && code !== "ENOTDIR") return null;
-      const parent = (0, import_node_path23.dirname)(directory);
+      const parent = (0, import_node_path25.dirname)(directory);
       if (parent === directory) return null;
       directory = parent;
       continue;
@@ -68109,8 +68484,8 @@ async function resolveGitIdentityPaths(canonicalWorkspacePath) {
     const gitDirectory = resolveGitPath(directory, gitDirMatch[1].trim());
     let commonDirectory = gitDirectory;
     try {
-      const commonRaw = (await (0, import_promises14.readFile)((0, import_node_path23.join)(gitDirectory, "commondir"), "utf8")).trim();
-      if (commonRaw) commonDirectory = (0, import_node_path23.resolve)(gitDirectory, commonRaw);
+      const commonRaw = (await (0, import_promises14.readFile)((0, import_node_path25.join)(gitDirectory, "commondir"), "utf8")).trim();
+      if (commonRaw) commonDirectory = (0, import_node_path25.resolve)(gitDirectory, commonRaw);
     } catch (error61) {
       const code = error61.code;
       if (code !== "ENOENT" && code !== "ENOTDIR") return null;
@@ -68138,7 +68513,7 @@ function createWorkspaceRunLeaseSnapshotProbe(loadSnapshot) {
     return pending.promise;
   };
   return (workspacePath, options) => {
-    const key = process.platform === "win32" ? (0, import_node_path23.resolve)(workspacePath).toLowerCase() : (0, import_node_path23.resolve)(workspacePath);
+    const key = process.platform === "win32" ? (0, import_node_path25.resolve)(workspacePath).toLowerCase() : (0, import_node_path25.resolve)(workspacePath);
     const existing = snapshots.get(key);
     if (!existing) return startSnapshot(key, options?.coalescePending === true);
     if (!options?.fresh) return existing.promise;
@@ -68155,7 +68530,7 @@ var DEFAULT_PROBE = {
   snapshot: createWorkspaceRunLeaseSnapshotProbe(snapshotWorkspace),
   pathExists: async (workspacePath) => {
     try {
-      await (0, import_promises14.access)((0, import_node_path23.resolve)(workspacePath));
+      await (0, import_promises14.access)((0, import_node_path25.resolve)(workspacePath));
       return true;
     } catch (error61) {
       return error61.code !== "ENOENT";
@@ -68164,11 +68539,11 @@ var DEFAULT_PROBE = {
 };
 async function snapshotWorkspace(workspacePath) {
   try {
-    const canonicalWorkspacePath = await (0, import_promises14.realpath)((0, import_node_path23.resolve)(workspacePath));
+    const canonicalWorkspacePath = await (0, import_promises14.realpath)((0, import_node_path25.resolve)(workspacePath));
     const gitPaths = await resolveGitIdentityPaths(canonicalWorkspacePath);
     if (!gitPaths) return null;
     return {
-      workspacePath: (0, import_node_path23.resolve)(workspacePath),
+      workspacePath: (0, import_node_path25.resolve)(workspacePath),
       workspaceIdentity: await filesystemIdentity(canonicalWorkspacePath),
       // The common Git directory identifies the checkout. A coding agent may
       // legitimately add or update origin without replacing that directory;
@@ -68221,7 +68596,7 @@ var WorkspaceRunLease = class _WorkspaceRunLease {
     const retryDelayMs = Math.max(0, options.retryDelayMs ?? DEFAULT_CAPTURE_RETRY_DELAY_MS);
     const captured = [];
     for (const target of targets) {
-      const normalizedTarget = { ...target, workspacePath: (0, import_node_path23.resolve)(target.workspacePath) };
+      const normalizedTarget = { ...target, workspacePath: (0, import_node_path25.resolve)(target.workspacePath) };
       const identity = await captureIdentity(
         probe,
         normalizedTarget.workspacePath,
@@ -68324,15 +68699,15 @@ function applyLeaseCheckResult(input2) {
 
 // src/daemon/admission.ts
 var import_node_fs23 = require("fs");
-var import_node_path26 = require("path");
+var import_node_path28 = require("path");
 
 // src/workspace-relocation.ts
 var import_node_child_process6 = require("child_process");
 var import_node_fs22 = require("fs");
-var import_node_path24 = require("path");
+var import_node_path26 = require("path");
 var MAX_RELOCATION_CANDIDATES = 200;
 var DEFAULT_PROBE2 = {
-  childDirectories: (parentPath, limit) => (0, import_node_fs22.readdirSync)(parentPath, { withFileTypes: true }).filter((entry) => entry.isDirectory()).slice(0, limit).map((entry) => (0, import_node_path24.join)(parentPath, entry.name)),
+  childDirectories: (parentPath, limit) => (0, import_node_fs22.readdirSync)(parentPath, { withFileTypes: true }).filter((entry) => entry.isDirectory()).slice(0, limit).map((entry) => (0, import_node_path26.join)(parentPath, entry.name)),
   gitRemoteUrl: (candidatePath) => {
     const result = (0, import_node_child_process6.spawnSync)("git", ["-C", candidatePath, "config", "--get", "remote.origin.url"], {
       encoding: "utf8",
@@ -68363,7 +68738,7 @@ function workspaceMatchesExpectedRepositories(input2) {
     input2.expectedRepoUrls.map(normalizeRepositoryIdentity).filter((identity2) => Boolean(identity2))
   );
   if (identities.size === 0) return false;
-  const remote = (input2.probe ?? DEFAULT_PROBE2).gitRemoteUrl((0, import_node_path24.resolve)(input2.workspacePath));
+  const remote = (input2.probe ?? DEFAULT_PROBE2).gitRemoteUrl((0, import_node_path26.resolve)(input2.workspacePath));
   const identity = remote ? normalizeRepositoryIdentity(remote) : null;
   return Boolean(identity && identities.has(identity));
 }
@@ -68373,8 +68748,8 @@ function discoverRelocatedWorkspace(input2) {
   );
   if (identities.size === 0) return null;
   const searchRoots = [
-    (0, import_node_path24.dirname)((0, import_node_path24.resolve)(input2.missingPath)),
-    ...(input2.approvedWorkspacePaths ?? []).map((path2) => (0, import_node_path24.dirname)((0, import_node_path24.resolve)(path2)))
+    (0, import_node_path26.dirname)((0, import_node_path26.resolve)(input2.missingPath)),
+    ...(input2.approvedWorkspacePaths ?? []).map((path2) => (0, import_node_path26.dirname)((0, import_node_path26.resolve)(path2)))
   ].filter((path2, index, paths) => paths.indexOf(path2) === index);
   const candidates = [];
   for (const root of searchRoots) {
@@ -68386,10 +68761,10 @@ function discoverRelocatedWorkspace(input2) {
     }
   }
   const matches = [];
-  for (const candidate of new Set(candidates.map((path2) => (0, import_node_path24.resolve)(path2)))) {
+  for (const candidate of new Set(candidates.map((path2) => (0, import_node_path26.resolve)(path2)))) {
     const remote = (input2.probe ?? DEFAULT_PROBE2).gitRemoteUrl(candidate);
     const identity = remote ? normalizeRepositoryIdentity(remote) : null;
-    if (identity && identities.has(identity)) matches.push((0, import_node_path24.resolve)(candidate));
+    if (identity && identities.has(identity)) matches.push((0, import_node_path26.resolve)(candidate));
     if (matches.length > 1) return null;
   }
   return matches[0] ?? null;
@@ -68397,7 +68772,7 @@ function discoverRelocatedWorkspace(input2) {
 
 // src/daemon/workspace.ts
 var import_node_child_process7 = require("child_process");
-var import_node_path25 = require("path");
+var import_node_path27 = require("path");
 
 // src/git/tree.ts
 var BRANCH_LABEL_MAX_LENGTH = 256;
@@ -68468,12 +68843,12 @@ function gitSafe(cwd, args) {
   }
 }
 function statusLocalWorkspace(params) {
-  const requestedPath = (0, import_node_path25.resolve)(requiredString(params, "workspacePath"));
+  const requestedPath = (0, import_node_path27.resolve)(requiredString(params, "workspacePath"));
   const rootOutput = gitSafe(requestedPath, ["rev-parse", "--show-toplevel"]);
   if (!rootOutput) {
     throw new Error("The selected folder is not inside a Git repository");
   }
-  const root = (0, import_node_path25.resolve)(rootOutput);
+  const root = (0, import_node_path27.resolve)(rootOutput);
   const tree = preflightGitTree(root, git);
   const headSha = gitSafe(root, ["rev-parse", "HEAD"]) || null;
   const upstream = gitSafe(root, ["rev-parse", "--abbrev-ref", "@{upstream}"]);
@@ -68594,22 +68969,22 @@ function settleProvider(ctx, backendKind, runtimeCommand) {
 function expectedRepositoryUrls(payload, explicitWorkspacePath) {
   return [
     ...(payload.repoLocalPaths ?? []).filter(
-      (repo) => explicitWorkspacePath ? (0, import_node_path26.resolve)(repo.localPath) === (0, import_node_path26.resolve)(explicitWorkspacePath) : false
+      (repo) => explicitWorkspacePath ? (0, import_node_path28.resolve)(repo.localPath) === (0, import_node_path28.resolve)(explicitWorkspacePath) : false
     ).map((repo) => repo.repoUrl),
     ...payload.localRepoUrls ?? []
   ];
 }
 function relocateWorkspace(ctx, payload, explicitWorkspacePath, expectedRepoUrls) {
-  const previousPath = (0, import_node_path26.resolve)(explicitWorkspacePath);
+  const previousPath = (0, import_node_path28.resolve)(explicitWorkspacePath);
   const remembered = ctx.workspaceRelocations.get(previousPath);
   const rememberedPath = remembered?.canonicalPath;
-  const relocated = rememberedPath && workspaceMatchesExpectedRepositories({ workspacePath: rememberedPath, expectedRepoUrls }) ? (0, import_node_path26.resolve)(rememberedPath) : discoverRelocatedWorkspace({
+  const relocated = rememberedPath && workspaceMatchesExpectedRepositories({ workspacePath: rememberedPath, expectedRepoUrls }) ? (0, import_node_path28.resolve)(rememberedPath) : discoverRelocatedWorkspace({
     missingPath: explicitWorkspacePath,
     approvedWorkspacePaths: payload.approvedWorkspacePaths,
     expectedRepoUrls
   });
   if (!relocated) return null;
-  if (!remembered || (0, import_node_path26.resolve)(remembered.canonicalPath) !== relocated) {
+  if (!remembered || (0, import_node_path28.resolve)(remembered.canonicalPath) !== relocated) {
     ctx.workspaceRelocations.set(previousPath, {
       conversationId: payload.conversationId,
       runId: payload.runId,
@@ -69114,7 +69489,7 @@ async function launchRun(ctx, payload, plan) {
 
 // src/daemon/journal.ts
 var import_node_fs24 = require("fs");
-var import_node_path27 = require("path");
+var import_node_path29 = require("path");
 var JOURNAL_VERSION = 1;
 var INTERRUPTED_ENTRY_TTL_MS = 24 * 60 * 6e4;
 function isEntry(value2) {
@@ -69258,7 +69633,7 @@ var RuntimeRunJournal = class {
   }
   persist() {
     const pendingPath = `${this.path}.pending`;
-    (0, import_node_fs24.mkdirSync)((0, import_node_path27.dirname)(this.path), { recursive: true });
+    (0, import_node_fs24.mkdirSync)((0, import_node_path29.dirname)(this.path), { recursive: true });
     try {
       (0, import_node_fs24.writeFileSync)(
         pendingPath,
@@ -69429,13 +69804,13 @@ function bindLocalApi(server, port) {
 
 // src/daemon/log.ts
 var import_node_fs25 = require("fs");
-var import_node_path28 = require("path");
+var import_node_path30 = require("path");
 var RECENT_LIMIT = 200;
 var MAX_BYTES = 5 * 1024 * 1024;
 var SIZE_CHECK_EVERY = 256;
 function openDaemonLog(configPath) {
-  const directory = (0, import_node_path28.join)((0, import_node_path28.dirname)(configPath), "logs");
-  const path2 = (0, import_node_path28.join)(directory, "daemon.jsonl");
+  const directory = (0, import_node_path30.join)((0, import_node_path30.dirname)(configPath), "logs");
+  const path2 = (0, import_node_path30.join)(directory, "daemon.jsonl");
   const recent = [];
   let handle = null;
   let written = 0;
@@ -70136,7 +70511,7 @@ async function handleNativeHook(deps, req, res) {
 }
 
 // src/daemon/routes/owner.ts
-var import_node_crypto14 = require("crypto");
+var import_node_crypto15 = require("crypto");
 var MAX_OUTSTANDING_CHALLENGES = 32;
 function handleOwner(deps, res) {
   const now = Date.now();
@@ -70148,7 +70523,7 @@ function handleOwner(deps, res) {
     if (!oldest) break;
     deps.adoptionChallenges.delete(oldest);
   }
-  const challenge = (0, import_node_crypto14.randomBytes)(24).toString("base64url");
+  const challenge = (0, import_node_crypto15.randomBytes)(24).toString("base64url");
   deps.adoptionChallenges.set(challenge, now + LOCAL_SERVICE_CHALLENGE_TTL_MS);
   const unsigned = {
     version: LOCAL_SERVICE_OWNER_VERSION,
@@ -70433,10 +70808,10 @@ var BindingSwitchGitError = class extends Error {
 
 // src/git/repo.ts
 var import_node_child_process8 = require("child_process");
-var import_node_crypto15 = require("crypto");
+var import_node_crypto16 = require("crypto");
 var import_node_fs27 = require("fs");
 var import_node_os15 = require("os");
-var import_node_path29 = require("path");
+var import_node_path31 = require("path");
 var import_node_url = require("url");
 var LOCAL_GIT_TIMEOUT_MS = 1e4;
 var NETWORK_GIT_TIMEOUT_MS = 3e4;
@@ -70468,8 +70843,8 @@ async function waitForCheckpointTestBarrier() {
   const barrierDir = process.env.NODE_ENV === "test" ? process.env.ALAN_TEST_GIT_CHECKPOINT_BARRIER_DIR : void 0;
   if (!barrierDir) return;
   (0, import_node_fs27.mkdirSync)(barrierDir, { recursive: true });
-  const readyPath = (0, import_node_path29.join)(barrierDir, "ready");
-  const releasePath = (0, import_node_path29.join)(barrierDir, "release");
+  const readyPath = (0, import_node_path31.join)(barrierDir, "ready");
+  const releasePath = (0, import_node_path31.join)(barrierDir, "release");
   (0, import_node_fs27.writeFileSync)(readyPath, "ready\n");
   const deadline = Date.now() + 5e3;
   while (!(0, import_node_fs27.existsSync)(releasePath)) {
@@ -70486,8 +70861,8 @@ async function waitForCheckpointFinalizeTestBarrier() {
   const barrierDir = process.env.NODE_ENV === "test" ? process.env.ALAN_TEST_GIT_CHECKPOINT_FINALIZE_BARRIER_DIR : void 0;
   if (!barrierDir) return;
   (0, import_node_fs27.mkdirSync)(barrierDir, { recursive: true });
-  const readyPath = (0, import_node_path29.join)(barrierDir, "ready");
-  const releasePath = (0, import_node_path29.join)(barrierDir, "release");
+  const readyPath = (0, import_node_path31.join)(barrierDir, "ready");
+  const releasePath = (0, import_node_path31.join)(barrierDir, "release");
   (0, import_node_fs27.writeFileSync)(readyPath, "ready\n");
   const deadline = Date.now() + 5e3;
   while (!(0, import_node_fs27.existsSync)(releasePath)) {
@@ -70628,7 +71003,7 @@ function acquireCheckpointRepositoryLocks(repoRoot) {
     "checkpoint_lock_unavailable"
   );
   const locks = {
-    headLockPath: (0, import_node_path29.join)(gitDir, "HEAD.lock"),
+    headLockPath: (0, import_node_path31.join)(gitDir, "HEAD.lock"),
     headLockHeld: false,
     indexLockPath: `${indexPath}.lock`,
     indexLockHeld: false,
@@ -70670,8 +71045,8 @@ function assertCheckpointHead(repoRoot, expectedRef, expectedHeadSha) {
   }
 }
 function createCheckpointIndexBaseline(repoRoot, checkpointSha) {
-  const tempDir = (0, import_node_fs27.mkdtempSync)((0, import_node_path29.join)((0, import_node_os15.tmpdir)(), "alan-checkpoint-index-"));
-  const indexPath = (0, import_node_path29.join)(tempDir, "index");
+  const tempDir = (0, import_node_fs27.mkdtempSync)((0, import_node_path31.join)((0, import_node_os15.tmpdir)(), "alan-checkpoint-index-"));
+  const indexPath = (0, import_node_path31.join)(tempDir, "index");
   try {
     runGitWithOptions(
       repoRoot,
@@ -70732,7 +71107,7 @@ function commonRequest(params) {
   return {
     switchId: requiredString2(params, "switchId"),
     repoKey: requiredString2(params, "repoKey"),
-    repoPath: (0, import_node_path29.resolve)(requiredString2(params, "repoPath"))
+    repoPath: (0, import_node_path31.resolve)(requiredString2(params, "repoPath"))
   };
 }
 function assertCommitSha(sha, key) {
@@ -70771,9 +71146,9 @@ function expandScpSyntax(value2) {
   return scp ? `ssh://${scp[1]}@${scp[2]}/${scp[3]}` : value2;
 }
 function localRemoteUrl(repoRoot, value2) {
-  const looksLocal = (0, import_node_path29.isAbsolute)(value2) || value2.startsWith("./") || value2.startsWith("../");
+  const looksLocal = (0, import_node_path31.isAbsolute)(value2) || value2.startsWith("./") || value2.startsWith("../");
   if (!looksLocal) return null;
-  const absolute = (0, import_node_path29.isAbsolute)(value2) ? value2 : (0, import_node_path29.resolve)(repoRoot, value2);
+  const absolute = (0, import_node_path31.isAbsolute)(value2) ? value2 : (0, import_node_path31.resolve)(repoRoot, value2);
   return `file://${trimRepoPath(canonicalPathWithMissingTail(absolute))}`;
 }
 function assertRemoteIsAllowed(parsed) {
@@ -70850,19 +71225,19 @@ function inspectedRemoteUrl(repoRoot, params) {
 }
 function canonicalPathWithMissingTail(path2) {
   const missingSegments = [];
-  let cursor = (0, import_node_path29.resolve)(path2);
+  let cursor = (0, import_node_path31.resolve)(path2);
   while (!(0, import_node_fs27.existsSync)(cursor)) {
-    const parent = (0, import_node_path29.dirname)(cursor);
+    const parent = (0, import_node_path31.dirname)(cursor);
     if (parent === cursor) {
       throw new BindingSwitchGitError(
         "path_canonicalization_failed",
         "The selected path has no existing canonical ancestor"
       );
     }
-    missingSegments.unshift((0, import_node_path29.basename)(cursor));
+    missingSegments.unshift((0, import_node_path31.basename)(cursor));
     cursor = parent;
   }
-  return (0, import_node_path29.join)(import_node_fs27.realpathSync.native(cursor), ...missingSegments);
+  return (0, import_node_path31.join)(import_node_fs27.realpathSync.native(cursor), ...missingSegments);
 }
 function resolveRepositoryRoot(requestedPath) {
   if (!(0, import_node_fs27.existsSync)(requestedPath)) {
@@ -70878,7 +71253,7 @@ function resolveRepositoryRoot(requestedPath) {
       "The selected folder is not inside a Git repository"
     );
   }
-  return import_node_fs27.realpathSync.native((0, import_node_path29.resolve)(root.stdout.trim()));
+  return import_node_fs27.realpathSync.native((0, import_node_path31.resolve)(root.stdout.trim()));
 }
 function listWorktrees(repoRoot) {
   return runGit(repoRoot, ["worktree", "list", "--porcelain"]).split("\n\n").flatMap((entry) => {
@@ -70897,7 +71272,7 @@ function resolveAuthorizedRepository(params, requireTrustedContext = false) {
   const { repoPath } = commonRequest(params);
   const repoRoot = resolveRepositoryRoot(repoPath);
   const expectedRepoRoot = requireTrustedContext ? requiredString2(params, "expectedRepoRoot") : optionalString(params, "expectedRepoRoot");
-  if (expectedRepoRoot && resolveRepositoryRoot((0, import_node_path29.resolve)(expectedRepoRoot)) !== repoRoot) {
+  if (expectedRepoRoot && resolveRepositoryRoot((0, import_node_path31.resolve)(expectedRepoRoot)) !== repoRoot) {
     throw new BindingSwitchGitError(
       "repository_path_changed",
       "The selected path now resolves to a different Git repository"
@@ -70905,7 +71280,7 @@ function resolveAuthorizedRepository(params, requireTrustedContext = false) {
   }
   const projectPath = requireTrustedContext ? requiredString2(params, "projectPath") : optionalString(params, "projectPath");
   if (!projectPath) return repoRoot;
-  const projectRoot = resolveRepositoryRoot((0, import_node_path29.resolve)(projectPath));
+  const projectRoot = resolveRepositoryRoot((0, import_node_path31.resolve)(projectPath));
   const registrations = listWorktrees(projectRoot);
   const registered = registrations.find(({ path: path2 }) => path2 === repoRoot);
   if (!registered) {
@@ -70934,8 +71309,8 @@ function updateLengthPrefixed(hash2, value2) {
   hash2.update("\0");
 }
 function proposedTreeSha(repoRoot, headSha) {
-  const tempDir = (0, import_node_fs27.mkdtempSync)((0, import_node_path29.join)((0, import_node_os15.tmpdir)(), "alan-switch-index-"));
-  const indexPath = (0, import_node_path29.join)(tempDir, "index");
+  const tempDir = (0, import_node_fs27.mkdtempSync)((0, import_node_path31.join)((0, import_node_os15.tmpdir)(), "alan-switch-index-"));
+  const indexPath = (0, import_node_path31.join)(tempDir, "index");
   const options = { env: { GIT_INDEX_FILE: indexPath } };
   try {
     if (headSha) {
@@ -70968,7 +71343,7 @@ function statusFingerprint(repoRoot, porcelain, proposedTree) {
     "git_status_unreadable"
   );
   const untrackedPaths = untrackedRaw.split("\0").filter(Boolean);
-  const hash2 = (0, import_node_crypto15.createHash)("sha256");
+  const hash2 = (0, import_node_crypto16.createHash)("sha256");
   updateLengthPrefixed(hash2, porcelain);
   updateLengthPrefixed(hash2, proposedTree);
   updateLengthPrefixed(hash2, unstagedPatch);
@@ -71523,9 +71898,9 @@ async function stopBackgroundTaskForRun(deps, payload) {
 
 // src/daemon/sweep.ts
 var import_node_fs29 = require("fs");
-var import_node_path30 = require("path");
+var import_node_path32 = require("path");
 function retiredPaths(configPath) {
-  const directory = (0, import_node_path30.dirname)(configPath);
+  const directory = (0, import_node_path32.dirname)(configPath);
   return [
     // The durable event outbox and its journal.
     `${configPath}.event-outbox.enc`,
@@ -71535,7 +71910,7 @@ function retiredPaths(configPath) {
     `${configPath}.native-transcript-cursors.json`,
     `${configPath}.native-transcript-cursors.json.d`,
     `${configPath}.native-transcript-cursors.json.migrated`,
-    (0, import_node_path30.join)(directory, "native-hook-inbox")
+    (0, import_node_path32.join)(directory, "native-hook-inbox")
   ];
 }
 function sweepRetiredArtifacts(configPath) {
@@ -71558,10 +71933,10 @@ var UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12
 async function startDaemon(args) {
   bindConfigPath(args);
   const stored = readConfig();
-  const installationId = stored.installationId ?? (0, import_node_crypto16.randomUUID)();
+  const installationId = stored.installationId ?? (0, import_node_crypto17.randomUUID)();
   const configPath = getConfigPath();
   const endpointProfile = stored.endpointProfile ?? resolveEndpointProfile(args);
-  const daemonSessionId = (0, import_node_crypto16.randomUUID)();
+  const daemonSessionId = (0, import_node_crypto17.randomUUID)();
   let heartbeatSeq = 0;
   const runtimeId = argValue(args, "--runtime-id") ?? process.env.ALAN_RUNTIME_ID ?? stored.runtimeId;
   const runtimeTokenOverride = argValue(args, "--token") ?? process.env.ALAN_RUNTIME_TOKEN;
@@ -71581,9 +71956,9 @@ async function startDaemon(args) {
     wsUrl = endpointMismatch.expectedWsUrl;
   }
   let localApiPort = getLocalApiPort(args, stored);
-  const localApiToken = stored.localApiToken ?? (0, import_node_crypto16.randomBytes)(24).toString("hex");
-  const localServiceId = stored.localServiceId ?? (0, import_node_crypto16.randomUUID)();
-  const localServiceSecret = stored.localServiceSecret ?? (0, import_node_crypto16.randomBytes)(32).toString("base64url");
+  const localApiToken = stored.localApiToken ?? (0, import_node_crypto17.randomBytes)(24).toString("hex");
+  const localServiceId = stored.localServiceId ?? (0, import_node_crypto17.randomUUID)();
+  const localServiceSecret = stored.localServiceSecret ?? (0, import_node_crypto17.randomBytes)(32).toString("base64url");
   const localServiceStartedAtMs = Date.now();
   if (stored.daemonEpoch !== void 0 && (!Number.isSafeInteger(stored.daemonEpoch) || stored.daemonEpoch < 0 || stored.daemonEpoch >= Number.MAX_SAFE_INTEGER)) {
     throw new Error("daemon config contains an invalid durable epoch; repair the runtime config");
@@ -71739,7 +72114,7 @@ async function startDaemon(args) {
   const workspaceRelocations = /* @__PURE__ */ new Map();
   for (const relocation of stored.workspaceRelocations ?? []) {
     if (relocation?.conversationId && relocation.runId && relocation.previousPath && relocation.canonicalPath) {
-      workspaceRelocations.set((0, import_node_path31.resolve)(relocation.previousPath), relocation);
+      workspaceRelocations.set((0, import_node_path33.resolve)(relocation.previousPath), relocation);
     }
   }
   if (stored.localApiPort !== localApiPort || stored.localApiToken !== localApiToken || stored.localServiceId !== localServiceId || stored.localServiceSecret !== localServiceSecret || stored.daemonEpoch !== daemonEpoch || stored.installationId !== installationId) {
@@ -72491,10 +72866,10 @@ async function startDaemon(args) {
 
 // src/service-manager.ts
 var import_node_child_process9 = require("child_process");
-var import_node_crypto17 = require("crypto");
+var import_node_crypto18 = require("crypto");
 var import_node_fs30 = require("fs");
 var import_node_os17 = require("os");
-var import_node_path32 = require("path");
+var import_node_path34 = require("path");
 var SERVICE_LABEL = "ai.tryalan.agent";
 var SYSTEMD_UNIT = "alan-agent.service";
 var WINDOWS_TASK = "Alan Agent";
@@ -72539,8 +72914,8 @@ function buildDarwinServicePlan(input2, daemonArgs, names) {
   if (userId === void 0) throw new Error("Cannot determine the current macOS user ID");
   const domain2 = `gui/${userId}`;
   const serviceTarget = `${domain2}/${names.launchd}`;
-  const manifestPath = (0, import_node_path32.join)(input2.homeDir, "Library", "LaunchAgents", `${names.launchd}.plist`);
-  const logDir = (0, import_node_path32.join)(resolveAgentConfigDirectory(input2.profile, input2.homeDir), "logs");
+  const manifestPath = (0, import_node_path34.join)(input2.homeDir, "Library", "LaunchAgents", `${names.launchd}.plist`);
+  const logDir = (0, import_node_path34.join)(resolveAgentConfigDirectory(input2.profile, input2.homeDir), "logs");
   const programArguments = daemonArgs.map((arg) => `    <string>${xml(arg)}</string>`).join("\n");
   const environmentEntries2 = Object.entries(input2.environment ?? {}).map(([key, value2]) => `    <key>${xml(key)}</key>
     <string>${xml(value2)}</string>`).join("\n");
@@ -72569,9 +72944,9 @@ ${environmentBlock}  <key>RunAtLoad</key>
   <key>ThrottleInterval</key>
   <integer>5</integer>
   <key>StandardOutPath</key>
-  <string>${xml((0, import_node_path32.join)(logDir, "daemon-launcher.log"))}</string>
+  <string>${xml((0, import_node_path34.join)(logDir, "daemon-launcher.log"))}</string>
   <key>StandardErrorPath</key>
-  <string>${xml((0, import_node_path32.join)(logDir, "daemon-launcher-error.log"))}</string>
+  <string>${xml((0, import_node_path34.join)(logDir, "daemon-launcher-error.log"))}</string>
 </dict>
 </plist>
 `;
@@ -72647,7 +73022,7 @@ ${environmentBlock}  <key>RunAtLoad</key>
   };
 }
 function buildLinuxServicePlan(input2, daemonArgs, names) {
-  const manifestPath = (0, import_node_path32.join)(input2.homeDir, ".config", "systemd", "user", names.systemd);
+  const manifestPath = (0, import_node_path34.join)(input2.homeDir, ".config", "systemd", "user", names.systemd);
   const environmentLines = Object.entries(input2.environment ?? {}).map(([key, value2]) => `Environment=${systemdArg(`${key}=${value2}`)}`).join("\n");
   const manifest = `[Unit]
 Description=Alan local agent daemon
@@ -72732,7 +73107,7 @@ WantedBy=default.target
   };
 }
 function buildWindowsServicePlan(input2, names) {
-  const logDir = import_node_path32.win32.join(resolveAgentConfigDirectory(input2.profile, input2.homeDir), "logs");
+  const logDir = import_node_path34.win32.join(resolveAgentConfigDirectory(input2.profile, input2.homeDir), "logs");
   const legacyEnvironmentPrefix = Object.entries(input2.environment ?? {}).map(([key, value2]) => `$env:${key} = ${powershellLiteral(value2)}`).join("; ");
   const legacyDirectArguments = [input2.cliEntry, "daemon", "--profile", input2.profile].map((part) => part.includes(" ") ? `"${part}"` : part).join(" ");
   const legacyExecutable = legacyEnvironmentPrefix ? "powershell.exe" : input2.nodeExecutable;
@@ -72746,14 +73121,14 @@ function buildWindowsServicePlan(input2, names) {
     "$startInfo = [System.Diagnostics.ProcessStartInfo]::new()",
     `$startInfo.FileName = ${powershellLiteral(input2.nodeExecutable)}`,
     `$startInfo.Arguments = ${powershellLiteral(daemonArguments)}`,
-    `$startInfo.WorkingDirectory = ${powershellLiteral(import_node_path32.win32.dirname(input2.cliEntry))}`,
+    `$startInfo.WorkingDirectory = ${powershellLiteral(import_node_path34.win32.dirname(input2.cliEntry))}`,
     "$startInfo.UseShellExecute = $false",
     "$startInfo.CreateNoWindow = $true",
     "$startInfo.RedirectStandardOutput = $true",
     "$startInfo.RedirectStandardError = $true",
     ...environmentStatements,
-    `$stdout = [System.IO.File]::Open(${powershellLiteral(import_node_path32.win32.join(logDir, "daemon-launcher.log"))}, [System.IO.FileMode]::Create, [System.IO.FileAccess]::Write, [System.IO.FileShare]::ReadWrite)`,
-    `$stderr = [System.IO.File]::Open(${powershellLiteral(import_node_path32.win32.join(logDir, "daemon-launcher-error.log"))}, [System.IO.FileMode]::Create, [System.IO.FileAccess]::Write, [System.IO.FileShare]::ReadWrite)`,
+    `$stdout = [System.IO.File]::Open(${powershellLiteral(import_node_path34.win32.join(logDir, "daemon-launcher.log"))}, [System.IO.FileMode]::Create, [System.IO.FileAccess]::Write, [System.IO.FileShare]::ReadWrite)`,
+    `$stderr = [System.IO.File]::Open(${powershellLiteral(import_node_path34.win32.join(logDir, "daemon-launcher-error.log"))}, [System.IO.FileMode]::Create, [System.IO.FileAccess]::Write, [System.IO.FileShare]::ReadWrite)`,
     "$process = [System.Diagnostics.Process]::new()",
     "$process.StartInfo = $startInfo",
     "try { if (-not $process.Start()) { throw 'Alan daemon process did not start' }; $stdoutCopy = $process.StandardOutput.BaseStream.CopyToAsync($stdout); $stderrCopy = $process.StandardError.BaseStream.CopyToAsync($stderr); $process.WaitForExit(); [System.Threading.Tasks.Task]::WaitAll([System.Threading.Tasks.Task[]]@($stdoutCopy, $stderrCopy)); $exitCode = $process.ExitCode } finally { $stdout.Dispose(); $stderr.Dispose(); $process.Dispose() }",
@@ -72762,7 +73137,7 @@ function buildWindowsServicePlan(input2, names) {
   const executable = powershellLiteral("powershell.exe");
   const launcherArguments = `-NoProfile -NonInteractive -WindowStyle Hidden -EncodedCommand ${Buffer.from(launcherScript, "utf16le").toString("base64")}`;
   const settingsScript = "New-ScheduledTaskSettingsSet -RestartCount 3 -RestartInterval (New-TimeSpan -Minutes 1) -ExecutionTimeLimit ([TimeSpan]::Zero) -AllowStartIfOnBatteries -DontStopIfGoingOnBatteries";
-  const ownerMarker = `Alan daemon owner v1 ${(0, import_node_crypto17.createHash)("sha256").update(
+  const ownerMarker = `Alan daemon owner v1 ${(0, import_node_crypto18.createHash)("sha256").update(
     JSON.stringify({
       executable: input2.nodeExecutable,
       cliEntry: input2.cliEntry,
@@ -72770,18 +73145,18 @@ function buildWindowsServicePlan(input2, names) {
       taskBaseName: names.windows
     })
   ).digest("hex")}`;
-  const definitionMarker = `${ownerMarker}; definition v3 ${(0, import_node_crypto17.createHash)("sha256").update(
+  const definitionMarker = `${ownerMarker}; definition v3 ${(0, import_node_crypto18.createHash)("sha256").update(
     JSON.stringify({
       executable: "powershell.exe",
       launcherArguments,
-      workingDirectory: import_node_path32.win32.dirname(input2.cliEntry),
+      workingDirectory: import_node_path34.win32.dirname(input2.cliEntry),
       settingsScript,
       taskBaseName: names.windows
     })
   ).digest("hex")}`;
   const windowsDefinitionContext = [
     `$expectedLauncherArguments = ${powershellLiteral(launcherArguments)}`,
-    `$expectedWorkingDirectory = ${powershellLiteral(import_node_path32.win32.dirname(input2.cliEntry))}`,
+    `$expectedWorkingDirectory = ${powershellLiteral(import_node_path34.win32.dirname(input2.cliEntry))}`,
     `$expectedOwnerMarker = ${powershellLiteral(`${ownerMarker};`)}`,
     `$expectedDefinitionMarker = ${powershellLiteral(definitionMarker)}`,
     `$expectedLegacyExecutable = ${powershellLiteral(legacyExecutable)}`,
@@ -72924,13 +73299,13 @@ function currentServicePlan(args, runtime, options = {}) {
     homeDir: options.homeDir ?? (0, import_node_os17.homedir)(),
     userId: options.userId,
     nodeExecutable: runtime?.executable ?? process.execPath,
-    cliEntry: currentPlatform === "win32" ? import_node_path32.win32.resolve(cliEntry) : (0, import_node_path32.resolve)(cliEntry),
+    cliEntry: currentPlatform === "win32" ? import_node_path34.win32.resolve(cliEntry) : (0, import_node_path34.resolve)(cliEntry),
     profile,
     environment: runtime?.environment
   });
 }
 function writeManifestAtomic(path2, contents) {
-  (0, import_node_fs30.mkdirSync)((0, import_node_path32.dirname)(path2), { recursive: true, mode: 448 });
+  (0, import_node_fs30.mkdirSync)((0, import_node_path34.dirname)(path2), { recursive: true, mode: 448 });
   const pendingPath = `${path2}.pending-${process.pid}`;
   try {
     (0, import_node_fs30.writeFileSync)(pendingPath, contents, { mode: 384 });
@@ -73464,10 +73839,10 @@ ${result.output}
 }
 
 // src/mcp-config-adapters.ts
-var import_node_crypto18 = require("crypto");
+var import_node_crypto19 = require("crypto");
 var import_node_fs31 = require("fs");
 var import_node_os18 = require("os");
-var import_node_path33 = require("path");
+var import_node_path35 = require("path");
 var log2 = {
   info: (...args) => console.info("[mcp-config-adapters]", ...args),
   warn: (...args) => console.warn("[mcp-config-adapters]", ...args),
@@ -73495,7 +73870,7 @@ function readFileOr(path2) {
   return (0, import_node_fs31.existsSync)(path2) ? (0, import_node_fs31.readFileSync)(path2, "utf-8") : null;
 }
 function acquireConfigLock(path2) {
-  (0, import_node_fs31.mkdirSync)((0, import_node_path33.dirname)(path2), { recursive: true });
+  (0, import_node_fs31.mkdirSync)((0, import_node_path35.dirname)(path2), { recursive: true });
   const lockPath = `${path2}.alan-lock`;
   const startedAt = Date.now();
   while (true) {
@@ -73521,8 +73896,8 @@ function acquireConfigLock(path2) {
   }
 }
 function writeFileSafe(path2, content) {
-  (0, import_node_fs31.mkdirSync)((0, import_node_path33.dirname)(path2), { recursive: true });
-  const pendingPath = `${path2}.alan-pending-${process.pid}-${(0, import_node_crypto18.randomBytes)(6).toString("hex")}`;
+  (0, import_node_fs31.mkdirSync)((0, import_node_path35.dirname)(path2), { recursive: true });
+  const pendingPath = `${path2}.alan-pending-${process.pid}-${(0, import_node_crypto19.randomBytes)(6).toString("hex")}`;
   try {
     (0, import_node_fs31.writeFileSync)(pendingPath, content, { encoding: "utf8", mode: 384, flag: "wx" });
     (0, import_node_fs31.renameSync)(pendingPath, path2);
@@ -73531,7 +73906,7 @@ function writeFileSafe(path2, content) {
   }
 }
 function saveMalformedBackup(path2, content) {
-  const hash2 = (0, import_node_crypto18.createHash)("sha256").update(content).digest("hex").slice(0, 16);
+  const hash2 = (0, import_node_crypto19.createHash)("sha256").update(content).digest("hex").slice(0, 16);
   const backupPath = `${path2}.alan-backup-${hash2}`;
   if (!(0, import_node_fs31.existsSync)(backupPath)) (0, import_node_fs31.copyFileSync)(path2, backupPath);
   return backupPath;
@@ -73539,7 +73914,7 @@ function saveMalformedBackup(path2, content) {
 var claudeAdapter = {
   cli: "Claude Code",
   get configPath() {
-    return (0, import_node_path33.join)(homeDirectory(), ".claude.json");
+    return (0, import_node_path35.join)(homeDirectory(), ".claude.json");
   },
   get guardDir() {
     return homeDirectory();
@@ -73572,10 +73947,10 @@ var claudeAdapter = {
 var codexAdapter = {
   cli: "Codex",
   get configPath() {
-    return (0, import_node_path33.join)(homeDirectory(), ".codex", "config.toml");
+    return (0, import_node_path35.join)(homeDirectory(), ".codex", "config.toml");
   },
   get guardDir() {
-    return (0, import_node_path33.join)(homeDirectory(), ".codex");
+    return (0, import_node_path35.join)(homeDirectory(), ".codex");
   },
   merge(existing, servers) {
     let config4 = {};
@@ -73621,10 +73996,10 @@ var codexAdapter = {
 var cursorAdapter = {
   cli: "Cursor",
   get configPath() {
-    return (0, import_node_path33.join)(homeDirectory(), ".cursor", "mcp.json");
+    return (0, import_node_path35.join)(homeDirectory(), ".cursor", "mcp.json");
   },
   get guardDir() {
-    return (0, import_node_path33.join)(homeDirectory(), ".cursor");
+    return (0, import_node_path35.join)(homeDirectory(), ".cursor");
   },
   merge(existing, servers) {
     const config4 = parseJsonSafe(existing);
@@ -73659,10 +74034,10 @@ function createAntigravityAdapter() {
   return {
     cli: "Antigravity CLI",
     get configPath() {
-      return (0, import_node_path33.join)(homeDirectory(), ".gemini", "config", "mcp_config.json");
+      return (0, import_node_path35.join)(homeDirectory(), ".gemini", "config", "mcp_config.json");
     },
     get guardDir() {
-      return (0, import_node_path33.join)(homeDirectory(), ".gemini", "config");
+      return (0, import_node_path35.join)(homeDirectory(), ".gemini", "config");
     },
     // Antigravity sends `initialize` without ever completing OAuth
     // (google-antigravity/antigravity-cli#25), so a credential-free entry only
@@ -73698,10 +74073,10 @@ var antigravityAdapter = createAntigravityAdapter();
 var geminiAdapter = {
   cli: "Gemini CLI",
   get configPath() {
-    return (0, import_node_path33.join)(homeDirectory(), ".gemini", "settings.json");
+    return (0, import_node_path35.join)(homeDirectory(), ".gemini", "settings.json");
   },
   get guardDir() {
-    return (0, import_node_path33.join)(homeDirectory(), ".gemini");
+    return (0, import_node_path35.join)(homeDirectory(), ".gemini");
   },
   merge(existing, servers) {
     const config4 = parseJsonSafe(existing);
@@ -73731,10 +74106,10 @@ var geminiAdapter = {
 var kimiAdapter = {
   cli: "Kimi CLI",
   get configPath() {
-    return (0, import_node_path33.join)(homeDirectory(), ".kimi", "mcp.json");
+    return (0, import_node_path35.join)(homeDirectory(), ".kimi", "mcp.json");
   },
   get guardDir() {
-    return (0, import_node_path33.join)(homeDirectory(), ".kimi");
+    return (0, import_node_path35.join)(homeDirectory(), ".kimi");
   },
   merge(existing, servers) {
     const config4 = parseJsonSafe(existing);
@@ -73764,10 +74139,10 @@ var kimiAdapter = {
 var opencodeAdapter = {
   cli: "OpenCode",
   get configPath() {
-    return (0, import_node_path33.join)(homeDirectory(), ".config", "opencode", "opencode.json");
+    return (0, import_node_path35.join)(homeDirectory(), ".config", "opencode", "opencode.json");
   },
   get guardDir() {
-    return (0, import_node_path33.join)(homeDirectory(), ".config", "opencode");
+    return (0, import_node_path35.join)(homeDirectory(), ".config", "opencode");
   },
   merge(existing, servers) {
     const config4 = parseJsonSafe(existing);
@@ -73797,10 +74172,10 @@ var opencodeAdapter = {
 var factoryAdapter = {
   cli: "Factory Droid",
   get configPath() {
-    return (0, import_node_path33.join)(homeDirectory(), ".factory", "mcp.json");
+    return (0, import_node_path35.join)(homeDirectory(), ".factory", "mcp.json");
   },
   get guardDir() {
-    return (0, import_node_path33.join)(homeDirectory(), ".factory");
+    return (0, import_node_path35.join)(homeDirectory(), ".factory");
   },
   merge(existing, servers) {
     const config4 = parseJsonSafe(existing);
@@ -73837,10 +74212,10 @@ var factoryAdapter = {
 var ampAdapter = {
   cli: "Amp",
   get configPath() {
-    return (0, import_node_path33.join)(homeDirectory(), ".config", "amp", "settings.json");
+    return (0, import_node_path35.join)(homeDirectory(), ".config", "amp", "settings.json");
   },
   get guardDir() {
-    return (0, import_node_path33.join)(homeDirectory(), ".config", "amp");
+    return (0, import_node_path35.join)(homeDirectory(), ".config", "amp");
   },
   merge(existing, servers) {
     const config4 = parseJsonSafe(existing);
@@ -73869,10 +74244,10 @@ var ampAdapter = {
 var commandCodeAdapter = {
   cli: "Command Code",
   get configPath() {
-    return (0, import_node_path33.join)(homeDirectory(), ".commandcode", "mcp.json");
+    return (0, import_node_path35.join)(homeDirectory(), ".commandcode", "mcp.json");
   },
   get guardDir() {
-    return (0, import_node_path33.join)(homeDirectory(), ".commandcode");
+    return (0, import_node_path35.join)(homeDirectory(), ".commandcode");
   },
   merge(existing, servers) {
     const config4 = parseJsonSafe(existing);
@@ -73909,10 +74284,10 @@ var commandCodeAdapter = {
 var copilotAdapter = {
   cli: "GitHub Copilot CLI",
   get configPath() {
-    return (0, import_node_path33.join)(homeDirectory(), ".copilot", "mcp-config.json");
+    return (0, import_node_path35.join)(homeDirectory(), ".copilot", "mcp-config.json");
   },
   get guardDir() {
-    return (0, import_node_path33.join)(homeDirectory(), ".copilot");
+    return (0, import_node_path35.join)(homeDirectory(), ".copilot");
   },
   merge(existing, servers) {
     const config4 = parseJsonSafe(existing);
@@ -73949,10 +74324,10 @@ var copilotAdapter = {
 var grokAdapter = {
   cli: "Grok CLI",
   get configPath() {
-    return (0, import_node_path33.join)(homeDirectory(), ".grok", "config.toml");
+    return (0, import_node_path35.join)(homeDirectory(), ".grok", "config.toml");
   },
   get guardDir() {
-    return (0, import_node_path33.join)(homeDirectory(), ".grok");
+    return (0, import_node_path35.join)(homeDirectory(), ".grok");
   },
   merge(existing, servers) {
     let config4 = {};
@@ -74420,12 +74795,12 @@ var McpSyncService = class {
 
 // src/cli/ingestion-hooks.ts
 var import_node_fs33 = require("fs");
-var import_node_path35 = require("path");
+var import_node_path37 = require("path");
 
 // src/native/hook-config.ts
 var import_node_fs32 = require("fs");
 var import_node_os19 = require("os");
-var import_node_path34 = require("path");
+var import_node_path36 = require("path");
 var INGESTION_HOOK_MARKER = "# alan-session-ingest";
 var PROVIDER_HOOK_EVENTS = [
   { providerEvent: "Stop", event: "turn_end" },
@@ -74512,7 +74887,7 @@ function hooksOf(settings2) {
   return isRecord7(settings2.hooks) ? settings2.hooks : {};
 }
 function writeSettings2(path2, settings2) {
-  (0, import_node_fs32.mkdirSync)((0, import_node_path34.dirname)(path2), { recursive: true, mode: 448 });
+  (0, import_node_fs32.mkdirSync)((0, import_node_path36.dirname)(path2), { recursive: true, mode: 448 });
   const temporary = `${path2}.${process.pid}.tmp`;
   try {
     (0, import_node_fs32.writeFileSync)(temporary, `${JSON.stringify(settings2, null, 2)}
@@ -74603,7 +74978,7 @@ var VERSIONED_NODE_DIR = /\/(?:Cellar\/node(?:@[^/]+)?|\.nvm\/versions\/node|nod
 var STABLE_NODE_PATHS = ["/opt/homebrew/bin/node", "/usr/local/bin/node"];
 function systemNodeProbe(env) {
   return {
-    pathEntries: (env.PATH ?? "").split(import_node_path35.delimiter),
+    pathEntries: (env.PATH ?? "").split(import_node_path37.delimiter),
     realpath: (path2) => {
       try {
         return (0, import_node_fs33.realpathSync)(path2);
@@ -74618,7 +74993,7 @@ function stableNodeExecutable(execPath, probe) {
   const binary = probe.realpath(execPath);
   if (!binary) return execPath;
   const candidates = [
-    ...probe.pathEntries.filter((entry) => (0, import_node_path35.isAbsolute)(entry)).map((entry) => (0, import_node_path35.join)(entry, "node")),
+    ...probe.pathEntries.filter((entry) => (0, import_node_path37.isAbsolute)(entry)).map((entry) => (0, import_node_path37.join)(entry, "node")),
     ...STABLE_NODE_PATHS
   ];
   return candidates.find(
@@ -74630,7 +75005,7 @@ function currentHookRuntime(env = process.env) {
   if (!cliEntry) throw new Error("Cannot determine the alan-agent CLI entry path");
   return {
     executable: process.versions.electron ? process.execPath : stableNodeExecutable(process.execPath, systemNodeProbe(env)),
-    cliEntry: (0, import_node_path35.resolve)(cliEntry),
+    cliEntry: (0, import_node_path37.resolve)(cliEntry),
     environment: process.versions.electron ? { ELECTRON_RUN_AS_NODE: "1" } : void 0
   };
 }
@@ -74934,10 +75309,10 @@ function decodeResumeFallbackContext(encoded) {
 
 // src/sandbox/run.ts
 var import_node_os21 = require("os");
-var import_node_path37 = require("path");
+var import_node_path39 = require("path");
 
 // src/ws/client.ts
-var import_node_crypto19 = require("crypto");
+var import_node_crypto20 = require("crypto");
 
 // ../shared/dist/agent-liveness.js
 var AGENT_LIVENESS_PROTOCOL_VERSION = 1;
@@ -74997,7 +75372,7 @@ var agentProbeAckSchema = external_exports.object({
 // src/resource-diagnostics.ts
 var import_node_fs34 = require("fs");
 var import_node_os20 = require("os");
-var import_node_path36 = require("path");
+var import_node_path38 = require("path");
 var import_node_perf_hooks = require("perf_hooks");
 var MAX_RESOURCE_FILE_BYTES = 16384;
 var RESOURCE_READ_TIMEOUT_MS = 500;
@@ -75037,7 +75412,7 @@ function meminfoBytes(text2, field) {
 function cgroupDirectory(text2) {
   const path2 = text2?.match(/^0::(\/[^\n]*)$/m)?.[1];
   if (!path2 || path2.split("/").includes("..")) return void 0;
-  return import_node_path36.posix.join("/sys/fs/cgroup", path2);
+  return import_node_path38.posix.join("/sys/fs/cgroup", path2);
 }
 async function collectAgentResourceDiagnostics(options = {}) {
   const platform7 = options.platform ?? process.platform;
@@ -75188,7 +75563,7 @@ var WSClient = class {
   socket;
   runEvents;
   eventAuthorityReady;
-  agentSessionId = (0, import_node_crypto19.randomUUID)();
+  agentSessionId = (0, import_node_crypto20.randomUUID)();
   heartbeatSeq = 0;
   heartbeatTimer = null;
   resourceSampler = new AgentResourceSampler();
@@ -75669,7 +76044,7 @@ function sameRegistration(left, right) {
 }
 
 // src/sandbox/host.ts
-var import_node_crypto20 = require("crypto");
+var import_node_crypto21 = require("crypto");
 var WebRunHost = class extends BaseRunHost {
   constructor(wsClient, conversationId) {
     super();
@@ -75731,7 +76106,7 @@ var WebRunHost = class extends BaseRunHost {
     this.applicationProblem = createAlanProblem({
       domain: "application",
       code: input2.code,
-      id: (0, import_node_crypto20.randomUUID)(),
+      id: (0, import_node_crypto21.randomUUID)(),
       title: APPLICATION_PROBLEM_TITLES[input2.code],
       detail: input2.message,
       // Carries the technical cause without putting an SDK error in front of the person.
@@ -76308,7 +76683,7 @@ function applyUserMessage(turn, patch) {
 // src/sandbox/run.ts
 async function runSandbox(config4) {
   if (!config4.sandboxId) throw new Error("Sandbox lifecycle delivery requires sandboxId");
-  const sandboxStatePath = (0, import_node_path37.join)((0, import_node_os21.homedir)(), ".alan", "agent", "config.json");
+  const sandboxStatePath = (0, import_node_path39.join)((0, import_node_os21.homedir)(), ".alan", "agent", "config.json");
   const sandboxApiUrl = config4.apiUrl ?? "https://api.tryalan.ai";
   let stopped = false;
   const transcriptShutdown = new AbortController();
@@ -76749,7 +77124,7 @@ async function runSandbox(config4) {
 // src/skills/skill-cli.ts
 var import_promises16 = require("fs/promises");
 var import_node_os22 = require("os");
-var import_node_path38 = require("path");
+var import_node_path40 = require("path");
 async function runSkillsCommand(args) {
   const [subcommand, ...options] = args;
   const homeDirectory2 = option2(options, "--home") ?? (0, import_node_os22.homedir)();
@@ -76793,7 +77168,7 @@ async function defaultScanInput(homeDirectory2) {
   });
 }
 async function readProtectedJson(path2) {
-  const absolutePath = (0, import_node_path38.resolve)(path2);
+  const absolutePath = (0, import_node_path40.resolve)(path2);
   const stat4 = await (0, import_promises16.lstat)(absolutePath);
   if (!stat4.isFile()) throw new Error(`Skill input is not a regular file: ${absolutePath}`);
   if (process.platform !== "win32" && (stat4.mode & 63) !== 0) {