@aiden-ade/sandbox-agent 0.1.50 → 0.1.51

package/dist/index.cjs

@@ -36,7 +36,7 @@ var require_XMLHttpRequest = __commonJS({
     "use strict";
     var fs = require("fs");
     var Url = require("url");
-    var spawn5 = require("child_process").spawn;
+    var spawn6 = require("child_process").spawn;
     module2.exports = XMLHttpRequest3;
     XMLHttpRequest3.XMLHttpRequest = XMLHttpRequest3;
     function XMLHttpRequest3(opts) {
@@ -332,7 +332,7 @@ var require_XMLHttpRequest = __commonJS({
           var syncFile = ".node-xmlhttprequest-sync-" + process.pid;
           fs.writeFileSync(syncFile, "", "utf8");
           var execString = "var http = require('http'), https = require('https'), fs = require('fs');var doRequest = http" + (ssl ? "s" : "") + ".request;var options = " + JSON.stringify(options) + ";var responseText = '';var responseData = Buffer.alloc(0);var req = doRequest(options, function(response) {response.on('data', function(chunk) {  var data = Buffer.from(chunk);  responseText += data.toString('utf8');  responseData = Buffer.concat([responseData, data]);});response.on('end', function() {fs.writeFileSync('" + contentFile + "', JSON.stringify({err: null, data: {statusCode: response.statusCode, headers: response.headers, text: responseText, data: responseData.toString('base64')}}), 'utf8');fs.unlinkSync('" + syncFile + "');});response.on('error', function(error) {fs.writeFileSync('" + contentFile + "', 'NODE-XMLHTTPREQUEST-ERROR:' + JSON.stringify(error), 'utf8');fs.unlinkSync('" + syncFile + "');});}).on('error', function(error) {fs.writeFileSync('" + contentFile + "', 'NODE-XMLHTTPREQUEST-ERROR:' + JSON.stringify(error), 'utf8');fs.unlinkSync('" + syncFile + "');});" + (data ? "req.write('" + JSON.stringify(data).slice(1, -1).replace(/'/g, "\\'") + "');" : "") + "req.end();";
-          var syncProc = spawn5(process.argv[0], ["-e", execString]);
+          var syncProc = spawn6(process.argv[0], ["-e", execString]);
           var statusText;
           while (fs.existsSync(syncFile)) {
           }
@@ -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",
@@ -4811,7 +4811,7 @@ var require_websocket_server = __commonJS({
 });
 
 // src/index.ts
-var import_node_child_process8 = require("child_process");
+var import_node_child_process9 = require("child_process");
 
 // src/cli-executable.ts
 var import_node_child_process = require("child_process");
@@ -4956,7 +4956,7 @@ function resolveViaWhere(command, env) {
   return null;
 }
 function runCliProbeAsync(executable, env, args = ["--version"], timeoutMs = 3e3, spawnOptions) {
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     const isWin = (0, import_node_os.platform)() === "win32";
     let command = executable;
     let commandArgs = args;
@@ -4976,7 +4976,7 @@ function runCliProbeAsync(executable, env, args = ["--version"], timeoutMs = 3e3
         stdio: closeStdin ? ["pipe", "pipe", "pipe"] : void 0
       });
     } catch (error) {
-      resolve6({ status: null, stdout: "", stderr: "", error });
+      resolve7({ status: null, stdout: "", stderr: "", error });
       return;
     }
     if (closeStdin) {
@@ -4990,10 +4990,10 @@ function runCliProbeAsync(executable, env, args = ["--version"], timeoutMs = 3e3
     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, stdout, stderr, signal: signal ?? null })
+      (status, signal) => resolve7({ status, stdout, stderr, signal: signal ?? null })
     );
   });
 }
@@ -5204,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");
@@ -19128,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 {
@@ -19142,7 +19142,7 @@ async function collectCodexLimits(env) {
   const codexCommand = resolveExecutable("codex", runtimeEnv, "ALAN_CODEX_PATH");
   if (!codexCommand)
     return [];
-  return withTimeout(new Promise((resolve6) => {
+  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"]
@@ -19154,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++;
@@ -21987,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);
@@ -22987,232 +22987,1350 @@ Object.assign(lookup, {
   connect: lookup
 });
 
-// src/cli-ensure-install.ts
+// 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 CLI_RUNTIME_VERSIONS_ENV = "ALAN_CLI_RUNTIME_VERSIONS";
-var INSTALLABLE_PROVIDER_PACKAGES = {
-  claude_cli: { npmPackage: "@anthropic-ai/claude-code", command: "claude", label: "Claude Code" },
-  codex_app_server: { npmPackage: "@openai/codex", command: "codex", label: "Codex" },
-  copilot_cli: { npmPackage: "@github/copilot", command: "copilot", label: "Copilot" },
-  opencode_cli: { npmPackage: "opencode-ai", command: "opencode", label: "opencode" }
-};
-var INSTALL_TIMEOUT_MS = 12e4;
-var installOutcomes = /* @__PURE__ */ new Map();
-function canInstallProviderCli(backendKind) {
-  return Boolean(backendKind && INSTALLABLE_PROVIDER_PACKAGES[backendKind]);
+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);
 }
-function pinnedVersion(npmPackage) {
-  const raw = process.env[CLI_RUNTIME_VERSIONS_ENV];
-  if (!raw) return "latest";
-  try {
-    const parsed = JSON.parse(raw);
-    const version = parsed[npmPackage];
-    if (typeof version === "string" && version.trim()) return version.trim();
-  } catch {
+var BindingSwitchGitError = class extends Error {
+  constructor(code, message, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "BindingSwitchGitError";
   }
-  return "latest";
+};
+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 runNpmInstall(installSpec, env, timeoutMs) {
-  return new Promise((resolve6) => {
-    const isWin = (0, import_node_os4.platform)() === "win32";
-    let child;
-    try {
-      child = (0, import_node_child_process3.spawn)("npm", ["install", "-g", installSpec], {
-        env,
-        shell: isWin,
-        windowsHide: isWin ? true : void 0,
-        timeout: timeoutMs,
-        stdio: ["ignore", "pipe", "pipe"]
-      });
-    } catch (error) {
-      resolve6({ status: null, stdout: "", stderr: "", error });
-      return;
+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 = "";
-    child.stdout?.setEncoding("utf8").on("data", (chunk) => {
-      stdout += chunk;
+    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?.setEncoding("utf8").on("data", (chunk) => {
-      stderr += 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());
     });
-    child.once("error", (error) => resolve6({ status: null, stdout, stderr, error }));
-    child.once(
-      "close",
-      (status, signal) => resolve6({
-        status,
-        stdout,
-        stderr,
-        // Spawn `timeout` kills by signal without an `error` event; surface it
-        // so a timed-out install is reported as a failure, not status null + ok.
-        ...signal ? { error: new Error(`npm install killed by ${signal}`) } : {}
-      })
-    );
   });
 }
-async function attemptInstall(spec, options) {
-  const installSpec = `${spec.npmPackage}@${pinnedVersion(spec.npmPackage)}`;
-  const notify = options?.notify ?? ((message) => console.info(`[cli-ensure-install] ${message}`));
-  notify(`Installing ${spec.label} CLI (${installSpec})\u2026`);
-  const runner = options?.runner ?? runNpmInstall;
-  const result = await runner(installSpec, getDaemonCliEnvironment(), INSTALL_TIMEOUT_MS);
-  if (result.error || result.status !== 0) {
-    console.warn(`[cli-ensure-install] npm install -g ${installSpec} failed`, {
-      status: result.status,
-      error: result.error?.message,
-      output: `${result.stderr || result.stdout}`.trim().slice(-500)
-    });
-    notify(`Failed to install ${spec.label} CLI (${installSpec}).`);
-    return false;
-  }
-  invalidateResolvedCli(spec.command);
-  notify(`Installed ${spec.label} CLI (${installSpec}).`);
-  return true;
+function runGit(cwd, args, code = "git_operation_failed") {
+  return runGitWithOptions(cwd, args, {}, code);
 }
-function ensureProviderCliInstalled(backendKind, options) {
-  if (!backendKind) return Promise.resolve(false);
-  const spec = INSTALLABLE_PROVIDER_PACKAGES[backendKind];
-  if (!spec) return Promise.resolve(false);
-  const existing = installOutcomes.get(spec.npmPackage);
-  if (existing) return existing;
-  const attempt = attemptInstall(spec, options).catch((error) => {
-    console.warn(`[cli-ensure-install] install attempt for ${spec.npmPackage} threw`, error);
-    return false;
-  });
-  installOutcomes.set(spec.npmPackage, attempt);
-  return attempt;
+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();
 }
-
-// src/computer-readiness.ts
-var import_node_fs5 = 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 AGENT_CONFIG_KEYS = /* @__PURE__ */ new Map([
-  ["apiUrl", "string"],
-  ["wsUrl", "string"],
-  ["endpointProfile", "string"],
-  ["teamId", "string"],
-  ["runtimeId", "string"],
-  ["runtimeToken", "string"],
-  ["localApiPort", "number"],
-  ["localApiToken", "string"],
-  ["displayName", "string"]
-]);
-function sanitizeAgentConfig(config) {
-  const sanitized = { ...config };
-  delete sanitized.teamId;
-  delete sanitized.organizationId;
-  delete sanitized.currentTeamId;
-  delete sanitized.currentOrganizationId;
-  return sanitized;
+function sourceChangedDuringCheckpoint(message) {
+  return new BindingSwitchGitError("source_changed_since_approval", message);
 }
-function isValidAgentConfig(configPath) {
+function acquireCheckpointHeadLock(locks) {
   try {
-    const stat = (0, import_node_fs4.lstatSync)(configPath);
-    if (!stat.isFile() || stat.isSymbolicLink()) return false;
-    const parsed = JSON.parse((0, import_node_fs4.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]) => {
-      const expectedType = AGENT_CONFIG_KEYS.get(key);
-      return expectedType === void 0 || typeof value2 === expectedType;
-    });
+    (0, import_node_fs4.writeFileSync)(locks.headLockPath, "", { flag: "wx" });
+    locks.headLockHeld = true;
   } catch {
-    return false;
+    throw sourceChangedDuringCheckpoint(
+      "Source repository is being changed by another Git operation"
+    );
   }
 }
-function migrateLegacyAgentConfig(input) {
-  const profile = normalizeAgentEndpointProfile(input?.profile ?? null) ?? "production";
-  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;
-  let copied = false;
+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 {
-    const sourceDirectoryStat = (0, import_node_fs4.lstatSync)(legacyBaseDir);
-    const sourceFileStat = (0, import_node_fs4.lstatSync)(legacyPath);
-    if (!sourceDirectoryStat.isDirectory() || sourceDirectoryStat.isSymbolicLink()) return false;
-    const alanDirectoryExisted = (0, import_node_fs4.existsSync)(alanBaseDir);
-    if (alanDirectoryExisted) {
-      const alanDirectoryStat = (0, import_node_fs4.lstatSync)(alanBaseDir);
-      if (!alanDirectoryStat.isDirectory() || alanDirectoryStat.isSymbolicLink()) return false;
+    (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;
     }
-    (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);
-    copied = true;
-    const migrated = sanitizeAgentConfig(
-      JSON.parse((0, import_node_fs4.readFileSync)(alanPath, "utf8"))
+    throw sourceChangedDuringCheckpoint(
+      "Source repository is being changed by another Git operation"
     );
-    (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);
-    if (!isValidAgentConfig(alanPath)) {
-      (0, import_node_fs4.unlinkSync)(alanPath);
-      return false;
-    }
-    return true;
-  } catch {
-    if (copied && (0, import_node_fs4.existsSync)(alanPath)) (0, import_node_fs4.unlinkSync)(alanPath);
-    return false;
   }
 }
-function resolveAgentConfigPath(input) {
-  if (input?.explicitPath?.trim()) return input.explicitPath.trim();
-  const profile = normalizeAgentEndpointProfile(
-    typeof input?.profile === "string" ? input.profile : input?.profile ?? null
-  ) ?? "production";
-  const baseDir = input?.baseDir ?? DEFAULT_AGENT_DIR;
-  if (input?.baseDir === void 0) migrateLegacyAgentConfig({ profile });
-  return (0, import_node_path4.join)(baseDir, resolveAgentConfigFileName(profile));
+function releaseCheckpointRepositoryLocks(locks) {
+  releaseCheckpointHeadLock(locks);
+  if (locks.indexLockHeld) {
+    (0, import_node_fs4.rmSync)(locks.indexLockPath, { force: true });
+    locks.indexLockHeld = false;
+  }
 }
-function configExistsAtPath(configPath) {
-  return (0, import_node_fs4.existsSync)(configPath);
+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 resolveEndpointProfileFromArgs(args) {
-  const index = args.indexOf("--profile");
-  const raw = index === -1 ? process.env.ALAN_AGENT_PROFILE : args[index + 1];
-  return normalizeAgentEndpointProfile(raw) ?? "production";
+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 bindAgentConfigPathFromArgs(args) {
-  const explicit = process.env.ALAN_AGENT_CONFIG_PATH?.trim();
-  if (explicit) return explicit;
-  const profile = resolveEndpointProfileFromArgs(args);
-  const configPath = resolveAgentConfigPath({ profile });
-  process.env.ALAN_AGENT_CONFIG_PATH = configPath;
-  return configPath;
+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"
+    );
+  }
 }
-
-// src/computer-readiness.ts
-var WorkspaceAccessTracker = class {
-  constructor(inspect = (path) => inspectWorkspaceReadiness(path)) {
-    this.inspect = inspect;
+function requiredString(params, key) {
+  const value2 = params[key];
+  if (typeof value2 !== "string" || value2.trim() === "") {
+    throw new BindingSwitchGitError("invalid_git_request", `${key} is required`);
   }
-  issue = null;
-  track(path, readiness) {
-    if (readiness.ready) {
-      this.issue = null;
-      return;
-    }
-    this.issue = { path, readiness };
+  if (/[\0\r\n]/.test(value2)) {
+    throw new BindingSwitchGitError("invalid_git_request", `${key} contains unsafe characters`);
   }
-  recheck() {
-    if (!this.issue) return null;
-    const readiness = this.inspect(this.issue.path);
-    if (readiness.ready) {
-      this.issue = null;
-      return readiness;
-    }
-    this.issue = { path: this.issue.path, readiness };
-    return readiness;
+  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`);
+  }
+}
+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");
+  }
+}
+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 {
+    parsed = new URL(urlValue);
+  } catch {
+    throw new BindingSwitchGitError("invalid_git_request", "Remote URL is invalid");
+  }
+  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 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 assertCanonicalPathContained(childPath, parentPath, code, message) {
+  if (!isPathContained(
+    canonicalPathWithMissingTail(childPath),
+    canonicalPathWithMissingTail(parentPath)
+  )) {
+    throw new BindingSwitchGitError(code, message);
+  }
+}
+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}`
+    );
+  }
+  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 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
+      }
+    ];
+  });
+}
+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"
+    );
+  }
+  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 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");
+    }
+    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 {
+      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 });
+    }
+  }
+  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");
+    }
+    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
+  };
+}
+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 };
+}
+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 isAncestor(repoRoot, ancestor, descendant) {
+  return runGitResult(repoRoot, ["merge-base", "--is-ancestor", ancestor, descendant]).status === 0;
+}
+function assertCleanTarget(repoRoot) {
+  if (readStatus(repoRoot).dirty) {
+    throw new BindingSwitchGitError(
+      "target_checkout_dirty",
+      "The destination checkout has uncommitted changes"
+    );
+  }
+}
+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 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 {
+    repoRoot,
+    path: repoRoot,
+    branch,
+    headSha: targetSha,
+    replayed
+  };
+}
+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 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)
+  );
+  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"
+      );
+    }
+    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`
+      );
+    }
+  }
+  (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 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"
+    );
+  }
+  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 {
+    repoRoot: worktreePath,
+    path: worktreePath,
+    branch,
+    headSha: targetSha,
+    replayed: false
+  };
+}
+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}`
+    );
+  }
+  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);
+  }
+}
+
+// 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" },
+  codex_app_server: { npmPackage: "@openai/codex", command: "codex", label: "Codex" },
+  copilot_cli: { npmPackage: "@github/copilot", command: "copilot", label: "Copilot" },
+  opencode_cli: { npmPackage: "opencode-ai", command: "opencode", label: "opencode" }
+};
+var INSTALL_TIMEOUT_MS = 12e4;
+var installOutcomes = /* @__PURE__ */ new Map();
+function canInstallProviderCli(backendKind) {
+  return Boolean(backendKind && INSTALLABLE_PROVIDER_PACKAGES[backendKind]);
+}
+function pinnedVersion(npmPackage) {
+  const raw = process.env[CLI_RUNTIME_VERSIONS_ENV];
+  if (!raw) return "latest";
+  try {
+    const parsed = JSON.parse(raw);
+    const version = parsed[npmPackage];
+    if (typeof version === "string" && version.trim()) return version.trim();
+  } catch {
+  }
+  return "latest";
+}
+function runNpmInstall(installSpec, env, timeoutMs) {
+  return new Promise((resolve7) => {
+    const isWin = (0, import_node_os5.platform)() === "win32";
+    let child;
+    try {
+      child = (0, import_node_child_process4.spawn)("npm", ["install", "-g", installSpec], {
+        env,
+        shell: isWin,
+        windowsHide: isWin ? true : void 0,
+        timeout: timeoutMs,
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+    } catch (error) {
+      resolve7({ status: null, stdout: "", stderr: "", error });
+      return;
+    }
+    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,
+        // Spawn `timeout` kills by signal without an `error` event; surface it
+        // so a timed-out install is reported as a failure, not status null + ok.
+        ...signal ? { error: new Error(`npm install killed by ${signal}`) } : {}
+      })
+    );
+  });
+}
+async function attemptInstall(spec, options) {
+  const installSpec = `${spec.npmPackage}@${pinnedVersion(spec.npmPackage)}`;
+  const notify = options?.notify ?? ((message) => console.info(`[cli-ensure-install] ${message}`));
+  notify(`Installing ${spec.label} CLI (${installSpec})\u2026`);
+  const runner = options?.runner ?? runNpmInstall;
+  const result = await runner(installSpec, getDaemonCliEnvironment(), INSTALL_TIMEOUT_MS);
+  if (result.error || result.status !== 0) {
+    console.warn(`[cli-ensure-install] npm install -g ${installSpec} failed`, {
+      status: result.status,
+      error: result.error?.message,
+      output: `${result.stderr || result.stdout}`.trim().slice(-500)
+    });
+    notify(`Failed to install ${spec.label} CLI (${installSpec}).`);
+    return false;
+  }
+  invalidateResolvedCli(spec.command);
+  notify(`Installed ${spec.label} CLI (${installSpec}).`);
+  return true;
+}
+function ensureProviderCliInstalled(backendKind, options) {
+  if (!backendKind) return Promise.resolve(false);
+  const spec = INSTALLABLE_PROVIDER_PACKAGES[backendKind];
+  if (!spec) return Promise.resolve(false);
+  const existing = installOutcomes.get(spec.npmPackage);
+  if (existing) return existing;
+  const attempt = attemptInstall(spec, options).catch((error) => {
+    console.warn(`[cli-ensure-install] install attempt for ${spec.npmPackage} threw`, error);
+    return false;
+  });
+  installOutcomes.set(spec.npmPackage, attempt);
+  return attempt;
+}
+
+// src/computer-readiness.ts
+var import_node_fs6 = require("fs");
+
+// src/runtime-config.ts
+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"],
+  ["endpointProfile", "string"],
+  ["teamId", "string"],
+  ["runtimeId", "string"],
+  ["runtimeToken", "string"],
+  ["localApiPort", "number"],
+  ["localApiToken", "string"],
+  ["displayName", "string"]
+]);
+function sanitizeAgentConfig(config) {
+  const sanitized = { ...config };
+  delete sanitized.teamId;
+  delete sanitized.organizationId;
+  delete sanitized.currentTeamId;
+  delete sanitized.currentOrganizationId;
+  return sanitized;
+}
+function isValidAgentConfig(configPath) {
+  try {
+    const stat = (0, import_node_fs5.lstatSync)(configPath);
+    if (!stat.isFile() || stat.isSymbolicLink()) return false;
+    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]) => {
+      const expectedType = AGENT_CONFIG_KEYS.get(key);
+      return expectedType === void 0 || typeof value2 === expectedType;
+    });
+  } catch {
+    return false;
+  }
+}
+function migrateLegacyAgentConfig(input) {
+  const profile = normalizeAgentEndpointProfile(input?.profile ?? null) ?? "production";
+  const alanBaseDir = input?.alanBaseDir ?? DEFAULT_AGENT_DIR;
+  const legacyBaseDir = input?.legacyBaseDir ?? LEGACY_AGENT_DIR;
+  const fileName = resolveAgentConfigFileName(profile);
+  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_fs5.lstatSync)(legacyBaseDir);
+    const sourceFileStat = (0, import_node_fs5.lstatSync)(legacyPath);
+    if (!sourceDirectoryStat.isDirectory() || sourceDirectoryStat.isSymbolicLink()) return false;
+    const alanDirectoryExisted = (0, import_node_fs5.existsSync)(alanBaseDir);
+    if (alanDirectoryExisted) {
+      const alanDirectoryStat = (0, import_node_fs5.lstatSync)(alanBaseDir);
+      if (!alanDirectoryStat.isDirectory() || alanDirectoryStat.isSymbolicLink()) return false;
+    }
+    (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_fs5.readFileSync)(alanPath, "utf8"))
+    );
+    (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_fs5.unlinkSync)(alanPath);
+      return false;
+    }
+    return true;
+  } catch {
+    if (copied && (0, import_node_fs5.existsSync)(alanPath)) (0, import_node_fs5.unlinkSync)(alanPath);
+    return false;
+  }
+}
+function resolveAgentConfigPath(input) {
+  if (input?.explicitPath?.trim()) return input.explicitPath.trim();
+  const profile = normalizeAgentEndpointProfile(
+    typeof input?.profile === "string" ? input.profile : input?.profile ?? null
+  ) ?? "production";
+  const baseDir = input?.baseDir ?? DEFAULT_AGENT_DIR;
+  if (input?.baseDir === void 0) migrateLegacyAgentConfig({ profile });
+  return (0, import_node_path5.join)(baseDir, resolveAgentConfigFileName(profile));
+}
+function configExistsAtPath(configPath) {
+  return (0, import_node_fs5.existsSync)(configPath);
+}
+function resolveEndpointProfileFromArgs(args) {
+  const index = args.indexOf("--profile");
+  const raw = index === -1 ? process.env.ALAN_AGENT_PROFILE : args[index + 1];
+  return normalizeAgentEndpointProfile(raw) ?? "production";
+}
+function bindAgentConfigPathFromArgs(args) {
+  const explicit = process.env.ALAN_AGENT_CONFIG_PATH?.trim();
+  if (explicit) return explicit;
+  const profile = resolveEndpointProfileFromArgs(args);
+  const configPath = resolveAgentConfigPath({ profile });
+  process.env.ALAN_AGENT_CONFIG_PATH = configPath;
+  return configPath;
+}
+
+// src/computer-readiness.ts
+var WorkspaceAccessTracker = class {
+  constructor(inspect = (path) => inspectWorkspaceReadiness(path)) {
+    this.inspect = inspect;
+  }
+  issue = null;
+  track(path, readiness) {
+    if (readiness.ready) {
+      this.issue = null;
+      return;
+    }
+    this.issue = { path, readiness };
+  }
+  recheck() {
+    if (!this.issue) return null;
+    const readiness = this.inspect(this.issue.path);
+    if (readiness.ready) {
+      this.issue = null;
+      return readiness;
+    }
+    this.issue = { path: this.issue.path, readiness };
+    return readiness;
   }
   recoveryPath() {
     return this.issue?.path ?? null;
@@ -23222,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]):[\\/]/);
@@ -23288,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.",
@@ -23400,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;
@@ -23550,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 = ":";
@@ -23714,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;
@@ -23749,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);
@@ -23827,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;
@@ -23857,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,
@@ -23943,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() },
@@ -24029,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")
@@ -24060,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,
@@ -24082,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;
@@ -24106,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) {
@@ -24148,16 +25266,16 @@ 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);
+    const childPath = (0, import_node_path7.join)(parentPath, name);
     try {
-      if ((0, import_node_fs7.statSync)(childPath).isDirectory()) children.push(childPath);
+      if ((0, import_node_fs8.statSync)(childPath).isDirectory()) children.push(childPath);
     } catch {
     }
   }
