@aiden-ade/sandbox-agent 0.1.49 → 0.1.51

package/dist/index.cjs

@@ -3247,7 +3247,7 @@ var require_extension = __commonJS({
   "../../node_modules/engine.io-client/node_modules/ws/lib/extension.js"(exports2, module2) {
     "use strict";
     var { tokenChars } = require_validation();
-    function push(dest, name, elem) {
+    function push2(dest, name, elem) {
       if (dest[name] === void 0) dest[name] = [elem];
       else dest[name].push(elem);
     }
@@ -3277,7 +3277,7 @@ var require_extension = __commonJS({
             if (end === -1) end = i;
             const name = header.slice(start, end);
             if (code === 44) {
-              push(offers, name, params);
+              push2(offers, name, params);
               params = /* @__PURE__ */ Object.create(null);
             } else {
               extensionName = name;
@@ -3296,9 +3296,9 @@ var require_extension = __commonJS({
               throw new SyntaxError(`Unexpected character at index ${i}`);
             }
             if (end === -1) end = i;
-            push(params, header.slice(start, end), true);
+            push2(params, header.slice(start, end), true);
             if (code === 44) {
-              push(offers, extensionName, params);
+              push2(offers, extensionName, params);
               params = /* @__PURE__ */ Object.create(null);
               extensionName = void 0;
             }
@@ -3344,9 +3344,9 @@ var require_extension = __commonJS({
               value2 = value2.replace(/\\/g, "");
               mustUnescape = false;
             }
-            push(params, paramName, value2);
+            push2(params, paramName, value2);
             if (code === 44) {
-              push(offers, extensionName, params);
+              push2(offers, extensionName, params);
               params = /* @__PURE__ */ Object.create(null);
               extensionName = void 0;
             }
@@ -3363,16 +3363,16 @@ var require_extension = __commonJS({
       if (end === -1) end = i;
       const token = header.slice(start, end);
       if (extensionName === void 0) {
-        push(offers, token, params);
+        push2(offers, token, params);
       } else {
         if (paramName === void 0) {
-          push(params, token, true);
+          push2(params, token, true);
         } else if (mustUnescape) {
-          push(params, paramName, token.replace(/\\/g, ""));
+          push2(params, paramName, token.replace(/\\/g, ""));
         } else {
-          push(params, paramName, token);
+          push2(params, paramName, token);
         }
-        push(offers, extensionName, params);
+        push2(offers, extensionName, params);
       }
       return offers;
     }
@@ -3404,7 +3404,7 @@ var require_websocket = __commonJS({
     var http2 = require("http");
     var net = require("net");
     var tls = require("tls");
-    var { randomBytes: randomBytes5, createHash: createHash7 } = require("crypto");
+    var { randomBytes: randomBytes5, createHash: createHash8 } = require("crypto");
     var { Duplex, Readable } = require("stream");
     var { URL: URL2 } = require("url");
     var PerMessageDeflate = require_permessage_deflate();
@@ -4061,7 +4061,7 @@ var require_websocket = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest = createHash7("sha1").update(key + GUID).digest("base64");
+        const digest = createHash8("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -4428,7 +4428,7 @@ var require_websocket_server = __commonJS({
     var EventEmitter = require("events");
     var http2 = require("http");
     var { Duplex } = require("stream");
-    var { createHash: createHash7 } = require("crypto");
+    var { createHash: createHash8 } = require("crypto");
     var extension = require_extension();
     var PerMessageDeflate = require_permessage_deflate();
     var subprotocol = require_subprotocol();
@@ -4725,7 +4725,7 @@ var require_websocket_server = __commonJS({
           );
         }
         if (this._state > RUNNING) return abortHandshake(socket, 503);
-        const digest = createHash7("sha1").update(key + GUID).digest("base64");
+        const digest = createHash8("sha1").update(key + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -4810,6 +4810,351 @@ var require_websocket_server = __commonJS({
   }
 });
 
+// src/index.ts
+var import_node_child_process9 = require("child_process");
+
+// src/cli-executable.ts
+var import_node_child_process = require("child_process");
+var import_node_fs = require("fs");
+var import_node_os = require("os");
+var import_node_path = require("path");
+var PROVIDER_CLI_COMMANDS = {
+  claude_cli: { provider: "claude_cli", command: "claude", envVars: ["ALAN_CLAUDE_PATH"] },
+  codex_app_server: {
+    provider: "codex_app_server",
+    command: "codex",
+    envVars: ["ALAN_CODEX_PATH"]
+  },
+  copilot_cli: { provider: "copilot_cli", command: "copilot", envVars: ["ALAN_COPILOT_PATH"] },
+  cursor_agent_cli: {
+    provider: "cursor_agent_cli",
+    command: "cursor-agent",
+    envVars: ["ALAN_CURSOR_AGENT_PATH"]
+  },
+  antigravity_cli: {
+    provider: "antigravity_cli",
+    command: "agy",
+    envVars: ["ALAN_ANTIGRAVITY_PATH"]
+  },
+  kimi_cli: { provider: "kimi_cli", command: "kimi-cli", envVars: ["ALAN_KIMI_PATH"] },
+  grok_cli: { provider: "grok_cli", command: "grok", envVars: ["ALAN_GROK_PATH"] },
+  opencode_cli: { provider: "opencode_cli", command: "opencode", envVars: ["ALAN_OPENCODE_PATH"] },
+  droid_cli: { provider: "droid_cli", command: "droid", envVars: ["ALAN_DROID_PATH"] },
+  supatest_cli: { provider: "supatest_cli", command: "supatest", envVars: ["ALAN_SUPATEST_PATH"] }
+};
+var DISCOVERABLE_PROVIDER_KINDS = Object.keys(PROVIDER_CLI_COMMANDS);
+var PROVIDER_ALIASES = {
+  agy: "antigravity_cli",
+  antigravity: "antigravity_cli",
+  antigravity_cli: "antigravity_cli",
+  codex: "codex_app_server",
+  gemini: "antigravity_cli",
+  gemini_cli: "antigravity_cli"
+};
+var BACKEND_CLI_COMMANDS = {
+  claude_cli: "claude",
+  codex: "codex",
+  codex_app_server: "codex",
+  copilot_cli: "copilot",
+  cursor_agent_cli: "cursor-agent",
+  agy: "agy",
+  antigravity: "agy",
+  antigravity_cli: "agy",
+  gemini_cli: "agy",
+  gemini: "agy",
+  kimi_cli: "kimi-cli",
+  grok_cli: "grok",
+  opencode_cli: "opencode",
+  droid_cli: "droid",
+  supatest_cli: "supatest"
+};
+var CLI_COMMAND_ALIASES = {
+  "kimi-cli": ["kimi"],
+  grok: ["grok-build"]
+};
+var resolvedCliCache = /* @__PURE__ */ new Map();
+var NEGATIVE_RESOLUTION_TTL_MS = 15e3;
+var negativeResolutionExpiry = /* @__PURE__ */ new Map();
+var cachedLoginShellEnv = null;
+function parseEnvOutput(output) {
+  const loginEnv = {};
+  for (const line of output.split("\n")) {
+    if (!line.trim()) continue;
+    const eqIdx = line.indexOf("=");
+    if (eqIdx <= 0) continue;
+    const key = line.slice(0, eqIdx);
+    if (/\s/.test(key)) continue;
+    loginEnv[key] = line.slice(eqIdx + 1);
+  }
+  if (!loginEnv.HOME) loginEnv.HOME = process.env.HOME ?? (0, import_node_os.homedir)();
+  if (!loginEnv.SHELL) loginEnv.SHELL = process.env.SHELL ?? "/bin/zsh";
+  return loginEnv;
+}
+function loadLoginShellEnvironment() {
+  if (cachedLoginShellEnv) return cachedLoginShellEnv;
+  if ((0, import_node_os.platform)() === "win32") {
+    cachedLoginShellEnv = process.env;
+    return cachedLoginShellEnv;
+  }
+  try {
+    const shell = (process.env.SHELL || "/bin/bash").replace(/'/g, "'\\''");
+    const envOutput = (0, import_node_child_process.execSync)(`'${shell}' -ilc 'env'`, {
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 5e3
+    });
+    cachedLoginShellEnv = parseEnvOutput(envOutput);
+  } catch {
+    cachedLoginShellEnv = process.env;
+  }
+  return cachedLoginShellEnv;
+}
+function getDaemonCliEnvironment() {
+  const base = (0, import_node_os.platform)() === "win32" ? process.env : loadLoginShellEnvironment();
+  return augmentCliPath(base);
+}
+function cacheResolvedCli(command, resolvedPath) {
+  resolvedCliCache.set(command, resolvedPath);
+  if (resolvedPath === null) {
+    negativeResolutionExpiry.set(command, Date.now() + NEGATIVE_RESOLUTION_TTL_MS);
+  } else {
+    negativeResolutionExpiry.delete(command);
+  }
+}
+function getCachedResolvedCli(command) {
+  const cached = resolvedCliCache.get(command);
+  if (cached === null) {
+    const expiresAt = negativeResolutionExpiry.get(command);
+    if (expiresAt === void 0 || Date.now() >= expiresAt) {
+      resolvedCliCache.delete(command);
+      negativeResolutionExpiry.delete(command);
+      return void 0;
+    }
+  }
+  return cached;
+}
+function resolveViaWhere(command, env) {
+  if ((0, import_node_os.platform)() !== "win32") return null;
+  const whereExe = (0, import_node_path.join)(
+    env.SystemRoot ?? process.env.SystemRoot ?? "C:\\Windows",
+    "System32",
+    "where.exe"
+  );
+  if (!(0, import_node_fs.existsSync)(whereExe)) return null;
+  const result = (0, import_node_child_process.spawnSync)(whereExe, [command], {
+    encoding: "utf8",
+    env,
+    windowsHide: true,
+    timeout: 3e3
+  });
+  if (result.error || result.status !== 0) return null;
+  for (const line of result.stdout.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    if (isRunnableFile(trimmed)) return trimmed;
+  }
+  return null;
+}
+function runCliProbeAsync(executable, env, args = ["--version"], timeoutMs = 3e3, spawnOptions) {
+  return new Promise((resolve7) => {
+    const isWin = (0, import_node_os.platform)() === "win32";
+    let command = executable;
+    let commandArgs = args;
+    if (isWin && /\.(cmd|bat)$/i.test(executable)) {
+      command = env.ComSpec ?? process.env.ComSpec ?? "cmd.exe";
+      commandArgs = ["/d", "/s", "/c", executable, ...args];
+    }
+    const useShell = isWin && command === executable && !/[\\/]/.test(executable);
+    const closeStdin = spawnOptions?.closeStdin === true;
+    let child;
+    try {
+      child = (0, import_node_child_process.spawn)(command, commandArgs, {
+        env,
+        shell: useShell,
+        windowsHide: isWin ? true : void 0,
+        timeout: timeoutMs,
+        stdio: closeStdin ? ["pipe", "pipe", "pipe"] : void 0
+      });
+    } catch (error) {
+      resolve7({ status: null, stdout: "", stderr: "", error });
+      return;
+    }
+    if (closeStdin) {
+      child.stdin?.end();
+    }
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.setEncoding("utf8").on("data", (chunk) => {
+      stdout += chunk;
+    });
+    child.stderr?.setEncoding("utf8").on("data", (chunk) => {
+      stderr += chunk;
+    });
+    child.once("error", (error) => resolve7({ status: null, stdout, stderr, error }));
+    child.once(
+      "close",
+      (status, signal) => resolve7({ status, stdout, stderr, signal: signal ?? null })
+    );
+  });
+}
+function runCliVersionProbeAsync(executable, env, args = ["--version"], timeoutMs = 3e3) {
+  return runCliProbeAsync(executable, env, args, timeoutMs);
+}
+function pathSeparator() {
+  return (0, import_node_os.platform)() === "win32" ? ";" : ":";
+}
+function splitPath(pathValue) {
+  if (!pathValue) return [];
+  return pathValue.split(pathSeparator()).filter(Boolean);
+}
+function isRunnableFile(path) {
+  if (!(0, import_node_fs.existsSync)(path)) return false;
+  if ((0, import_node_os.platform)() === "win32") return true;
+  try {
+    (0, import_node_fs.accessSync)(path, import_node_fs.constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function windowsCommandCandidates(command, pathExt) {
+  const trimmed = command.trim();
+  if (!trimmed) return [];
+  const hasExtension = /\.[a-z0-9]+$/i.test(trimmed);
+  if (hasExtension) return [trimmed];
+  const extensions = pathExt.split(";").map((ext) => ext.trim()).filter(Boolean);
+  return [trimmed, ...extensions.map((ext) => `${trimmed}${ext}`)];
+}
+function augmentCliPath(env) {
+  const home = env.HOME || env.USERPROFILE || (0, import_node_os.homedir)();
+  const isWin = (0, import_node_os.platform)() === "win32";
+  const extraPaths = isWin ? [
+    (0, import_node_path.join)(home, "AppData", "Roaming", "npm"),
+    (0, import_node_path.join)(home, "AppData", "Local", "Programs", "Microsoft", "WindowsApps"),
+    (0, import_node_path.join)(home, ".local", "bin"),
+    "C:\\Program Files\\nodejs",
+    "C:\\Program Files\\Git\\cmd"
+  ] : [
+    (0, import_node_path.join)(home, ".local", "bin"),
+    (0, import_node_path.join)(home, ".local", "node", "bin"),
+    (0, import_node_path.join)(home, ".bun", "bin"),
+    (0, import_node_path.join)(home, ".cargo", "bin"),
+    "/opt/homebrew/bin",
+    "/usr/local/bin"
+  ];
+  const basePath = env.PATH ?? "";
+  const existing = new Set(splitPath(basePath));
+  const missing = extraPaths.filter((dir) => !existing.has(dir));
+  if (missing.length === 0) return env;
+  return {
+    ...env,
+    PATH: missing.length > 0 ? `${missing.join(pathSeparator())}${pathSeparator()}${basePath}` : basePath
+  };
+}
+function resolveCliExecutable(command, env = getDaemonCliEnvironment()) {
+  const trimmed = command.trim();
+  if (!trimmed) return null;
+  const cached = getCachedResolvedCli(trimmed);
+  if (cached === null) return null;
+  if (cached && isRunnableFile(cached)) return cached;
+  if ((trimmed.includes("/") || trimmed.includes("\\")) && isRunnableFile(trimmed)) {
+    cacheResolvedCli(trimmed, trimmed);
+    return trimmed;
+  }
+  const enriched = augmentCliPath(env);
+  const home = enriched.HOME || enriched.USERPROFILE || (0, import_node_os.homedir)();
+  const isWin = (0, import_node_os.platform)() === "win32";
+  const pathExt = enriched.PATHEXT ?? (isWin ? ".EXE;.CMD;.BAT;.COM" : "");
+  const commandNames = [trimmed, ...CLI_COMMAND_ALIASES[trimmed] ?? []];
+  const names = commandNames.flatMap(
+    (name) => isWin ? windowsCommandCandidates(name, pathExt) : [name]
+  );
+  const candidates = [];
+  for (const name of names) {
+    if (name.includes("/") || name.includes("\\")) {
+      candidates.push(name);
+      continue;
+    }
+    for (const dir of splitPath(enriched.PATH)) {
+      candidates.push((0, import_node_path.join)(dir, name));
+    }
+    candidates.push((0, import_node_path.join)(home, ".local", "bin", name), (0, import_node_path.join)(home, ".local", "node", "bin", name));
+    if (!isWin) {
+      candidates.push((0, import_node_path.join)("/opt/homebrew/bin", name), (0, import_node_path.join)("/usr/local/bin", name));
+    } else {
+      candidates.push((0, import_node_path.join)(home, "AppData", "Roaming", "npm", name));
+    }
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const candidate of candidates) {
+    if (seen.has(candidate)) continue;
+    seen.add(candidate);
+    if (isRunnableFile(candidate)) {
+      cacheResolvedCli(trimmed, candidate);
+      return candidate;
+    }
+  }
+  const viaWhere = resolveViaWhere(trimmed, enriched);
+  if (viaWhere) {
+    cacheResolvedCli(trimmed, viaWhere);
+    return viaWhere;
+  }
+  cacheResolvedCli(trimmed, null);
+  return null;
+}
+function normalizeDiscoverableProvider(provider) {
+  const alias = PROVIDER_ALIASES[provider];
+  if (alias) return alias;
+  if (provider in PROVIDER_CLI_COMMANDS) {
+    return provider;
+  }
+  return null;
+}
+function resolveProviderCliCommand(provider, env = getDaemonCliEnvironment()) {
+  const normalized = normalizeDiscoverableProvider(provider);
+  if (!normalized) return null;
+  const spec = PROVIDER_CLI_COMMANDS[normalized];
+  const override = spec.envVars.map((name) => process.env[name]?.trim() || env[name]?.trim()).find(Boolean);
+  if (override) {
+    const resolved2 = resolveCliExecutable(override, env) ?? (isRunnableFile(override) ? override : null);
+    if (resolved2) cacheResolvedCli(spec.command, resolved2);
+    return resolved2;
+  }
+  const resolved = resolveCliExecutable(spec.command, env);
+  if (resolved) cacheResolvedCli(spec.command, resolved);
+  return resolved;
+}
+function resolveBackendRuntimeCommand(backendKind, env = getDaemonCliEnvironment()) {
+  if (!backendKind) return void 0;
+  const command = BACKEND_CLI_COMMANDS[backendKind];
+  if (!command) return void 0;
+  const cached = getCachedResolvedCli(command);
+  if (cached === null) return void 0;
+  if (cached && isRunnableFile(cached)) return cached;
+  const spec = Object.values(PROVIDER_CLI_COMMANDS).find((entry) => entry.command === command);
+  const envOverride = spec ? spec.envVars.map((name) => env[name]?.trim()).find(Boolean) : void 0;
+  const resolved = resolveCliExecutable(envOverride?.trim() || command, env);
+  cacheResolvedCli(command, resolved);
+  return resolved ?? void 0;
+}
+function invalidateResolvedCli(command) {
+  const trimmed = command.trim();
+  if (trimmed) {
+    resolvedCliCache.delete(trimmed);
+    negativeResolutionExpiry.delete(trimmed);
+  }
+}
+function revalidateBackendRuntimeCommand(backendKind, env = getDaemonCliEnvironment()) {
+  if (!backendKind) return void 0;
+  const command = BACKEND_CLI_COMMANDS[backendKind];
+  if (!command) return void 0;
+  invalidateResolvedCli(command);
+  const spec = Object.values(PROVIDER_CLI_COMMANDS).find((entry) => entry.command === command);
+  const envOverride = spec ? spec.envVars.map((name) => env[name]?.trim()).find(Boolean) : void 0;
+  if (envOverride) invalidateResolvedCli(envOverride);
+  return resolveBackendRuntimeCommand(backendKind, env);
+}
+
 // src/cli-help.ts
 var HELP_TEXT = `Alan agent CLI
 
@@ -4859,12 +5204,12 @@ function resolveCommand(args, env) {
 }
 
 // src/daemon.ts
-var import_node_child_process6 = require("child_process");
-var import_node_crypto3 = require("crypto");
-var import_node_fs13 = require("fs");
+var import_node_child_process7 = require("child_process");
+var import_node_crypto5 = require("crypto");
+var import_node_fs14 = require("fs");
 var import_node_http = __toESM(require("http"), 1);
-var import_node_os8 = require("os");
-var import_node_path11 = require("path");
+var import_node_os9 = require("os");
+var import_node_path12 = require("path");
 
 // ../agent-core/dist/index.js
 var import_fs = require("fs");
@@ -5029,6 +5374,16 @@ Your job is to take the repository in this fresh cloud sandbox from an unknown s
 - You are inside an ephemeral cloud sandbox. Its filesystem can be captured as a reusable snapshot for future sessions.
 - Do not assume you are on the user's laptop or that tools outside this sandbox exist.
 - Install and build inside the workspace. Keep all setup repeatable from a fresh clone.
+
+### Sandbox privileges
+
+- You are the non-root user \`alan\`; \`HOME=/home/alan\`, repos in \`/home/alan/workspace\`, which you fully own. Node/pnpm/CLIs are on \`PATH\`, and \`npm install -g\` needs no sudo.
+- **Installing system packages is allowed**, via sudo scoped to package managers: \`sudo apt-get\`, \`sudo apt\`, \`sudo dpkg\`, \`sudo add-apt-repository\`. Other sudo (\`su\`, \`sh\`, \`systemctl\`) is refused by design.
+- **Always \`sudo apt-get update\` first.** Package lists ship empty, so installing without it fails with "Unable to locate package" \u2014 which reads as "permission denied" but is not:
+  \`sudo apt-get update && sudo apt-get install -y --no-install-recommends <pkgs>\`
+- Never hand-compile system packages into \`$HOME\` to route around a permission you already have. Use apt; fall back to a user-local install only if the package truly is not in apt.
+- No Docker daemon or socket. Ports below 1024 bind fine without elevation.
+- Read the real error before blaming permissions: \`ELIFECYCLE\` is a generic pnpm epilogue, not a diagnosis. Find the \`ERR_\`/\`gyp ERR!\` line above it. A native build failure means a missing system package, not a missing privilege.
 - Persist the final ordered commands with \`set_environment_setup_commands\`. Each command is replayed in a fresh shell, so no command may depend on shell state from a previous command.
 - The snapshot policy is \`block_if_dirty\`: the working tree must be clean before capture.
 
@@ -5038,8 +5393,8 @@ Your job is to take the repository in this fresh cloud sandbox from an unknown s
 2. **Set up** \u2014 install dependencies, select compatible runtimes, configure non-secret defaults, and build. Diagnose failures yourself before asking the user.
 3. **Run and verify** \u2014 start the real app or service. Prove it works using process stability, logs, HTTP probes, and \`agent-browser\` interaction when a UI exists. A process merely starting or dependencies merely installing is not success.
 4. **Persist** \u2014 call \`set_environment_setup_commands\` with only the ordered commands you actually verified from a fresh-shell model.
-5. **Prepare capture** \u2014 ensure every repository is clean. Verify that \`git status --porcelain --untracked-files=all\` is empty; generated untracked files count as dirty and must be removed or covered by an appropriate existing ignore rule. If setup requires tracked changes, create a focused branch, commit them, push it, and open a PR with \`github_pr_create\` explaining why the setup change is needed. Never commit secrets.
-6. **Human gate** \u2014 summarize the evidence and ask the user to reply exactly \`Capture snapshot\`. Do not call \`capture_environment_snapshot\` before that explicit confirmation.
+5. **Prepare capture** \u2014 ensure every repository is clean. Verify that \`git status --porcelain --untracked-files=all\` is empty; generated untracked files count as dirty and must be removed or covered by an appropriate existing ignore rule. If setup requires tracked changes, create a focused branch, commit them, push it, and open a PR with \`github_pr_create\` explaining why the setup change is needed. When this setup session is attached to a task, link that PR with \`github_pr_link_task\`. Never commit secrets.
+6. **Human gate** \u2014 summarize the evidence and ask the user to approve the snapshot. The chat shows them a **Capture snapshot** button, so invite them to use it rather than dictating an exact phrase to type. Do not call \`capture_environment_snapshot\` before that approval arrives.
 7. **Capture and re-verify** \u2014 after approval, call \`capture_environment_snapshot\` with \`afterSnapshot: "resume"\`. Poll \`get_cloud_machine\` until the snapshot is ready, then confirm the sandbox remains usable and repeat the key runtime probe before declaring completion.
 
 ## Autonomy
@@ -11023,7 +11378,7 @@ var EPIC_STATUS_OPTIONS = [
     value: "canceled",
     label: "Canceled",
     color: CATEGORICAL_COLORS.slateClosed,
-    group: "done"
+    group: "closed"
   }
 ];
 var DEFAULT_EPIC_STATUSES = EPIC_STATUS_OPTIONS.map((o) => ({
@@ -11777,7 +12132,12 @@ function normalizeCodexCliErrorMessage(message) {
   if (lower.includes("reconnecting") && lower.includes("request timed out")) {
     return "Codex connection to OpenAI timed out while waiting for the turn to continue. Retry the message; if it repeats, check network/API latency or reduce slow MCP/tool calls in the turn.";
   }
-  if (lower.includes("access token could not be refreshed") || lower.includes("refresh_token_invalidated") || lower.includes("refresh token has been invalidated")) {
+  if (lower.includes("access token could not be refreshed") || lower.includes("refresh_token_invalidated") || lower.includes("refresh token has been invalidated") || // OpenAI's ChatGPT backend rejects a stale bearer with this pair on both the
+  // HTTP and WSS paths, e.g. "Reconnecting... 2/5 (unexpected status 401
+  // Unauthorized: Provided authentication token is expired. ... auth error
+  // code: token_expired)". Left unmapped these render as a raw retry banner
+  // with a generic "check your API key" hint and no recovery path.
+  lower.includes("token_expired") || lower.includes("provided authentication token is expired")) {
     return "Codex CLI connection expired. Re-authenticate the Codex CLI on this computer (run `codex login`) or reconnect it in Cloud settings, then retry.";
   }
   return message;
@@ -12014,12 +12374,29 @@ function formatCliSpawnError(command, error) {
       `CLI command not found: ${command}. Install it or configure this provider with the full executable path.`
     );
   }
+  if (error.code === "ETXTBSY") {
+    return new Error(
+      `CLI "${command}" is still being written by an installer (ETXTBSY) and did not become runnable in time. Retry in a moment.`
+    );
+  }
   return error;
 }
-function waitForSpawnOutcome(child) {
+var SPAWN_RETRY_DELAYS_BY_CODE = {
+  ETXTBSY: [250, 750, 1500, 3e3, 5e3],
+  ENOENT: [250, 750]
+};
+var delay = (ms) => new Promise((resolve22) => setTimeout(resolve22, ms));
+var SPAWN_OUTCOME_TIMEOUT_MS = 2e3;
+function waitForSpawnOutcome(child, timeoutMs = SPAWN_OUTCOME_TIMEOUT_MS) {
   return new Promise((resolve22) => {
-    child.once("spawn", () => resolve22(null));
-    child.once("error", (error) => resolve22(error));
+    const timer = setTimeout(() => resolve22(null), timeoutMs);
+    timer.unref?.();
+    const settle = (value2) => {
+      clearTimeout(timer);
+      resolve22(value2);
+    };
+    child.once("spawn", () => settle(null));
+    child.once("error", (error) => settle(error));
   });
 }
 function createGenericCliBackend(options) {
@@ -12037,28 +12414,35 @@ function createGenericCliBackend(options) {
       const args = options.buildArgs?.(context, prompt) ?? options.args.map((arg) => arg === "{{prompt}}" ? prompt : arg);
       let command = options.command;
       let child = spawnCli(command, args, context);
-      if (context.revalidateCommand) {
-        const spawnError = await waitForSpawnOutcome(child);
-        if (spawnError) {
-          const fresh = spawnError.code === "ENOENT" ? context.revalidateCommand()?.trim() || null : null;
-          if (fresh && fresh !== command) {
-            console.warn(
-              `[${options.kind}] Spawn failed ENOENT for "${command}" \u2014 re-resolved to "${fresh}", retrying once`
-            );
-            command = fresh;
-            child = spawnCli(command, args, context);
-          } else {
-            throw formatCliSpawnError(command, spawnError);
-          }
-        }
-      }
       state.process = child;
       state.lastRawOutputAtMs = Date.now();
-      context.onProcessSpawned?.(child);
       context.registerLivenessProbe?.(() => ({
         providerAlive: child.exitCode === null,
         lastRawOutputAgoMs: typeof state.lastRawOutputAtMs === "number" ? Date.now() - state.lastRawOutputAtMs : null
       }));
+      for (let attempt = 0; ; attempt++) {
+        if (child.pid !== void 0) break;
+        const spawnError = await waitForSpawnOutcome(child);
+        if (!spawnError) break;
+        const delays = SPAWN_RETRY_DELAYS_BY_CODE[spawnError.code ?? ""] ?? [];
+        if (attempt >= delays.length) {
+          throw formatCliSpawnError(command, spawnError);
+        }
+        const waitMs = delays[attempt];
+        console.warn(
+          `[${options.kind}] Spawn of "${command}" failed ${spawnError.code} \u2014 a CLI installer is likely mid-flight; retrying in ${waitMs}ms (attempt ${attempt + 1}/${delays.length})`
+        );
+        await delay(waitMs);
+        const fresh = context.revalidateCommand?.()?.trim() || null;
+        if (fresh && fresh !== command) {
+          console.warn(`[${options.kind}] Re-resolved "${command}" to "${fresh}"`);
+          command = fresh;
+        }
+        child = spawnCli(command, args, context);
+      }
+      state.process = child;
+      state.lastRawOutputAtMs = Date.now();
+      context.onProcessSpawned?.(child);
       const safeArgs = args.map(
         (a, i) => i > 0 && args[i - 1] === "--system-prompt" ? `"<system-prompt ${a.length} chars>"` : a
       );
@@ -18625,18 +19009,18 @@ ${output.stderr}`;
 }
 
 // ../shared/dist/node/local-workspace.js
-var import_node_fs = require("fs");
-var import_node_os = require("os");
-var import_node_path = require("path");
-function resolveAlanDefaultWorkspacePath(homeDirectory = (0, import_node_os.homedir)()) {
-  return (0, import_node_path.join)(homeDirectory, ".alan", "workspace");
-}
-
-// ../shared/dist/node/provider-limits.js
-var import_node_child_process = require("child_process");
 var import_node_fs2 = require("fs");
 var import_node_os2 = require("os");
 var import_node_path2 = require("path");
+function resolveAlanDefaultWorkspacePath(homeDirectory = (0, import_node_os2.homedir)()) {
+  return (0, import_node_path2.join)(homeDirectory, ".alan", "workspace");
+}
+
+// ../shared/dist/node/provider-limits.js
+var import_node_child_process2 = require("child_process");
+var import_node_fs3 = require("fs");
+var import_node_os3 = require("os");
+var import_node_path3 = require("path");
 var CACHE_TTL_MS = 6e4;
 var cachedLimits = null;
 function numericValue(value2) {
@@ -18647,42 +19031,42 @@ 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_path3.delimiter).filter(Boolean);
 }
 function isExecutableFile(path) {
   try {
-    (0, import_node_fs2.accessSync)(path, import_node_fs2.constants.X_OK);
+    (0, import_node_fs3.accessSync)(path, import_node_fs3.constants.X_OK);
     return true;
   } catch {
     return false;
   }
 }
-function augmentCliPath(env) {
-  const home = env.HOME || (0, import_node_os2.homedir)();
+function augmentCliPath2(env) {
+  const home = env.HOME || (0, import_node_os3.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"),
+    (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"),
     "/opt/homebrew/bin",
     "/usr/local/bin"
   ];
-  const existing = new Set(splitPath(env.PATH));
+  const existing = new Set(splitPath2(env.PATH));
   const missing = extraPaths.filter((path) => !existing.has(path));
   if (missing.length === 0)
     return env;
   return {
     ...env,
-    PATH: `${missing.join(import_node_path2.delimiter)}${import_node_path2.delimiter}${env.PATH ?? ""}`
+    PATH: `${missing.join(import_node_path3.delimiter)}${import_node_path3.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_path3.join)(dir, command);
     if (isExecutableFile(candidate))
       return candidate;
   }
@@ -18744,8 +19128,8 @@ async function withTimeout(promise, timeoutMs, fallback) {
   try {
     return await Promise.race([
       promise,
-      new Promise((resolve6) => {
-        timer = setTimeout(() => resolve6(fallback), timeoutMs);
+      new Promise((resolve7) => {
+        timer = setTimeout(() => resolve7(fallback), timeoutMs);
       })
     ]);
   } finally {
@@ -18754,12 +19138,12 @@ async function withTimeout(promise, timeoutMs, fallback) {
   }
 }
 async function collectCodexLimits(env) {
-  const runtimeEnv = augmentCliPath(env);
+  const runtimeEnv = augmentCliPath2(env);
   const codexCommand = resolveExecutable("codex", runtimeEnv, "ALAN_CODEX_PATH");
   if (!codexCommand)
     return [];
-  return withTimeout(new Promise((resolve6) => {
-    const child = (0, import_node_child_process.spawn)(codexCommand, ["-s", "read-only", "-a", "untrusted", "app-server"], {
+  return withTimeout(new Promise((resolve7) => {
+    const child = (0, import_node_child_process2.spawn)(codexCommand, ["-s", "read-only", "-a", "untrusted", "app-server"], {
       env: runtimeEnv,
       stdio: ["pipe", "pipe", "ignore"]
     });
@@ -18770,7 +19154,7 @@ async function collectCodexLimits(env) {
       pending.clear();
       if (!child.killed)
         child.kill();
-      resolve6(windows);
+      resolve7(windows);
     };
     const request = (method, params = {}) => {
       const id = nextId++;
@@ -18826,10 +19210,10 @@ async function collectCodexLimits(env) {
   }), 4e3, []);
 }
 function readClaudeCredentialsPayload() {
-  const path = (0, import_node_path2.join)((0, import_node_os2.homedir)(), ".claude", ".credentials.json");
-  if ((0, import_node_fs2.existsSync)(path)) {
+  const path = (0, import_node_path3.join)((0, import_node_os3.homedir)(), ".claude", ".credentials.json");
+  if ((0, import_node_fs3.existsSync)(path)) {
     try {
-      return JSON.parse((0, import_node_fs2.readFileSync)(path, "utf8"));
+      return JSON.parse((0, import_node_fs3.readFileSync)(path, "utf8"));
     } catch {
       return null;
     }
@@ -18837,7 +19221,7 @@ function readClaudeCredentialsPayload() {
   if (process.platform !== "darwin")
     return null;
   try {
-    const raw = (0, import_node_child_process.execFileSync)("security", ["find-generic-password", "-s", "Claude Code-credentials", "-w"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+    const raw = (0, import_node_child_process2.execFileSync)("security", ["find-generic-password", "-s", "Claude Code-credentials", "-w"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
     if (!raw)
       return null;
     return JSON.parse(raw);
@@ -20536,11 +20920,11 @@ var SocketWithoutUpgrade = class _SocketWithoutUpgrade extends Emitter {
    */
   _resetPingTimeout() {
     this.clearTimeoutFn(this._pingTimeoutTimer);
-    const delay = this._pingInterval + this._pingTimeout;
-    this._pingTimeoutTime = Date.now() + delay;
+    const delay2 = this._pingInterval + this._pingTimeout;
+    this._pingTimeoutTime = Date.now() + delay2;
     this._pingTimeoutTimer = this.setTimeoutFn(() => {
       this._onClose("ping timeout");
-    }, delay);
+    }, delay2);
     if (this.opts.autoUnref) {
       this._pingTimeoutTimer.unref();
     }
@@ -21603,9 +21987,9 @@ var Socket2 = class extends Emitter {
    * @return a Promise that will be fulfilled when the server acknowledges the event
    */
   emitWithAck(ev, ...args) {
-    return new Promise((resolve6, reject) => {
+    return new Promise((resolve7, reject) => {
       const fn = (arg1, arg2) => {
-        return arg1 ? reject(arg1) : resolve6(arg2);
+        return arg1 ? reject(arg1) : resolve7(arg2);
       };
       fn.withError = true;
       args.push(fn);
@@ -22521,8 +22905,8 @@ var Manager = class extends Emitter {
       this.emitReserved("reconnect_failed");
       this._reconnecting = false;
     } else {
-      const delay = this.backoff.duration();
-      debug10("will wait %dms before reconnect attempt", delay);
+      const delay2 = this.backoff.duration();
+      debug10("will wait %dms before reconnect attempt", delay2);
       this._reconnecting = true;
       const timer = this.setTimeoutFn(() => {
         if (self.skipReconnect)
@@ -22542,7 +22926,7 @@ var Manager = class extends Emitter {
             self.onreconnect();
           }
         });
-      }, delay);
+      }, delay2);
       if (this.opts.autoUnref) {
         timer.unref();
       }
@@ -22591,365 +22975,1139 @@ function lookup(uri, opts) {
     }
     io = cache[id];
   }
-  if (parsed.query && !opts.query) {
-    opts.query = parsed.queryKey;
+  if (parsed.query && !opts.query) {
+    opts.query = parsed.queryKey;
+  }
+  return io.socket(parsed.path, opts);
+}
+Object.assign(lookup, {
+  Manager,
+  Socket: Socket2,
+  io: lookup,
+  connect: lookup
+});
+
+// src/binding-switch-git.ts
+var import_node_child_process3 = require("child_process");
+var import_node_crypto = require("crypto");
+var import_node_fs4 = require("fs");
+var import_node_os4 = require("os");
+var import_node_path4 = require("path");
+var import_node_url = require("url");
+var BINDING_SWITCH_GIT_METHODS = [
+  "git.status",
+  "git.checkpoint",
+  "git.push",
+  "git.fetch",
+  "git.prepare_checkout",
+  "git.prepare_worktree",
+  "git.verify_head"
+];
+function isBindingSwitchGitMethod(method) {
+  return BINDING_SWITCH_GIT_METHODS.includes(method);
+}
+var BindingSwitchGitError = class extends Error {
+  constructor(code, message, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "BindingSwitchGitError";
+  }
+};
+var LOCAL_GIT_TIMEOUT_MS = 1e4;
+var NETWORK_GIT_TIMEOUT_MS = 3e4;
+var MAX_GIT_OUTPUT_BYTES = 10 * 1024 * 1024;
+function runGitResult(cwd, args, options = {}) {
+  const result = (0, import_node_child_process3.spawnSync)("git", args, {
+    cwd,
+    env: { ...getDaemonCliEnvironment(), ...options.env },
+    encoding: "utf8",
+    input: options.input,
+    maxBuffer: MAX_GIT_OUTPUT_BYTES,
+    timeout: LOCAL_GIT_TIMEOUT_MS
+  });
+  if (result.error) {
+    return { status: 1, stdout: "", stderr: result.error.message };
+  }
+  return {
+    status: result.status ?? 1,
+    stdout: result.stdout ?? "",
+    stderr: result.stderr ?? ""
+  };
+}
+function networkGitTimeoutMs() {
+  if (process.env.NODE_ENV !== "test") return NETWORK_GIT_TIMEOUT_MS;
+  const override = Number.parseInt(process.env.ALAN_TEST_GIT_NETWORK_TIMEOUT_MS ?? "", 10);
+  return Number.isFinite(override) && override >= 10 ? Math.min(override, NETWORK_GIT_TIMEOUT_MS) : NETWORK_GIT_TIMEOUT_MS;
+}
+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_fs4.mkdirSync)(barrierDir, { recursive: true });
+  const readyPath = (0, import_node_path4.join)(barrierDir, "ready");
+  const releasePath = (0, import_node_path4.join)(barrierDir, "release");
+  (0, import_node_fs4.writeFileSync)(readyPath, "ready\n");
+  const deadline = Date.now() + 5e3;
+  while (!(0, import_node_fs4.existsSync)(releasePath)) {
+    if (Date.now() >= deadline) {
+      throw new BindingSwitchGitError(
+        "checkpoint_prepare_timeout",
+        "Checkpoint preparation test barrier timed out"
+      );
+    }
+    await new Promise((resolvePromise) => setTimeout(resolvePromise, 10));
+  }
+}
+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_fs4.mkdirSync)(barrierDir, { recursive: true });
+  const readyPath = (0, import_node_path4.join)(barrierDir, "ready");
+  const releasePath = (0, import_node_path4.join)(barrierDir, "release");
+  (0, import_node_fs4.writeFileSync)(readyPath, "ready\n");
+  const deadline = Date.now() + 5e3;
+  while (!(0, import_node_fs4.existsSync)(releasePath)) {
+    if (Date.now() >= deadline) {
+      throw new BindingSwitchGitError(
+        "checkpoint_finalize_timeout",
+        "Checkpoint finalization test barrier timed out"
+      );
+    }
+    await new Promise((resolvePromise) => setTimeout(resolvePromise, 10));
+  }
+}
+async function runNetworkGit(cwd, args, code) {
+  return new Promise((resolvePromise, rejectPromise) => {
+    const child = (0, import_node_child_process3.spawn)("git", args, {
+      cwd,
+      env: {
+        ...getDaemonCliEnvironment(),
+        GCM_INTERACTIVE: "Never",
+        GIT_TERMINAL_PROMPT: "0",
+        ...process.env.NODE_ENV === "test" && process.env.ALAN_TEST_GIT_SSH_COMMAND ? { GIT_SSH_COMMAND: process.env.ALAN_TEST_GIT_SSH_COMMAND } : {}
+      },
+      detached: process.platform !== "win32",
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    let outputExceeded = false;
+    let timedOut = false;
+    let settled = false;
+    const killTree = () => {
+      if (child.pid && process.platform !== "win32") {
+        try {
+          process.kill(-child.pid, "SIGKILL");
+          return;
+        } catch {
+        }
+      }
+      child.kill("SIGKILL");
+    };
+    const timer = setTimeout(() => {
+      timedOut = true;
+      killTree();
+    }, networkGitTimeoutMs());
+    timer.unref?.();
+    const append = (current, chunk) => {
+      if (Buffer.byteLength(current) + chunk.byteLength > MAX_GIT_OUTPUT_BYTES) {
+        outputExceeded = true;
+        killTree();
+        return current;
+      }
+      return current + chunk.toString("utf8");
+    };
+    child.stdout.on("data", (chunk) => {
+      stdout = append(stdout, chunk);
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr = append(stderr, chunk);
+    });
+    child.once("error", (error) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      rejectPromise(new BindingSwitchGitError(code, error.message));
+    });
+    child.once("close", (exitCode) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      if (timedOut) {
+        rejectPromise(
+          new BindingSwitchGitError(
+            "git_network_timeout",
+            "The Git network operation timed out and was cancelled"
+          )
+        );
+        return;
+      }
+      if (outputExceeded) {
+        rejectPromise(
+          new BindingSwitchGitError(
+            "git_output_limit_exceeded",
+            "The Git network operation produced too much output and was cancelled"
+          )
+        );
+        return;
+      }
+      if (exitCode !== 0) {
+        rejectPromise(
+          new BindingSwitchGitError(code, (stderr || stdout || "Git network command failed").trim())
+        );
+        return;
+      }
+      resolvePromise(stdout.trim());
+    });
+  });
+}
+function runGit(cwd, args, code = "git_operation_failed") {
+  return runGitWithOptions(cwd, args, {}, code);
+}
+function runGitWithOptions(cwd, args, options, code = "git_operation_failed") {
+  const result = runGitResult(cwd, args, options);
+  if (result.status !== 0) {
+    throw new BindingSwitchGitError(
+      code,
+      (result.stderr || result.stdout || "Git command failed").trim()
+    );
+  }
+  return result.stdout.trim();
+}
+function sourceChangedDuringCheckpoint(message) {
+  return new BindingSwitchGitError("source_changed_since_approval", message);
+}
+function acquireCheckpointHeadLock(locks) {
+  try {
+    (0, import_node_fs4.writeFileSync)(locks.headLockPath, "", { flag: "wx" });
+    locks.headLockHeld = true;
+  } catch {
+    throw sourceChangedDuringCheckpoint(
+      "Source repository is being changed by another Git operation"
+    );
+  }
+}
+function releaseCheckpointHeadLock(locks) {
+  if (!locks.headLockHeld) return;
+  (0, import_node_fs4.rmSync)(locks.headLockPath, { force: true });
+  locks.headLockHeld = false;
+}
+function acquireCheckpointRepositoryLocks(repoRoot) {
+  const gitDir = runGit(
+    repoRoot,
+    ["rev-parse", "--absolute-git-dir"],
+    "checkpoint_lock_unavailable"
+  );
+  const indexPath = runGit(
+    repoRoot,
+    ["rev-parse", "--path-format=absolute", "--git-path", "index"],
+    "checkpoint_lock_unavailable"
+  );
+  const locks = {
+    headLockPath: (0, import_node_path4.join)(gitDir, "HEAD.lock"),
+    headLockHeld: false,
+    indexLockPath: `${indexPath}.lock`,
+    indexLockHeld: false,
+    indexPath
+  };
+  try {
+    (0, import_node_fs4.writeFileSync)(locks.indexLockPath, "", { flag: "wx" });
+    locks.indexLockHeld = true;
+    acquireCheckpointHeadLock(locks);
+    return locks;
+  } catch {
+    if (locks.indexLockHeld) {
+      (0, import_node_fs4.rmSync)(locks.indexLockPath, { force: true });
+      locks.indexLockHeld = false;
+    }
+    throw sourceChangedDuringCheckpoint(
+      "Source repository is being changed by another Git operation"
+    );
+  }
+}
+function releaseCheckpointRepositoryLocks(locks) {
+  releaseCheckpointHeadLock(locks);
+  if (locks.indexLockHeld) {
+    (0, import_node_fs4.rmSync)(locks.indexLockPath, { force: true });
+    locks.indexLockHeld = false;
+  }
+}
+function assertCheckpointHead(repoRoot, expectedRef, expectedHeadSha) {
+  const currentRef = runGit(
+    repoRoot,
+    ["symbolic-ref", "-q", "HEAD"],
+    "source_changed_since_approval"
+  );
+  const currentHead = runGit(repoRoot, ["rev-parse", "HEAD"], "source_changed_since_approval");
+  if (currentRef !== expectedRef || currentHead !== expectedHeadSha) {
+    throw sourceChangedDuringCheckpoint(
+      "Source HEAD or branch changed during checkpoint finalization"
+    );
+  }
+}
+function createCheckpointIndexBaseline(repoRoot, checkpointSha) {
+  const tempDir = (0, import_node_fs4.mkdtempSync)((0, import_node_path4.join)((0, import_node_os4.tmpdir)(), "alan-checkpoint-index-"));
+  const indexPath = (0, import_node_path4.join)(tempDir, "index");
+  try {
+    runGitWithOptions(
+      repoRoot,
+      ["read-tree", checkpointSha],
+      { env: { GIT_INDEX_FILE: indexPath } },
+      "checkpoint_index_sync_failed"
+    );
+    return { indexPath, tempDir };
+  } catch (error) {
+    (0, import_node_fs4.rmSync)(tempDir, { recursive: true, force: true });
+    throw error;
+  }
+}
+function installCheckpointIndexBaseline(locks, baselineIndexPath) {
+  try {
+    (0, import_node_fs4.copyFileSync)(baselineIndexPath, locks.indexLockPath);
+    (0, import_node_fs4.renameSync)(locks.indexLockPath, locks.indexPath);
+    locks.indexLockHeld = false;
+  } catch (error) {
+    throw new BindingSwitchGitError(
+      "checkpoint_index_sync_failed",
+      error instanceof Error ? error.message : "The checkpoint index could not be installed"
+    );
+  }
+}
+function requiredString(params, key) {
+  const value2 = params[key];
+  if (typeof value2 !== "string" || value2.trim() === "") {
+    throw new BindingSwitchGitError("invalid_git_request", `${key} is required`);
+  }
+  if (/[\0\r\n]/.test(value2)) {
+    throw new BindingSwitchGitError("invalid_git_request", `${key} contains unsafe characters`);
+  }
+  return value2;
+}
+function requiredCommitMessage(params) {
+  const value2 = params.commitMessage;
+  if (typeof value2 !== "string" || value2.trim() === "") {
+    throw new BindingSwitchGitError("invalid_git_request", "commitMessage is required");
+  }
+  if (value2.includes("\0")) {
+    throw new BindingSwitchGitError(
+      "invalid_git_request",
+      "commitMessage contains unsafe characters"
+    );
+  }
+  return value2;
+}
+function optionalString(params, key) {
+  const value2 = params[key];
+  if (value2 === void 0 || value2 === null) return void 0;
+  if (typeof value2 !== "string" || value2.trim() === "" || /[\0\r\n]/.test(value2)) {
+    throw new BindingSwitchGitError("invalid_git_request", `${key} is invalid`);
+  }
+  return value2;
+}
+function commonRequest(params) {
+  return {
+    switchId: requiredString(params, "switchId"),
+    repoKey: requiredString(params, "repoKey"),
+    repoPath: (0, import_node_path4.resolve)(requiredString(params, "repoPath"))
+  };
+}
+function assertCommitSha(sha, key) {
+  if (!/^[0-9a-f]{40,64}$/i.test(sha)) {
+    throw new BindingSwitchGitError("invalid_git_request", `${key} is not a commit SHA`);
   }
-  return io.socket(parsed.path, opts);
 }
-Object.assign(lookup, {
-  Manager,
-  Socket: Socket2,
-  io: lookup,
-  connect: lookup
-});
-
-// src/cli-ensure-install.ts
-var import_node_child_process3 = require("child_process");
-var import_node_os4 = require("os");
-
-// src/cli-executable.ts
-var import_node_child_process2 = require("child_process");
-var import_node_fs3 = require("fs");
-var import_node_os3 = require("os");
-var import_node_path3 = require("path");
-var PROVIDER_CLI_COMMANDS = {
-  claude_cli: { provider: "claude_cli", command: "claude", envVars: ["ALAN_CLAUDE_PATH"] },
-  codex_app_server: {
-    provider: "codex_app_server",
-    command: "codex",
-    envVars: ["ALAN_CODEX_PATH"]
-  },
-  copilot_cli: { provider: "copilot_cli", command: "copilot", envVars: ["ALAN_COPILOT_PATH"] },
-  cursor_agent_cli: {
-    provider: "cursor_agent_cli",
-    command: "cursor-agent",
-    envVars: ["ALAN_CURSOR_AGENT_PATH"]
-  },
-  antigravity_cli: {
-    provider: "antigravity_cli",
-    command: "agy",
-    envVars: ["ALAN_ANTIGRAVITY_PATH"]
-  },
-  kimi_cli: { provider: "kimi_cli", command: "kimi-cli", envVars: ["ALAN_KIMI_PATH"] },
-  grok_cli: { provider: "grok_cli", command: "grok", envVars: ["ALAN_GROK_PATH"] },
-  opencode_cli: { provider: "opencode_cli", command: "opencode", envVars: ["ALAN_OPENCODE_PATH"] },
-  droid_cli: { provider: "droid_cli", command: "droid", envVars: ["ALAN_DROID_PATH"] },
-  supatest_cli: { provider: "supatest_cli", command: "supatest", envVars: ["ALAN_SUPATEST_PATH"] }
-};
-var DISCOVERABLE_PROVIDER_KINDS = Object.keys(PROVIDER_CLI_COMMANDS);
-var PROVIDER_ALIASES = {
-  agy: "antigravity_cli",
-  antigravity: "antigravity_cli",
-  antigravity_cli: "antigravity_cli",
-  codex: "codex_app_server",
-  gemini: "antigravity_cli",
-  gemini_cli: "antigravity_cli"
-};
-var BACKEND_CLI_COMMANDS = {
-  claude_cli: "claude",
-  codex: "codex",
-  codex_app_server: "codex",
-  copilot_cli: "copilot",
-  cursor_agent_cli: "cursor-agent",
-  agy: "agy",
-  antigravity: "agy",
-  antigravity_cli: "agy",
-  gemini_cli: "agy",
-  gemini: "agy",
-  kimi_cli: "kimi-cli",
-  grok_cli: "grok",
-  opencode_cli: "opencode",
-  droid_cli: "droid",
-  supatest_cli: "supatest"
-};
-var CLI_COMMAND_ALIASES = {
-  "kimi-cli": ["kimi"],
-  grok: ["grok-build"]
-};
-var resolvedCliCache = /* @__PURE__ */ new Map();
-var NEGATIVE_RESOLUTION_TTL_MS = 15e3;
-var negativeResolutionExpiry = /* @__PURE__ */ new Map();
-var cachedLoginShellEnv = null;
-function parseEnvOutput(output) {
-  const loginEnv = {};
-  for (const line of output.split("\n")) {
-    if (!line.trim()) continue;
-    const eqIdx = line.indexOf("=");
-    if (eqIdx <= 0) continue;
-    const key = line.slice(0, eqIdx);
-    if (/\s/.test(key)) continue;
-    loginEnv[key] = line.slice(eqIdx + 1);
+function assertValidBranch(branch) {
+  if (branch.startsWith("-")) {
+    throw new BindingSwitchGitError("invalid_git_request", "branch is not a safe Git ref");
+  }
+  const result = (0, import_node_child_process3.spawnSync)("git", ["check-ref-format", "--branch", branch], {
+    env: getDaemonCliEnvironment(),
+    encoding: "utf8"
+  });
+  if (result.status !== 0) {
+    throw new BindingSwitchGitError("invalid_git_request", "branch is not a valid Git ref");
   }
-  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;
 }
-function loadLoginShellEnvironment() {
-  if (cachedLoginShellEnv) return cachedLoginShellEnv;
-  if ((0, import_node_os3.platform)() === "win32") {
-    cachedLoginShellEnv = process.env;
-    return cachedLoginShellEnv;
+function validatedRemote(params) {
+  const remote = optionalString(params, "remote") ?? "origin";
+  if (remote.startsWith("-") || remote.includes("/") || remote.includes("\\")) {
+    throw new BindingSwitchGitError("invalid_git_request", "remote is not a safe remote name");
+  }
+  return remote;
+}
+function canonicalRemoteUrl(repoRoot, value2) {
+  const trimmed = value2.trim();
+  if (!trimmed || /[\0\r\n]/.test(trimmed)) {
+    throw new BindingSwitchGitError("invalid_git_request", "Remote URL is invalid");
+  }
+  const scpStyle = trimmed.match(/^([^/@:\s]+)@([^/:\s]+):(.+)$/);
+  const urlValue = scpStyle ? `ssh://${scpStyle[1]}@${scpStyle[2]}/${scpStyle[3]}` : trimmed;
+  if ((0, import_node_path4.isAbsolute)(urlValue) || urlValue.startsWith("./") || urlValue.startsWith("../")) {
+    const absolute = (0, import_node_path4.isAbsolute)(urlValue) ? urlValue : (0, import_node_path4.resolve)(repoRoot, urlValue);
+    return `file://${canonicalPathWithMissingTail(absolute).replace(/\/+$/, "").replace(/\.git$/, "")}`;
   }
+  let parsed;
   try {
-    const shell = (process.env.SHELL || "/bin/bash").replace(/'/g, "'\\''");
-    const envOutput = (0, import_node_child_process2.execSync)(`'${shell}' -ilc 'env'`, {
-      encoding: "utf8",
-      stdio: ["pipe", "pipe", "pipe"],
-      timeout: 5e3
-    });
-    cachedLoginShellEnv = parseEnvOutput(envOutput);
+    parsed = new URL(urlValue);
   } catch {
-    cachedLoginShellEnv = process.env;
+    throw new BindingSwitchGitError("invalid_git_request", "Remote URL is invalid");
   }
-  return cachedLoginShellEnv;
+  if (parsed.protocol === "file:") {
+    return `file://${canonicalPathWithMissingTail((0, import_node_url.fileURLToPath)(parsed)).replace(/\/+$/, "").replace(/\.git$/, "")}`;
+  }
+  if (parsed.search || parsed.hash) {
+    throw new BindingSwitchGitError("invalid_git_request", "Remote URL is invalid");
+  }
+  if (!["https:", "http:", "ssh:", "git:"].includes(parsed.protocol)) {
+    throw new BindingSwitchGitError(
+      "invalid_git_request",
+      "Remote URL uses an unsupported protocol"
+    );
+  }
+  if (parsed.password || (parsed.protocol === "http:" || parsed.protocol === "https:") && parsed.username) {
+    throw new BindingSwitchGitError(
+      "remote_url_credentials_rejected",
+      "Credential-bearing remote URLs are not allowed for environment migration"
+    );
+  }
+  const defaultPort = parsed.protocol === "https:" && parsed.port === "443" || parsed.protocol === "http:" && parsed.port === "80" || parsed.protocol === "ssh:" && parsed.port === "22";
+  const transport = parsed.protocol === "https:" || parsed.protocol === "ssh:" ? "secure:" : parsed.protocol;
+  const authority = `${parsed.hostname.toLowerCase()}${parsed.port && !defaultPort ? `:${parsed.port}` : ""}`;
+  const path = parsed.pathname.replace(/\/+/g, "/").replace(/\/+$/, "").replace(/\.git$/, "");
+  return `${transport}//${authority}${path}`;
+}
+function verifiedRemote(repoRoot, params, includePushUrls) {
+  const remote = validatedRemote(params);
+  const expectedRemoteUrl = canonicalRemoteUrl(
+    repoRoot,
+    requiredString(params, "expectedRemoteUrl")
+  );
+  const fetchUrls = runGit(
+    repoRoot,
+    ["remote", "get-url", "--all", remote],
+    "git_remote_unavailable"
+  ).split("\n").filter(Boolean);
+  const pushUrls = includePushUrls ? runGit(repoRoot, ["remote", "get-url", "--push", "--all", remote], "git_remote_unavailable").split("\n").filter(Boolean) : [];
+  const urls = [...fetchUrls, ...pushUrls];
+  if (urls.length === 0 || urls.some((url2) => canonicalRemoteUrl(repoRoot, url2) !== expectedRemoteUrl)) {
+    throw new BindingSwitchGitError(
+      "remote_url_mismatch",
+      "The configured Git remote does not match the repository selected for migration"
+    );
+  }
+  return { remote, expectedRemoteUrl };
 }
-function getDaemonCliEnvironment() {
-  const base = (0, import_node_os3.platform)() === "win32" ? process.env : loadLoginShellEnvironment();
-  return augmentCliPath2(base);
+function isPathContained(childPath, parentPath) {
+  const rel = (0, import_node_path4.relative)((0, import_node_path4.resolve)(parentPath), (0, import_node_path4.resolve)(childPath));
+  return rel === "" || !(0, import_node_path4.isAbsolute)(rel) && rel !== ".." && !rel.startsWith(`..${import_node_path4.sep}`);
+}
+function canonicalPathWithMissingTail(path) {
+  const missingSegments = [];
+  let cursor = (0, import_node_path4.resolve)(path);
+  while (!(0, import_node_fs4.existsSync)(cursor)) {
+    const parent = (0, import_node_path4.dirname)(cursor);
+    if (parent === cursor) {
+      throw new BindingSwitchGitError(
+        "path_canonicalization_failed",
+        "The selected path has no existing canonical ancestor"
+      );
+    }
+    missingSegments.unshift((0, import_node_path4.basename)(cursor));
+    cursor = parent;
+  }
+  return (0, import_node_path4.join)(import_node_fs4.realpathSync.native(cursor), ...missingSegments);
 }
-function cacheResolvedCli(command, resolvedPath) {
-  resolvedCliCache.set(command, resolvedPath);
-  if (resolvedPath === null) {
-    negativeResolutionExpiry.set(command, Date.now() + NEGATIVE_RESOLUTION_TTL_MS);
-  } else {
-    negativeResolutionExpiry.delete(command);
+function assertCanonicalPathContained(childPath, parentPath, code, message) {
+  if (!isPathContained(
+    canonicalPathWithMissingTail(childPath),
+    canonicalPathWithMissingTail(parentPath)
+  )) {
+    throw new BindingSwitchGitError(code, message);
   }
 }
-function getCachedResolvedCli(command) {
-  const cached = resolvedCliCache.get(command);
-  if (cached === null) {
-    const expiresAt = negativeResolutionExpiry.get(command);
-    if (expiresAt === void 0 || Date.now() >= expiresAt) {
-      resolvedCliCache.delete(command);
-      negativeResolutionExpiry.delete(command);
-      return void 0;
-    }
+function alanWorktreeRoot(projectRoot) {
+  return (0, import_node_path4.join)((0, import_node_path4.dirname)(projectRoot), `${(0, import_node_path4.basename)(projectRoot)}-alan-worktrees`);
+}
+function resolveRepositoryRoot(requestedPath) {
+  if (!(0, import_node_fs4.existsSync)(requestedPath)) {
+    throw new BindingSwitchGitError(
+      "repository_not_found",
+      `The selected repository path does not exist: ${requestedPath}`
+    );
   }
-  return cached;
+  const root = runGitResult(requestedPath, ["rev-parse", "--show-toplevel"]);
+  if (root.status !== 0 || !root.stdout.trim()) {
+    throw new BindingSwitchGitError(
+      "repository_not_found",
+      "The selected folder is not inside a Git repository"
+    );
+  }
+  return import_node_fs4.realpathSync.native((0, import_node_path4.resolve)(root.stdout.trim()));
 }
-function resolveViaWhere(command, env) {
-  if ((0, import_node_os3.platform)() !== "win32") return null;
-  const whereExe = (0, import_node_path3.join)(
-    env.SystemRoot ?? process.env.SystemRoot ?? "C:\\Windows",
-    "System32",
-    "where.exe"
-  );
-  if (!(0, import_node_fs3.existsSync)(whereExe)) return null;
-  const result = (0, import_node_child_process2.spawnSync)(whereExe, [command], {
-    encoding: "utf8",
-    env,
-    windowsHide: true,
-    timeout: 3e3
+function listWorktrees(repoRoot) {
+  return runGit(repoRoot, ["worktree", "list", "--porcelain"]).split("\n\n").flatMap((entry) => {
+    const lines = entry.split("\n");
+    const path = lines.find((line) => line.startsWith("worktree "))?.slice("worktree ".length);
+    if (!path) return [];
+    return [
+      {
+        path: canonicalPathWithMissingTail(path),
+        branch: lines.find((line) => line.startsWith("branch "))?.slice("branch ".length).replace("refs/heads/", "") ?? null
+      }
+    ];
   });
-  if (result.error || result.status !== 0) return null;
-  for (const line of result.stdout.split(/\r?\n/)) {
-    const trimmed = line.trim();
-    if (!trimmed) continue;
-    if (isRunnableFile(trimmed)) return trimmed;
+}
+function resolveAuthorizedRepository(params, requireTrustedContext = false) {
+  const { repoPath } = commonRequest(params);
+  const repoRoot = resolveRepositoryRoot(repoPath);
+  const expectedRepoRoot = requireTrustedContext ? requiredString(params, "expectedRepoRoot") : optionalString(params, "expectedRepoRoot");
+  if (expectedRepoRoot && resolveRepositoryRoot((0, import_node_path4.resolve)(expectedRepoRoot)) !== repoRoot) {
+    throw new BindingSwitchGitError(
+      "repository_path_changed",
+      "The selected path now resolves to a different Git repository"
+    );
   }
-  return null;
+  const projectPath = requireTrustedContext ? requiredString(params, "projectPath") : optionalString(params, "projectPath");
+  if (!projectPath) return repoRoot;
+  const projectRoot = resolveRepositoryRoot((0, import_node_path4.resolve)(projectPath));
+  const registrations = listWorktrees(projectRoot);
+  const registered = registrations.find(({ path }) => path === repoRoot);
+  if (!registered) {
+    throw new BindingSwitchGitError(
+      "repository_path_not_authorized",
+      "The selected repository is not the Project checkout or one of its registered worktrees"
+    );
+  }
+  const mainRoot = registrations[0]?.path;
+  if (mainRoot && repoRoot !== mainRoot && !isPathContained(repoRoot, canonicalPathWithMissingTail(alanWorktreeRoot(mainRoot)))) {
+    throw new BindingSwitchGitError(
+      "repository_path_not_authorized",
+      "The selected worktree is outside the Alan-managed worktree directory"
+    );
+  }
+  return repoRoot;
 }
-function runCliProbeAsync(executable, env, args = ["--version"], timeoutMs = 3e3, spawnOptions) {
-  return new Promise((resolve6) => {
-    const isWin = (0, import_node_os3.platform)() === "win32";
-    let command = executable;
-    let commandArgs = args;
-    if (isWin && /\.(cmd|bat)$/i.test(executable)) {
-      command = env.ComSpec ?? process.env.ComSpec ?? "cmd.exe";
-      commandArgs = ["/d", "/s", "/c", executable, ...args];
+function readRawGit(repoRoot, args, code) {
+  const result = runGitResult(repoRoot, args);
+  if (result.status !== 0) {
+    throw new BindingSwitchGitError(
+      code,
+      (result.stderr || result.stdout || "Git inspection failed").trim()
+    );
+  }
+  return result.stdout;
+}
+function updateLengthPrefixed(hash, value2) {
+  const bytes = Buffer.from(value2, "utf8");
+  hash.update(String(bytes.byteLength));
+  hash.update("\0");
+  hash.update(bytes);
+  hash.update("\0");
+}
+function proposedTreeSha(repoRoot, headSha) {
+  const tempDir = (0, import_node_fs4.mkdtempSync)((0, import_node_path4.join)((0, import_node_os4.tmpdir)(), "alan-switch-index-"));
+  const indexPath = (0, import_node_path4.join)(tempDir, "index");
+  const options = { env: { GIT_INDEX_FILE: indexPath } };
+  try {
+    if (headSha) {
+      runGitWithOptions(repoRoot, ["read-tree", headSha], options, "git_status_unreadable");
+    } else {
+      runGitWithOptions(repoRoot, ["read-tree", "--empty"], options, "git_status_unreadable");
     }
-    const useShell = isWin && command === executable && !/[\\/]/.test(executable);
-    const closeStdin = spawnOptions?.closeStdin === true;
-    let child;
+    runGitWithOptions(repoRoot, ["add", "--all"], options, "git_status_unreadable");
+    const treeSha = runGitWithOptions(repoRoot, ["write-tree"], options, "git_status_unreadable");
+    assertCommitSha(treeSha, "proposedTreeSha");
+    return treeSha;
+  } finally {
+    (0, import_node_fs4.rmSync)(tempDir, { recursive: true, force: true });
+  }
+}
+function statusFingerprint(repoRoot, porcelain, proposedTree) {
+  const unstagedPatch = readRawGit(
+    repoRoot,
+    ["diff", "--binary", "--full-index", "--no-ext-diff", "--submodule=log"],
+    "git_status_unreadable"
+  );
+  const stagedPatch = readRawGit(
+    repoRoot,
+    ["diff", "--cached", "--binary", "--full-index", "--no-ext-diff", "--submodule=log"],
+    "git_status_unreadable"
+  );
+  const untrackedRaw = readRawGit(
+    repoRoot,
+    ["ls-files", "--others", "--exclude-standard", "-z"],
+    "git_status_unreadable"
+  );
+  const untrackedPaths = untrackedRaw.split("\0").filter(Boolean);
+  const hash = (0, import_node_crypto.createHash)("sha256");
+  updateLengthPrefixed(hash, porcelain);
+  updateLengthPrefixed(hash, proposedTree);
+  updateLengthPrefixed(hash, unstagedPatch);
+  updateLengthPrefixed(hash, stagedPatch);
+  for (let index = 0; index < untrackedPaths.length; index += 128) {
+    const paths = untrackedPaths.slice(index, index + 128);
+    const hashes = readRawGit(
+      repoRoot,
+      ["hash-object", "--no-filters", "--", ...paths],
+      "git_status_unreadable"
+    );
+    updateLengthPrefixed(hash, paths.join("\0"));
+    updateLengthPrefixed(hash, hashes);
+  }
+  return hash.digest("hex");
+}
+function readStatus(repoRoot) {
+  const headResult = runGitResult(repoRoot, ["rev-parse", "HEAD"]);
+  const headSha = headResult.status === 0 ? headResult.stdout.trim() || null : null;
+  const branchResult = runGitResult(repoRoot, ["branch", "--show-current"]);
+  const branch = branchResult.status === 0 ? branchResult.stdout.trim() || null : null;
+  const proposedTree = proposedTreeSha(repoRoot, headSha);
+  const porcelain = runGit(repoRoot, ["status", "--porcelain=v1", "-z", "--untracked-files=all"]);
+  const displayStatus = runGit(repoRoot, ["status", "--porcelain=v1", "--untracked-files=all"]);
+  const upstreamResult = runGitResult(repoRoot, [
+    "rev-parse",
+    "--abbrev-ref",
+    "--symbolic-full-name",
+    "@{upstream}"
+  ]);
+  const upstream = upstreamResult.status === 0 ? upstreamResult.stdout.trim() || null : null;
+  let ahead = null;
+  let behind = null;
+  if (upstream) {
+    const counts = runGit(repoRoot, [
+      "rev-list",
+      "--left-right",
+      "--count",
+      `${upstream}...HEAD`
+    ]).split(/\s+/);
+    const parsedBehind = Number.parseInt(counts[0] ?? "", 10);
+    const parsedAhead = Number.parseInt(counts[1] ?? "", 10);
+    behind = Number.isNaN(parsedBehind) ? null : parsedBehind;
+    ahead = Number.isNaN(parsedAhead) ? null : parsedAhead;
+  }
+  return {
+    repoRoot,
+    branch,
+    headSha,
+    dirty: porcelain.length > 0,
+    filesChanged: displayStatus ? displayStatus.split("\n").length : 0,
+    ahead,
+    behind,
+    hasUpstream: upstream !== null,
+    upstream,
+    statusFingerprint: statusFingerprint(repoRoot, porcelain, proposedTree),
+    proposedTreeSha: proposedTree
+  };
+}
+function assertExpectedBranch(status, expectedBranch) {
+  assertValidBranch(expectedBranch);
+  if (status.branch !== expectedBranch) {
+    throw new BindingSwitchGitError(
+      "source_changed_since_approval",
+      `Source branch changed from ${expectedBranch} to ${status.branch ?? "detached HEAD"}`
+    );
+  }
+}
+function assertSourcePreconditions(status, expectedHeadSha, expectedStatusFingerprint, expectedBranch) {
+  assertCommitSha(expectedHeadSha, "expectedHeadSha");
+  if (expectedBranch !== void 0) assertExpectedBranch(status, expectedBranch);
+  if (status.headSha !== expectedHeadSha) {
+    throw new BindingSwitchGitError(
+      "source_changed_since_approval",
+      `Source HEAD changed from ${expectedHeadSha} to ${status.headSha ?? "unborn"}`
+    );
+  }
+  if (expectedStatusFingerprint !== void 0 && status.statusFingerprint !== expectedStatusFingerprint) {
+    throw new BindingSwitchGitError(
+      "source_changed_since_approval",
+      "Source files changed after the migration inspection"
+    );
+  }
+}
+function commitHasSwitchTrailers(repoRoot, switchId, repoKey) {
+  const message = runGitResult(repoRoot, ["show", "-s", "--format=%B", "HEAD"]);
+  if (message.status !== 0) return false;
+  const lines = message.stdout.split(/\r?\n/);
+  return lines.includes(`Alan-Switch-Id: ${switchId}`) && lines.includes(`Alan-Repository-Id: ${repoKey}`);
+}
+async function checkpoint(params) {
+  const { switchId, repoKey } = commonRequest(params);
+  const repoRoot = resolveAuthorizedRepository(params, true);
+  const expectedHeadSha = requiredString(params, "expectedHeadSha");
+  const expectedStatusFingerprint = requiredString(params, "expectedStatusFingerprint");
+  const expectedProposedTreeSha = requiredString(params, "expectedProposedTreeSha");
+  assertCommitSha(expectedProposedTreeSha, "expectedProposedTreeSha");
+  const expectedBranch = requiredString(params, "expectedBranch");
+  const status = readStatus(repoRoot);
+  assertExpectedBranch(status, expectedBranch);
+  if (commitHasSwitchTrailers(repoRoot, switchId, repoKey)) {
+    if (!status.headSha) {
+      throw new BindingSwitchGitError("source_head_unreadable", "Checkpoint HEAD is unreadable");
+    }
+    const expectedRef2 = `refs/heads/${expectedBranch}`;
+    const baseline2 = createCheckpointIndexBaseline(repoRoot, status.headSha);
+    let locks2 = null;
     try {
-      child = (0, import_node_child_process2.spawn)(command, commandArgs, {
-        env,
-        shell: useShell,
-        windowsHide: isWin ? true : void 0,
-        timeout: timeoutMs,
-        stdio: closeStdin ? ["pipe", "pipe", "pipe"] : void 0
-      });
-    } catch (error) {
-      resolve6({ status: null, stdout: "", stderr: "", error });
-      return;
+      locks2 = acquireCheckpointRepositoryLocks(repoRoot);
+      assertCheckpointHead(repoRoot, expectedRef2, status.headSha);
+      installCheckpointIndexBaseline(locks2, baseline2.indexPath);
+      return { repoRoot, sha: status.headSha, replayed: true };
+    } finally {
+      if (locks2) releaseCheckpointRepositoryLocks(locks2);
+      (0, import_node_fs4.rmSync)(baseline2.tempDir, { recursive: true, force: true });
     }
-    if (closeStdin) {
-      child.stdin?.end();
+  }
+  assertSourcePreconditions(status, expectedHeadSha, expectedStatusFingerprint, expectedBranch);
+  if (status.proposedTreeSha !== expectedProposedTreeSha) {
+    throw new BindingSwitchGitError(
+      "source_changed_since_approval",
+      "The proposed checkpoint tree changed after migration approval"
+    );
+  }
+  if (!status.dirty) {
+    if (!status.headSha) {
+      throw new BindingSwitchGitError("source_head_unreadable", "Source HEAD is unreadable");
     }
-    let stdout = "";
-    let stderr = "";
-    child.stdout?.setEncoding("utf8").on("data", (chunk) => {
-      stdout += chunk;
-    });
-    child.stderr?.setEncoding("utf8").on("data", (chunk) => {
-      stderr += chunk;
-    });
-    child.once("error", (error) => resolve6({ status: null, stdout, stderr, error }));
-    child.once(
-      "close",
-      (status, signal) => resolve6({ status, stdout, stderr, signal: signal ?? null })
+    return { repoRoot, sha: status.headSha, replayed: true };
+  }
+  const commitMessage = requiredCommitMessage(params).trim();
+  const authorName = requiredString(params, "authorName");
+  const authorEmail = requiredString(params, "authorEmail");
+  const expectedHeadTree = runGit(
+    repoRoot,
+    ["rev-parse", `${expectedHeadSha}^{tree}`],
+    "source_head_unreadable"
+  );
+  if (expectedHeadTree === expectedProposedTreeSha) {
+    throw new BindingSwitchGitError(
+      "checkpoint_empty",
+      "The inspected changes did not produce a checkpoint commit"
+    );
+  }
+  const proposedTreeObject = runGitResult(repoRoot, [
+    "cat-file",
+    "-e",
+    `${expectedProposedTreeSha}^{tree}`
+  ]);
+  if (proposedTreeObject.status !== 0) {
+    throw new BindingSwitchGitError(
+      "checkpoint_tree_unavailable",
+      "The approved checkpoint tree is no longer available"
+    );
+  }
+  await waitForCheckpointTestBarrier();
+  const currentBranch = runGit(repoRoot, ["branch", "--show-current"]);
+  const currentHead = runGit(repoRoot, ["rev-parse", "HEAD"], "source_head_unreadable");
+  if (currentBranch !== expectedBranch || currentHead !== expectedHeadSha) {
+    throw new BindingSwitchGitError(
+      "source_changed_since_approval",
+      "Source HEAD or branch changed during checkpoint preparation"
+    );
+  }
+  const message = `${commitMessage}
+
+Alan-Switch-Id: ${switchId}
+Alan-Repository-Id: ${repoKey}`;
+  const sha = runGitWithOptions(
+    repoRoot,
+    ["commit-tree", expectedProposedTreeSha, "-p", expectedHeadSha],
+    {
+      env: {
+        GIT_AUTHOR_EMAIL: authorEmail,
+        GIT_AUTHOR_NAME: authorName,
+        GIT_COMMITTER_EMAIL: authorEmail,
+        GIT_COMMITTER_NAME: authorName
+      },
+      input: `${message}
+`
+    },
+    "checkpoint_commit_failed"
+  );
+  assertCommitSha(sha, "checkpointSha");
+  const expectedRef = `refs/heads/${expectedBranch}`;
+  const currentRef = runGit(
+    repoRoot,
+    ["symbolic-ref", "-q", "HEAD"],
+    "source_changed_since_approval"
+  );
+  if (currentRef !== expectedRef) {
+    throw new BindingSwitchGitError(
+      "source_changed_since_approval",
+      "Source branch changed during checkpoint preparation"
+    );
+  }
+  await waitForCheckpointFinalizeTestBarrier();
+  const baseline = createCheckpointIndexBaseline(repoRoot, sha);
+  let locks = null;
+  let refAdvanced = false;
+  let indexInstalled = false;
+  try {
+    locks = acquireCheckpointRepositoryLocks(repoRoot);
+    assertCheckpointHead(repoRoot, expectedRef, expectedHeadSha);
+    releaseCheckpointHeadLock(locks);
+    runGit(
+      repoRoot,
+      ["update-ref", expectedRef, sha, expectedHeadSha],
+      "source_changed_since_approval"
     );
-  });
+    refAdvanced = true;
+    acquireCheckpointHeadLock(locks);
+    assertCheckpointHead(repoRoot, expectedRef, sha);
+    installCheckpointIndexBaseline(locks, baseline.indexPath);
+    indexInstalled = true;
+    return { repoRoot, sha, replayed: false };
+  } finally {
+    if (refAdvanced && !indexInstalled) {
+      if (locks) releaseCheckpointHeadLock(locks);
+      runGitResult(repoRoot, ["update-ref", expectedRef, expectedHeadSha, sha]);
+    }
+    if (locks) releaseCheckpointRepositoryLocks(locks);
+    (0, import_node_fs4.rmSync)(baseline.tempDir, { recursive: true, force: true });
+  }
+}
+function resolveRemoteBranch(repoRoot, params) {
+  const expectedBranch = requiredString(params, "expectedBranch");
+  const requestedBranch = optionalString(params, "branch");
+  if (requestedBranch && requestedBranch !== expectedBranch) {
+    throw new BindingSwitchGitError("invalid_git_request", "branch must match expectedBranch");
+  }
+  const currentBranch = runGit(repoRoot, ["branch", "--show-current"]);
+  const branch = expectedBranch;
+  assertValidBranch(branch);
+  if (currentBranch !== expectedBranch) {
+    throw new BindingSwitchGitError(
+      "source_changed_since_approval",
+      `Source branch changed from ${expectedBranch} to ${currentBranch || "detached HEAD"}`
+    );
+  }
+  const { remote } = verifiedRemote(repoRoot, params, true);
+  return { branch, remote };
+}
+async function push(params) {
+  const repoRoot = resolveAuthorizedRepository(params, true);
+  const expectedHeadSha = requiredString(params, "expectedHeadSha");
+  const expectedBranch = requiredString(params, "expectedBranch");
+  const status = readStatus(repoRoot);
+  assertSourcePreconditions(status, expectedHeadSha, void 0, expectedBranch);
+  if (status.dirty) {
+    throw new BindingSwitchGitError(
+      "source_dirty_after_checkpoint",
+      "The source has uncommitted changes and cannot be published"
+    );
+  }
+  const { branch, remote } = resolveRemoteBranch(repoRoot, params);
+  const latest = readStatus(repoRoot);
+  assertSourcePreconditions(latest, expectedHeadSha, void 0, expectedBranch);
+  if (latest.dirty) {
+    throw new BindingSwitchGitError(
+      "source_dirty_after_checkpoint",
+      "The source has uncommitted changes and cannot be published"
+    );
+  }
+  const before = await runNetworkGit(
+    repoRoot,
+    ["ls-remote", "--heads", remote, `refs/heads/${branch}`],
+    "git_remote_unavailable"
+  );
+  const remoteBefore = before.trim().split(/\s+/)[0] || null;
+  await runNetworkGit(
+    repoRoot,
+    ["push", remote, `${expectedHeadSha}:refs/heads/${expectedBranch}`],
+    "git_push_failed"
+  );
+  const remoteHead = (await runNetworkGit(
+    repoRoot,
+    ["ls-remote", "--heads", remote, `refs/heads/${branch}`],
+    "push_verification_failed"
+  )).split(/\s+/)[0]?.trim();
+  if (remoteHead !== expectedHeadSha) {
+    throw new BindingSwitchGitError(
+      "push_verification_failed",
+      `Remote branch ${branch} is at ${remoteHead || "an unreadable SHA"}, expected ${expectedHeadSha}`
+    );
+  }
+  const afterPush = readStatus(repoRoot);
+  if (afterPush.headSha !== expectedHeadSha || afterPush.branch !== expectedBranch || afterPush.dirty || afterPush.statusFingerprint !== latest.statusFingerprint) {
+    throw new BindingSwitchGitError(
+      "source_changed_since_approval",
+      "The source changed while the approved commit was being published",
+      {
+        published: {
+          pushedSha: expectedHeadSha,
+          branch,
+          remote,
+          replayed: remoteBefore === expectedHeadSha
+        }
+      }
+    );
+  }
+  return {
+    repoRoot,
+    pushedSha: expectedHeadSha,
+    branch,
+    remote,
+    replayed: remoteBefore === expectedHeadSha
+  };
 }
-function runCliVersionProbeAsync(executable, env, args = ["--version"], timeoutMs = 3e3) {
-  return runCliProbeAsync(executable, env, args, timeoutMs);
+async function fetchPublishedBranch(repoRoot, branch, expectedSha, params) {
+  assertValidBranch(branch);
+  assertCommitSha(expectedSha, "expectedSha");
+  const { remote } = verifiedRemote(repoRoot, params, false);
+  await runNetworkGit(
+    repoRoot,
+    ["fetch", "--no-tags", remote, `refs/heads/${branch}`],
+    "git_fetch_failed"
+  );
+  const fetchedSha = runGit(repoRoot, ["rev-parse", "FETCH_HEAD"], "target_sha_unavailable");
+  if (fetchedSha !== expectedSha) {
+    throw new BindingSwitchGitError(
+      "target_sha_mismatch",
+      `Fetched ${branch} at ${fetchedSha}, expected the published SHA ${expectedSha}`
+    );
+  }
+  const commit = runGitResult(repoRoot, ["cat-file", "-e", `${expectedSha}^{commit}`]);
+  if (commit.status !== 0) {
+    throw new BindingSwitchGitError(
+      "target_sha_unavailable",
+      `The published SHA ${expectedSha} is not available in the destination repository`
+    );
+  }
+  return { fetchedSha, remote };
 }
-function pathSeparator() {
-  return (0, import_node_os3.platform)() === "win32" ? ";" : ":";
+async function fetchBranch(params) {
+  const repoRoot = resolveAuthorizedRepository(params, true);
+  const branch = requiredString(params, "branch");
+  const expectedSha = requiredString(params, "expectedSha");
+  const { fetchedSha, remote } = await fetchPublishedBranch(repoRoot, branch, expectedSha, params);
+  return { repoRoot, fetchedSha, branch, remote };
 }
-function splitPath2(pathValue) {
-  if (!pathValue) return [];
-  return pathValue.split(pathSeparator()).filter(Boolean);
+function isAncestor(repoRoot, ancestor, descendant) {
+  return runGitResult(repoRoot, ["merge-base", "--is-ancestor", ancestor, descendant]).status === 0;
 }
-function isRunnableFile(path) {
-  if (!(0, import_node_fs3.existsSync)(path)) return false;
-  if ((0, import_node_os3.platform)() === "win32") return true;
-  try {
-    (0, import_node_fs3.accessSync)(path, import_node_fs3.constants.X_OK);
-    return true;
-  } catch {
-    return false;
+function assertCleanTarget(repoRoot) {
+  if (readStatus(repoRoot).dirty) {
+    throw new BindingSwitchGitError(
+      "target_checkout_dirty",
+      "The destination checkout has uncommitted changes"
+    );
   }
 }
-function windowsCommandCandidates(command, pathExt) {
-  const trimmed = command.trim();
-  if (!trimmed) return [];
-  const hasExtension = /\.[a-z0-9]+$/i.test(trimmed);
-  if (hasExtension) return [trimmed];
-  const extensions = pathExt.split(";").map((ext) => ext.trim()).filter(Boolean);
-  return [trimmed, ...extensions.map((ext) => `${trimmed}${ext}`)];
+function assertBranchAvailableAtPath(repoRoot, branch, allowedPath) {
+  const canonicalAllowedPath = canonicalPathWithMissingTail(allowedPath);
+  const conflicting = listWorktrees(repoRoot).find(
+    (worktree) => worktree.branch === branch && worktree.path !== canonicalAllowedPath
+  );
+  if (conflicting) {
+    throw new BindingSwitchGitError(
+      "target_branch_in_use",
+      `Branch ${branch} is already checked out at ${conflicting.path}`
+    );
+  }
 }
-function augmentCliPath2(env) {
-  const home = env.HOME || env.USERPROFILE || (0, import_node_os3.homedir)();
-  const isWin = (0, import_node_os3.platform)() === "win32";
-  const extraPaths = isWin ? [
-    (0, import_node_path3.join)(home, "AppData", "Roaming", "npm"),
-    (0, import_node_path3.join)(home, "AppData", "Local", "Programs", "Microsoft", "WindowsApps"),
-    (0, import_node_path3.join)(home, ".local", "bin"),
-    "C:\\Program Files\\nodejs",
-    "C:\\Program Files\\Git\\cmd"
-  ] : [
-    (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"),
-    "/opt/homebrew/bin",
-    "/usr/local/bin"
-  ];
-  const basePath = env.PATH ?? "";
-  const existing = new Set(splitPath2(basePath));
-  const missing = extraPaths.filter((dir) => !existing.has(dir));
-  if (missing.length === 0) return env;
+function advanceBranchAtCheckout(checkoutRoot, branch, targetSha) {
+  const before = readStatus(checkoutRoot);
+  if (before.branch === branch && before.headSha === targetSha) return true;
+  assertBranchAvailableAtPath(checkoutRoot, branch, checkoutRoot);
+  const branchExists = runGitResult(checkoutRoot, ["show-ref", "--verify", "--quiet", `refs/heads/${branch}`]).status === 0;
+  if (branchExists) {
+    const branchHead = runGit(checkoutRoot, ["rev-parse", `refs/heads/${branch}`]);
+    if (!isAncestor(checkoutRoot, branchHead, targetSha)) {
+      throw new BindingSwitchGitError(
+        "target_branch_diverged",
+        `Local branch ${branch} cannot fast-forward to the published SHA`
+      );
+    }
+    if (before.branch !== branch) {
+      runGit(checkoutRoot, ["switch", branch], "target_checkout_failed");
+    }
+  } else {
+    runGit(checkoutRoot, ["switch", "-c", branch, targetSha], "target_checkout_failed");
+  }
+  const currentHead = runGit(checkoutRoot, ["rev-parse", "HEAD"]);
+  if (currentHead !== targetSha) {
+    if (!isAncestor(checkoutRoot, currentHead, targetSha)) {
+      throw new BindingSwitchGitError(
+        "target_branch_diverged",
+        `Local branch ${branch} cannot fast-forward to the published SHA`
+      );
+    }
+    runGit(checkoutRoot, ["merge", "--ff-only", targetSha], "target_fast_forward_failed");
+  }
+  const verified = readStatus(checkoutRoot);
+  if (verified.branch !== branch || verified.headSha !== targetSha) {
+    throw new BindingSwitchGitError(
+      "target_verification_failed",
+      "The destination checkout did not land on the published branch and SHA"
+    );
+  }
+  return false;
+}
+async function prepareCheckout(params) {
+  const repoRoot = resolveAuthorizedRepository(params, true);
+  const branch = requiredString(params, "branch");
+  const targetSha = requiredString(params, "targetSha");
+  await fetchPublishedBranch(repoRoot, branch, targetSha, params);
+  assertCleanTarget(repoRoot);
+  const replayed = advanceBranchAtCheckout(repoRoot, branch, targetSha);
   return {
-    ...env,
-    PATH: missing.length > 0 ? `${missing.join(pathSeparator())}${pathSeparator()}${basePath}` : basePath
+    repoRoot,
+    path: repoRoot,
+    branch,
+    headSha: targetSha,
+    replayed
   };
 }
-function resolveCliExecutable(command, env = getDaemonCliEnvironment()) {
-  const trimmed = command.trim();
-  if (!trimmed) return null;
-  const cached = getCachedResolvedCli(trimmed);
-  if (cached === null) return null;
-  if (cached && isRunnableFile(cached)) return cached;
-  if ((trimmed.includes("/") || trimmed.includes("\\")) && isRunnableFile(trimmed)) {
-    cacheResolvedCli(trimmed, trimmed);
-    return trimmed;
+async function prepareWorktree(params) {
+  const repoRoot = resolveAuthorizedRepository(params, true);
+  const registrations = listWorktrees(repoRoot);
+  const projectRoot = registrations[0]?.path;
+  if (!projectRoot || projectRoot !== repoRoot) {
+    throw new BindingSwitchGitError(
+      "project_checkout_required",
+      "Worktree preparation requires the Project's main checkout"
+    );
   }
-  const enriched = augmentCliPath2(env);
-  const home = enriched.HOME || enriched.USERPROFILE || (0, import_node_os3.homedir)();
-  const isWin = (0, import_node_os3.platform)() === "win32";
-  const pathExt = enriched.PATHEXT ?? (isWin ? ".EXE;.CMD;.BAT;.COM" : "");
-  const commandNames = [trimmed, ...CLI_COMMAND_ALIASES[trimmed] ?? []];
-  const names = commandNames.flatMap(
-    (name) => isWin ? windowsCommandCandidates(name, pathExt) : [name]
+  const worktreePath = (0, import_node_path4.resolve)(requiredString(params, "worktreePath"));
+  const managedRoot = alanWorktreeRoot(projectRoot);
+  const pathError = "The destination worktree path is outside the Alan-managed worktree directory";
+  const intendedManagedRoot = (0, import_node_path4.join)(
+    import_node_fs4.realpathSync.native((0, import_node_path4.dirname)(managedRoot)),
+    (0, import_node_path4.basename)(managedRoot)
   );
-  const candidates = [];
-  for (const name of names) {
-    if (name.includes("/") || name.includes("\\")) {
-      candidates.push(name);
-      continue;
-    }
-    for (const dir of splitPath2(enriched.PATH)) {
-      candidates.push((0, import_node_path3.join)(dir, name));
+  if (canonicalPathWithMissingTail(managedRoot) !== intendedManagedRoot) {
+    throw new BindingSwitchGitError("worktree_path_not_authorized", pathError);
+  }
+  assertCanonicalPathContained(
+    worktreePath,
+    managedRoot,
+    "worktree_path_not_authorized",
+    pathError
+  );
+  const canonicalWorktreePath = canonicalPathWithMissingTail(worktreePath);
+  if (canonicalWorktreePath === canonicalPathWithMissingTail(managedRoot)) {
+    throw new BindingSwitchGitError("worktree_path_not_authorized", pathError);
+  }
+  const branch = requiredString(params, "branch");
+  const targetSha = requiredString(params, "targetSha");
+  await fetchPublishedBranch(repoRoot, branch, targetSha, params);
+  const refreshed = listWorktrees(repoRoot);
+  const registeredAtPath = refreshed.find(({ path }) => path === canonicalWorktreePath);
+  const registeredForBranch = refreshed.find(({ branch: value2 }) => value2 === branch);
+  if (registeredAtPath) {
+    if (registeredAtPath.branch !== branch) {
+      throw new BindingSwitchGitError(
+        "worktree_path_conflict",
+        "The destination path is registered to a different branch"
+      );
     }
-    candidates.push((0, import_node_path3.join)(home, ".local", "bin", name), (0, import_node_path3.join)(home, ".local", "node", "bin", name));
-    if (!isWin) {
-      candidates.push((0, import_node_path3.join)("/opt/homebrew/bin", name), (0, import_node_path3.join)("/usr/local/bin", name));
-    } else {
-      candidates.push((0, import_node_path3.join)(home, "AppData", "Roaming", "npm", name));
+    assertCleanTarget(worktreePath);
+    const replayed = advanceBranchAtCheckout(worktreePath, branch, targetSha);
+    return {
+      repoRoot: worktreePath,
+      path: worktreePath,
+      branch,
+      headSha: targetSha,
+      replayed
+    };
+  }
+  if (registeredForBranch) {
+    throw new BindingSwitchGitError(
+      "target_branch_in_use",
+      `Branch ${branch} is already checked out at ${registeredForBranch.path}`
+    );
+  }
+  if ((0, import_node_fs4.existsSync)(worktreePath)) {
+    throw new BindingSwitchGitError(
+      "worktree_path_conflict",
+      "The destination worktree path already exists and is not registered"
+    );
+  }
+  const branchExists = runGitResult(repoRoot, ["show-ref", "--verify", "--quiet", `refs/heads/${branch}`]).status === 0;
+  if (branchExists) {
+    const branchHead = runGit(repoRoot, ["rev-parse", `refs/heads/${branch}`]);
+    if (!isAncestor(repoRoot, branchHead, targetSha)) {
+      throw new BindingSwitchGitError(
+        "target_branch_diverged",
+        `Local branch ${branch} cannot fast-forward to the published SHA`
+      );
     }
   }
-  const seen = /* @__PURE__ */ new Set();
-  for (const candidate of candidates) {
-    if (seen.has(candidate)) continue;
-    seen.add(candidate);
-    if (isRunnableFile(candidate)) {
-      cacheResolvedCli(trimmed, candidate);
-      return candidate;
+  (0, import_node_fs4.mkdirSync)((0, import_node_path4.dirname)(worktreePath), { recursive: true });
+  if (branchExists) {
+    runGit(repoRoot, ["worktree", "add", worktreePath, branch], "worktree_prepare_failed");
+    const currentHead = runGit(worktreePath, ["rev-parse", "HEAD"]);
+    if (currentHead !== targetSha) {
+      runGit(worktreePath, ["merge", "--ff-only", targetSha], "target_fast_forward_failed");
     }
+  } else {
+    runGit(
+      repoRoot,
+      ["worktree", "add", "-b", branch, worktreePath, targetSha],
+      "worktree_prepare_failed"
+    );
   }
-  const viaWhere = resolveViaWhere(trimmed, enriched);
-  if (viaWhere) {
-    cacheResolvedCli(trimmed, viaWhere);
-    return viaWhere;
+  const createdRoot = resolveRepositoryRoot(worktreePath);
+  assertCanonicalPathContained(createdRoot, managedRoot, "worktree_path_not_authorized", pathError);
+  if (createdRoot !== import_node_fs4.realpathSync.native(worktreePath)) {
+    throw new BindingSwitchGitError(
+      "worktree_path_changed",
+      "The destination worktree resolved to an unexpected path after creation"
+    );
   }
-  cacheResolvedCli(trimmed, null);
-  return null;
-}
-function normalizeDiscoverableProvider(provider) {
-  const alias = PROVIDER_ALIASES[provider];
-  if (alias) return alias;
-  if (provider in PROVIDER_CLI_COMMANDS) {
-    return provider;
+  const verified = readStatus(createdRoot);
+  if (verified.branch !== branch || verified.headSha !== targetSha) {
+    throw new BindingSwitchGitError(
+      "target_verification_failed",
+      "The destination worktree did not land on the published branch and SHA"
+    );
   }
-  return null;
+  return {
+    repoRoot: worktreePath,
+    path: worktreePath,
+    branch,
+    headSha: targetSha,
+    replayed: false
+  };
 }
-function resolveProviderCliCommand(provider, env = getDaemonCliEnvironment()) {
-  const normalized = normalizeDiscoverableProvider(provider);
-  if (!normalized) return null;
-  const spec = PROVIDER_CLI_COMMANDS[normalized];
-  const override = spec.envVars.map((name) => process.env[name]?.trim() || env[name]?.trim()).find(Boolean);
-  if (override) {
-    const resolved2 = resolveCliExecutable(override, env) ?? (isRunnableFile(override) ? override : null);
-    if (resolved2) cacheResolvedCli(spec.command, resolved2);
-    return resolved2;
+function verifyHead(params) {
+  const repoRoot = resolveAuthorizedRepository(params, true);
+  const expectedSha = requiredString(params, "expectedSha");
+  assertCommitSha(expectedSha, "expectedSha");
+  assertCleanTarget(repoRoot);
+  const headSha = runGit(repoRoot, ["rev-parse", "HEAD"], "target_head_unreadable");
+  if (headSha !== expectedSha) {
+    throw new BindingSwitchGitError(
+      "verify_head_mismatch",
+      `Destination HEAD is ${headSha}, expected ${expectedSha}`
+    );
   }
-  const resolved = resolveCliExecutable(spec.command, env);
-  if (resolved) cacheResolvedCli(spec.command, resolved);
-  return resolved;
-}
-function resolveBackendRuntimeCommand(backendKind, env = getDaemonCliEnvironment()) {
-  if (!backendKind) return void 0;
-  const command = BACKEND_CLI_COMMANDS[backendKind];
-  if (!command) return void 0;
-  const cached = getCachedResolvedCli(command);
-  if (cached === null) return void 0;
-  if (cached && isRunnableFile(cached)) return cached;
-  const spec = Object.values(PROVIDER_CLI_COMMANDS).find((entry) => entry.command === command);
-  const envOverride = spec ? spec.envVars.map((name) => env[name]?.trim()).find(Boolean) : void 0;
-  const resolved = resolveCliExecutable(envOverride?.trim() || command, env);
-  cacheResolvedCli(command, resolved);
-  return resolved ?? void 0;
-}
-function invalidateResolvedCli(command) {
-  const trimmed = command.trim();
-  if (trimmed) {
-    resolvedCliCache.delete(trimmed);
-    negativeResolutionExpiry.delete(trimmed);
+  return { repoRoot, headSha, verified: true };
+}
+function statusBindingSwitchGit(params) {
+  return readStatus(resolveAuthorizedRepository(params));
+}
+async function executeBindingSwitchGitRpc(method, params) {
+  switch (method) {
+    case "git.status":
+      return statusBindingSwitchGit(params);
+    case "git.checkpoint":
+      return checkpoint(params);
+    case "git.push":
+      return push(params);
+    case "git.fetch":
+      return fetchBranch(params);
+    case "git.prepare_checkout":
+      return prepareCheckout(params);
+    case "git.prepare_worktree":
+      return prepareWorktree(params);
+    case "git.verify_head":
+      return verifyHead(params);
   }
 }
-function revalidateBackendRuntimeCommand(backendKind, env = getDaemonCliEnvironment()) {
-  if (!backendKind) return void 0;
-  const command = BACKEND_CLI_COMMANDS[backendKind];
-  if (!command) return void 0;
-  invalidateResolvedCli(command);
-  const spec = Object.values(PROVIDER_CLI_COMMANDS).find((entry) => entry.command === command);
-  const envOverride = spec ? spec.envVars.map((name) => env[name]?.trim()).find(Boolean) : void 0;
-  if (envOverride) invalidateResolvedCli(envOverride);
-  return resolveBackendRuntimeCommand(backendKind, env);
-}
 
 // src/cli-ensure-install.ts
+var import_node_child_process4 = require("child_process");
+var import_node_os5 = require("os");
 var CLI_RUNTIME_VERSIONS_ENV = "ALAN_CLI_RUNTIME_VERSIONS";
 var INSTALLABLE_PROVIDER_PACKAGES = {
   claude_cli: { npmPackage: "@anthropic-ai/claude-code", command: "claude", label: "Claude Code" },
@@ -22974,11 +24132,11 @@ function pinnedVersion(npmPackage) {
   return "latest";
 }
 function runNpmInstall(installSpec, env, timeoutMs) {
-  return new Promise((resolve6) => {
-    const isWin = (0, import_node_os4.platform)() === "win32";
+  return new Promise((resolve7) => {
+    const isWin = (0, import_node_os5.platform)() === "win32";
     let child;
     try {
-      child = (0, import_node_child_process3.spawn)("npm", ["install", "-g", installSpec], {
+      child = (0, import_node_child_process4.spawn)("npm", ["install", "-g", installSpec], {
         env,
         shell: isWin,
         windowsHide: isWin ? true : void 0,
@@ -22986,7 +24144,7 @@ function runNpmInstall(installSpec, env, timeoutMs) {
         stdio: ["ignore", "pipe", "pipe"]
       });
     } catch (error) {
-      resolve6({ status: null, stdout: "", stderr: "", error });
+      resolve7({ status: null, stdout: "", stderr: "", error });
       return;
     }
     let stdout = "";
@@ -22997,10 +24155,10 @@ function runNpmInstall(installSpec, env, timeoutMs) {
     child.stderr?.setEncoding("utf8").on("data", (chunk) => {
       stderr += chunk;
     });
-    child.once("error", (error) => resolve6({ status: null, stdout, stderr, error }));
+    child.once("error", (error) => resolve7({ status: null, stdout, stderr, error }));
     child.once(
       "close",
-      (status, signal) => resolve6({
+      (status, signal) => resolve7({
         status,
         stdout,
         stderr,
@@ -23045,14 +24203,14 @@ function ensureProviderCliInstalled(backendKind, options) {
 }
 
 // src/computer-readiness.ts
-var import_node_fs5 = require("fs");
+var import_node_fs6 = require("fs");
 
 // src/runtime-config.ts
-var import_node_fs4 = require("fs");
-var import_node_os5 = require("os");
-var import_node_path4 = require("path");
-var DEFAULT_AGENT_DIR = (0, import_node_path4.join)((0, import_node_os5.homedir)(), ".alan", "agent");
-var LEGACY_AGENT_DIR = (0, import_node_path4.join)((0, import_node_os5.homedir)(), ".aiden", "agent");
+var import_node_fs5 = require("fs");
+var import_node_os6 = require("os");
+var import_node_path5 = require("path");
+var DEFAULT_AGENT_DIR = (0, import_node_path5.join)((0, import_node_os6.homedir)(), ".alan", "agent");
+var LEGACY_AGENT_DIR = (0, import_node_path5.join)((0, import_node_os6.homedir)(), ".aiden", "agent");
 var AGENT_CONFIG_KEYS = /* @__PURE__ */ new Map([
   ["apiUrl", "string"],
   ["wsUrl", "string"],
@@ -23074,9 +24232,9 @@ function sanitizeAgentConfig(config) {
 }
 function isValidAgentConfig(configPath) {
   try {
-    const stat = (0, import_node_fs4.lstatSync)(configPath);
+    const stat = (0, import_node_fs5.lstatSync)(configPath);
     if (!stat.isFile() || stat.isSymbolicLink()) return false;
-    const parsed = JSON.parse((0, import_node_fs4.readFileSync)(configPath, "utf8"));
+    const parsed = JSON.parse((0, import_node_fs5.readFileSync)(configPath, "utf8"));
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return false;
     const entries = Object.entries(parsed);
     return entries.some(([key]) => AGENT_CONFIG_KEYS.has(key)) && entries.every(([key, value2]) => {
@@ -23092,36 +24250,36 @@ function migrateLegacyAgentConfig(input) {
   const alanBaseDir = input?.alanBaseDir ?? DEFAULT_AGENT_DIR;
   const legacyBaseDir = input?.legacyBaseDir ?? LEGACY_AGENT_DIR;
   const fileName = resolveAgentConfigFileName(profile);
-  const legacyPath = (0, import_node_path4.join)(legacyBaseDir, fileName);
-  const alanPath = (0, import_node_path4.join)(alanBaseDir, fileName);
-  if ((0, import_node_fs4.existsSync)(alanPath) || !isValidAgentConfig(legacyPath)) return false;
+  const legacyPath = (0, import_node_path5.join)(legacyBaseDir, fileName);
+  const alanPath = (0, import_node_path5.join)(alanBaseDir, fileName);
+  if ((0, import_node_fs5.existsSync)(alanPath) || !isValidAgentConfig(legacyPath)) return false;
   let copied = false;
   try {
-    const sourceDirectoryStat = (0, import_node_fs4.lstatSync)(legacyBaseDir);
-    const sourceFileStat = (0, import_node_fs4.lstatSync)(legacyPath);
+    const sourceDirectoryStat = (0, import_node_fs5.lstatSync)(legacyBaseDir);
+    const sourceFileStat = (0, import_node_fs5.lstatSync)(legacyPath);
     if (!sourceDirectoryStat.isDirectory() || sourceDirectoryStat.isSymbolicLink()) return false;
-    const alanDirectoryExisted = (0, import_node_fs4.existsSync)(alanBaseDir);
+    const alanDirectoryExisted = (0, import_node_fs5.existsSync)(alanBaseDir);
     if (alanDirectoryExisted) {
-      const alanDirectoryStat = (0, import_node_fs4.lstatSync)(alanBaseDir);
+      const alanDirectoryStat = (0, import_node_fs5.lstatSync)(alanBaseDir);
       if (!alanDirectoryStat.isDirectory() || alanDirectoryStat.isSymbolicLink()) return false;
     }
-    (0, import_node_fs4.mkdirSync)(alanBaseDir, { recursive: true, mode: sourceDirectoryStat.mode & 511 });
-    if (!alanDirectoryExisted) (0, import_node_fs4.chmodSync)(alanBaseDir, sourceDirectoryStat.mode & 511);
-    (0, import_node_fs4.copyFileSync)(legacyPath, alanPath, import_node_fs4.constants.COPYFILE_EXCL);
+    (0, import_node_fs5.mkdirSync)(alanBaseDir, { recursive: true, mode: sourceDirectoryStat.mode & 511 });
+    if (!alanDirectoryExisted) (0, import_node_fs5.chmodSync)(alanBaseDir, sourceDirectoryStat.mode & 511);
+    (0, import_node_fs5.copyFileSync)(legacyPath, alanPath, import_node_fs5.constants.COPYFILE_EXCL);
     copied = true;
     const migrated = sanitizeAgentConfig(
-      JSON.parse((0, import_node_fs4.readFileSync)(alanPath, "utf8"))
+      JSON.parse((0, import_node_fs5.readFileSync)(alanPath, "utf8"))
     );
-    (0, import_node_fs4.writeFileSync)(alanPath, JSON.stringify(migrated, null, 2));
-    (0, import_node_fs4.chmodSync)(alanPath, sourceFileStat.mode & 511);
-    (0, import_node_fs4.utimesSync)(alanPath, sourceFileStat.atime, sourceFileStat.mtime);
+    (0, import_node_fs5.writeFileSync)(alanPath, JSON.stringify(migrated, null, 2));
+    (0, import_node_fs5.chmodSync)(alanPath, sourceFileStat.mode & 511);
+    (0, import_node_fs5.utimesSync)(alanPath, sourceFileStat.atime, sourceFileStat.mtime);
     if (!isValidAgentConfig(alanPath)) {
-      (0, import_node_fs4.unlinkSync)(alanPath);
+      (0, import_node_fs5.unlinkSync)(alanPath);
       return false;
     }
     return true;
   } catch {
-    if (copied && (0, import_node_fs4.existsSync)(alanPath)) (0, import_node_fs4.unlinkSync)(alanPath);
+    if (copied && (0, import_node_fs5.existsSync)(alanPath)) (0, import_node_fs5.unlinkSync)(alanPath);
     return false;
   }
 }
@@ -23132,10 +24290,10 @@ function resolveAgentConfigPath(input) {
   ) ?? "production";
   const baseDir = input?.baseDir ?? DEFAULT_AGENT_DIR;
   if (input?.baseDir === void 0) migrateLegacyAgentConfig({ profile });
-  return (0, import_node_path4.join)(baseDir, resolveAgentConfigFileName(profile));
+  return (0, import_node_path5.join)(baseDir, resolveAgentConfigFileName(profile));
 }
 function configExistsAtPath(configPath) {
-  return (0, import_node_fs4.existsSync)(configPath);
+  return (0, import_node_fs5.existsSync)(configPath);
 }
 function resolveEndpointProfileFromArgs(args) {
   const index = args.indexOf("--profile");
@@ -23182,9 +24340,9 @@ var WorkspaceAccessTracker = class {
   }
 };
 var DEFAULT_WORKSPACE_PROBE = {
-  stat: (path) => (0, import_node_fs5.statSync)(path),
-  access: (path, mode) => (0, import_node_fs5.accessSync)(path, mode),
-  exists: (path) => (0, import_node_fs5.existsSync)(path)
+  stat: (path) => (0, import_node_fs6.statSync)(path),
+  access: (path, mode) => (0, import_node_fs6.accessSync)(path, mode),
+  exists: (path) => (0, import_node_fs6.existsSync)(path)
 };
 function workspaceVolumeRoot(path) {
   const windowsDrive = path.match(/^([A-Za-z]):[\\/]/);
@@ -23248,7 +24406,7 @@ function inspectWorkspaceReadiness(workspacePath, probe = DEFAULT_WORKSPACE_PROB
         probe
       );
     }
-    probe.access(workspacePath, import_node_fs5.constants.R_OK | import_node_fs5.constants.W_OK | import_node_fs5.constants.X_OK);
+    probe.access(workspacePath, import_node_fs6.constants.R_OK | import_node_fs6.constants.W_OK | import_node_fs6.constants.X_OK);
     return {
       ready: true,
       message: "Workspace path is configured and accessible.",
@@ -23360,7 +24518,7 @@ function buildComputerReadiness(input) {
 }
 
 // src/core-agent.ts
-var import_node_os6 = require("os");
+var import_node_os7 = require("os");
 var CoreAgent = class _CoreAgent extends BaseMachineAgent {
   childProcess = null;
   _aborted = false;
@@ -23510,7 +24668,7 @@ var CoreAgent = class _CoreAgent extends BaseMachineAgent {
     if (this.runtime.backendKind === "grok_cli" && this.providerApiKey) {
       augmented.XAI_API_KEY = this.providerApiKey;
     }
-    if ((0, import_node_os6.platform)() !== "win32") {
+    if ((0, import_node_os7.platform)() !== "win32") {
       const home = augmented.HOME ?? "/home/user";
       const extraPaths = [`${home}/.local/node/bin`, `${home}/.local/bin`];
       const separator = ":";
@@ -23674,9 +24832,9 @@ ${meta.description}`);
 };
 
 // src/event-outbox.ts
-var import_node_crypto = require("crypto");
-var import_node_fs6 = require("fs");
-var import_node_path5 = require("path");
+var import_node_crypto2 = require("crypto");
+var import_node_fs7 = require("fs");
+var import_node_path6 = require("path");
 var OUTBOX_VERSION = 1;
 var MAX_INTERMEDIATE_EVENTS_PER_RUN = 200;
 var MAX_ENCRYPTED_OUTBOX_BYTES = 64 * 1024 * 1024;
@@ -23709,7 +24867,7 @@ function truncateUtf8(value2, maxBytes) {
   return `${encoded.subarray(0, maxBytes).toString("utf8").replace(/\uFFFD$/u, "")}\u2026`;
 }
 function terminalFingerprint(event) {
-  return (0, import_node_crypto.createHash)("sha256").update(JSON.stringify(event)).digest("hex").slice(0, 16);
+  return (0, import_node_crypto2.createHash)("sha256").update(JSON.stringify(event)).digest("hex").slice(0, 16);
 }
 function condenseTerminalEvent(event) {
   const fingerprint = terminalFingerprint(event);
@@ -23787,7 +24945,7 @@ var EncryptedEventOutbox = class _EncryptedEventOutbox {
       throw new Error("event outbox maxIntermediateEventsPerRun must be a non-negative integer");
     }
     this.entries = this.read();
-    if (!(0, import_node_fs6.existsSync)(this.path)) {
+    if (!(0, import_node_fs7.existsSync)(this.path)) {
       this.lastPersistedSignature = _EncryptedEventOutbox.EMPTY_SIGNATURE;
     } else if (this.entries.length > 0) {
       this.lastPersistedSignature = this.serializeForPersist().signature;
@@ -23817,7 +24975,7 @@ var EncryptedEventOutbox = class _EncryptedEventOutbox {
   maxIntermediateEventsPerRun;
   enqueue(conversationId, runId, event) {
     const entry = {
-      eventId: (0, import_node_crypto.randomUUID)(),
+      eventId: (0, import_node_crypto2.randomUUID)(),
       conversationId,
       runId,
       event,
@@ -23903,7 +25061,7 @@ var EncryptedEventOutbox = class _EncryptedEventOutbox {
     const markerConversationId = runEntry?.conversationId ?? conversationId;
     if (!markerConversationId) return;
     const marker = {
-      eventId: (0, import_node_crypto.randomUUID)(),
+      eventId: (0, import_node_crypto2.randomUUID)(),
       conversationId: markerConversationId,
       runId,
       event: { type: "text", text: CONDENSATION_NOTICE, ts: Date.now() },
@@ -23989,14 +25147,14 @@ var EncryptedEventOutbox = class _EncryptedEventOutbox {
     this.retryTimer = null;
   }
   read() {
-    if (!(0, import_node_fs6.existsSync)(this.path)) return [];
+    if (!(0, import_node_fs7.existsSync)(this.path)) return [];
     let envelope;
     try {
-      envelope = JSON.parse((0, import_node_fs6.readFileSync)(this.path, "utf8"));
+      envelope = JSON.parse((0, import_node_fs7.readFileSync)(this.path, "utf8"));
       if (envelope.version !== OUTBOX_VERSION) {
         throw new Error(`unsupported event outbox version ${String(envelope.version)}`);
       }
-      const decipher = (0, import_node_crypto.createDecipheriv)(
+      const decipher = (0, import_node_crypto2.createDecipheriv)(
         "aes-256-gcm",
         this.key,
         Buffer.from(envelope.iv, "base64url")
@@ -24020,21 +25178,21 @@ var EncryptedEventOutbox = class _EncryptedEventOutbox {
       return { plaintext: "", signature: _EncryptedEventOutbox.EMPTY_SIGNATURE };
     }
     const plaintext = JSON.stringify({ entries: this.entries });
-    return { plaintext, signature: (0, import_node_crypto.createHash)("sha256").update(plaintext).digest("base64url") };
+    return { plaintext, signature: (0, import_node_crypto2.createHash)("sha256").update(plaintext).digest("base64url") };
   }
   persist() {
     const { plaintext, signature } = this.serializeForPersist();
     if (signature === this.lastPersistedSignature) return;
     try {
       if (this.entries.length === 0) {
-        (0, import_node_fs6.rmSync)(this.path, { force: true });
+        (0, import_node_fs7.rmSync)(this.path, { force: true });
         this.lastPersistedSignature = signature;
         this.persistFailureLogged = false;
         return;
       }
-      (0, import_node_fs6.mkdirSync)((0, import_node_path5.dirname)(this.path), { recursive: true, mode: 448 });
-      const iv = (0, import_node_crypto.randomBytes)(12);
-      const cipher = (0, import_node_crypto.createCipheriv)("aes-256-gcm", this.key, iv);
+      (0, import_node_fs7.mkdirSync)((0, import_node_path6.dirname)(this.path), { recursive: true, mode: 448 });
+      const iv = (0, import_node_crypto2.randomBytes)(12);
+      const cipher = (0, import_node_crypto2.createCipheriv)("aes-256-gcm", this.key, iv);
       const ciphertext = Buffer.concat([cipher.update(plaintext, "utf8"), cipher.final()]);
       const envelope = {
         version: OUTBOX_VERSION,
@@ -24042,13 +25200,13 @@ var EncryptedEventOutbox = class _EncryptedEventOutbox {
         authTag: cipher.getAuthTag().toString("base64url"),
         ciphertext: ciphertext.toString("base64url")
       };
-      const pendingPath = `${this.path}.pending-${process.pid}-${(0, import_node_crypto.randomBytes)(6).toString("hex")}`;
+      const pendingPath = `${this.path}.pending-${process.pid}-${(0, import_node_crypto2.randomBytes)(6).toString("hex")}`;
       try {
-        (0, import_node_fs6.writeFileSync)(pendingPath, JSON.stringify(envelope), { mode: 384 });
-        (0, import_node_fs6.chmodSync)(pendingPath, 384);
-        (0, import_node_fs6.renameSync)(pendingPath, this.path);
+        (0, import_node_fs7.writeFileSync)(pendingPath, JSON.stringify(envelope), { mode: 384 });
+        (0, import_node_fs7.chmodSync)(pendingPath, 384);
+        (0, import_node_fs7.renameSync)(pendingPath, this.path);
       } finally {
-        (0, import_node_fs6.rmSync)(pendingPath, { force: true });
+        (0, import_node_fs7.rmSync)(pendingPath, { force: true });
       }
       this.lastPersistedSignature = signature;
       this.persistFailureLogged = false;
@@ -24066,38 +25224,38 @@ var EncryptedEventOutbox = class _EncryptedEventOutbox {
 };
 
 // src/local-skill-scan.ts
-var import_node_fs7 = require("fs");
-var import_node_path6 = require("path");
+var import_node_fs8 = require("fs");
+var import_node_path7 = require("path");
 var SKILL_READ_LIMIT_BYTES = 8192;
 var SKILL_CACHE_TTL_MS = 3e4;
 function readSkillHead(path) {
-  const fd = (0, import_node_fs7.openSync)(path, "r");
+  const fd = (0, import_node_fs8.openSync)(path, "r");
   try {
     const buffer = Buffer.alloc(SKILL_READ_LIMIT_BYTES);
-    const bytesRead = (0, import_node_fs7.readSync)(fd, buffer, 0, SKILL_READ_LIMIT_BYTES, 0);
+    const bytesRead = (0, import_node_fs8.readSync)(fd, buffer, 0, SKILL_READ_LIMIT_BYTES, 0);
     return buffer.subarray(0, bytesRead).toString("utf-8");
   } finally {
-    (0, import_node_fs7.closeSync)(fd);
+    (0, import_node_fs8.closeSync)(fd);
   }
 }
 function scanSkillDir(dirPath, source, repoRoot, entries, errors) {
-  if (!(0, import_node_fs7.existsSync)(dirPath)) return;
+  if (!(0, import_node_fs8.existsSync)(dirPath)) return;
   let names;
   try {
-    names = (0, import_node_fs7.readdirSync)(dirPath);
+    names = (0, import_node_fs8.readdirSync)(dirPath);
   } catch (error) {
     errors.push(`Failed to scan ${dirPath}: ${error instanceof Error ? error.message : error}`);
     return;
   }
   for (const name of names) {
-    const skillPath = (0, import_node_path6.join)(dirPath, name, "SKILL.md");
+    const skillPath = (0, import_node_path7.join)(dirPath, name, "SKILL.md");
     let isDirectory = false;
     try {
-      isDirectory = (0, import_node_fs7.statSync)((0, import_node_path6.join)(dirPath, name)).isDirectory();
+      isDirectory = (0, import_node_fs8.statSync)((0, import_node_path7.join)(dirPath, name)).isDirectory();
     } catch {
       continue;
     }
-    if (!isDirectory || !(0, import_node_fs7.existsSync)(skillPath)) continue;
+    if (!isDirectory || !(0, import_node_fs8.existsSync)(skillPath)) continue;
     try {
       entries.push({ content: readSkillHead(skillPath), source, sourcePath: skillPath, repoRoot });
     } catch (error) {
@@ -24108,54 +25266,194 @@ function scanSkillDir(dirPath, source, repoRoot, entries, errors) {
 function discoverChildRepos(parentPath) {
   let names;
   try {
-    names = (0, import_node_fs7.readdirSync)(parentPath);
+    names = (0, import_node_fs8.readdirSync)(parentPath);
   } catch {
     return [];
   }
-  const children = [];
-  for (const name of names) {
-    if (name.startsWith(".")) continue;
-    const childPath = (0, import_node_path6.join)(parentPath, name);
-    try {
-      if ((0, import_node_fs7.statSync)(childPath).isDirectory()) children.push(childPath);
-    } catch {
-    }
+  const children = [];
+  for (const name of names) {
+    if (name.startsWith(".")) continue;
+    const childPath = (0, import_node_path7.join)(parentPath, name);
+    try {
+      if ((0, import_node_fs8.statSync)(childPath).isDirectory()) children.push(childPath);
+    } catch {
+    }
+  }
+  return children;
+}
+function scanLocalSkills(homeDir, projectPath) {
+  const rawEntries = [];
+  const errors = [];
+  for (const root of SKILL_DIRECTORY_ROOTS) {
+    scanSkillDir((0, import_node_path7.join)(homeDir, root), "global", void 0, rawEntries, errors);
+  }
+  if (projectPath) {
+    for (const dir of [projectPath, ...discoverChildRepos(projectPath)]) {
+      for (const root of SKILL_DIRECTORY_ROOTS) {
+        scanSkillDir((0, import_node_path7.join)(dir, root), "team", dir, rawEntries, errors);
+      }
+    }
+  }
+  return { skills: normalizeSkillEntries(rawEntries, "team"), errors };
+}
+var skillScanCache = /* @__PURE__ */ new Map();
+function scanLocalSkillsCached(homeDir, projectPath, options) {
+  const key = projectPath ?? "";
+  const now = Date.now();
+  if (!options?.refresh) {
+    const cached = skillScanCache.get(key);
+    if (cached && cached.expiresAt > now) return cached.result;
+  }
+  const result = scanLocalSkills(homeDir, projectPath);
+  skillScanCache.set(key, { expiresAt: now + SKILL_CACHE_TTL_MS, result });
+  return result;
+}
+
+// src/local-workspace-migration.ts
+var import_node_crypto3 = require("crypto");
+var MigrationStashApplyError = class extends Error {
+  stash;
+  stashPreserved = true;
+  constructor(stash, cause) {
+    super(`Could not apply migration stash ${stash.oid}; the stash was preserved`, { cause });
+    this.name = "MigrationStashApplyError";
+    this.stash = stash;
+  }
+};
+var BRANCH_LABEL_MAX_LENGTH = 256;
+function stripControlCharacters(value2) {
+  return Array.from(value2).filter((character) => {
+    const code = character.charCodeAt(0);
+    return code >= 32 && code !== 127;
+  }).join("");
+}
+function sanitizeLabel(value2, fallback) {
+  const sanitized = stripControlCharacters(value2).replace(/[^a-zA-Z0-9._/-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, BRANCH_LABEL_MAX_LENGTH);
+  return sanitized || fallback;
+}
+function sanitizeBranch(value2) {
+  const sanitized = stripControlCharacters(value2.trim()).slice(0, BRANCH_LABEL_MAX_LENGTH);
+  return sanitized || null;
+}
+function countPorcelainEntries(output) {
+  const records = output.split("\0");
+  let count = 0;
+  for (let index = 0; index < records.length; index += 1) {
+    const record = records[index];
+    if (!record) continue;
+    count += 1;
+    const status = record.slice(0, 2);
+    if (status.includes("R") || status.includes("C")) {
+      index += 1;
+    }
+  }
+  return count;
+}
+function preflightGitTree(cwd, git2) {
+  const currentBranch = sanitizeBranch(git2(cwd, ["branch", "--show-current"]));
+  const dirtyFileCount = countPorcelainEntries(
+    git2(cwd, ["status", "--porcelain=v1", "-z", "--untracked-files=all"])
+  );
+  return {
+    currentBranch,
+    dirtyFileCount,
+    isDirty: dirtyFileCount > 0
+  };
+}
+function preflightWorkspaceMigration(input, git2) {
+  return {
+    direction: input.direction,
+    source: preflightGitTree(input.sourcePath, git2),
+    destination: input.destinationPath ? preflightGitTree(input.destinationPath, git2) : null
+  };
+}
+function uniqueOperationLabel(operation, dependencies) {
+  const now = (dependencies.now ?? (() => /* @__PURE__ */ new Date()))();
+  const createdAt = now.toISOString();
+  const id = (dependencies.createId ?? import_node_crypto3.randomUUID)();
+  return {
+    label: [
+      "alan-migration",
+      sanitizeLabel(operation, "workspace"),
+      createdAt.replace(/[:.]/g, "-"),
+      sanitizeLabel(id, "operation")
+    ].join("/"),
+    createdAt
+  };
+}
+function createMigrationStash(input, dependencies) {
+  const before = preflightGitTree(input.cwd, dependencies.git);
+  if (!before.isDirty) return null;
+  const { label, createdAt } = uniqueOperationLabel(input.operation, dependencies);
+  dependencies.git(input.cwd, ["stash", "push", "--include-untracked", "--message", label]);
+  const oid = dependencies.git(input.cwd, ["rev-parse", "--verify", "refs/stash"]).trim();
+  if (!oid) {
+    throw new Error("Git did not return the created migration stash");
+  }
+  return { oid, label, createdAt };
+}
+function findStashRef(cwd, oid, git2) {
+  const matchingLine = git2(cwd, ["stash", "list", "--format=%H %gd"]).split("\n").find((line) => line.startsWith(`${oid} `));
+  return matchingLine?.slice(oid.length + 1).trim() || null;
+}
+function dropMigrationStash(cwd, stash, git2) {
+  const stashRef = findStashRef(cwd, stash.oid, git2);
+  if (!stashRef) return false;
+  git2(cwd, ["stash", "drop", stashRef]);
+  return true;
+}
+function applyMigrationStash(input, git2) {
+  try {
+    git2(input.cwd, ["stash", "apply", "--index", input.stash.oid]);
+  } catch (cause) {
+    throw new MigrationStashApplyError(input.stash, cause);
+  }
+  if (input.dropOnSuccess !== false) {
+    dropMigrationStash(input.cwd, input.stash, git2);
   }
-  return children;
+  return preflightGitTree(input.cwd, git2);
 }
-function scanLocalSkills(homeDir, projectPath) {
-  const rawEntries = [];
-  const errors = [];
-  for (const root of SKILL_DIRECTORY_ROOTS) {
-    scanSkillDir((0, import_node_path6.join)(homeDir, root), "global", void 0, rawEntries, errors);
+function resolveDirtyTree(input, dependencies) {
+  if (input.action === "discard" && input.confirmDiscard !== true) {
+    throw new Error("Discarding workspace changes requires explicit confirmation");
   }
-  if (projectPath) {
-    for (const dir of [projectPath, ...discoverChildRepos(projectPath)]) {
-      for (const root of SKILL_DIRECTORY_ROOTS) {
-        scanSkillDir((0, import_node_path6.join)(dir, root), "team", dir, rawEntries, errors);
+  const before = preflightGitTree(input.cwd, dependencies.git);
+  let stash = null;
+  let commitOid = null;
+  if (before.isDirty) {
+    switch (input.action) {
+      case "leave":
+        break;
+      case "move_via_stash":
+        stash = createMigrationStash({ cwd: input.cwd, operation: input.operation }, dependencies);
+        break;
+      case "commit_wip": {
+        const { label } = uniqueOperationLabel(input.operation, dependencies);
+        dependencies.git(input.cwd, ["add", "--all"]);
+        dependencies.git(input.cwd, ["commit", "--message", `WIP: ${label}`]);
+        commitOid = dependencies.git(input.cwd, ["rev-parse", "HEAD"]).trim() || null;
+        break;
       }
+      case "discard":
+        dependencies.git(input.cwd, ["reset", "--hard", "HEAD"]);
+        dependencies.git(input.cwd, ["clean", "-fd"]);
+        break;
     }
   }
-  return { skills: normalizeSkillEntries(rawEntries, "team"), errors };
-}
-var skillScanCache = /* @__PURE__ */ new Map();
-function scanLocalSkillsCached(homeDir, projectPath, options) {
-  const key = projectPath ?? "";
-  const now = Date.now();
-  if (!options?.refresh) {
-    const cached = skillScanCache.get(key);
-    if (cached && cached.expiresAt > now) return cached.result;
-  }
-  const result = scanLocalSkills(homeDir, projectPath);
-  skillScanCache.set(key, { expiresAt: now + SKILL_CACHE_TTL_MS, result });
-  return result;
+  return {
+    action: input.action,
+    before,
+    after: preflightGitTree(input.cwd, dependencies.git),
+    stash,
+    commitOid
+  };
 }
 
 // src/mcp-registration.ts
-var import_node_crypto2 = require("crypto");
-var import_node_fs8 = require("fs");
-var import_node_os7 = require("os");
-var import_node_path7 = require("path");
+var import_node_crypto4 = require("crypto");
+var import_node_fs9 = require("fs");
+var import_node_os8 = require("os");
+var import_node_path8 = require("path");
 
 // ../../node_modules/smol-toml/dist/error.js
 function getLineColFromPtr(string, ptr) {
@@ -24237,7 +25535,7 @@ function skipVoid(str, ptr, banNewLines, banComments) {
   }
   return ptr;
 }
-function skipUntil(str, ptr, sep2, end, banNewLines = false) {
+function skipUntil(str, ptr, sep3, end, banNewLines = false) {
   if (!end) {
     ptr = indexOfNewline(str, ptr);
     return ptr < 0 ? str.length : ptr;
@@ -24246,7 +25544,7 @@ function skipUntil(str, ptr, sep2, end, banNewLines = false) {
     let c = str[i];
     if (c === "#") {
       i = indexOfNewline(str, i);
-    } else if (c === sep2) {
+    } else if (c === sep3) {
       return i + 1;
     } else if (c === end || banNewLines && (c === "\n" || c === "\r" && str[i + 1] === "\n")) {
       return i;
@@ -24952,18 +26250,18 @@ var inspectAlanMcpThroughProviderCli = async (backendKind, expectedUrl, home) =>
   return result;
 };
 async function waitForConfigLock(lockPath) {
-  (0, import_node_fs8.mkdirSync)((0, import_node_path7.dirname)(lockPath), { recursive: true });
+  (0, import_node_fs9.mkdirSync)((0, import_node_path8.dirname)(lockPath), { recursive: true });
   const startedAt = Date.now();
   while (true) {
     try {
-      (0, import_node_fs8.mkdirSync)(lockPath);
-      return () => (0, import_node_fs8.rmSync)(lockPath, { recursive: true, force: true });
+      (0, import_node_fs9.mkdirSync)(lockPath);
+      return () => (0, import_node_fs9.rmSync)(lockPath, { recursive: true, force: true });
     } catch (error) {
       const code = error && typeof error === "object" && "code" in error ? error.code : void 0;
       if (code !== "EEXIST") throw error;
       try {
-        if (Date.now() - (0, import_node_fs8.statSync)(lockPath).mtimeMs > CONFIG_LOCK_STALE_MS) {
-          (0, import_node_fs8.rmSync)(lockPath, { recursive: true, force: true });
+        if (Date.now() - (0, import_node_fs9.statSync)(lockPath).mtimeMs > CONFIG_LOCK_STALE_MS) {
+          (0, import_node_fs9.rmSync)(lockPath, { recursive: true, force: true });
           continue;
         }
       } catch {
@@ -24972,14 +26270,14 @@ async function waitForConfigLock(lockPath) {
       if (Date.now() - startedAt >= CONFIG_LOCK_WAIT_MS) {
         throw new Error(`Alan could not safely update ${lockPath.slice(0, -".alan-lock".length)}`);
       }
-      await new Promise((resolve6) => setTimeout(resolve6, CONFIG_LOCK_POLL_MS));
+      await new Promise((resolve7) => setTimeout(resolve7, CONFIG_LOCK_POLL_MS));
     }
   }
 }
 function saveMalformedBackup(path, content) {
-  const hash = (0, import_node_crypto2.createHash)("sha256").update(content).digest("hex").slice(0, 12);
+  const hash = (0, import_node_crypto4.createHash)("sha256").update(content).digest("hex").slice(0, 12);
   const backupPath = `${path}.alan-backup-${hash}`;
-  if (!(0, import_node_fs8.existsSync)(backupPath)) (0, import_node_fs8.copyFileSync)(path, backupPath);
+  if (!(0, import_node_fs9.existsSync)(backupPath)) (0, import_node_fs9.copyFileSync)(path, backupPath);
   return backupPath;
 }
 function parseJsonObject2(path, content) {
@@ -25024,24 +26322,24 @@ function mergeCodexAlanSection(path, existingContent, desiredContent) {
   return merged;
 }
 function atomicWriteManagedConfig(path, content) {
-  const pendingPath = `${path}.alan-pending-${process.pid}-${(0, import_node_crypto2.randomBytes)(6).toString("hex")}`;
+  const pendingPath = `${path}.alan-pending-${process.pid}-${(0, import_node_crypto4.randomBytes)(6).toString("hex")}`;
   try {
-    (0, import_node_fs8.writeFileSync)(pendingPath, content, { encoding: "utf8", mode: 384, flag: "wx" });
-    (0, import_node_fs8.renameSync)(pendingPath, path);
+    (0, import_node_fs9.writeFileSync)(pendingPath, content, { encoding: "utf8", mode: 384, flag: "wx" });
+    (0, import_node_fs9.renameSync)(pendingPath, path);
   } finally {
-    (0, import_node_fs8.rmSync)(pendingPath, { force: true });
+    (0, import_node_fs9.rmSync)(pendingPath, { force: true });
   }
 }
-async function ensureAlanMcpRegistered(backendKind, registration, home = (0, import_node_os7.homedir)(), inspectCli = inspectAlanMcpThroughProviderCli) {
+async function ensureAlanMcpRegistered(backendKind, registration, home = (0, import_node_os8.homedir)(), inspectCli = inspectAlanMcpThroughProviderCli) {
   try {
     const mcpServers = buildAlanMcpServers(registration);
     const files = alanMcpConfigFilesForBackend(backendKind, mcpServers, home);
     const paths = [];
     for (const file of files) {
-      (0, import_node_fs8.mkdirSync)((0, import_node_path7.dirname)(file.path), { recursive: true });
+      (0, import_node_fs9.mkdirSync)((0, import_node_path8.dirname)(file.path), { recursive: true });
       const releaseLock = await waitForConfigLock(`${file.path}.alan-lock`);
       try {
-        const current = (0, import_node_fs8.existsSync)(file.path) ? (0, import_node_fs8.readFileSync)(file.path, "utf8") : null;
+        const current = (0, import_node_fs9.existsSync)(file.path) ? (0, import_node_fs9.readFileSync)(file.path, "utf8") : null;
         const content = file.path.endsWith(".toml") ? mergeCodexAlanSection(file.path, current, file.content) : mergeJsonConfig(file.path, current, file.content);
         if (current !== content) atomicWriteManagedConfig(file.path, content);
         paths.push(file.path);
@@ -25092,13 +26390,13 @@ async function ensureAlanMcpRegistered(backendKind, registration, home = (0, imp
     return { ok: false, paths: [], error: err instanceof Error ? err.message : String(err) };
   }
 }
-async function verifyAlanMcpRegistered(backendKind, home = (0, import_node_os7.homedir)(), inspectCli = inspectAlanMcpThroughProviderCli) {
+async function verifyAlanMcpRegistered(backendKind, home = (0, import_node_os8.homedir)(), inspectCli = inspectAlanMcpThroughProviderCli) {
   const files = alanMcpConfigFilesForBackend(backendKind, {}, home);
-  const missing = files.map((f) => f.path).filter((p) => !(0, import_node_fs8.existsSync)(p));
+  const missing = files.map((f) => f.path).filter((p) => !(0, import_node_fs9.existsSync)(p));
   const presentEntries = files.map((file) => ({
     path: file.path,
-    url: (0, import_node_fs8.existsSync)(file.path) ? readUsableAlanMcpUrl(file.path) : null
-  })).filter((entry) => (0, import_node_fs8.existsSync)(entry.path));
+    url: (0, import_node_fs9.existsSync)(file.path) ? readUsableAlanMcpUrl(file.path) : null
+  })).filter((entry) => (0, import_node_fs9.existsSync)(entry.path));
   let invalid = presentEntries.filter((entry) => !entry.url).map((entry) => entry.path);
   const urls = new Set(presentEntries.flatMap((entry) => entry.url ? [entry.url] : []));
   if (urls.size > 1) invalid = presentEntries.map((entry) => entry.path);
@@ -25154,15 +26452,15 @@ function removeAlanFromJsonConfig(path, existingContent) {
   }
   return JSON.stringify(config);
 }
-async function unregisterAlanMcp(backendKind, home = (0, import_node_os7.homedir)()) {
+async function unregisterAlanMcp(backendKind, home = (0, import_node_os8.homedir)()) {
   const removedPaths = [];
   const errors = [];
   const files = alanMcpConfigFilesForBackend(backendKind, {}, home);
   for (const file of files) {
-    if (!(0, import_node_fs8.existsSync)(file.path)) continue;
+    if (!(0, import_node_fs9.existsSync)(file.path)) continue;
     const releaseLock = await waitForConfigLock(`${file.path}.alan-lock`);
     try {
-      const current = (0, import_node_fs8.readFileSync)(file.path, "utf8");
+      const current = (0, import_node_fs9.readFileSync)(file.path, "utf8");
       let next;
       if (file.path.endsWith(".toml")) {
         const stripped = stripCodexAlanMcpSection(current);
@@ -25193,7 +26491,7 @@ function isHttpUrl(value2) {
   }
 }
 function readUsableAlanMcpUrl(path) {
-  const content = (0, import_node_fs8.readFileSync)(path, "utf8");
+  const content = (0, import_node_fs9.readFileSync)(path, "utf8");
   if (path.endsWith(".toml")) {
     const lines = content.split("\n");
     const start = lines.findIndex((line) => line.trim() === "[mcp_servers.alan]");
@@ -25484,7 +26782,7 @@ ${result.stderr}`.trim();
 }
 
 // src/provider-model-discovery.ts
-var import_node_fs9 = require("fs");
+var import_node_fs10 = require("fs");
 var MODEL_DISCOVERY_TIMEOUT_MS = 8e3;
 var ANTIGRAVITY_MODEL_DISCOVERY_TIMEOUT_MS = 12e3;
 var OPENCODE_ZEN_MODEL_IDS = OPENCODE_ZEN_MODELS.map((model) => model.id);
@@ -25698,7 +26996,7 @@ function filterClaudeDatedModelIds(ids) {
 }
 function resolveExecutableForModelScan(executable) {
   try {
-    return (0, import_node_fs9.realpathSync)(executable);
+    return (0, import_node_fs10.realpathSync)(executable);
   } catch {
     return executable;
   }
@@ -25706,7 +27004,7 @@ function resolveExecutableForModelScan(executable) {
 function extractClaudeModelIdsFromExecutable(executable) {
   try {
     const resolved = resolveExecutableForModelScan(executable);
-    const text = (0, import_node_fs9.readFileSync)(resolved).toString("latin1");
+    const text = (0, import_node_fs10.readFileSync)(resolved).toString("latin1");
     const matches = text.match(CLAUDE_MODEL_ID_PATTERN) ?? [];
     const unique = [
       ...new Set(matches.map((id) => id.trim()).filter((id) => isValidClaudeModelId(id))),
@@ -25833,8 +27131,8 @@ async function discoverProviderModels(provider, executable, env) {
 }
 
 // src/run-journal.ts
-var import_node_fs10 = require("fs");
-var import_node_path8 = require("path");
+var import_node_fs11 = require("fs");
+var import_node_path9 = require("path");
 var JOURNAL_VERSION = 1;
 var INTERRUPTED_ENTRY_TTL_MS = 24 * 60 * 6e4;
 function isEntry(value2) {
@@ -25853,9 +27151,9 @@ function isEntry(value2) {
 var RuntimeRunJournal = class {
   constructor(path, nowMs = Date.now()) {
     this.path = path;
-    if (!(0, import_node_fs10.existsSync)(path)) return;
+    if (!(0, import_node_fs11.existsSync)(path)) return;
     try {
-      const parsed = JSON.parse((0, import_node_fs10.readFileSync)(path, "utf8"));
+      const parsed = JSON.parse((0, import_node_fs11.readFileSync)(path, "utf8"));
       if (parsed.version !== JOURNAL_VERSION || !Array.isArray(parsed.entries)) {
         throw new Error("unsupported run journal format");
       }
@@ -25978,18 +27276,18 @@ var RuntimeRunJournal = class {
   }
   persist() {
     const pendingPath = `${this.path}.pending`;
-    (0, import_node_fs10.mkdirSync)((0, import_node_path8.dirname)(this.path), { recursive: true });
+    (0, import_node_fs11.mkdirSync)((0, import_node_path9.dirname)(this.path), { recursive: true });
     try {
-      (0, import_node_fs10.writeFileSync)(
+      (0, import_node_fs11.writeFileSync)(
         pendingPath,
         `${JSON.stringify({ version: JOURNAL_VERSION, entries: [...this.entries.values()] })}
 `,
         { mode: 384 }
       );
-      (0, import_node_fs10.chmodSync)(pendingPath, 384);
-      (0, import_node_fs10.renameSync)(pendingPath, this.path);
+      (0, import_node_fs11.chmodSync)(pendingPath, 384);
+      (0, import_node_fs11.renameSync)(pendingPath, this.path);
     } catch (error) {
-      (0, import_node_fs10.rmSync)(pendingPath, { force: true });
+      (0, import_node_fs11.rmSync)(pendingPath, { force: true });
       throw error;
     }
   }
@@ -26001,8 +27299,8 @@ var RunStartGate = class {
   async acquire() {
     const previous = this.tail;
     let releaseCurrent;
-    const current = new Promise((resolve6) => {
-      releaseCurrent = resolve6;
+    const current = new Promise((resolve7) => {
+      releaseCurrent = resolve7;
     });
     this.tail = previous.then(() => current);
     await previous;
@@ -26016,17 +27314,17 @@ var RunStartGate = class {
 };
 
 // src/version.ts
-var AGENT_VERSION = "0.1.49";
+var AGENT_VERSION = "0.1.51";
 
 // src/workspace-relocation.ts
-var import_node_child_process4 = require("child_process");
-var import_node_fs11 = require("fs");
-var import_node_path9 = require("path");
+var import_node_child_process5 = require("child_process");
+var import_node_fs12 = require("fs");
+var import_node_path10 = require("path");
 var MAX_RELOCATION_CANDIDATES = 200;
 var DEFAULT_PROBE = {
-  childDirectories: (parentPath, limit) => (0, import_node_fs11.readdirSync)(parentPath, { withFileTypes: true }).filter((entry) => entry.isDirectory()).slice(0, limit).map((entry) => (0, import_node_path9.join)(parentPath, entry.name)),
+  childDirectories: (parentPath, limit) => (0, import_node_fs12.readdirSync)(parentPath, { withFileTypes: true }).filter((entry) => entry.isDirectory()).slice(0, limit).map((entry) => (0, import_node_path10.join)(parentPath, entry.name)),
   gitRemoteUrl: (candidatePath) => {
-    const result = (0, import_node_child_process4.spawnSync)("git", ["-C", candidatePath, "config", "--get", "remote.origin.url"], {
+    const result = (0, import_node_child_process5.spawnSync)("git", ["-C", candidatePath, "config", "--get", "remote.origin.url"], {
       encoding: "utf8",
       env: getDaemonCliEnvironment(),
       timeout: 2e3
@@ -26055,7 +27353,7 @@ function workspaceMatchesExpectedRepositories(input) {
     input.expectedRepoUrls.map(normalizeRepositoryIdentity).filter((identity2) => Boolean(identity2))
   );
   if (identities.size === 0) return false;
-  const remote = (input.probe ?? DEFAULT_PROBE).gitRemoteUrl((0, import_node_path9.resolve)(input.workspacePath));
+  const remote = (input.probe ?? DEFAULT_PROBE).gitRemoteUrl((0, import_node_path10.resolve)(input.workspacePath));
   const identity = remote ? normalizeRepositoryIdentity(remote) : null;
   return Boolean(identity && identities.has(identity));
 }
@@ -26065,8 +27363,8 @@ function discoverRelocatedWorkspace(input) {
   );
   if (identities.size === 0) return null;
   const searchRoots = [
-    (0, import_node_path9.dirname)((0, import_node_path9.resolve)(input.missingPath)),
-    ...(input.approvedWorkspacePaths ?? []).map((path) => (0, import_node_path9.dirname)((0, import_node_path9.resolve)(path)))
+    (0, import_node_path10.dirname)((0, import_node_path10.resolve)(input.missingPath)),
+    ...(input.approvedWorkspacePaths ?? []).map((path) => (0, import_node_path10.dirname)((0, import_node_path10.resolve)(path)))
   ].filter((path, index, paths) => paths.indexOf(path) === index);
   const candidates = [];
   for (const root of searchRoots) {
@@ -26078,19 +27376,19 @@ function discoverRelocatedWorkspace(input) {
     }
   }
   const matches = [];
-  for (const candidate of new Set(candidates.map((path) => (0, import_node_path9.resolve)(path)))) {
+  for (const candidate of new Set(candidates.map((path) => (0, import_node_path10.resolve)(path)))) {
     const remote = (input.probe ?? DEFAULT_PROBE).gitRemoteUrl(candidate);
     const identity = remote ? normalizeRepositoryIdentity(remote) : null;
-    if (identity && identities.has(identity)) matches.push((0, import_node_path9.resolve)(candidate));
+    if (identity && identities.has(identity)) matches.push((0, import_node_path10.resolve)(candidate));
     if (matches.length > 1) return null;
   }
   return matches[0] ?? null;
 }
 
 // src/workspace-run-lease.ts
-var import_node_child_process5 = require("child_process");
-var import_node_fs12 = require("fs");
-var import_node_path10 = require("path");
+var import_node_child_process6 = require("child_process");
+var import_node_fs13 = require("fs");
+var import_node_path11 = require("path");
 var WORKSPACE_LEASE_CHECK_INTERVAL_MS = 1e3;
 function parsePositiveMs(value2, fallback) {
   const parsed = value2 ? Number(value2) : Number.NaN;
@@ -26101,7 +27399,7 @@ var WORKSPACE_LEASE_GIT_TIMEOUT_MS = parsePositiveMs(
   2e3
 );
 function gitValue(cwd, args) {
-  const result = (0, import_node_child_process5.spawnSync)("git", ["-C", cwd, ...args], {
+  const result = (0, import_node_child_process6.spawnSync)("git", ["-C", cwd, ...args], {
     encoding: "utf8",
     env: getDaemonCliEnvironment(),
     timeout: WORKSPACE_LEASE_GIT_TIMEOUT_MS
@@ -26110,17 +27408,17 @@ function gitValue(cwd, args) {
   return result.stdout.trim() || null;
 }
 function filesystemIdentity(path) {
-  const canonicalPath = import_node_fs12.realpathSync.native(path);
-  const stat = (0, import_node_fs12.statSync)(canonicalPath);
+  const canonicalPath = import_node_fs13.realpathSync.native(path);
+  const stat = (0, import_node_fs13.statSync)(canonicalPath);
   return `${canonicalPath}:${stat.dev}:${stat.ino}`;
 }
 function resolveGitPath(workspacePath, value2) {
-  return (0, import_node_path10.isAbsolute)(value2) ? value2 : (0, import_node_path10.resolve)(workspacePath, value2);
+  return (0, import_node_path11.isAbsolute)(value2) ? value2 : (0, import_node_path11.resolve)(workspacePath, value2);
 }
 var DEFAULT_PROBE2 = {
   snapshot: (workspacePath) => {
     try {
-      const canonicalWorkspacePath = import_node_fs12.realpathSync.native((0, import_node_path10.resolve)(workspacePath));
+      const canonicalWorkspacePath = import_node_fs13.realpathSync.native((0, import_node_path11.resolve)(workspacePath));
       const repositoryRoot = gitValue(canonicalWorkspacePath, ["rev-parse", "--show-toplevel"]);
       const gitDirectory = gitValue(canonicalWorkspacePath, ["rev-parse", "--git-dir"]);
       const commonDirectory = gitValue(canonicalWorkspacePath, ["rev-parse", "--git-common-dir"]);
@@ -26129,7 +27427,7 @@ var DEFAULT_PROBE2 = {
       const remote = gitValue(canonicalWorkspacePath, ["config", "--get", "remote.origin.url"]);
       const remoteIdentity = remote ? normalizeRepositoryIdentity(remote) : null;
       return {
-        workspacePath: (0, import_node_path10.resolve)(workspacePath),
+        workspacePath: (0, import_node_path11.resolve)(workspacePath),
         workspaceIdentity: filesystemIdentity(canonicalWorkspacePath),
         repositoryIdentity: `${filesystemIdentity(
           resolveGitPath(canonicalWorkspacePath, commonDirectory)
@@ -26143,7 +27441,7 @@ var DEFAULT_PROBE2 = {
   },
   pathExists: (workspacePath) => {
     try {
-      return (0, import_node_fs12.existsSync)((0, import_node_path10.resolve)(workspacePath));
+      return (0, import_node_fs13.existsSync)((0, import_node_path11.resolve)(workspacePath));
     } catch {
       return true;
     }
@@ -26174,7 +27472,7 @@ var WorkspaceRunLease = class _WorkspaceRunLease {
   static capture(targets, probe = DEFAULT_PROBE2) {
     const captured = [];
     for (const target of targets) {
-      const normalizedTarget = { ...target, workspacePath: (0, import_node_path10.resolve)(target.workspacePath) };
+      const normalizedTarget = { ...target, workspacePath: (0, import_node_path11.resolve)(target.workspacePath) };
       const identity = probe.snapshot(normalizedTarget.workspacePath);
       if (!identity) return { lease: null, failure: unavailableFailure(normalizedTarget) };
       if (normalizedTarget.expectedBranch && identity.branch !== normalizedTarget.expectedBranch) {
@@ -26316,34 +27614,62 @@ var PRODUCTION_API_URL = "https://api.tryalan.ai";
 var PRODUCTION_WS_URL = "wss://ws.tryalan.ai";
 var LOCAL_API_URL = "http://localhost:8400";
 var LOCAL_WS_URL = "ws://localhost:8401";
-function requiredString(params, key) {
+function requiredString2(params, key) {
   const value2 = params[key];
   if (typeof value2 !== "string" || value2.trim() === "") {
     throw new Error(`${key} is required`);
   }
   return value2;
 }
+var DIRTY_WORKSPACE_ACTIONS = /* @__PURE__ */ new Set([
+  "move_via_stash",
+  "commit_wip",
+  "discard",
+  "leave"
+]);
+function parseDirtyWorkspaceResolution(value2) {
+  if (value2 === void 0) return void 0;
+  if (!value2 || typeof value2 !== "object" || Array.isArray(value2)) {
+    throw new Error("dirtyResolution must be an object");
+  }
+  const raw = value2;
+  const parseAction = (key) => {
+    const action = raw[key];
+    if (action === void 0) return void 0;
+    if (typeof action !== "string" || !DIRTY_WORKSPACE_ACTIONS.has(action)) {
+      throw new Error(`${key} is not a supported dirty workspace action`);
+    }
+    return action;
+  };
+  return {
+    sourceAction: parseAction("sourceAction"),
+    destinationAction: parseAction("destinationAction"),
+    sourceCommitMessage: typeof raw.sourceCommitMessage === "string" ? raw.sourceCommitMessage : void 0,
+    destinationCommitMessage: typeof raw.destinationCommitMessage === "string" ? raw.destinationCommitMessage : void 0,
+    confirmDiscard: raw.confirmDiscard === true
+  };
+}
 function assertValidGitRef(ref, label) {
   if (!ref || ref.startsWith("-") || ref.includes("\0")) {
     throw new Error(`${label} is not a safe git ref`);
   }
-  const result = (0, import_node_child_process6.spawnSync)("git", ["check-ref-format", "--branch", ref], {
+  const result = (0, import_node_child_process7.spawnSync)("git", ["check-ref-format", "--branch", ref], {
     env: getDaemonCliEnvironment(),
     encoding: "utf8"
   });
   if (result.status !== 0) throw new Error(`${label} is not a valid git ref`);
 }
-function isPathContained(childPath, parentPath) {
-  const rel = (0, import_node_path11.relative)((0, import_node_path11.resolve)(parentPath), (0, import_node_path11.resolve)(childPath));
-  return rel === "" || !(0, import_node_path11.isAbsolute)(rel) && rel !== ".." && !rel.startsWith(`..${import_node_path11.sep}`);
+function isPathContained2(childPath, parentPath) {
+  const rel = (0, import_node_path12.relative)((0, import_node_path12.resolve)(parentPath), (0, import_node_path12.resolve)(childPath));
+  return rel === "" || !(0, import_node_path12.isAbsolute)(rel) && rel !== ".." && !rel.startsWith(`..${import_node_path12.sep}`);
 }
 function assertPathContained(childPath, parentPath, label) {
-  if (!isPathContained(childPath, parentPath)) {
+  if (!isPathContained2(childPath, parentPath)) {
     throw new Error(`${label} escapes allowed directory`);
   }
 }
 function git(cwd, args) {
-  const result = (0, import_node_child_process6.spawnSync)("git", args, {
+  const result = (0, import_node_child_process7.spawnSync)("git", args, {
     cwd,
     env: getDaemonCliEnvironment(),
     encoding: "utf8",
@@ -26362,14 +27688,23 @@ function gitSafe(cwd, args) {
   }
 }
 function worktreeDir(projectPath) {
-  const resolved = (0, import_node_path11.resolve)(projectPath);
-  return (0, import_node_path11.join)((0, import_node_path11.dirname)(resolved), `${(0, import_node_path11.basename)(resolved)}-alan-worktrees`);
+  const resolved = (0, import_node_path12.resolve)(projectPath);
+  return (0, import_node_path12.join)((0, import_node_path12.dirname)(resolved), `${(0, import_node_path12.basename)(resolved)}-alan-worktrees`);
+}
+function hasAlanWorktreeAncestor(targetPath) {
+  let cursor = (0, import_node_path12.resolve)(targetPath);
+  while (true) {
+    if ((0, import_node_path12.basename)(cursor).endsWith("-alan-worktrees")) return true;
+    const parent = (0, import_node_path12.dirname)(cursor);
+    if (parent === cursor) return false;
+    cursor = parent;
+  }
 }
 function pathSegment(value2) {
   return value2.toLowerCase().replace(/^alan\//, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 64) || "task";
 }
 function repoName(repoUrl, localPath) {
-  return repoUrl.replace(/\.git$/, "").split("/").pop() || (0, import_node_path11.basename)(localPath) || "repo";
+  return repoUrl.replace(/\.git$/, "").split("/").pop() || (0, import_node_path12.basename)(localPath) || "repo";
 }
 function findWorktreeByBranch(repoPath, branchName) {
   const output = gitSafe(repoPath, ["worktree", "list", "--porcelain"]);
@@ -26385,21 +27720,21 @@ function findWorktreeByBranch(repoPath, branchName) {
 function ensureGitWorktree(input) {
   assertValidGitRef(input.branchName, "branchName");
   assertValidGitRef(input.baseBranch, "baseBranch");
-  const repoPath = (0, import_node_path11.resolve)(input.repoPath);
+  const repoPath = (0, import_node_path12.resolve)(input.repoPath);
   const root = input.allowedRoot ?? worktreeDir(repoPath);
   const existingPath = findWorktreeByBranch(input.repoPath, input.branchName);
   if (existingPath) {
-    if ((0, import_node_path11.resolve)(existingPath) === repoPath) {
+    if ((0, import_node_path12.resolve)(existingPath) === repoPath) {
       throw new Error(`${input.branchName} is checked out in the shared checkout`);
     }
     return existingPath;
   }
   assertPathContained(input.worktreePath, root, "worktreePath");
-  (0, import_node_fs13.mkdirSync)((0, import_node_path11.dirname)(input.worktreePath), { recursive: true });
+  (0, import_node_fs14.mkdirSync)((0, import_node_path12.dirname)(input.worktreePath), { recursive: true });
   if (!gitSafe(input.repoPath, ["branch", "--list", input.branchName])) {
     git(input.repoPath, ["branch", input.branchName, input.baseBranch]);
   }
-  if ((0, import_node_fs13.existsSync)(input.worktreePath)) {
+  if ((0, import_node_fs14.existsSync)(input.worktreePath)) {
     if (gitSafe(input.worktreePath, ["branch", "--show-current"]) === input.branchName) {
       return input.worktreePath;
     }
@@ -26409,40 +27744,172 @@ function ensureGitWorktree(input) {
   return input.worktreePath;
 }
 function resolveProjectWorktreePaths(projectPath, gitRoot, gitWorktreePath) {
-  const resolvedProjectPath = (0, import_node_path11.resolve)(projectPath);
-  const resolvedGitRoot = (0, import_node_path11.resolve)(gitRoot);
-  const projectRelativePath = (0, import_node_path11.relative)(resolvedGitRoot, resolvedProjectPath);
-  if (projectRelativePath === ".." || projectRelativePath.startsWith(`..${import_node_path11.sep}`) || (0, import_node_path11.isAbsolute)(projectRelativePath)) {
+  const resolvedProjectPath = (0, import_node_path12.resolve)(projectPath);
+  const resolvedGitRoot = (0, import_node_path12.resolve)(gitRoot);
+  const projectRelativePath = (0, import_node_path12.relative)(resolvedGitRoot, resolvedProjectPath);
+  if (projectRelativePath === ".." || projectRelativePath.startsWith(`..${import_node_path12.sep}`) || (0, import_node_path12.isAbsolute)(projectRelativePath)) {
     throw new Error("The selected Project folder is outside its Git repository");
   }
   return {
     repoPath: resolvedGitRoot,
-    projectPath: projectRelativePath ? (0, import_node_path11.join)((0, import_node_path11.resolve)(gitWorktreePath), projectRelativePath) : (0, import_node_path11.resolve)(gitWorktreePath)
+    projectPath: projectRelativePath ? (0, import_node_path12.join)((0, import_node_path12.resolve)(gitWorktreePath), projectRelativePath) : (0, import_node_path12.resolve)(gitWorktreePath)
+  };
+}
+function preflightLocalWorkspaceMigration(params) {
+  const direction = params.direction;
+  if (direction !== "to-checkout" && direction !== "to-worktree") {
+    throw new Error("direction must be to-checkout or to-worktree");
+  }
+  const targets = Array.isArray(params.targets) ? params.targets : [];
+  if (targets.length !== 1) {
+    throw new Error("Dirty workspace migration currently supports exactly one repository");
+  }
+  const rawTarget = targets[0];
+  const projectPath = (0, import_node_path12.resolve)(requiredString2(rawTarget, "projectPath"));
+  const projectRootOutput = gitSafe(projectPath, ["rev-parse", "--show-toplevel"]);
+  if (!projectRootOutput) {
+    throw new Error("The selected Project folder is not inside a Git repository");
+  }
+  const projectRoot = (0, import_node_path12.resolve)(projectRootOutput);
+  if (direction === "to-worktree") {
+    const result2 = preflightWorkspaceMigration(
+      {
+        direction: "checkout_to_worktree",
+        sourcePath: projectRoot
+      },
+      git
+    );
+    return {
+      direction,
+      source: result2.source,
+      destination: null,
+      requiresResolution: result2.source.isDirty
+    };
+  }
+  const requestedWorktreePath = (0, import_node_path12.resolve)(requiredString2(rawTarget, "worktreePath"));
+  const worktreeRootOutput = gitSafe(requestedWorktreePath, ["rev-parse", "--show-toplevel"]);
+  if (!worktreeRootOutput) {
+    throw new Error("The task worktree is not a registered Git worktree");
+  }
+  const result = preflightWorkspaceMigration(
+    {
+      direction: "worktree_to_checkout",
+      sourcePath: (0, import_node_path12.resolve)(worktreeRootOutput),
+      destinationPath: projectRoot
+    },
+    git
+  );
+  return {
+    direction,
+    source: result.source,
+    destination: result.destination,
+    requiresResolution: result.source.isDirty || Boolean(result.destination?.isDirty)
+  };
+}
+function statusLocalWorkspace(params) {
+  const requestedPath = (0, import_node_path12.resolve)(requiredString2(params, "worktreePath"));
+  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_path12.resolve)(rootOutput);
+  const tree = preflightGitTree(root, git);
+  const headSha = gitSafe(root, ["rev-parse", "HEAD"]) || null;
+  const upstream = gitSafe(root, ["rev-parse", "--abbrev-ref", "@{upstream}"]);
+  const hasUpstream = upstream !== "";
+  let ahead = null;
+  let behind = null;
+  if (hasUpstream) {
+    const counts = gitSafe(root, ["rev-list", "--left-right", "--count", "@{upstream}...HEAD"]);
+    const [behindRaw, aheadRaw] = counts.split(/\s+/);
+    const parsedBehind = Number.parseInt(behindRaw ?? "", 10);
+    const parsedAhead = Number.parseInt(aheadRaw ?? "", 10);
+    behind = Number.isNaN(parsedBehind) ? null : parsedBehind;
+    ahead = Number.isNaN(parsedAhead) ? null : parsedAhead;
+  }
+  return {
+    branch: tree.currentBranch,
+    headSha,
+    dirty: tree.isDirty,
+    filesChanged: tree.dirtyFileCount,
+    ahead,
+    behind,
+    hasUpstream
   };
 }
+function ensureGitWorktreeWithDirtyResolution(input, resolution) {
+  const repoPath = (0, import_node_path12.resolve)(input.repoPath);
+  const before = preflightGitTree(repoPath, git);
+  let sourceStash = null;
+  if (before.isDirty) {
+    const action = resolution?.sourceAction;
+    if (!action) {
+      throw new Error(
+        `The Project checkout has ${before.dirtyFileCount} uncommitted file${before.dirtyFileCount === 1 ? "" : "s"}. Choose how to preserve them before moving into a worktree.`
+      );
+    }
+    if (action === "commit_wip" && before.currentBranch !== input.baseBranch) {
+      throw new Error(
+        `Commit as WIP would stay on "${before.currentBranch ?? "the current checkout"}", not the selected base "${input.baseBranch}". Choose Move changes with task instead.`
+      );
+    }
+    const resolved = resolveDirtyTree(
+      {
+        cwd: repoPath,
+        action,
+        operation: "checkout-to-worktree",
+        confirmDiscard: resolution?.confirmDiscard
+      },
+      { git }
+    );
+    sourceStash = resolved.stash;
+  }
+  const existingPath = findWorktreeByBranch(repoPath, input.branchName);
+  const worktreePath = ensureGitWorktree(input);
+  if (!sourceStash) return worktreePath;
+  try {
+    applyMigrationStash({ cwd: worktreePath, stash: sourceStash }, git);
+    return worktreePath;
+  } catch (error) {
+    if (!existingPath) {
+      gitSafe(worktreePath, ["reset", "--hard", "HEAD"]);
+      gitSafe(worktreePath, ["clean", "-fd"]);
+      gitSafe(repoPath, ["worktree", "remove", worktreePath]);
+      gitSafe(repoPath, ["worktree", "prune"]);
+    }
+    throw error;
+  }
+}
 function ensureWorktree(params) {
   const input = {
-    projectPath: requiredString(params, "projectPath"),
-    taskId: requiredString(params, "taskId"),
-    branchName: requiredString(params, "branchName"),
+    projectPath: requiredString2(params, "projectPath"),
+    taskId: requiredString2(params, "taskId"),
+    branchName: requiredString2(params, "branchName"),
     baseBranch: typeof params.baseBranch === "string" ? params.baseBranch : void 0,
-    repoLocalPaths: Array.isArray(params.repoLocalPaths) ? params.repoLocalPaths : []
+    repoLocalPaths: Array.isArray(params.repoLocalPaths) ? params.repoLocalPaths : [],
+    dirtyResolution: parseDirtyWorkspaceResolution(params.dirtyResolution)
   };
+  if ((input.repoLocalPaths?.length ?? 0) > 1) {
+    throw new Error("A task worktree requires exactly one Git repository.");
+  }
   if (input.repoLocalPaths?.length) {
-    const taskRoot2 = (0, import_node_path11.join)(
+    const taskRoot2 = (0, import_node_path12.join)(
       worktreeDir(input.projectPath),
       `${pathSegment(input.branchName)}-${input.taskId.slice(0, 8)}`
     );
     return {
       worktrees: input.repoLocalPaths.map((repo) => {
         const baseBranch2 = repo.branch || input.baseBranch || "main";
-        const worktreePath2 = ensureGitWorktree({
-          repoPath: repo.localPath,
-          worktreePath: (0, import_node_path11.join)(taskRoot2, pathSegment(repoName(repo.repoUrl, repo.localPath))),
-          branchName: input.branchName,
-          baseBranch: baseBranch2,
-          allowedRoot: worktreeDir(input.projectPath)
-        });
+        const worktreePath2 = ensureGitWorktreeWithDirtyResolution(
+          {
+            repoPath: repo.localPath,
+            worktreePath: (0, import_node_path12.join)(taskRoot2, pathSegment(repoName(repo.repoUrl, repo.localPath))),
+            branchName: input.branchName,
+            baseBranch: baseBranch2,
+            allowedRoot: worktreeDir(input.projectPath)
+          },
+          input.dirtyResolution
+        );
         return {
           repoId: repo.repoId ?? null,
           repoUrl: repo.repoUrl,
@@ -26450,26 +27917,30 @@ function ensureWorktree(params) {
           branchName: input.branchName,
           baseBranch: baseBranch2
         };
-      })
+      }),
+      ...input.dirtyResolution ? { dirtyResolution: input.dirtyResolution } : {}
     };
   }
-  const gitRoot = gitSafe((0, import_node_path11.resolve)(input.projectPath), ["rev-parse", "--show-toplevel"]);
+  const gitRoot = gitSafe((0, import_node_path12.resolve)(input.projectPath), ["rev-parse", "--show-toplevel"]);
   if (!gitRoot) {
     throw new Error("The selected Project folder is not inside a Git repository");
   }
-  const repoPath = (0, import_node_path11.resolve)(gitRoot);
+  const repoPath = (0, import_node_path12.resolve)(gitRoot);
   const baseBranch = input.baseBranch || gitSafe(repoPath, ["branch", "--show-current"]) || "HEAD";
-  const taskRoot = (0, import_node_path11.join)(
+  const taskRoot = (0, import_node_path12.join)(
     worktreeDir(repoPath),
     `${pathSegment(input.branchName)}-${input.taskId.slice(0, 8)}`
   );
   resolveProjectWorktreePaths(input.projectPath, repoPath, taskRoot);
-  const worktreePath = ensureGitWorktree({
-    repoPath,
-    worktreePath: taskRoot,
-    branchName: input.branchName,
-    baseBranch
-  });
+  const worktreePath = ensureGitWorktreeWithDirtyResolution(
+    {
+      repoPath,
+      worktreePath: taskRoot,
+      branchName: input.branchName,
+      baseBranch
+    },
+    input.dirtyResolution
+  );
   const projectWorktreePath = resolveProjectWorktreePaths(
     input.projectPath,
     repoPath,
@@ -26482,13 +27953,286 @@ function ensureWorktree(params) {
         branchName: input.branchName,
         baseBranch
       }
-    ]
+    ],
+    ...input.dirtyResolution ? { dirtyResolution: input.dirtyResolution } : {}
+  };
+}
+function listRegisteredWorktrees(cwd) {
+  return git(cwd, ["worktree", "list", "--porcelain"]).split("\n\n").flatMap((entry) => {
+    const lines = entry.split("\n");
+    const path = lines.find((line) => line.startsWith("worktree "))?.slice("worktree ".length);
+    if (!path) return [];
+    return [
+      {
+        path: (0, import_node_path12.resolve)(path),
+        branch: lines.find((line) => line.startsWith("branch "))?.slice("branch ".length).replace("refs/heads/", "")
+      }
+    ];
+  });
+}
+function removeWorktreesIfClean(params, removeGit = git) {
+  const projectPath = (0, import_node_path12.resolve)(requiredString2(params, "projectPath"));
+  const targets = Array.isArray(params.targets) ? params.targets : [];
+  if (targets.length === 0) throw new Error("At least one worktree target is required");
+  const projectRootOutput = gitSafe(projectPath, ["rev-parse", "--show-toplevel"]);
+  const projectRoot = projectRootOutput ? (0, import_node_path12.resolve)(projectRootOutput) : null;
+  const projectRegistrations = projectRoot ? listRegisteredWorktrees(projectRoot) : [];
+  const planned = targets.map((target) => {
+    const rawTarget = target;
+    const requestedPath = (0, import_node_path12.resolve)(requiredString2(rawTarget, "worktreePath"));
+    const branchName = requiredString2(rawTarget, "branchName");
+    assertValidGitRef(branchName, "branchName");
+    const registrationSets = [];
+    if (projectRegistrations.length > 0) registrationSets.push(projectRegistrations);
+    if ((0, import_node_fs14.existsSync)(requestedPath)) {
+      const requestedRoot = gitSafe(requestedPath, ["rev-parse", "--show-toplevel"]);
+      if (!requestedRoot) {
+        throw new Error(
+          `The earlier task worktree is not a registered Git worktree: ${requestedPath}`
+        );
+      }
+      const requestedRegistrations = listRegisteredWorktrees((0, import_node_path12.resolve)(requestedRoot));
+      if (!registrationSets.some(
+        (entries) => entries.length === requestedRegistrations.length && entries.every((entry, index) => entry.path === requestedRegistrations[index]?.path)
+      )) {
+        registrationSets.push(requestedRegistrations);
+      }
+    }
+    for (const registrations of registrationSets) {
+      const mainRoot = registrations[0]?.path;
+      const registeredTarget = registrations.find(
+        (entry) => requestedPath === entry.path || isPathContained2(requestedPath, entry.path)
+      );
+      if (!registeredTarget || !mainRoot) continue;
+      if (registeredTarget.path === mainRoot) {
+        throw new Error("Refusing to remove the Project's main checkout");
+      }
+      if (registeredTarget.branch !== branchName) {
+        throw new Error(
+          `The registered worktree branch changed from "${branchName}" to "${registeredTarget.branch ?? "detached HEAD"}".`
+        );
+      }
+      const allowedRoots = [
+        worktreeDir(mainRoot),
+        worktreeDir(projectPath),
+        ...projectRoot ? [worktreeDir(projectRoot)] : []
+      ];
+      if (!allowedRoots.some((root) => isPathContained2(registeredTarget.path, root))) {
+        throw new Error("The registered worktree is outside an Alan-managed worktree directory");
+      }
+      if (git(registeredTarget.path, ["status", "--porcelain"]).trim()) {
+        throw new Error(
+          `The earlier task worktree has uncommitted changes at ${requestedPath}. Commit or discard them before changing Project, branch, or worktree mode.`
+        );
+      }
+      return {
+        requestedPath,
+        worktreeRoot: registeredTarget.path,
+        mainRoot,
+        branchName,
+        replayed: false
+      };
+    }
+    if (!(0, import_node_fs14.existsSync)(requestedPath) && hasAlanWorktreeAncestor(requestedPath)) {
+      return {
+        requestedPath,
+        worktreeRoot: null,
+        mainRoot: null,
+        branchName,
+        replayed: true
+      };
+    }
+    throw new Error(
+      `The earlier task worktree is not safely registered and was not changed: ${requestedPath}`
+    );
+  });
+  const removalRoots = planned.flatMap(
+    (target) => target.worktreeRoot && target.mainRoot ? [{ worktreeRoot: target.worktreeRoot, mainRoot: target.mainRoot }] : []
+  );
+  if (new Set(removalRoots.map(({ worktreeRoot }) => worktreeRoot)).size !== removalRoots.length) {
+    throw new Error("Duplicate worktree targets were not changed");
+  }
+  for (const target of removalRoots) {
+    removeGit(target.mainRoot, ["worktree", "remove", target.worktreeRoot]);
+    gitSafe(target.mainRoot, ["worktree", "prune"]);
+  }
+  return {
+    ok: true,
+    removed: planned.map(({ requestedPath, branchName, replayed }) => ({
+      worktreePath: requestedPath,
+      branchName,
+      replayed
+    }))
+  };
+}
+function migrateWorktreeToCheckout(params, removeGit = git) {
+  const dirtyResolution = parseDirtyWorkspaceResolution(params.dirtyResolution);
+  const targets = Array.isArray(params.targets) ? params.targets : [];
+  if (targets.length !== 1) {
+    throw new Error(
+      "Multi-repository worktree migration is not supported; no repositories were changed."
+    );
+  }
+  const target = targets[0];
+  const rawTarget = target;
+  const projectPath = (0, import_node_path12.resolve)(requiredString2(rawTarget, "projectPath"));
+  const requestedWorktreePath = (0, import_node_path12.resolve)(requiredString2(rawTarget, "worktreePath"));
+  const branch = requiredString2(rawTarget, "branch");
+  assertValidGitRef(branch, "branch");
+  const projectRootOutput = gitSafe(projectPath, ["rev-parse", "--show-toplevel"]);
+  if (!projectRootOutput) {
+    throw new Error("The selected Project folder is not inside a Git repository");
+  }
+  const projectRoot = (0, import_node_path12.resolve)(projectRootOutput);
+  const projectRelativePath = (0, import_node_path12.relative)(projectRoot, projectPath);
+  if (projectRelativePath === ".." || projectRelativePath.startsWith(`..${import_node_path12.sep}`) || (0, import_node_path12.isAbsolute)(projectRelativePath)) {
+    throw new Error("The selected Project folder is outside its Git repository");
+  }
+  const registered = git(projectRoot, ["worktree", "list", "--porcelain"]).split("\n\n").map((entry) => {
+    const lines = entry.split("\n");
+    return {
+      path: lines.find((line) => line.startsWith("worktree "))?.slice("worktree ".length),
+      branch: lines.find((line) => line.startsWith("branch "))?.slice("branch ".length).replace("refs/heads/", "")
+    };
+  });
+  const registeredTarget = registered.find(({ path, branch: registeredBranch }) => {
+    if (!path || registeredBranch !== branch) return false;
+    const root = (0, import_node_path12.resolve)(path);
+    return requestedWorktreePath === root || isPathContained2(requestedWorktreePath, root);
+  });
+  const currentBranch = gitSafe(projectRoot, ["branch", "--show-current"]);
+  if (!registeredTarget?.path) {
+    if (currentBranch === branch) {
+      return {
+        ok: true,
+        replayed: true,
+        migrated: [{ ...target, projectPath, worktreePath: requestedWorktreePath, branch }],
+        ...dirtyResolution ? { dirtyResolution } : {}
+      };
+    }
+    throw new Error(
+      `The task worktree is no longer registered and the Project is not on branch "${branch}".`
+    );
+  }
+  const worktreeRoot = (0, import_node_path12.resolve)(registeredTarget.path);
+  const worktreeRelativePath = (0, import_node_path12.relative)(worktreeRoot, requestedWorktreePath);
+  if (worktreeRelativePath !== projectRelativePath) {
+    throw new Error(
+      "The configured Project and task worktree do not point at the same repository subdirectory."
+    );
+  }
+  const allowedRoots = [worktreeDir(projectRoot), worktreeDir(projectPath)];
+  if (!allowedRoots.some((allowedRoot) => isPathContained2(worktreeRoot, allowedRoot))) {
+    throw new Error("The task worktree escapes the Project worktree directory.");
+  }
+  if (!(0, import_node_fs14.existsSync)(worktreeRoot)) {
+    throw new Error(`Worktree directory not found: ${worktreeRoot}`);
+  }
+  const sourceBefore = preflightGitTree(worktreeRoot, git);
+  const destinationBefore = preflightGitTree(projectRoot, git);
+  if (sourceBefore.isDirty && !dirtyResolution?.sourceAction) {
+    throw new Error(
+      `The task worktree has ${sourceBefore.dirtyFileCount} uncommitted file${sourceBefore.dirtyFileCount === 1 ? "" : "s"}. Choose how to preserve them before migrating.`
+    );
+  }
+  if (destinationBefore.isDirty && !dirtyResolution?.destinationAction) {
+    throw new Error(
+      `The Project checkout has ${destinationBefore.dirtyFileCount} uncommitted file${destinationBefore.dirtyFileCount === 1 ? "" : "s"}. Choose how to preserve them before migrating.`
+    );
+  }
+  if (sourceBefore.isDirty && dirtyResolution?.sourceAction === "leave") {
+    throw new Error("Task worktree changes cannot be left behind when releasing the worktree.");
+  }
+  if (destinationBefore.isDirty && dirtyResolution?.destinationAction === "leave") {
+    throw new Error("Project checkout changes cannot stay in place while switching branches.");
+  }
+  const destinationResolved = destinationBefore.isDirty ? resolveDirtyTree(
+    {
+      cwd: projectRoot,
+      action: dirtyResolution?.destinationAction ?? "leave",
+      operation: "worktree-to-checkout-destination",
+      confirmDiscard: dirtyResolution?.confirmDiscard
+    },
+    { git }
+  ) : null;
+  const sourceResolved = sourceBefore.isDirty ? resolveDirtyTree(
+    {
+      cwd: worktreeRoot,
+      action: dirtyResolution?.sourceAction ?? "leave",
+      operation: "worktree-to-checkout-source",
+      confirmDiscard: dirtyResolution?.confirmDiscard
+    },
+    { git }
+  ) : null;
+  try {
+    git(projectRoot, ["show-ref", "--verify", "--quiet", `refs/heads/${branch}`]);
+  } catch {
+    throw new Error(`The target branch "${branch}" is not available in the Project.`);
+  }
+  removeGit(projectRoot, ["worktree", "remove", worktreeRoot]);
+  gitSafe(projectRoot, ["worktree", "prune"]);
+  try {
+    git(projectRoot, ["checkout", branch]);
+  } catch (checkoutError) {
+    try {
+      git(projectRoot, ["worktree", "add", worktreeRoot, branch]);
+      if (sourceResolved?.stash) {
+        applyMigrationStash({ cwd: worktreeRoot, stash: sourceResolved.stash }, git);
+      }
+      if (destinationResolved?.stash) {
+        applyMigrationStash({ cwd: projectRoot, stash: destinationResolved.stash }, git);
+      }
+    } catch (restoreError) {
+      const checkoutMessage2 = checkoutError instanceof Error ? checkoutError.message : String(checkoutError);
+      const restoreMessage = restoreError instanceof Error ? restoreError.message : String(restoreError);
+      throw new Error(
+        `Project checkout failed (${checkoutMessage2}) and the task worktree could not be restored (${restoreMessage}).`
+      );
+    }
+    const checkoutMessage = checkoutError instanceof Error ? checkoutError.message : String(checkoutError);
+    throw new Error(
+      `Project checkout failed (${checkoutMessage}); restored the task worktree at ${worktreeRoot}.`
+    );
+  }
+  if (sourceResolved?.stash) {
+    try {
+      applyMigrationStash({ cwd: projectRoot, stash: sourceResolved.stash }, git);
+    } catch (applyError) {
+      gitSafe(projectRoot, ["reset", "--hard", "HEAD"]);
+      gitSafe(projectRoot, ["clean", "-fd"]);
+      try {
+        if (destinationBefore.currentBranch && destinationBefore.currentBranch !== branch) {
+          git(projectRoot, ["checkout", destinationBefore.currentBranch]);
+        }
+        git(projectRoot, ["worktree", "add", worktreeRoot, branch]);
+        applyMigrationStash({ cwd: worktreeRoot, stash: sourceResolved.stash }, git);
+        if (destinationResolved?.stash) {
+          applyMigrationStash({ cwd: projectRoot, stash: destinationResolved.stash }, git);
+        }
+      } catch (restoreError) {
+        const applyMessage2 = applyError instanceof Error ? applyError.message : String(applyError);
+        const restoreMessage = restoreError instanceof Error ? restoreError.message : String(restoreError);
+        throw new Error(
+          `Moving uncommitted changes failed (${applyMessage2}); automatic workspace restoration also failed (${restoreMessage}). The named migration stash was preserved.`
+        );
+      }
+      const applyMessage = applyError instanceof Error ? applyError.message : String(applyError);
+      throw new Error(
+        `Moving uncommitted changes failed (${applyMessage}); the original worktree and checkout were restored.`
+      );
+    }
+  }
+  return {
+    ok: true,
+    replayed: false,
+    migrated: [{ ...target, projectPath, worktreePath: requestedWorktreePath, branch }],
+    ...dirtyResolution ? { dirtyResolution } : {}
   };
 }
 function ensureSharedCheckoutBranch(input) {
   assertValidGitRef(input.branchName, "branchName");
   assertValidGitRef(input.baseBranch, "baseBranch");
-  const repoPath = (0, import_node_path11.resolve)(input.repoPath);
+  const repoPath = (0, import_node_path12.resolve)(input.repoPath);
   if (gitSafe(repoPath, ["rev-parse", "--is-inside-work-tree"]) !== "true") {
     return { checkedOut: false, reason: `${repoPath} is not a git work tree` };
   }
@@ -26533,7 +28277,7 @@ function resolveSharedCheckoutTargets(input) {
 }
 function resolveRuntimeCwd(payload) {
   const multiRepoWorktree = payload.worktreeInfo?.allWorktrees?.[0]?.worktreePath;
-  if (multiRepoWorktree) return (0, import_node_path11.dirname)(multiRepoWorktree);
+  if (multiRepoWorktree) return (0, import_node_path12.dirname)(multiRepoWorktree);
   if (isAlanDefaultWorkspace(payload.projectPath)) return resolveAlanDefaultWorkspacePath();
   return payload.worktreeInfo?.worktreePath ?? payload.projectPath ?? process.cwd();
 }
@@ -26646,14 +28390,14 @@ function localServiceOwnerPayload(owner) {
   ].join("\0");
 }
 function signLocalServiceOwner(secret, owner) {
-  return (0, import_node_crypto3.createHmac)("sha256", secret).update(localServiceOwnerPayload(owner)).digest("hex");
+  return (0, import_node_crypto5.createHmac)("sha256", secret).update(localServiceOwnerPayload(owner)).digest("hex");
 }
 function signLocalServiceAdoption(secret, serviceId, challenge) {
-  return (0, import_node_crypto3.createHmac)("sha256", secret).update(["adopt", serviceId, challenge].join("\0")).digest("hex");
+  return (0, import_node_crypto5.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_crypto3.timingSafeEqual)(Buffer.from(actual, "hex"), Buffer.from(expected, "hex"));
+  return (0, import_node_crypto5.timingSafeEqual)(Buffer.from(actual, "hex"), Buffer.from(expected, "hex"));
 }
 function parseLocalServiceOwner(value2) {
   if (!value2 || typeof value2 !== "object") return null;
@@ -26755,12 +28499,12 @@ function getConfigPath() {
   return process.env.ALAN_AGENT_CONFIG_PATH ?? boundAgentConfigPath ?? resolveAgentConfigPath({ profile: "production" });
 }
 function getEndpointDefaultsPath() {
-  return process.env.ALAN_AGENT_ENDPOINTS_PATH ?? (0, import_node_path11.join)((0, import_node_path11.dirname)(getConfigPath()), "endpoints.json");
+  return process.env.ALAN_AGENT_ENDPOINTS_PATH ?? (0, import_node_path12.join)((0, import_node_path12.dirname)(getConfigPath()), "endpoints.json");
 }
 function readConfig() {
   const configPath = getConfigPath();
-  if (!(0, import_node_fs13.existsSync)(configPath)) return {};
-  const parsed = JSON.parse((0, import_node_fs13.readFileSync)(configPath, "utf8"));
+  if (!(0, import_node_fs14.existsSync)(configPath)) return {};
+  const parsed = JSON.parse((0, import_node_fs14.readFileSync)(configPath, "utf8"));
   const sanitized = sanitizeAgentConfig(parsed);
   if (Object.keys(parsed).some((key) => !Object.hasOwn(sanitized, key))) {
     writeConfig(sanitized);
@@ -26776,27 +28520,27 @@ function readConfigForRegistration() {
 }
 function readEndpointDefaults() {
   const endpointsPath = getEndpointDefaultsPath();
-  if (!(0, import_node_fs13.existsSync)(endpointsPath)) return {};
+  if (!(0, import_node_fs14.existsSync)(endpointsPath)) return {};
   try {
-    return JSON.parse((0, import_node_fs13.readFileSync)(endpointsPath, "utf8"));
+    return JSON.parse((0, import_node_fs14.readFileSync)(endpointsPath, "utf8"));
   } catch {
     return {};
   }
 }
 function writeConfig(config) {
   const configPath = getConfigPath();
-  (0, import_node_fs13.mkdirSync)((0, import_node_path11.dirname)(configPath), { recursive: true, mode: 448 });
-  const pendingPath = `${configPath}.pending-${process.pid}-${(0, import_node_crypto3.randomBytes)(6).toString("hex")}`;
+  (0, import_node_fs14.mkdirSync)((0, import_node_path12.dirname)(configPath), { recursive: true, mode: 448 });
+  const pendingPath = `${configPath}.pending-${process.pid}-${(0, import_node_crypto5.randomBytes)(6).toString("hex")}`;
   try {
-    (0, import_node_fs13.writeFileSync)(
+    (0, import_node_fs14.writeFileSync)(
       pendingPath,
       JSON.stringify(sanitizeAgentConfig(config), null, 2),
       { mode: 384 }
     );
-    (0, import_node_fs13.chmodSync)(pendingPath, 384);
-    (0, import_node_fs13.renameSync)(pendingPath, configPath);
+    (0, import_node_fs14.chmodSync)(pendingPath, 384);
+    (0, import_node_fs14.renameSync)(pendingPath, configPath);
   } finally {
-    (0, import_node_fs13.rmSync)(pendingPath, { force: true });
+    (0, import_node_fs14.rmSync)(pendingPath, { force: true });
   }
 }
 function maintenanceLeasePath(configPath) {
@@ -26804,9 +28548,9 @@ function maintenanceLeasePath(configPath) {
 }
 function readLocalDaemonMaintenanceLease(configPath, nowMs = Date.now()) {
   const path = maintenanceLeasePath(configPath);
-  if (!(0, import_node_fs13.existsSync)(path)) return null;
+  if (!(0, import_node_fs14.existsSync)(path)) return null;
   try {
-    const lease = JSON.parse((0, import_node_fs13.readFileSync)(path, "utf8"));
+    const lease = JSON.parse((0, import_node_fs14.readFileSync)(path, "utf8"));
     if (lease.version !== 1 || typeof lease.id !== "string" || lease.reason !== "credential_cleanup" && lease.reason !== "daemon_startup" && lease.reason !== "watchdog" || !(lease.reason === "credential_cleanup" && lease.expiresAtMs === null || typeof lease.expiresAtMs === "number" && Number.isFinite(lease.expiresAtMs))) {
       throw new Error("invalid maintenance lease");
     }
@@ -26823,8 +28567,8 @@ function readLocalDaemonMaintenanceLease(configPath, nowMs = Date.now()) {
       expiresAtMs: nowMs + 5e3
     };
     try {
-      (0, import_node_fs13.writeFileSync)(path, JSON.stringify(fallback), { mode: 384 });
-      (0, import_node_fs13.chmodSync)(path, 384);
+      (0, import_node_fs14.writeFileSync)(path, JSON.stringify(fallback), { mode: 384 });
+      (0, import_node_fs14.chmodSync)(path, 384);
     } catch {
     }
     return fallback;
@@ -26835,15 +28579,15 @@ function acquireLocalDaemonMaintenanceLease(configPath, reason, ttlMs = 5e3) {
   if (existing) return { acquired: false, lease: existing };
   const lease = {
     version: 1,
-    id: (0, import_node_crypto3.randomUUID)(),
+    id: (0, import_node_crypto5.randomUUID)(),
     reason,
     expiresAtMs: reason === "credential_cleanup" ? null : Date.now() + Math.max(1e3, Math.min(ttlMs, 6e4))
   };
   const path = maintenanceLeasePath(configPath);
-  (0, import_node_fs13.mkdirSync)((0, import_node_path11.dirname)(path), { recursive: true, mode: 448 });
+  (0, import_node_fs14.mkdirSync)((0, import_node_path12.dirname)(path), { recursive: true, mode: 448 });
   try {
-    (0, import_node_fs13.writeFileSync)(path, JSON.stringify(lease), { mode: 384, flag: "wx" });
-    (0, import_node_fs13.chmodSync)(path, 384);
+    (0, import_node_fs14.writeFileSync)(path, JSON.stringify(lease), { mode: 384, flag: "wx" });
+    (0, import_node_fs14.chmodSync)(path, 384);
     return { acquired: true, lease };
   } catch (error) {
     const raced = readLocalDaemonMaintenanceLease(configPath);
@@ -26859,9 +28603,9 @@ function daemonOwnerLeasePath(configPath) {
 }
 function readLocalDaemonOwnerLease(configPath) {
   const path = daemonOwnerLeasePath(configPath);
-  if (!(0, import_node_fs13.existsSync)(path)) return null;
+  if (!(0, import_node_fs14.existsSync)(path)) return null;
   try {
-    const lease = JSON.parse((0, import_node_fs13.readFileSync)(path, "utf8"));
+    const lease = JSON.parse((0, import_node_fs14.readFileSync)(path, "utf8"));
     if (lease.version !== 1 || typeof lease.id !== "string" || typeof lease.daemonSessionId !== "string" || !Number.isSafeInteger(lease.pid) || lease.pid <= 0 || typeof lease.startedAtMs !== "number" || !Number.isFinite(lease.startedAtMs) || typeof lease.runtimeId !== "string" || typeof lease.localServiceId !== "string" || !Number.isSafeInteger(lease.localApiPort) || lease.localApiPort < 0 || lease.localApiPort > 65535 || typeof lease.localApiToken !== "string" || lease.localApiToken.length === 0) {
       throw new Error("invalid daemon owner lease");
     }
@@ -26903,7 +28647,7 @@ async function acquireLocalDaemonOwnerLease(input) {
   }
   const lease = {
     version: 1,
-    id: (0, import_node_crypto3.randomUUID)(),
+    id: (0, import_node_crypto5.randomUUID)(),
     daemonSessionId: input.daemonSessionId,
     pid: process.pid,
     startedAtMs: Date.now(),
@@ -26913,10 +28657,10 @@ async function acquireLocalDaemonOwnerLease(input) {
     localApiToken: input.localApiToken
   };
   const path = daemonOwnerLeasePath(input.configPath);
-  (0, import_node_fs13.mkdirSync)((0, import_node_path11.dirname)(path), { recursive: true, mode: 448 });
+  (0, import_node_fs14.mkdirSync)((0, import_node_path12.dirname)(path), { recursive: true, mode: 448 });
   try {
-    (0, import_node_fs13.writeFileSync)(path, JSON.stringify(lease), { mode: 384, flag: "wx" });
-    (0, import_node_fs13.chmodSync)(path, 384);
+    (0, import_node_fs14.writeFileSync)(path, JSON.stringify(lease), { mode: 384, flag: "wx" });
+    (0, import_node_fs14.chmodSync)(path, 384);
     return { acquired: true, lease };
   } catch (error) {
     const raced = readLocalDaemonOwnerLease(input.configPath);
@@ -26931,27 +28675,27 @@ function updateLocalDaemonOwnerEndpoint(configPath, lease, localApiPort) {
   const path = daemonOwnerLeasePath(configPath);
   const pendingPath = `${path}.pending-${lease.id}`;
   try {
-    (0, import_node_fs13.writeFileSync)(pendingPath, JSON.stringify(updated), { mode: 384 });
-    (0, import_node_fs13.chmodSync)(pendingPath, 384);
-    (0, import_node_fs13.renameSync)(pendingPath, path);
+    (0, import_node_fs14.writeFileSync)(pendingPath, JSON.stringify(updated), { mode: 384 });
+    (0, import_node_fs14.chmodSync)(pendingPath, 384);
+    (0, import_node_fs14.renameSync)(pendingPath, path);
     return updated;
   } finally {
-    (0, import_node_fs13.rmSync)(pendingPath, { force: true });
+    (0, import_node_fs14.rmSync)(pendingPath, { force: true });
   }
 }
 function releaseLocalDaemonOwnerLease(configPath, leaseId) {
   releaseOwnedJsonFile(daemonOwnerLeasePath(configPath), leaseId);
 }
 function releaseOwnedJsonFile(path, ownerId, ownerField = "id") {
-  const releasePath = `${path}.release-${process.pid}-${(0, import_node_crypto3.randomBytes)(6).toString("hex")}`;
+  const releasePath = `${path}.release-${process.pid}-${(0, import_node_crypto5.randomBytes)(6).toString("hex")}`;
   try {
-    (0, import_node_fs13.renameSync)(path, releasePath);
+    (0, import_node_fs14.renameSync)(path, releasePath);
   } catch (error) {
     if (error.code === "ENOENT") return;
     throw error;
   }
   try {
-    const content = (0, import_node_fs13.readFileSync)(releasePath, "utf8");
+    const content = (0, import_node_fs14.readFileSync)(releasePath, "utf8");
     let capturedOwnerId = null;
     try {
       const captured = JSON.parse(content);
@@ -26960,13 +28704,13 @@ function releaseOwnedJsonFile(path, ownerId, ownerField = "id") {
     }
     if (capturedOwnerId === ownerId) return;
     try {
-      (0, import_node_fs13.writeFileSync)(path, content, { mode: 384, flag: "wx" });
-      (0, import_node_fs13.chmodSync)(path, 384);
+      (0, import_node_fs14.writeFileSync)(path, content, { mode: 384, flag: "wx" });
+      (0, import_node_fs14.chmodSync)(path, 384);
     } catch (error) {
       if (error.code !== "EEXIST") throw error;
     }
   } finally {
-    (0, import_node_fs13.rmSync)(releasePath, { force: true });
+    (0, import_node_fs14.rmSync)(releasePath, { force: true });
   }
 }
 function inspectLocalDaemonRunJournal(configPath) {
@@ -26976,8 +28720,8 @@ function inspectLocalDaemonRunJournal(configPath) {
   try {
     let activeRunCount = 0;
     for (const artifact of [path, pendingPath]) {
-      if (!(0, import_node_fs13.existsSync)(artifact)) continue;
-      const parsed = JSON.parse((0, import_node_fs13.readFileSync)(artifact, "utf8"));
+      if (!(0, import_node_fs14.existsSync)(artifact)) continue;
+      const parsed = JSON.parse((0, import_node_fs14.readFileSync)(artifact, "utf8"));
       if (parsed.version !== 1 || !Array.isArray(parsed.entries))
         throw new Error("invalid journal");
       if (artifact === path) {
@@ -26996,7 +28740,7 @@ function inspectLocalDaemonRunJournal(configPath) {
         }).length;
         continue;
       }
-      const legacyStartedAtMs = (0, import_node_fs13.statSync)(pendingPath).mtimeMs;
+      const legacyStartedAtMs = (0, import_node_fs14.statSync)(pendingPath).mtimeMs;
       activeRunCount += parsed.entries.filter((entry) => {
         if (!entry || typeof entry !== "object") throw new Error("invalid pending run entry");
         const startedAtMs = entry.startedAtMs;
@@ -27018,38 +28762,38 @@ function pendingSetupIntentPath() {
   return `${getConfigPath()}.setup-pending`;
 }
 function setupTokenHash(setupToken) {
-  return (0, import_node_crypto3.createHash)("sha256").update(setupToken).digest("hex");
+  return (0, import_node_crypto5.createHash)("sha256").update(setupToken).digest("hex");
 }
 function getOrCreateSetupAttemptId(setupToken) {
   const intentPath = pendingSetupIntentPath();
   const tokenHash = setupTokenHash(setupToken);
-  if ((0, import_node_fs13.existsSync)(intentPath)) {
+  if ((0, import_node_fs14.existsSync)(intentPath)) {
     try {
-      const stored = JSON.parse((0, import_node_fs13.readFileSync)(intentPath, "utf8"));
+      const stored = JSON.parse((0, import_node_fs14.readFileSync)(intentPath, "utf8"));
       if (stored.setupTokenHash === tokenHash && typeof stored.registrationAttemptId === "string" && stored.registrationAttemptId.length > 0) {
         return stored.registrationAttemptId;
       }
     } catch {
     }
   }
-  const registrationAttemptId = (0, import_node_crypto3.randomUUID)();
-  (0, import_node_fs13.mkdirSync)((0, import_node_path11.dirname)(intentPath), { recursive: true, mode: 448 });
-  const writePath = `${intentPath}.pending-${process.pid}-${(0, import_node_crypto3.randomBytes)(6).toString("hex")}`;
+  const registrationAttemptId = (0, import_node_crypto5.randomUUID)();
+  (0, import_node_fs14.mkdirSync)((0, import_node_path12.dirname)(intentPath), { recursive: true, mode: 448 });
+  const writePath = `${intentPath}.pending-${process.pid}-${(0, import_node_crypto5.randomBytes)(6).toString("hex")}`;
   try {
-    (0, import_node_fs13.writeFileSync)(
+    (0, import_node_fs14.writeFileSync)(
       writePath,
       JSON.stringify({ setupTokenHash: tokenHash, registrationAttemptId }, null, 2),
       { mode: 384 }
     );
-    (0, import_node_fs13.chmodSync)(writePath, 384);
-    (0, import_node_fs13.renameSync)(writePath, intentPath);
+    (0, import_node_fs14.chmodSync)(writePath, 384);
+    (0, import_node_fs14.renameSync)(writePath, intentPath);
   } finally {
-    (0, import_node_fs13.rmSync)(writePath, { force: true });
+    (0, import_node_fs14.rmSync)(writePath, { force: true });
   }
   return registrationAttemptId;
 }
 function clearPendingSetupIntent() {
-  (0, import_node_fs13.rmSync)(pendingSetupIntentPath(), { force: true });
+  (0, import_node_fs14.rmSync)(pendingSetupIntentPath(), { force: true });
 }
 function pendingDeviceAuthorizationPath() {
   return `${getConfigPath()}.device-auth-pending`;
@@ -27070,35 +28814,35 @@ function parseDeviceAuthorizationOperationContent(content) {
 }
 function restoreCapturedFileUnlessReplaced(path, content) {
   try {
-    (0, import_node_fs13.writeFileSync)(path, content, { mode: 384, flag: "wx" });
-    (0, import_node_fs13.chmodSync)(path, 384);
+    (0, import_node_fs14.writeFileSync)(path, content, { mode: 384, flag: "wx" });
+    (0, import_node_fs14.chmodSync)(path, 384);
   } catch (error) {
     if (error.code !== "EEXIST") throw error;
   }
 }
 function quarantineCorruptDeviceAuthorizationOperation(path) {
-  const quarantinePath = `${path}.corrupt-${process.pid}-${(0, import_node_crypto3.randomBytes)(6).toString("hex")}`;
+  const quarantinePath = `${path}.corrupt-${process.pid}-${(0, import_node_crypto5.randomBytes)(6).toString("hex")}`;
   try {
-    (0, import_node_fs13.renameSync)(path, quarantinePath);
+    (0, import_node_fs14.renameSync)(path, quarantinePath);
   } catch (error) {
     if (error.code === "ENOENT") return null;
     throw error;
   }
   try {
-    const capturedContent = (0, import_node_fs13.readFileSync)(quarantinePath, "utf8");
+    const capturedContent = (0, import_node_fs14.readFileSync)(quarantinePath, "utf8");
     if (parseDeviceAuthorizationOperationContent(capturedContent)) {
       restoreCapturedFileUnlessReplaced(path, capturedContent);
     }
   } finally {
-    (0, import_node_fs13.rmSync)(quarantinePath, { force: true });
+    (0, import_node_fs14.rmSync)(quarantinePath, { force: true });
   }
-  if (!(0, import_node_fs13.existsSync)(path)) return null;
-  return parseDeviceAuthorizationOperationContent((0, import_node_fs13.readFileSync)(path, "utf8"));
+  if (!(0, import_node_fs14.existsSync)(path)) return null;
+  return parseDeviceAuthorizationOperationContent((0, import_node_fs14.readFileSync)(path, "utf8"));
 }
 function readDeviceAuthorizationOperation() {
   const path = deviceAuthorizationOperationPath();
-  if (!(0, import_node_fs13.existsSync)(path)) return null;
-  const parsed = parseDeviceAuthorizationOperationContent((0, import_node_fs13.readFileSync)(path, "utf8"));
+  if (!(0, import_node_fs14.existsSync)(path)) return null;
+  const parsed = parseDeviceAuthorizationOperationContent((0, import_node_fs14.readFileSync)(path, "utf8"));
   const lease = parsed ?? quarantineCorruptDeviceAuthorizationOperation(path);
   if (!lease) return null;
   if (lease.expiresAtMs <= Date.now()) {
@@ -27112,14 +28856,14 @@ function acquireDeviceAuthorizationOperation() {
   if (existing) return null;
   const lease = {
     version: 1,
-    id: (0, import_node_crypto3.randomUUID)(),
+    id: (0, import_node_crypto5.randomUUID)(),
     expiresAtMs: Date.now() + 6e4
   };
   const path = deviceAuthorizationOperationPath();
-  (0, import_node_fs13.mkdirSync)((0, import_node_path11.dirname)(path), { recursive: true, mode: 448 });
+  (0, import_node_fs14.mkdirSync)((0, import_node_path12.dirname)(path), { recursive: true, mode: 448 });
   try {
-    (0, import_node_fs13.writeFileSync)(path, JSON.stringify(lease), { mode: 384, flag: "wx" });
-    (0, import_node_fs13.chmodSync)(path, 384);
+    (0, import_node_fs14.writeFileSync)(path, JSON.stringify(lease), { mode: 384, flag: "wx" });
+    (0, import_node_fs14.chmodSync)(path, 384);
     return lease;
   } catch (error) {
     if (error.code === "EEXIST") return null;
@@ -27132,17 +28876,17 @@ function extendDeviceAuthorizationOperation(operationId, expiresAtMs) {
     throw new Error("browser authorization operation ownership was lost");
   }
   const path = deviceAuthorizationOperationPath();
-  const pendingPath = `${path}.pending-${process.pid}-${(0, import_node_crypto3.randomBytes)(6).toString("hex")}`;
+  const pendingPath = `${path}.pending-${process.pid}-${(0, import_node_crypto5.randomBytes)(6).toString("hex")}`;
   try {
-    (0, import_node_fs13.writeFileSync)(
+    (0, import_node_fs14.writeFileSync)(
       pendingPath,
       JSON.stringify({ ...current, expiresAtMs: Math.max(expiresAtMs, Date.now() + 6e4) }),
       { mode: 384 }
     );
-    (0, import_node_fs13.chmodSync)(pendingPath, 384);
-    (0, import_node_fs13.renameSync)(pendingPath, path);
+    (0, import_node_fs14.chmodSync)(pendingPath, 384);
+    (0, import_node_fs14.renameSync)(pendingPath, path);
   } finally {
-    (0, import_node_fs13.rmSync)(pendingPath, { force: true });
+    (0, import_node_fs14.rmSync)(pendingPath, { force: true });
   }
 }
 function assertDeviceAuthorizationOperationOwner(operationId) {
@@ -27153,12 +28897,12 @@ function assertDeviceAuthorizationOperationOwner(operationId) {
 function clearPendingDeviceAuthorization(operationId) {
   const path = pendingDeviceAuthorizationPath();
   if (!operationId) {
-    (0, import_node_fs13.rmSync)(path, { force: true });
+    (0, import_node_fs14.rmSync)(path, { force: true });
     return;
   }
-  if (!(0, import_node_fs13.existsSync)(path)) return;
+  if (!(0, import_node_fs14.existsSync)(path)) return;
   try {
-    const pending = JSON.parse((0, import_node_fs13.readFileSync)(path, "utf8"));
+    const pending = JSON.parse((0, import_node_fs14.readFileSync)(path, "utf8"));
     if (pending.operationId !== operationId) return;
   } catch {
     return;
@@ -27167,9 +28911,9 @@ function clearPendingDeviceAuthorization(operationId) {
 }
 function readPendingDeviceAuthorization(apiUrl) {
   const path = pendingDeviceAuthorizationPath();
-  if (!(0, import_node_fs13.existsSync)(path)) return null;
+  if (!(0, import_node_fs14.existsSync)(path)) return null;
   try {
-    const pending = JSON.parse((0, import_node_fs13.readFileSync)(path, "utf8"));
+    const pending = JSON.parse((0, import_node_fs14.readFileSync)(path, "utf8"));
     const expiresAtMs = Date.parse(pending.expiresAt ?? "");
     if (pending.apiUrl !== apiUrl || typeof pending.deviceCode !== "string" || typeof pending.userCode !== "string" || typeof pending.verificationUri !== "string" || typeof pending.installationId !== "string" || pending.operationId !== void 0 && typeof pending.operationId !== "string" || !Number.isFinite(pending.intervalSeconds) || !Number.isFinite(expiresAtMs) || expiresAtMs <= Date.now()) {
       return null;
@@ -27181,20 +28925,20 @@ function readPendingDeviceAuthorization(apiUrl) {
 }
 function writePendingDeviceAuthorization(pending) {
   const path = pendingDeviceAuthorizationPath();
-  (0, import_node_fs13.mkdirSync)((0, import_node_path11.dirname)(path), { recursive: true, mode: 448 });
-  const writePath = `${path}.pending-${process.pid}-${(0, import_node_crypto3.randomBytes)(6).toString("hex")}`;
+  (0, import_node_fs14.mkdirSync)((0, import_node_path12.dirname)(path), { recursive: true, mode: 448 });
+  const writePath = `${path}.pending-${process.pid}-${(0, import_node_crypto5.randomBytes)(6).toString("hex")}`;
   try {
-    (0, import_node_fs13.writeFileSync)(writePath, JSON.stringify(pending, null, 2), { mode: 384 });
-    (0, import_node_fs13.chmodSync)(writePath, 384);
-    (0, import_node_fs13.renameSync)(writePath, path);
+    (0, import_node_fs14.writeFileSync)(writePath, JSON.stringify(pending, null, 2), { mode: 384 });
+    (0, import_node_fs14.chmodSync)(writePath, 384);
+    (0, import_node_fs14.renameSync)(writePath, path);
   } finally {
-    (0, import_node_fs13.rmSync)(writePath, { force: true });
+    (0, import_node_fs14.rmSync)(writePath, { force: true });
   }
 }
 function removeAlanOwnedLocalArtifacts() {
   const configPath = getConfigPath();
-  const directory = (0, import_node_path11.dirname)(configPath);
-  const configName = (0, import_node_path11.basename)(configPath).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const directory = (0, import_node_path12.dirname)(configPath);
+  const configName = (0, import_node_path12.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}$`
   );
@@ -27211,13 +28955,13 @@ function removeAlanOwnedLocalArtifacts() {
     `${configPath}.pending-runs.json.pending`,
     maintenanceLeasePath(configPath)
   ]);
-  if ((0, import_node_fs13.existsSync)(directory)) {
-    for (const entry of (0, import_node_fs13.readdirSync)(directory)) {
-      if (alanAtomicSidecarPattern.test(entry)) artifacts.add((0, import_node_path11.join)(directory, entry));
+  if ((0, import_node_fs14.existsSync)(directory)) {
+    for (const entry of (0, import_node_fs14.readdirSync)(directory)) {
+      if (alanAtomicSidecarPattern.test(entry)) artifacts.add((0, import_node_path12.join)(directory, entry));
     }
   }
-  for (const artifact of artifacts) (0, import_node_fs13.rmSync)(artifact, { force: true });
-  (0, import_node_fs13.rmSync)(configPath, { force: true });
+  for (const artifact of artifacts) (0, import_node_fs14.rmSync)(artifact, { force: true });
+  (0, import_node_fs14.rmSync)(configPath, { force: true });
 }
 function argValue(args, name) {
   const index = args.indexOf(name);
@@ -27273,7 +29017,7 @@ function getLocalApiPort(args, stored) {
 }
 function sleep(ms) {
   if (ms <= 0) return Promise.resolve();
-  return new Promise((resolve6) => setTimeout(resolve6, ms));
+  return new Promise((resolve7) => setTimeout(resolve7, ms));
 }
 function normalizeBackendKind2(backendKind) {
   if (backendKind === "codex") return "codex_app_server";
@@ -27439,13 +29183,13 @@ var DurablePendingRunStarts = class extends Map {
   }
   persist() {
     if (this.size === 0) {
-      (0, import_node_fs13.rmSync)(this.path, { force: true });
+      (0, import_node_fs14.rmSync)(this.path, { force: true });
       return;
     }
     const pendingPath = `${this.path}.pending`;
-    (0, import_node_fs13.mkdirSync)((0, import_node_path11.dirname)(this.path), { recursive: true, mode: 448 });
+    (0, import_node_fs14.mkdirSync)((0, import_node_path12.dirname)(this.path), { recursive: true, mode: 448 });
     try {
-      (0, import_node_fs13.writeFileSync)(
+      (0, import_node_fs14.writeFileSync)(
         pendingPath,
         JSON.stringify({
           version: 1,
@@ -27458,10 +29202,10 @@ var DurablePendingRunStarts = class extends Map {
         }),
         { mode: 384 }
       );
-      (0, import_node_fs13.chmodSync)(pendingPath, 384);
-      (0, import_node_fs13.renameSync)(pendingPath, this.path);
+      (0, import_node_fs14.chmodSync)(pendingPath, 384);
+      (0, import_node_fs14.renameSync)(pendingPath, this.path);
     } finally {
-      (0, import_node_fs13.rmSync)(pendingPath, { force: true });
+      (0, import_node_fs14.rmSync)(pendingPath, { force: true });
     }
   }
 };
@@ -27601,7 +29345,7 @@ function buildApplicationRunFailure(input) {
   const problem = createAlanProblem({
     domain: "application",
     code: input.code,
-    id: (0, import_node_crypto3.randomUUID)(),
+    id: (0, import_node_crypto5.randomUUID)(),
     title: "Alan could not complete the agent run",
     detail: input.detail,
     occurredAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -27696,21 +29440,21 @@ function reconcileActiveRuns(input) {
   }
 }
 function collectRuntimeMetadata() {
-  const cpuList = (0, import_node_os8.cpus)();
+  const cpuList = (0, import_node_os9.cpus)();
   const metadata = {
-    platform: (0, import_node_os8.platform)(),
-    arch: (0, import_node_os8.arch)(),
-    osVersion: (0, import_node_os8.release)(),
+    platform: (0, import_node_os9.platform)(),
+    arch: (0, import_node_os9.arch)(),
+    osVersion: (0, import_node_os9.release)(),
     agentVersion: AGENT_VERSION,
-    memoryBytes: (0, import_node_os8.totalmem)(),
-    memoryFreeBytes: (0, import_node_os8.freemem)()
+    memoryBytes: (0, import_node_os9.totalmem)(),
+    memoryFreeBytes: (0, import_node_os9.freemem)()
   };
   if (cpuList.length > 0) {
     metadata.cpuModel = cpuList[0]?.model;
     metadata.cpuCores = cpuList.length;
   }
   try {
-    const disk = (0, import_node_fs13.statfsSync)((0, import_node_os8.homedir)());
+    const disk = (0, import_node_fs14.statfsSync)((0, import_node_os9.homedir)());
     metadata.diskFreeBytes = disk.bavail * disk.bsize;
     metadata.diskTotalBytes = disk.blocks * disk.bsize;
   } catch {
@@ -27928,7 +29672,7 @@ var RuntimePresenter = class {
       this.applicationProblem = createAlanProblem({
         domain: "application",
         code: /local path no longer exists/i.test(message) ? "app.workspace.missing" : "app.internal",
-        id: (0, import_node_crypto3.randomUUID)(),
+        id: (0, import_node_crypto5.randomUUID)(),
         title: "Alan could not start the agent run",
         detail: message,
         occurredAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -27966,9 +29710,9 @@ async function setupDaemon(args) {
   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_os8.hostname)();
+  const displayName = argValue(args, "--name") ?? (0, import_node_os9.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_crypto3.randomUUID)();
+  const installationId = argValue(args, "--installation-id") ?? previousConfig.installationId ?? (0, import_node_crypto5.randomUUID)();
   if (scope !== "team" && scope !== "user") {
     throw new Error("setup --scope must be either 'team' or 'user'");
   }
@@ -27977,7 +29721,7 @@ async function setupDaemon(args) {
       "setup requires --setup-token <token> or --token <Alan access token>.\nFor normal setup, copy the setup token from Alan and run: alan-agent setup --setup-token <token>\nFor browser authorization, run: alan-agent login"
     );
   }
-  const registrationAttemptId = setupToken ? getOrCreateSetupAttemptId(setupToken) : (0, import_node_crypto3.randomUUID)();
+  const registrationAttemptId = setupToken ? getOrCreateSetupAttemptId(setupToken) : (0, import_node_crypto5.randomUUID)();
   const registrationUrl = `${apiUrl}/public/runtimes${setupToken ? "/register-with-setup-token" : ""}`;
   const registrationInit = {
     method: "POST",
@@ -27989,7 +29733,7 @@ async function setupDaemon(args) {
       ...teamId ? { teamId } : {},
       ...setupToken ? { setupToken, registrationAttemptId } : {},
       displayName,
-      hostname: (0, import_node_os8.hostname)(),
+      hostname: (0, import_node_os9.hostname)(),
       runtimeKind: "machine",
       managementKind: "user_managed",
       hostKind: "daemon",
@@ -28012,7 +29756,7 @@ async function setupDaemon(args) {
     }
     const retriableStatus = response && (response.status === 408 || response.status === 429 || response.status >= 500);
     if (response && (!retriableStatus || response.ok) || attempt === 3) break;
-    await new Promise((resolve6) => setTimeout(resolve6, attempt * 100));
+    await new Promise((resolve7) => setTimeout(resolve7, attempt * 100));
   }
   if (!response) {
     const detail = transportError instanceof Error ? transportError.message : String(transportError);
@@ -28043,10 +29787,10 @@ async function setupDaemon(args) {
     runtimeToken: body.runtimeToken,
     runtimeRenewalToken: body.runtimeRenewalToken,
     localApiPort: getLocalApiPort(args, {}),
-    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"),
-    eventSpoolKey: previousConfig.eventSpoolKey ?? (0, import_node_crypto3.randomBytes)(32).toString("base64url"),
+    localApiToken: previousConfig.localApiToken ?? (0, import_node_crypto5.randomBytes)(24).toString("hex"),
+    localServiceId: previousConfig.localServiceId ?? (0, import_node_crypto5.randomUUID)(),
+    localServiceSecret: previousConfig.localServiceSecret ?? (0, import_node_crypto5.randomBytes)(32).toString("base64url"),
+    eventSpoolKey: previousConfig.eventSpoolKey ?? (0, import_node_crypto5.randomBytes)(32).toString("base64url"),
     daemonEpoch: previousConfig.daemonEpoch,
     displayName: body.runtime.displayName ?? displayName,
     installationId
@@ -28073,10 +29817,10 @@ async function loginWithDeviceCode(args) {
     }
     const previousConfig = readConfigForRegistration();
     const { apiUrl, wsUrl, endpointProfile } = resolveEndpoints(args);
-    const displayName = argValue(args, "--name") ?? (0, import_node_os8.hostname)();
+    const displayName = argValue(args, "--name") ?? (0, import_node_os9.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_crypto5.randomUUID)();
     let authorization = resumed ? { ...resumed, operationId: operation.id } : null;
     if (!authorization) {
       clearPendingDeviceAuthorization();
@@ -28085,7 +29829,7 @@ async function loginWithDeviceCode(args) {
         headers: { "content-type": "application/json" },
         body: JSON.stringify({
           displayName,
-          hostname: (0, import_node_os8.hostname)(),
+          hostname: (0, import_node_os9.hostname)(),
           capabilities: discoverCapabilities(),
           metadata: {
             ...await collectRuntimeMetadataWithProviderLimits(),
@@ -28152,10 +29896,10 @@ async function loginWithDeviceCode(args) {
         runtimeToken: body.runtimeToken,
         runtimeRenewalToken: body.runtimeRenewalToken,
         localApiPort: getLocalApiPort(args, {}),
-        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"),
-        eventSpoolKey: previousConfig.eventSpoolKey ?? (0, import_node_crypto3.randomBytes)(32).toString("base64url"),
+        localApiToken: previousConfig.localApiToken ?? (0, import_node_crypto5.randomBytes)(24).toString("hex"),
+        localServiceId: previousConfig.localServiceId ?? (0, import_node_crypto5.randomUUID)(),
+        localServiceSecret: previousConfig.localServiceSecret ?? (0, import_node_crypto5.randomBytes)(32).toString("base64url"),
+        eventSpoolKey: previousConfig.eventSpoolKey ?? (0, import_node_crypto5.randomBytes)(32).toString("base64url"),
         daemonEpoch: previousConfig.daemonEpoch,
         displayName: body.runtime.displayName ?? displayName,
         installationId
@@ -28175,10 +29919,10 @@ async function loginWithDeviceCode(args) {
 async function startDaemon(args) {
   bindConfigPath(args);
   const stored = readConfig();
-  const installationId = stored.installationId ?? (0, import_node_crypto3.randomUUID)();
+  const installationId = stored.installationId ?? (0, import_node_crypto5.randomUUID)();
   const configPath = getConfigPath();
   const endpointProfile = stored.endpointProfile ?? resolveEndpointProfile(args);
-  const daemonSessionId = (0, import_node_crypto3.randomUUID)();
+  const daemonSessionId = (0, import_node_crypto5.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;
@@ -28195,11 +29939,11 @@ async function startDaemon(args) {
     wsUrl = endpointMismatch.expectedWsUrl;
   }
   let localApiPort = getLocalApiPort(args, stored);
-  const localApiToken = stored.localApiToken ?? (0, import_node_crypto3.randomBytes)(24).toString("hex");
-  const localServiceId = stored.localServiceId ?? (0, import_node_crypto3.randomUUID)();
-  const localServiceSecret = stored.localServiceSecret ?? (0, import_node_crypto3.randomBytes)(32).toString("base64url");
+  const localApiToken = stored.localApiToken ?? (0, import_node_crypto5.randomBytes)(24).toString("hex");
+  const localServiceId = stored.localServiceId ?? (0, import_node_crypto5.randomUUID)();
+  const localServiceSecret = stored.localServiceSecret ?? (0, import_node_crypto5.randomBytes)(32).toString("base64url");
   const localServiceStartedAtMs = Date.now();
-  const eventSpoolKey = stored.eventSpoolKey ?? (0, import_node_crypto3.randomBytes)(32).toString("base64url");
+  const eventSpoolKey = stored.eventSpoolKey ?? (0, import_node_crypto5.randomBytes)(32).toString("base64url");
   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");
   }
@@ -28319,7 +30063,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_path11.resolve)(relocation.previousPath), relocation);
+      workspaceRelocations.set((0, import_node_path12.resolve)(relocation.previousPath), relocation);
     }
   }
   if (stored.localApiPort !== localApiPort || stored.localApiToken !== localApiToken || stored.localServiceId !== localServiceId || stored.localServiceSecret !== localServiceSecret || stored.eventSpoolKey !== eventSpoolKey || stored.daemonEpoch !== daemonEpoch || stored.installationId !== installationId) {
@@ -28635,20 +30379,25 @@ async function startDaemon(args) {
       pendingDeliveryLost.push({ conversationId: entry.conversationId, runId });
     }
   });
-  socket.on("desktop:rpc", (message) => {
+  socket.on("desktop:rpc", async (message) => {
     if (!message?.id || !message.method) return;
     try {
       const params = message.params ?? {};
-      if (message.method !== "worktree.ensure") {
+      const result = message.method === "worktree.ensure" ? ensureWorktree(params) : message.method === "worktree.remove_if_clean" ? removeWorktreesIfClean(params) : message.method === "worktree.migrate_to_checkout" ? migrateWorktreeToCheckout(params) : message.method === "worktree.migration_preflight" ? preflightLocalWorkspaceMigration(params) : message.method === "worktree.status" ? statusLocalWorkspace(params) : isBindingSwitchGitMethod(message.method) ? await executeBindingSwitchGitRpc(message.method, params) : (() => {
         throw new Error(`Method not found: ${message.method}`);
-      }
-      const result = ensureWorktree(params);
+      })();
       socket.emit("desktop:rpc", { jsonrpc: "2.0", id: message.id, result });
     } catch (error) {
+      const stableCode = error instanceof BindingSwitchGitError ? error.code : "runtime_operation_failed";
+      const stableDetails = error instanceof BindingSwitchGitError ? error.details : void 0;
       socket.emit("desktop:rpc", {
         jsonrpc: "2.0",
         id: message.id,
-        error: { code: -32e3, message: error.message }
+        error: {
+          code: -32e3,
+          message: error.message,
+          data: { ...stableDetails, code: stableCode }
+        }
       });
     }
   });
@@ -28656,6 +30405,17 @@ async function startDaemon(args) {
     if (!payload?.runId || !payload.conversationId || typeof payload.content !== "string") {
       return;
     }
+    const isTaskWorkspacePayload = Boolean(
+      payload.worktreeInfo?.worktreePath || payload.worktreeInfo?.allWorktrees?.length
+    );
+    if ((payload.worktreeInfo?.allWorktrees?.length ?? 0) > 1 || isTaskWorkspacePayload && (payload.repoLocalPaths?.length ?? 0) > 1) {
+      socket.emit("agent.rejected", {
+        runId: payload.runId,
+        message: "A task worktree requires exactly one Git repository.",
+        code: "single_repository_worktree_required"
+      });
+      return;
+    }
     const existingRun = activeAgents.get(payload.runId);
     if (existingRun) {
       if (existingRun.conversationId !== payload.conversationId) {
@@ -28748,31 +30508,31 @@ async function startDaemon(args) {
     const workspaceRequired = Boolean(explicitWorkspacePath);
     if (isAlanDefaultWorkspace(payload.projectPath)) {
       try {
-        (0, import_node_fs13.mkdirSync)(cwd, { recursive: true });
+        (0, import_node_fs14.mkdirSync)(cwd, { recursive: true });
       } catch {
       }
     }
     let workspaceReadiness = inspectWorkspaceReadiness(workspaceRequired ? cwd : void 0);
     const expectedRepoUrls = [
       ...(payload.repoLocalPaths ?? []).filter(
-        (repo) => explicitWorkspacePath ? (0, import_node_path11.resolve)(repo.localPath) === (0, import_node_path11.resolve)(explicitWorkspacePath) : false
+        (repo) => explicitWorkspacePath ? (0, import_node_path12.resolve)(repo.localPath) === (0, import_node_path12.resolve)(explicitWorkspacePath) : false
       ).map((repo) => repo.repoUrl),
       ...payload.localRepoUrls ?? []
     ];
     if (workspaceReadiness.code === "workspace_missing" && explicitWorkspacePath && !payload.worktreeInfo) {
-      const previousPath = (0, import_node_path11.resolve)(explicitWorkspacePath);
+      const previousPath = (0, import_node_path12.resolve)(explicitWorkspacePath);
       const remembered = workspaceRelocations.get(previousPath);
       const rememberedPath = remembered?.canonicalPath;
       const relocated = rememberedPath && workspaceMatchesExpectedRepositories({
         workspacePath: rememberedPath,
         expectedRepoUrls
-      }) ? (0, import_node_path11.resolve)(rememberedPath) : discoverRelocatedWorkspace({
+      }) ? (0, import_node_path12.resolve)(rememberedPath) : discoverRelocatedWorkspace({
         missingPath: explicitWorkspacePath,
         approvedWorkspacePaths: payload.approvedWorkspacePaths,
         expectedRepoUrls
       });
       if (relocated) {
-        if (!remembered || (0, import_node_path11.resolve)(remembered.canonicalPath) !== relocated) {
+        if (!remembered || (0, import_node_path12.resolve)(remembered.canonicalPath) !== relocated) {
           workspaceRelocations.set(previousPath, {
             conversationId: payload.conversationId,
             runId: payload.runId,
@@ -29240,7 +31000,7 @@ async function startDaemon(args) {
       const requestId = payload.requestId;
       try {
         const projectPath = isAlanDefaultWorkspace(payload.projectPath) ? resolveAlanDefaultWorkspacePath() : payload.projectPath;
-        const result = scanLocalSkillsCached((0, import_node_os8.homedir)(), projectPath, {
+        const result = scanLocalSkillsCached((0, import_node_os9.homedir)(), projectPath, {
           refresh: payload.refresh === true
         });
         socket.emit("runtime.skills.result", {
@@ -29268,7 +31028,7 @@ async function startDaemon(args) {
         if (!oldest) break;
         adoptionChallenges.delete(oldest);
       }
-      const challenge = (0, import_node_crypto3.randomBytes)(24).toString("base64url");
+      const challenge = (0, import_node_crypto5.randomBytes)(24).toString("base64url");
       adoptionChallenges.set(challenge, now + LOCAL_SERVICE_CHALLENGE_TTL_MS);
       const unsignedOwner = {
         version: LOCAL_SERVICE_OWNER_VERSION,
@@ -29471,7 +31231,7 @@ async function startDaemon(args) {
       `${describeOccupiedLocalDaemon(localApiPort)} The token in ${getConfigPath()} no longer matches the running daemon; quit Alan desktop or run setup again.`
     );
   }
-  const localApiListening = new Promise((resolve6, reject) => {
+  const localApiListening = new Promise((resolve7, reject) => {
     const onError = (error) => {
       clearInterval(heartbeat);
       clearInterval(versionRefresh);
@@ -29500,7 +31260,7 @@ async function startDaemon(args) {
       if (address && typeof address === "object") localApiPort = address.port;
       pushLog(`local_api listening port=${localApiPort}`);
       console.info("[alan-agent] Local daemon API listening", { port: localApiPort });
-      resolve6();
+      resolve7();
     });
   });
   try {
@@ -29519,7 +31279,7 @@ async function startDaemon(args) {
     clearInterval(versionRefresh);
     clearInterval(workspaceLeaseMonitor);
     socket.disconnect();
-    await new Promise((resolve6) => localServer.close(() => resolve6()));
+    await new Promise((resolve7) => localServer.close(() => resolve7()));
     releaseOwnerLease();
     releaseStartupLease();
     throw error;
@@ -29538,8 +31298,8 @@ async function startDaemon(args) {
       }
       activeAgents.clear();
       socket.disconnect();
-      await new Promise((resolve6) => {
-        localServer.close(() => resolve6());
+      await new Promise((resolve7) => {
+        localServer.close(() => resolve7());
       });
     } finally {
       releaseOwnerLease();
@@ -29976,7 +31736,7 @@ function decodeResumeFallbackContext(encoded) {
 }
 
 // src/web-presenter.ts
-var import_node_crypto4 = require("crypto");
+var import_node_crypto6 = require("crypto");
 var WebPresenter = class {
   constructor(wsClient, conversationId, cwd) {
     this.conversationId = conversationId;
@@ -30153,7 +31913,7 @@ var WebPresenter = class {
       this.applicationProblem = createAlanProblem({
         domain: "application",
         code: /required tools|prepare the required tools/i.test(message) ? "app.service.unavailable" : "app.internal",
-        id: (0, import_node_crypto4.randomUUID)(),
+        id: (0, import_node_crypto6.randomUUID)(),
         title: "Alan could not continue the agent run",
         detail: message,
         occurredAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -30220,7 +31980,7 @@ var WebPresenter = class {
 };
 
 // src/ws-client.ts
-var import_node_crypto6 = require("crypto");
+var import_node_crypto8 = require("crypto");
 
 // ../shared/dist/agent-liveness.js
 var AGENT_LIVENESS_PROTOCOL_VERSION = 1;
@@ -30248,8 +32008,8 @@ var agentProbeAckSchema = external_exports.object({
 });
 
 // src/sandbox-outbox.ts
-var import_node_crypto5 = require("crypto");
-var import_node_fs14 = require("fs");
+var import_node_crypto7 = require("crypto");
+var import_node_fs15 = require("fs");
 var SANDBOX_EVENT_OUTBOX_ENV = "ALAN_EVENT_OUTBOX_ENABLED";
 function isSandboxEventOutboxEnabled(env = process.env) {
   return env[SANDBOX_EVENT_OUTBOX_ENV] === "true";
@@ -30258,7 +32018,7 @@ function deriveSandboxOutboxKey(sessionToken) {
   if (!sessionToken) {
     throw new Error("sandbox event outbox requires ALAN_SESSION_TOKEN for key derivation");
   }
-  return (0, import_node_crypto5.createHash)("sha256").update(sessionToken, "utf8").digest("base64url");
+  return (0, import_node_crypto7.createHash)("sha256").update(sessionToken, "utf8").digest("base64url");
 }
 function sandboxOutboxSpoolPath(conversationId) {
   return `/tmp/alan-agent-outbox-${conversationId}.enc`;
@@ -30272,7 +32032,7 @@ function createSandboxEventOutbox(input) {
     input.pushLog?.(
       `sandbox_outbox_spool_reset ${error instanceof Error ? error.message : String(error)}`
     );
-    (0, import_node_fs14.rmSync)(path, { force: true });
+    (0, import_node_fs15.rmSync)(path, { force: true });
     return new EncryptedEventOutbox(path, key, input.pushLog, input.options);
   }
 }
@@ -30395,7 +32155,7 @@ var WSClient = class {
   }
   socket;
   /** Stable id for this agent process; fences stale heartbeats server-side. */
-  agentSessionId = (0, import_node_crypto6.randomUUID)();
+  agentSessionId = (0, import_node_crypto8.randomUUID)();
   /** Monotonic heartbeat sequence — advances on every hello + heartbeat. */
   heartbeatSeq = 0;
   heartbeatTimer = null;
@@ -30475,9 +32235,9 @@ var WSClient = class {
     });
   }
   waitForConnection(timeoutMs = 15e3) {
-    return new Promise((resolve6, reject) => {
+    return new Promise((resolve7, reject) => {
       if (this.socket.connected) {
-        resolve6();
+        resolve7();
         return;
       }
       const timeout = setTimeout(
@@ -30486,7 +32246,7 @@ var WSClient = class {
       );
       this.socket.once("connect", () => {
         clearTimeout(timeout);
-        resolve6();
+        resolve7();
       });
       this.socket.once("connect_error", (err) => {
         clearTimeout(timeout);
@@ -30667,9 +32427,9 @@ async function runSandbox(config) {
       onUserMessage: (payload) => {
         if (payload === null) {
           if (pendingMessageResolve) {
-            const resolve6 = pendingMessageResolve;
+            const resolve7 = pendingMessageResolve;
             pendingMessageResolve = null;
-            resolve6(null);
+            resolve7(null);
           }
           return;
         }
@@ -30691,9 +32451,9 @@ async function runSandbox(config) {
           fileCount: payload.files?.length ?? 0
         });
         if (pendingMessageResolve) {
-          const resolve6 = pendingMessageResolve;
+          const resolve7 = pendingMessageResolve;
           pendingMessageResolve = null;
-          resolve6(payload);
+          resolve7(payload);
         } else {
           queuedMessages.push(payload);
         }
@@ -30886,8 +32646,8 @@ async function runSandbox(config) {
       });
       if (stopped) break;
     }
-    const nextPayload = queuedMessages.shift() ?? await new Promise((resolve6) => {
-      pendingMessageResolve = resolve6;
+    const nextPayload = queuedMessages.shift() ?? await new Promise((resolve7) => {
+      pendingMessageResolve = resolve7;
     });
     if (nextPayload === null || stopped) {
       break;
@@ -30969,10 +32729,10 @@ async function runSandbox(config) {
 }
 
 // src/service-manager.ts
-var import_node_child_process7 = require("child_process");
-var import_node_fs15 = require("fs");
-var import_node_os9 = require("os");
-var import_node_path12 = require("path");
+var import_node_child_process8 = require("child_process");
+var import_node_fs16 = require("fs");
+var import_node_os10 = require("os");
+var import_node_path13 = require("path");
 var SERVICE_LABEL = "ai.tryalan.agent";
 var SYSTEMD_UNIT = "alan-agent.service";
 var WINDOWS_TASK = "Alan Agent";
@@ -30992,8 +32752,8 @@ function buildDaemonServicePlan(input) {
     if (userId === void 0) throw new Error("Cannot determine the current macOS user ID");
     const domain = `gui/${userId}`;
     const serviceTarget = `${domain}/${SERVICE_LABEL}`;
-    const manifestPath = (0, import_node_path12.join)(input.homeDir, "Library", "LaunchAgents", `${SERVICE_LABEL}.plist`);
-    const logDir = (0, import_node_path12.join)(input.homeDir, ".alan", "agent", "logs");
+    const manifestPath = (0, import_node_path13.join)(input.homeDir, "Library", "LaunchAgents", `${SERVICE_LABEL}.plist`);
+    const logDir = (0, import_node_path13.join)(input.homeDir, ".alan", "agent", "logs");
     const programArguments = daemonArgs.map((arg) => `    <string>${xml(arg)}</string>`).join("\n");
     const manifest = `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
@@ -31015,9 +32775,9 @@ ${programArguments}
   <key>ThrottleInterval</key>
   <integer>5</integer>
   <key>StandardOutPath</key>
-  <string>${xml((0, import_node_path12.join)(logDir, "daemon.log"))}</string>
+  <string>${xml((0, import_node_path13.join)(logDir, "daemon.log"))}</string>
   <key>StandardErrorPath</key>
-  <string>${xml((0, import_node_path12.join)(logDir, "daemon-error.log"))}</string>
+  <string>${xml((0, import_node_path13.join)(logDir, "daemon-error.log"))}</string>
 </dict>
 </plist>
 `;
@@ -31056,7 +32816,7 @@ ${programArguments}
     };
   }
   if (input.platform === "linux") {
-    const manifestPath = (0, import_node_path12.join)(input.homeDir, ".config", "systemd", "user", SYSTEMD_UNIT);
+    const manifestPath = (0, import_node_path13.join)(input.homeDir, ".config", "systemd", "user", SYSTEMD_UNIT);
     const manifest = `[Unit]
 Description=Alan local agent daemon
 After=network-online.target
@@ -31153,7 +32913,7 @@ WantedBy=default.target
   };
 }
 function currentServicePlan(args) {
-  const currentPlatform = (0, import_node_os9.platform)();
+  const currentPlatform = (0, import_node_os10.platform)();
   if (currentPlatform !== "darwin" && currentPlatform !== "linux" && currentPlatform !== "win32") {
     throw new Error(`Daemon service installation is not supported on ${currentPlatform}`);
   }
@@ -31162,25 +32922,25 @@ function currentServicePlan(args) {
   if (!cliEntry) throw new Error("Cannot determine the alan-agent executable path");
   return buildDaemonServicePlan({
     platform: currentPlatform,
-    homeDir: (0, import_node_os9.homedir)(),
+    homeDir: (0, import_node_os10.homedir)(),
     nodeExecutable: process.execPath,
-    cliEntry: (0, import_node_path12.resolve)(cliEntry),
+    cliEntry: (0, import_node_path13.resolve)(cliEntry),
     profile
   });
 }
 function writeManifest(path, contents) {
-  (0, import_node_fs15.mkdirSync)((0, import_node_path12.dirname)(path), { recursive: true, mode: 448 });
+  (0, import_node_fs16.mkdirSync)((0, import_node_path13.dirname)(path), { recursive: true, mode: 448 });
   const pendingPath = `${path}.pending-${process.pid}`;
   try {
-    (0, import_node_fs15.writeFileSync)(pendingPath, contents, { mode: 384 });
-    (0, import_node_fs15.chmodSync)(pendingPath, 384);
-    (0, import_node_fs15.renameSync)(pendingPath, path);
+    (0, import_node_fs16.writeFileSync)(pendingPath, contents, { mode: 384 });
+    (0, import_node_fs16.chmodSync)(pendingPath, 384);
+    (0, import_node_fs16.renameSync)(pendingPath, path);
   } finally {
-    (0, import_node_fs15.rmSync)(pendingPath, { force: true });
+    (0, import_node_fs16.rmSync)(pendingPath, { force: true });
   }
 }
 function runServiceCommand(command) {
-  const result = (0, import_node_child_process7.spawnSync)(command.command, command.args, { encoding: "utf8" });
+  const result = (0, import_node_child_process8.spawnSync)(command.command, command.args, { encoding: "utf8" });
   const status = result.status ?? 1;
   const output = `${result.stdout ?? ""}${result.stderr ?? ""}`.trim();
   if (status !== 0 && !command.tolerateFailure) {
@@ -31198,8 +32958,8 @@ function installDaemonService(args = []) {
   }
   const plan = currentServicePlan(args);
   if (plan.manifestPath && plan.manifest) {
-    if ((0, import_node_os9.platform)() === "darwin") {
-      (0, import_node_fs15.mkdirSync)((0, import_node_path12.join)((0, import_node_os9.homedir)(), ".alan", "agent", "logs"), { recursive: true, mode: 448 });
+    if ((0, import_node_os10.platform)() === "darwin") {
+      (0, import_node_fs16.mkdirSync)((0, import_node_path13.join)((0, import_node_os10.homedir)(), ".alan", "agent", "logs"), { recursive: true, mode: 448 });
     }
     writeManifest(plan.manifestPath, plan.manifest);
   }
@@ -31209,7 +32969,7 @@ function installDaemonService(args = []) {
 function uninstallDaemonService(args = []) {
   const plan = currentServicePlan(args);
   for (const command of plan.uninstallCommands) runServiceCommand(command);
-  if (plan.manifestPath) (0, import_node_fs15.rmSync)(plan.manifestPath, { force: true });
+  if (plan.manifestPath) (0, import_node_fs16.rmSync)(plan.manifestPath, { force: true });
   console.info("[alan-agent] Per-user daemon service removed");
 }
 function printDaemonServiceStatus(args = []) {
@@ -31220,6 +32980,42 @@ function printDaemonServiceStatus(args = []) {
 }
 
 // src/index.ts
+function logEffectiveGitIdentity(lifecycle, projectPath) {
+  const readConfig2 = (key) => {
+    try {
+      const result = (0, import_node_child_process9.spawnSync)("git", ["config", "--get", key], {
+        cwd: projectPath,
+        env: getDaemonCliEnvironment(),
+        encoding: "utf8",
+        timeout: 5e3
+      });
+      const value2 = result.status === 0 ? result.stdout.trim() : "";
+      return value2 || null;
+    } catch {
+      return null;
+    }
+  };
+  const envName = process.env.GIT_AUTHOR_NAME || null;
+  const envEmail = process.env.GIT_AUTHOR_EMAIL || null;
+  const configName = readConfig2("user.name");
+  const configEmail = readConfig2("user.email");
+  const payload = {
+    projectPath,
+    envAuthorName: envName,
+    envAuthorEmail: envEmail,
+    configUserName: configName,
+    configUserEmail: configEmail
+  };
+  if (!envEmail && !configEmail) {
+    lifecycle.error("sandbox_agent_git_identity_missing", payload);
+    return;
+  }
+  if (envEmail && configEmail && envEmail !== configEmail) {
+    lifecycle.error("sandbox_agent_git_identity_mismatch", payload);
+    return;
+  }
+  lifecycle.info("sandbox_agent_git_identity", payload);
+}
 async function runSessionFromEnv() {
   const wsUrl = process.env.ALAN_WS_URL;
   const sessionId = process.env.ALAN_SESSION_ID;
@@ -31264,6 +33060,7 @@ async function runSessionFromEnv() {
     mode,
     model
   });
+  logEffectiveGitIdentity(lifecycle, projectPath);
   await runSandbox({
     wsUrl,
     sessionId,