@@ -24167,12 +25285,12 @@ 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);
+    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_path6.join)(dir, root), "team", dir, rawEntries, errors);
+        scanSkillDir((0, import_node_path7.join)(dir, root), "team", dir, rawEntries, errors);
       }
     }
   }
@@ -24191,11 +25309,151 @@ function scanLocalSkillsCached(homeDir, projectPath, options) {
   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 preflightGitTree(input.cwd, git2);
+}
+function resolveDirtyTree(input, dependencies) {
+  if (input.action === "discard" && input.confirmDiscard !== true) {
+    throw new Error("Discarding workspace changes requires explicit confirmation");
+  }
+  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 {
+    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) {
@@ -24277,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;
@@ -24286,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;
@@ -24992,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 {
@@ -25012,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) {
@@ -25064,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);
@@ -25132,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);
@@ -25194,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);
@@ -25233,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]");
@@ -25524,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);
@@ -25738,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;
   }
@@ -25746,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))),
@@ -25873,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) {
@@ -25893,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");
       }
@@ -26018,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;
     }
   }
@@ -26041,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;
@@ -26056,17 +27314,17 @@ var RunStartGate = class {
 };
 
 // src/version.ts
-var AGENT_VERSION = "0.1.50";
+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
@@ -26095,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));
 }
@@ -26105,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) {
@@ -26118,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;
@@ -26141,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
@@ -26150,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"]);
@@ -26169,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)
@@ -26183,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;
     }
@@ -26214,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) {
@@ -26356,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",
@@ -26402,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"]);
@@ -26425,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;
     }
@@ -26449,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,
@@ -26490,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,
@@ -26522,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` };
   }
@@ -26573,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();
 }
@@ -26686,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;
@@ -26795,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);
@@ -26816,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) {
@@ -26844,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");
     }
@@ -26863,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;
@@ -26875,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);
@@ -26899,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");
     }
@@ -26943,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(),
@@ -26953,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);
@@ -26971,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);
@@ -27000,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) {
@@ -27016,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) {
@@ -27036,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;
@@ -27058,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`;
@@ -27110,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()) {
@@ -27152,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;
@@ -27172,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) {
@@ -27193,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;
@@ -27207,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;
@@ -27221,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}$`
   );
@@ -27251,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);
@@ -27313,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";
@@ -27479,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,
@@ -27498,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 });
     }
   }
 };
@@ -27641,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(),
@@ -27736,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 {
@@ -27968,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(),
@@ -28006,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'");
   }
@@ -28017,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",
@@ -28029,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",
@@ -28052,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);
@@ -28083,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
@@ -28113,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();
@@ -28125,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(),
@@ -28192,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
@@ -28215,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;
@@ -28235,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");
   }
@@ -28359,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) {
@@ -28675,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 }
+        }
       });
     }
   });
@@ -28696,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) {
@@ -28788,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,
@@ -29280,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", {
@@ -29308,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,
@@ -29511,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);
@@ -29540,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 {
@@ -29559,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;
@@ -29578,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();
@@ -30016,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;
@@ -30193,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(),
@@ -30260,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;
@@ -30288,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";
@@ -30298,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`;
@@ -30312,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);
   }
 }
@@ -30435,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;
@@ -30515,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(
@@ -30526,7 +32246,7 @@ var WSClient = class {
       );
       this.socket.once("connect", () => {
         clearTimeout(timeout);
-        resolve6();
+        resolve7();
       });
       this.socket.once("connect_error", (err) => {
         clearTimeout(timeout);
@@ -30707,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;
         }
@@ -30731,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);
         }
@@ -30926,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;
@@ -31009,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";
@@ -31032,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">
@@ -31055,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>
 `;
@@ -31096,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
@@ -31193,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}`);
   }
@@ -31202,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) {
@@ -31238,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);
   }
@@ -31249,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 = []) {
@@ -31263,7 +32983,7 @@ function printDaemonServiceStatus(args = []) {
 function logEffectiveGitIdentity(lifecycle, projectPath) {
   const readConfig2 = (key) => {
     try {
-      const result = (0, import_node_child_process8.spawnSync)("git", ["config", "--get", key], {
+      const result = (0, import_node_child_process9.spawnSync)("git", ["config", "--get", key], {
         cwd: projectPath,
         env: getDaemonCliEnvironment(),
         encoding: "utf8",