@ai-development-environment/control-agent 0.0.89 → 0.0.91

package/dist/control-agent.js

@@ -2276,7 +2276,7 @@ var require_websocket = __commonJS({
     var http = __require("http");
     var net = __require("net");
     var tls = __require("tls");
-    var { randomBytes, createHash: createHash7 } = __require("crypto");
+    var { randomBytes, createHash: createHash8 } = __require("crypto");
     var { Duplex, Readable: Readable2 } = __require("stream");
     var { URL: URL2 } = __require("url");
     var PerMessageDeflate2 = require_permessage_deflate();
@@ -2944,7 +2944,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;
@@ -3313,7 +3313,7 @@ var require_websocket_server = __commonJS({
     var EventEmitter = __require("events");
     var http = __require("http");
     var { Duplex } = __require("stream");
-    var { createHash: createHash7 } = __require("crypto");
+    var { createHash: createHash8 } = __require("crypto");
     var extension2 = require_extension();
     var PerMessageDeflate2 = require_permessage_deflate();
     var subprotocol2 = require_subprotocol();
@@ -3620,7 +3620,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",
@@ -3801,12 +3801,12 @@ var require_isexe = __commonJS({
         if (typeof Promise !== "function") {
           throw new TypeError("callback not provided");
         }
-        return new Promise(function(resolve8, reject) {
+        return new Promise(function(resolve9, reject) {
           isexe(path, options || {}, function(er2, is) {
             if (er2) {
               reject(er2);
             } else {
-              resolve8(is);
+              resolve9(is);
             }
           });
         });
@@ -3872,27 +3872,27 @@ var require_which = __commonJS({
         opt = {};
       const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
       const found = [];
-      const step = (i) => new Promise((resolve8, reject) => {
+      const step = (i) => new Promise((resolve9, reject) => {
         if (i === pathEnv.length)
-          return opt.all && found.length ? resolve8(found) : reject(getNotFoundError(cmd));
+          return opt.all && found.length ? resolve9(found) : reject(getNotFoundError(cmd));
         const ppRaw = pathEnv[i];
         const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
         const pCmd = path.join(pathPart, cmd);
         const p4 = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
-        resolve8(subStep(p4, i, 0));
+        resolve9(subStep(p4, i, 0));
       });
-      const subStep = (p4, i, ii) => new Promise((resolve8, reject) => {
+      const subStep = (p4, i, ii) => new Promise((resolve9, reject) => {
         if (ii === pathExt.length)
-          return resolve8(step(i + 1));
+          return resolve9(step(i + 1));
         const ext = pathExt[ii];
         isexe(p4 + ext, { pathExt: pathExtExe }, (er2, is) => {
           if (!er2 && is) {
             if (opt.all)
               found.push(p4 + ext);
             else
-              return resolve8(p4 + ext);
+              return resolve9(p4 + ext);
           }
-          return resolve8(subStep(p4, i, ii + 1));
+          return resolve9(subStep(p4, i, ii + 1));
         });
       });
       return cb2 ? step(0).then((res) => cb2(null, res), cb2) : step(0);
@@ -4205,7 +4205,7 @@ var require_cross_spawn = __commonJS({
 });
 
 // src/index.ts
-import { rm as rm14 } from "node:fs/promises";
+import { rm as rm15 } from "node:fs/promises";
 
 // src/config.ts
 import { chmod, mkdir, readFile, rename, writeFile } from "node:fs/promises";
@@ -4498,8 +4498,8 @@ function createClient(options) {
     retryWait = async function randomisedExponentialBackoff(retries2) {
       const retryDelaySeconds = Math.pow(2, retries2);
       await new Promise(
-        (resolve8) => setTimeout(
-          resolve8,
+        (resolve9) => setTimeout(
+          resolve9,
           retryDelaySeconds * 1e3 + // add random timeout from 300ms to 3s
           Math.floor(Math.random() * (3e3 - 300) + 300)
         )
@@ -4735,7 +4735,7 @@ function createClient(options) {
     if (socket.readyState === WebSocketImpl.CLOSING) await throwOnClose;
     let release2 = () => {
     };
-    const released = new Promise((resolve8) => release2 = resolve8);
+    const released = new Promise((resolve9) => release2 = resolve9);
     return [
       socket,
       release2,
@@ -4898,7 +4898,7 @@ function createClient(options) {
       const iterator = (async function* iterator2() {
         for (; ; ) {
           if (!pending.length) {
-            await new Promise((resolve8) => deferred.resolve = resolve8);
+            await new Promise((resolve9) => deferred.resolve = resolve9);
           }
           while (pending.length) {
             yield pending.shift();
@@ -5480,7 +5480,7 @@ function createAgentSubscriptionClient(config) {
     shouldRetry: () => true,
     retryWait: async (retries) => {
       const delay = Math.min(3e4, 1e3 * 2 ** Math.min(retries, 5));
-      await new Promise((resolve8) => setTimeout(resolve8, delay));
+      await new Promise((resolve9) => setTimeout(resolve9, delay));
     },
     on: {
       connected: () => console.log("Connected to control-plane WebSocket"),
@@ -6128,6 +6128,7 @@ var WORKTREE_INSPECT_JOB_KIND = "worktree.inspect";
 var WORKTREE_OPERATION_JOB_KIND = "worktree.operation";
 var WORKTREE_COMMIT_JOB_KIND = "worktree.commit";
 var WORKTREE_AUTO_SYNC_JOB_KIND = "worktree.auto-sync";
+var WORKTREE_PREPARATION_JOB_KIND = "worktree.prepare";
 var WORKTREE_GIT_INSPECT_JOB_KIND = "worktree.git.inspect";
 var WORKTREE_GIT_OPERATION_JOB_KIND = "worktree.git.operation";
 var WORKTREE_WATCH_JOB_KIND = "worktree.watch";
@@ -6142,6 +6143,7 @@ var WORKTREE_JOB_KINDS = [
   WORKTREE_OPERATION_JOB_KIND,
   WORKTREE_COMMIT_JOB_KIND,
   WORKTREE_AUTO_SYNC_JOB_KIND,
+  WORKTREE_PREPARATION_JOB_KIND,
   WORKTREE_GIT_INSPECT_JOB_KIND,
   WORKTREE_GIT_OPERATION_JOB_KIND,
   WORKTREE_WATCH_JOB_KIND,
@@ -6170,10 +6172,21 @@ var WORKTREE_OPERATIONS = [
   "PULL",
   "PUSH",
   "RESET",
+  "CLEAR_LOCK",
   "STASH_ALL",
   "STAGE_ALL",
   "UNSTAGE_ALL"
 ];
+var WORKTREE_PREPARATION_KINDS = [
+  "WRITE",
+  "DELETE",
+  "ASSUME_UNCHANGED"
+];
+var WORKTREE_PREPARATION_ACTIONS = [
+  "INSPECT",
+  "APPLY",
+  "UNDO"
+];
 function validGitBranchName(value) {
   if (!value || value.length > 255 || value === "@" || value.startsWith("-"))
     return false;
@@ -6214,11 +6227,74 @@ function stashOid2(value, name) {
 }
 function safeRelativePath(value, name) {
   const path = stringValue4(value, name).replaceAll("\\", "/");
-  if (path.startsWith("/") || /^[A-Za-z]:\//.test(path) || path.split("/").includes("..") || path.includes("\0")) {
-    throw new Error(`${name} must stay within the worktree`);
+  const parts = path.split("/");
+  if (!path || path === "." || path.startsWith("/") || /^[A-Za-z]:\//.test(path) || /[\0\r\n]/.test(path) || parts.some((part) => !part || part === "." || part === "..") || parts.some((part) => part.toLowerCase() === ".git")) {
+    throw new Error(`${name} must be an exact file inside the worktree`);
+  }
+  return path;
+}
+function safePreparationPath(value, name) {
+  const path = safeRelativePath(value, name);
+  if (/[*?[\]]/.test(path)) {
+    throw new Error(`${name} must be an exact file inside the worktree`);
   }
   return path;
 }
+function safeDiffPath(value, name) {
+  try {
+    return safeRelativePath(value, name);
+  } catch {
+    throw new Error(`${name} must stay within the worktree`);
+  }
+}
+function preparationDefinitions(value, name) {
+  if (!Array.isArray(value) || value.length > 500) {
+    throw new Error(`${name} must be an array with at most 500 items`);
+  }
+  const definitions = value.map((entry, index) => {
+    const item = objectValue4(entry, `${name}[${index}]`);
+    const allowed = /* @__PURE__ */ new Set([
+      "id",
+      "kind",
+      "path",
+      "contentBase64",
+      "definitionHash"
+    ]);
+    const unexpected = Object.keys(item).find((key) => !allowed.has(key));
+    if (unexpected) {
+      throw new Error(`Unexpected ${name}[${index}] field: ${unexpected}`);
+    }
+    if (typeof item.kind !== "string" || !WORKTREE_PREPARATION_KINDS.includes(item.kind)) {
+      throw new Error(`${name}[${index}].kind is invalid`);
+    }
+    const contentBase64 = item.contentBase64 === null || item.contentBase64 === void 0 ? null : typeof item.contentBase64 === "string" ? item.contentBase64 : (() => {
+      throw new Error(
+        `${name}[${index}].contentBase64 must be a string`
+      );
+    })();
+    if (item.kind === "WRITE" && contentBase64 === null) {
+      throw new Error(`${name}[${index}].contentBase64 is required`);
+    }
+    if (item.kind !== "WRITE" && contentBase64 !== null) {
+      throw new Error(`${name}[${index}].contentBase64 is not allowed`);
+    }
+    return {
+      id: stringValue4(item.id, `${name}[${index}].id`),
+      kind: item.kind,
+      path: safePreparationPath(item.path, `${name}[${index}].path`),
+      contentBase64,
+      definitionHash: stringValue4(
+        item.definitionHash,
+        `${name}[${index}].definitionHash`
+      )
+    };
+  });
+  const paths = definitions.map((item) => item.path);
+  if (new Set(paths).size !== paths.length) {
+    throw new Error(`${name} paths must be unique`);
+  }
+  return definitions;
+}
 function worktreeBranchJobPayload(value) {
   const payload = objectValue4(value, "worktree branch payload");
   const allowed = /* @__PURE__ */ new Set([
@@ -6231,7 +6307,8 @@ function worktreeBranchJobPayload(value) {
     "action",
     "mode",
     "candidates",
-    "stashOnFailure"
+    "stashOnFailure",
+    "preparations"
   ]);
   const unexpected = Object.keys(payload).find((key) => !allowed.has(key));
   if (unexpected) {
@@ -6297,7 +6374,11 @@ function worktreeBranchJobPayload(value) {
     action: payload.action,
     mode: payload.mode,
     candidates,
-    stashOnFailure: payload.stashOnFailure
+    stashOnFailure: payload.stashOnFailure,
+    preparations: preparationDefinitions(
+      payload.preparations ?? [],
+      "worktree branch payload.preparations"
+    )
   };
 }
 function worktreeMovePushJobPayload(value) {
@@ -6357,7 +6438,8 @@ function worktreeMoveCheckoutJobPayload(value) {
     "expectedHeadSha",
     "baseBranch",
     "mode",
-    "stashOnFailure"
+    "stashOnFailure",
+    "preparations"
   ]);
   const unexpected = Object.keys(payload).find((key) => !allowed.has(key));
   if (unexpected) {
@@ -6418,7 +6500,11 @@ function worktreeMoveCheckoutJobPayload(value) {
       "worktree move checkout payload.baseBranch"
     ),
     mode: payload.mode,
-    stashOnFailure: payload.stashOnFailure
+    stashOnFailure: payload.stashOnFailure,
+    preparations: preparationDefinitions(
+      payload.preparations ?? [],
+      "worktree move checkout payload.preparations"
+    )
   };
 }
 function worktreeDeleteJobPayload(value) {
@@ -6560,7 +6646,9 @@ function worktreeJobPayload(value) {
     "expectedOrigin",
     "baseBranch",
     "operation",
-    "editorVariant"
+    "editorVariant",
+    "forcePreparations",
+    "preparations"
   ]);
   const unexpected = Object.keys(payload).find((key) => !allowed.has(key));
   if (unexpected)
@@ -6573,6 +6661,9 @@ function worktreeJobPayload(value) {
   if (editorVariant !== void 0 && !["CODE", "CODE_INSIDERS", "NONE"].includes(String(editorVariant))) {
     throw new Error("worktree payload.editorVariant is invalid");
   }
+  if (payload.forcePreparations !== void 0 && typeof payload.forcePreparations !== "boolean") {
+    throw new Error("worktree payload.forcePreparations must be a boolean");
+  }
   return {
     codebaseId: stringValue4(payload.codebaseId, "worktree payload.codebaseId"),
     folder: stringValue4(payload.folder, "worktree payload.folder"),
@@ -6589,7 +6680,12 @@ function worktreeJobPayload(value) {
       "worktree payload.baseBranch"
     ),
     ...operation === void 0 ? {} : { operation },
-    ...editorVariant === void 0 ? {} : { editorVariant }
+    ...editorVariant === void 0 ? {} : { editorVariant },
+    forcePreparations: payload.forcePreparations === true,
+    preparations: preparationDefinitions(
+      payload.preparations ?? [],
+      "worktree payload.preparations"
+    )
   };
 }
 function worktreeAutoSyncJobPayload(value) {
@@ -6601,7 +6697,9 @@ function worktreeAutoSyncJobPayload(value) {
     "expectedOrigin",
     "expectedBranch",
     "baseBranch",
-    "phase"
+    "phase",
+    "forcePreparations",
+    "preparations"
   ]);
   const unexpected = Object.keys(payload).find((key) => !allowed.has(key));
   if (unexpected) {
@@ -6612,6 +6710,11 @@ function worktreeAutoSyncJobPayload(value) {
   if (payload.phase !== "SYNC" && payload.phase !== "FINALIZE") {
     throw new Error("worktree auto sync payload.phase is invalid");
   }
+  if (payload.forcePreparations !== void 0 && typeof payload.forcePreparations !== "boolean") {
+    throw new Error(
+      "worktree auto sync payload.forcePreparations must be a boolean"
+    );
+  }
   return {
     codebaseId: stringValue4(
       payload.codebaseId,
@@ -6634,9 +6737,104 @@ function worktreeAutoSyncJobPayload(value) {
       payload.baseBranch,
       "worktree auto sync payload.baseBranch"
     ),
-    phase: payload.phase
+    phase: payload.phase,
+    forcePreparations: payload.forcePreparations === true,
+    preparations: preparationDefinitions(
+      payload.preparations ?? [],
+      "worktree auto sync payload.preparations"
+    )
   };
 }
+function worktreePreparationJobPayload(value) {
+  const payload = objectValue4(value, "worktree preparation payload");
+  const batched = payload.worktrees !== void 0;
+  const allowed = new Set(
+    batched ? ["codebaseId", "expectedOrigin", "action", "preparations", "worktrees"] : [
+      "codebaseId",
+      "folder",
+      "gitDirectory",
+      "expectedOrigin",
+      "action",
+      "preparations"
+    ]
+  );
+  const unexpected = Object.keys(payload).find((key) => !allowed.has(key));
+  if (unexpected) {
+    throw new Error(
+      `Unexpected worktree preparation payload field: ${unexpected}`
+    );
+  }
+  if (typeof payload.action !== "string" || !WORKTREE_PREPARATION_ACTIONS.includes(
+    payload.action
+  )) {
+    throw new Error("worktree preparation payload.action is invalid");
+  }
+  const common = {
+    codebaseId: stringValue4(
+      payload.codebaseId,
+      "worktree preparation payload.codebaseId"
+    ),
+    expectedOrigin: stringValue4(
+      payload.expectedOrigin,
+      "worktree preparation payload.expectedOrigin"
+    ),
+    action: payload.action,
+    preparations: preparationDefinitions(
+      payload.preparations,
+      "worktree preparation payload.preparations"
+    )
+  };
+  if (!batched) {
+    return {
+      ...common,
+      folder: stringValue4(
+        payload.folder,
+        "worktree preparation payload.folder"
+      ),
+      gitDirectory: stringValue4(
+        payload.gitDirectory,
+        "worktree preparation payload.gitDirectory"
+      )
+    };
+  }
+  if (!Array.isArray(payload.worktrees) || payload.worktrees.length > 500) {
+    throw new Error(
+      "worktree preparation payload.worktrees must be an array with at most 500 items"
+    );
+  }
+  const worktrees = payload.worktrees.map((value2, index) => {
+    const target2 = objectValue4(
+      value2,
+      `worktree preparation payload.worktrees[${index}]`
+    );
+    const unexpectedTarget = Object.keys(target2).find(
+      (key) => !["worktreeId", "folder", "gitDirectory"].includes(key)
+    );
+    if (unexpectedTarget) {
+      throw new Error(
+        `Unexpected worktree preparation payload.worktrees[${index}] field: ${unexpectedTarget}`
+      );
+    }
+    return {
+      worktreeId: stringValue4(
+        target2.worktreeId,
+        `worktree preparation payload.worktrees[${index}].worktreeId`
+      ),
+      folder: stringValue4(
+        target2.folder,
+        `worktree preparation payload.worktrees[${index}].folder`
+      ),
+      gitDirectory: stringValue4(
+        target2.gitDirectory,
+        `worktree preparation payload.worktrees[${index}].gitDirectory`
+      )
+    };
+  });
+  if (new Set(worktrees.map(({ worktreeId }) => worktreeId)).size !== worktrees.length) {
+    throw new Error("worktree preparation payload.worktreeIds must be unique");
+  }
+  return { ...common, worktrees };
+}
 function worktreeGitInspectPayload(value) {
   const payload = objectValue4(value, "worktree Git inspect payload");
   const allowed = /* @__PURE__ */ new Set([
@@ -6802,8 +7000,8 @@ function worktreeDiffPayload(value) {
   if (payload.side !== null && payload.side !== void 0 && payload.side !== "BEFORE" && payload.side !== "AFTER") {
     throw new Error("worktree diff payload.side is invalid");
   }
-  const path = payload.path === null || payload.path === void 0 ? null : safeRelativePath(payload.path, "worktree diff payload.path");
-  const previousPath = payload.previousPath === null || payload.previousPath === void 0 ? null : safeRelativePath(
+  const path = payload.path === null || payload.path === void 0 ? null : safeDiffPath(payload.path, "worktree diff payload.path");
+  const previousPath = payload.previousPath === null || payload.previousPath === void 0 ? null : safeDiffPath(
     payload.previousPath,
     "worktree diff payload.previousPath"
   );
@@ -8449,7 +8647,7 @@ function captureCommand(options) {
       outputTruncated: false
     });
   }
-  return new Promise((resolve8, reject) => {
+  return new Promise((resolve9, reject) => {
     const stdoutChunks = [];
     const stderrChunks = [];
     let stdoutBytes = 0;
@@ -8545,7 +8743,7 @@ function captureCommand(options) {
       clearTimeout(timeout);
       if (killTimer) clearTimeout(killTimer);
       options.signal.removeEventListener("abort", abort);
-      resolve8({
+      resolve9({
         exitCode,
         signal,
         timedOut,
@@ -8633,11 +8831,11 @@ async function reapOrphanedCommandProcesses(agentId, signal = new AbortControlle
   console.error(
     `Terminating ${signalled.length} command process(es) left by a previous agent run.`
   );
-  await new Promise((resolve8) => {
-    const timer = setTimeout(resolve8, TERMINATE_GRACE_MS);
+  await new Promise((resolve9) => {
+    const timer = setTimeout(resolve9, TERMINATE_GRACE_MS);
     timer.unref();
-    if (signal.aborted) resolve8();
-    else signal.addEventListener("abort", () => resolve8(), { once: true });
+    if (signal.aborted) resolve9();
+    else signal.addEventListener("abort", () => resolve9(), { once: true });
   });
   for (const orphan of signalled) signalGroup(orphan.processGroup, "SIGKILL");
   return signalled;
@@ -8693,14 +8891,14 @@ var runCommand = async (rawPayload, _timeoutMs, signal, _onLog, context) => {
             `Could not append command output; retrying in ${delay}ms:`,
             error instanceof Error ? error.message : error
           );
-          await new Promise((resolve8) => {
+          await new Promise((resolve9) => {
             const onAbort = () => {
               clearTimeout(retryTimer);
-              resolve8();
+              resolve9();
             };
             const retryTimer = setTimeout(() => {
               signal.removeEventListener("abort", onAbort);
-              resolve8();
+              resolve9();
             }, delay);
             retryTimer.unref();
             signal.addEventListener("abort", onAbort, { once: true });
@@ -8738,7 +8936,7 @@ var runCommand = async (rawPayload, _timeoutMs, signal, _onLog, context) => {
     }
   };
   try {
-    return await new Promise((resolve8, reject) => {
+    return await new Promise((resolve9, reject) => {
       let cancelled = false;
       let settled = false;
       const child = spawn2(process.env.SHELL || "/bin/sh", ["-l", scriptPath], {
@@ -8805,7 +9003,7 @@ var runCommand = async (rawPayload, _timeoutMs, signal, _onLog, context) => {
         signal.removeEventListener("abort", abort);
         flush();
         void uploadChain.then(
-          () => resolve8({
+          () => resolve9({
             exitCode,
             signal: closeSignal,
             timedOut: false,
@@ -12624,7 +12822,7 @@ function prependPathDirectory(directory, env = process.env) {
 // src/process-runner.ts
 import { spawn as spawn5 } from "node:child_process";
 async function runProcess(options) {
-  return new Promise((resolve8, reject) => {
+  return new Promise((resolve9, reject) => {
     let sequence = 0;
     let timedOut = false;
     let cancelled = false;
@@ -12719,7 +12917,7 @@ async function runProcess(options) {
       clearTimeout(timeout);
       options.signal.removeEventListener("abort", abort);
       void logChain.then(
-        () => resolve8({ exitCode, signal, timedOut, cancelled })
+        () => resolve9({ exitCode, signal, timedOut, cancelled })
       );
     });
   });
@@ -14158,6 +14356,20 @@ function rootPath(location) {
   }
   return path;
 }
+function isContainedPath(base, candidate) {
+  return candidate === base || candidate.startsWith(`${base}${sep6}`);
+}
+async function resolvedSkillRoot(location) {
+  const root = rootPath(location);
+  const resolvedRoot = await realpath6(root);
+  if (location.scope === "PROJECT") {
+    const resolvedProject = await realpath6(location.folder);
+    if (!isContainedPath(resolvedProject, resolvedRoot)) {
+      throw new Error("Project skill root resolves outside the project folder");
+    }
+  }
+  return { root, resolvedRoot };
+}
 function targetForFolder(targets, folder) {
   return folder ? targets.find((target2) => resolve6(target2.folder) === resolve6(folder)) : void 0;
 }
@@ -14198,14 +14410,15 @@ async function listPackageFiles(skillDirectory) {
   await visit(skillDirectory);
   return files;
 }
-async function readPackage(directory) {
+async function readPackage(directory, resolvedRoot) {
   const metadata = await lstat3(directory);
-  let resolvedDirectory = directory;
-  if (metadata.isSymbolicLink()) {
-    resolvedDirectory = await realpath6(directory);
-  } else if (!metadata.isDirectory()) {
+  if (!metadata.isSymbolicLink() && !metadata.isDirectory()) {
     throw new Error("Skill path is not a directory");
   }
+  const resolvedDirectory = await realpath6(directory);
+  if (!isContainedPath(resolvedRoot, resolvedDirectory)) {
+    throw new Error("Skill package resolves outside its configured root");
+  }
   const files = await listPackageFiles(resolvedDirectory);
   const definition = files.find((file) => file.path === "SKILL.md");
   if (!definition) throw new Error("Skill does not contain SKILL.md");
@@ -14245,6 +14458,15 @@ function consumersForRoot(configured, rootKind, scope) {
 async function scanRoot2(location, configured, targets, warnings) {
   const root = rootPath(location);
   if (!await directoryExists(root)) return [];
+  let resolvedRoot;
+  try {
+    resolvedRoot = (await resolvedSkillRoot(location)).resolvedRoot;
+  } catch (error) {
+    warnings.push(
+      `${root}: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return [];
+  }
   const consumers = consumersForRoot(
     configured,
     location.rootKind,
@@ -14257,7 +14479,7 @@ async function scanRoot2(location, configured, targets, warnings) {
     if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
     const directory = join9(root, entry.name);
     try {
-      const skillPackage = await readPackage(directory);
+      const skillPackage = await readPackage(directory, resolvedRoot);
       const relativeDirectory = location.folder ? relative6(location.folder, directory).split(sep6).join("/") : "";
       installations.push({
         ...location,
@@ -14332,9 +14554,10 @@ var readSkills = async (payload) => {
     if (!allowed.has(`${request.scope}:${root}`)) {
       throw new Error("Requested skill root is not enabled or configured");
     }
+    const { resolvedRoot } = await resolvedSkillRoot(request);
     packages.push({
       ...request,
-      package: await readPackage(join9(root, request.skillName))
+      package: await readPackage(join9(root, request.skillName), resolvedRoot)
     });
   }
   return { ...successfulProcess6, packages };
@@ -14588,7 +14811,7 @@ async function optionalGit(cwd, args) {
 }
 function cappedGit(cwd, args, limit) {
   const budget = limit - TRUNCATION_RESERVE;
-  return new Promise((resolve8, reject) => {
+  return new Promise((resolve9, reject) => {
     const child = spawn6("git", args, {
       cwd,
       env: {
@@ -14638,7 +14861,7 @@ function cappedGit(cwd, args, limit) {
         return;
       }
       const output = Buffer.concat(chunks).toString("utf8");
-      resolve8(
+      resolve9(
         truncated ? `${output.trimEnd()}
 
 [Truncated after ${budget} bytes]` : output.trim()
@@ -14948,10 +15171,494 @@ var runWorkflowGitCheckpoint = async (payloadValue, _timeoutMs, signal) => {
 
 // src/handlers/worktrees.ts
 import { createWriteStream as createWriteStream2, watch } from "node:fs";
-import { mkdtemp as mkdtemp6, open as open2, readFile as readFile8, realpath as realpath8, rm as rm9, stat as stat10 } from "node:fs/promises";
+import { mkdtemp as mkdtemp6, open as open2, readFile as readFile9, realpath as realpath9, rm as rm10, stat as stat10 } from "node:fs/promises";
 import { tmpdir as tmpdir6 } from "node:os";
-import { basename as basename5, dirname as dirname7, isAbsolute as isAbsolute6, join as join13, relative as relative7 } from "node:path";
+import { basename as basename5, dirname as dirname8, isAbsolute as isAbsolute7, join as join14, relative as relative8 } from "node:path";
 import { spawn as spawn7 } from "node:child_process";
+
+// src/handlers/worktree-preparations.ts
+import { createHash as createHash7 } from "node:crypto";
+import {
+  chmod as chmod4,
+  lstat as lstat4,
+  mkdir as mkdir5,
+  readFile as readFile8,
+  realpath as realpath8,
+  rm as rm9,
+  writeFile as writeFile7
+} from "node:fs/promises";
+import { dirname as dirname7, isAbsolute as isAbsolute6, join as join13, relative as relative7, resolve as resolve7 } from "node:path";
+var EXCLUDE_BEGIN = "# BEGIN AIDE PREPARATIONS";
+var EXCLUDE_END = "# END AIDE PREPARATIONS";
+function cleanError3(value) {
+  return (value instanceof Error ? value.message : String(value)).replace(/([a-z][a-z0-9+.-]*:\/\/)[^\s/@]+@/gi, "$1").slice(0, 2e3);
+}
+async function git3(folder, args, timeoutMs, signal) {
+  return captureCommand({
+    command: "git",
+    args: ["-C", folder, ...args],
+    timeoutMs,
+    signal,
+    env: {
+      ...process.env,
+      GIT_LITERAL_PATHSPECS: "1",
+      GIT_OPTIONAL_LOCKS: "0",
+      GIT_TERMINAL_PROMPT: "0"
+    }
+  });
+}
+function requireSuccess3(result, fallback) {
+  if (result.cancelled) throw new Error("Preparation was cancelled");
+  if (result.timedOut) throw new Error("Preparation timed out");
+  if (result.exitCode !== 0) {
+    throw new Error(cleanError3(result.stderr || fallback));
+  }
+  return result;
+}
+async function exists(path) {
+  try {
+    await lstat4(path);
+    return true;
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+}
+async function safeTarget(folder, path) {
+  const root = await realpath8(folder);
+  const target2 = resolve7(root, path);
+  const fromRoot = relative7(root, target2);
+  if (!fromRoot || fromRoot.startsWith("..") || isAbsolute6(fromRoot) || path.includes("\0")) {
+    throw new Error(
+      "Preparation path must be an exact file inside the worktree"
+    );
+  }
+  let current = root;
+  const segments = fromRoot.split(/[\\/]/);
+  for (const segment of segments.slice(0, -1)) {
+    current = join13(current, segment);
+    try {
+      const info = await lstat4(current);
+      if (info.isSymbolicLink()) {
+        throw new Error(`Preparation path crosses symbolic link: ${path}`);
+      }
+      if (!info.isDirectory()) {
+        throw new Error(`Preparation parent is not a directory: ${path}`);
+      }
+    } catch (error) {
+      if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+        break;
+      }
+      throw error;
+    }
+  }
+  return target2;
+}
+async function isTracked(folder, path, timeoutMs, signal) {
+  const result = await git3(
+    folder,
+    ["ls-files", "--error-unmatch", "--", path],
+    timeoutMs,
+    signal
+  );
+  if (result.exitCode === 0) return true;
+  if (result.exitCode === 1) return false;
+  requireSuccess3(result, `Could not inspect tracked path ${path}`);
+  return false;
+}
+async function isAssumeUnchanged(folder, path, timeoutMs, signal) {
+  const result = requireSuccess3(
+    await git3(folder, ["ls-files", "-v", "--", path], timeoutMs, signal),
+    `Could not inspect assume-unchanged state for ${path}`
+  );
+  const marker = result.stdout[0];
+  return Boolean(marker && /[a-z]/.test(marker));
+}
+async function setAssumeUnchanged(folder, path, assumed, timeoutMs, signal) {
+  requireSuccess3(
+    await git3(
+      folder,
+      [
+        "update-index",
+        assumed ? "--assume-unchanged" : "--no-assume-unchanged",
+        "--",
+        path
+      ],
+      timeoutMs,
+      signal
+    ),
+    `Could not ${assumed ? "mark" : "unmark"} ${path} as assume unchanged`
+  );
+}
+function excludeEntry(path) {
+  return `/${path}`;
+}
+function withoutAideExcludeBlock(value) {
+  const lines = value.split(/\r?\n/);
+  const output = [];
+  let inBlock = false;
+  for (const line of lines) {
+    if (line === EXCLUDE_BEGIN) {
+      inBlock = true;
+      continue;
+    }
+    if (line === EXCLUDE_END) {
+      inBlock = false;
+      continue;
+    }
+    if (!inBlock) output.push(line);
+  }
+  return output.join("\n").replace(/\n+$/, "");
+}
+async function excludeFile(folder, timeoutMs, signal) {
+  const result = requireSuccess3(
+    await git3(
+      folder,
+      ["rev-parse", "--git-path", "info/exclude"],
+      timeoutMs,
+      signal
+    ),
+    "Could not locate the repository exclude file"
+  );
+  const candidate = result.stdout.trim();
+  return isAbsolute6(candidate) ? candidate : resolve7(folder, candidate);
+}
+async function readExcludeEntries(folder, timeoutMs, signal) {
+  const path = await excludeFile(folder, timeoutMs, signal);
+  let value = "";
+  try {
+    value = await readFile8(path, "utf8");
+  } catch (error) {
+    if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT") {
+      throw error;
+    }
+  }
+  const start = value.split(/\r?\n/).indexOf(EXCLUDE_BEGIN);
+  const end = value.split(/\r?\n/).indexOf(EXCLUDE_END);
+  if (start < 0 || end <= start) return /* @__PURE__ */ new Set();
+  return new Set(value.split(/\r?\n/).slice(start + 1, end));
+}
+async function reconcileExcludeFile(folder, definitions, timeoutMs, signal) {
+  const path = await excludeFile(folder, timeoutMs, signal);
+  let existing = "";
+  try {
+    existing = await readFile8(path, "utf8");
+  } catch (error) {
+    if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT") {
+      throw error;
+    }
+  }
+  const base = withoutAideExcludeBlock(existing);
+  const entries = definitions.filter((definition) => definition.kind === "WRITE").map((definition) => excludeEntry(definition.path)).sort((left, right) => left.localeCompare(right));
+  const block = entries.length ? [EXCLUDE_BEGIN, ...entries, EXCLUDE_END].join("\n") : "";
+  const next = [base, block].filter(Boolean).join("\n\n");
+  await mkdir5(dirname7(path), { recursive: true });
+  await writeFile7(path, next ? `${next}
+` : "", "utf8");
+}
+function decodeContents(definition) {
+  if (definition.contentBase64 === null) {
+    throw new Error(`Write preparation ${definition.path} has no contents`);
+  }
+  const contents = Buffer.from(definition.contentBase64, "base64");
+  const canonicalInput = definition.contentBase64.replace(/=+$/, "");
+  if (contents.toString("base64").replace(/=+$/, "") !== canonicalInput) {
+    throw new Error(
+      `Write preparation ${definition.path} has invalid base64 contents`
+    );
+  }
+  return contents;
+}
+async function removeTarget(target2, path) {
+  try {
+    const info = await lstat4(target2);
+    if (info.isDirectory() && !info.isSymbolicLink()) {
+      throw new Error(`Preparation path is a directory: ${path}`);
+    }
+    await rm9(target2, { force: true });
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return;
+    }
+    throw error;
+  }
+}
+async function restoreFromHead(folder, definition, timeoutMs, signal) {
+  const target2 = await safeTarget(folder, definition.path);
+  if (await isTracked(folder, definition.path, timeoutMs, signal)) {
+    await setAssumeUnchanged(folder, definition.path, false, timeoutMs, signal);
+    const atHead = await git3(
+      folder,
+      ["cat-file", "-e", `HEAD:${definition.path}`],
+      timeoutMs,
+      signal
+    );
+    if (atHead.exitCode === 0) {
+      requireSuccess3(
+        await git3(
+          folder,
+          ["restore", "--source=HEAD", "--worktree", "--", definition.path],
+          timeoutMs,
+          signal
+        ),
+        `Could not restore ${definition.path} from HEAD`
+      );
+      return;
+    }
+    if (atHead.exitCode !== 1 && atHead.exitCode !== 128) {
+      requireSuccess3(atHead, `Could not inspect ${definition.path} in HEAD`);
+    }
+  }
+  await removeTarget(target2, definition.path);
+}
+async function applyOne(folder, definition, timeoutMs, signal) {
+  const target2 = await safeTarget(folder, definition.path);
+  const tracked = await isTracked(folder, definition.path, timeoutMs, signal);
+  if (definition.kind === "ASSUME_UNCHANGED") {
+    if (!tracked) return "NOT_APPLICABLE";
+    await setAssumeUnchanged(folder, definition.path, true, timeoutMs, signal);
+    return "APPLIED";
+  }
+  if (definition.kind === "DELETE") {
+    await removeTarget(target2, definition.path);
+  } else {
+    const contents = decodeContents(definition);
+    let executable = false;
+    try {
+      const info = await lstat4(target2);
+      if (info.isDirectory() && !info.isSymbolicLink()) {
+        throw new Error(`Preparation path is a directory: ${definition.path}`);
+      }
+      executable = info.isFile() && (info.mode & 73) !== 0;
+      if (info.isSymbolicLink()) await rm9(target2, { force: true });
+    } catch (error) {
+      if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT") {
+        throw error;
+      }
+    }
+    await mkdir5(dirname7(target2), { recursive: true, mode: 493 });
+    await safeTarget(folder, definition.path);
+    await writeFile7(target2, contents, { mode: executable ? 493 : 420 });
+    if (executable) await chmod4(target2, 493);
+  }
+  if (tracked) {
+    await setAssumeUnchanged(folder, definition.path, true, timeoutMs, signal);
+  }
+  return "APPLIED";
+}
+async function undoOne(folder, definition, timeoutMs, signal) {
+  if (definition.kind === "ASSUME_UNCHANGED") {
+    if (!await isTracked(folder, definition.path, timeoutMs, signal)) {
+      return "NOT_APPLICABLE";
+    }
+    await setAssumeUnchanged(folder, definition.path, false, timeoutMs, signal);
+    return "UNDONE";
+  }
+  await restoreFromHead(folder, definition, timeoutMs, signal);
+  return "UNDONE";
+}
+async function inspectOne(folder, definition, excludeEntries, timeoutMs, signal) {
+  const target2 = await safeTarget(folder, definition.path);
+  const tracked = await isTracked(folder, definition.path, timeoutMs, signal);
+  const assumed = tracked ? await isAssumeUnchanged(folder, definition.path, timeoutMs, signal) : false;
+  if (definition.kind === "ASSUME_UNCHANGED") {
+    return tracked ? assumed ? "APPLIED" : "DRIFTED" : "NOT_APPLICABLE";
+  }
+  if (definition.kind === "DELETE") {
+    return !await exists(target2) && (!tracked || assumed) ? "APPLIED" : "DRIFTED";
+  }
+  let matches = false;
+  try {
+    const info = await lstat4(target2);
+    if (info.isFile()) {
+      const expected = createHash7("sha256").update(decodeContents(definition)).digest("hex");
+      const actual = createHash7("sha256").update(await readFile8(target2)).digest("hex");
+      matches = actual === expected;
+    }
+  } catch (error) {
+    if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT") {
+      throw error;
+    }
+  }
+  const hidden = tracked ? assumed : excludeEntries.has(excludeEntry(definition.path));
+  return matches && hidden ? "APPLIED" : "DRIFTED";
+}
+async function executeWorktreePreparations(folder, definitions, action, timeoutMs, signal) {
+  let excludeError = null;
+  if (action !== "INSPECT") {
+    try {
+      await reconcileExcludeFile(folder, definitions, timeoutMs, signal);
+    } catch (error) {
+      excludeError = cleanError3(error);
+    }
+  }
+  let excludeEntries = /* @__PURE__ */ new Set();
+  try {
+    excludeEntries = await readExcludeEntries(folder, timeoutMs, signal);
+  } catch (error) {
+    excludeError ??= cleanError3(error);
+  }
+  const results = [];
+  for (const definition of definitions) {
+    if (definition.kind === "WRITE" && excludeError) {
+      results.push({
+        id: definition.id,
+        definitionHash: definition.definitionHash,
+        state: "ERROR",
+        message: excludeError
+      });
+      continue;
+    }
+    try {
+      const state = action === "APPLY" ? await applyOne(folder, definition, timeoutMs, signal) : action === "UNDO" ? await undoOne(folder, definition, timeoutMs, signal) : await inspectOne(
+        folder,
+        definition,
+        excludeEntries,
+        timeoutMs,
+        signal
+      );
+      results.push({
+        id: definition.id,
+        definitionHash: definition.definitionHash,
+        state
+      });
+    } catch (error) {
+      results.push({
+        id: definition.id,
+        definitionHash: definition.definitionHash,
+        state: "ERROR",
+        message: cleanError3(error)
+      });
+    }
+  }
+  return results;
+}
+async function suspendWorktreePreparations(folder, definitions, timeoutMs, signal, preserveAssumeUnchangedContents = false) {
+  let excludeError = null;
+  try {
+    await reconcileExcludeFile(folder, definitions, timeoutMs, signal);
+  } catch (error) {
+    excludeError = cleanError3(error);
+  }
+  const results = [];
+  for (const definition of definitions) {
+    if (definition.kind === "WRITE" && excludeError) {
+      results.push({
+        id: definition.id,
+        definitionHash: definition.definitionHash,
+        state: "ERROR",
+        message: excludeError
+      });
+      continue;
+    }
+    try {
+      if (definition.kind === "ASSUME_UNCHANGED") {
+        if (await isTracked(folder, definition.path, timeoutMs, signal)) {
+          if (preserveAssumeUnchangedContents) {
+            await setAssumeUnchanged(
+              folder,
+              definition.path,
+              false,
+              timeoutMs,
+              signal
+            );
+          } else {
+            await restoreFromHead(folder, definition, timeoutMs, signal);
+          }
+          results.push({
+            id: definition.id,
+            definitionHash: definition.definitionHash,
+            state: "SUSPENDED"
+          });
+        } else {
+          results.push({
+            id: definition.id,
+            definitionHash: definition.definitionHash,
+            state: "NOT_APPLICABLE"
+          });
+        }
+      } else {
+        await restoreFromHead(folder, definition, timeoutMs, signal);
+        results.push({
+          id: definition.id,
+          definitionHash: definition.definitionHash,
+          state: "SUSPENDED"
+        });
+      }
+    } catch (error) {
+      results.push({
+        id: definition.id,
+        definitionHash: definition.definitionHash,
+        state: "ERROR",
+        message: cleanError3(error)
+      });
+    }
+  }
+  return results;
+}
+async function preparationConflictPaths(folder, definitions, remoteBase, timeoutMs, signal) {
+  const paths = [];
+  for (const definition of definitions) {
+    const changedByBase = await git3(
+      folder,
+      ["diff", "--quiet", `HEAD...${remoteBase}`, "--", definition.path],
+      timeoutMs,
+      signal
+    );
+    if (changedByBase.exitCode === 1) {
+      const tracked = await isTracked(
+        folder,
+        definition.path,
+        timeoutMs,
+        signal
+      );
+      let managedChange = false;
+      if (tracked) {
+        const head = await git3(
+          folder,
+          ["rev-parse", `HEAD:${definition.path}`],
+          timeoutMs,
+          signal
+        );
+        const working = await git3(
+          folder,
+          ["hash-object", "--", definition.path],
+          timeoutMs,
+          signal
+        );
+        managedChange = head.exitCode !== 0 || working.exitCode !== 0 || head.stdout.trim() !== working.stdout.trim();
+      } else if (definition.kind === "WRITE") {
+        managedChange = await exists(await safeTarget(folder, definition.path));
+      } else {
+        const presentOnBase = await git3(
+          folder,
+          ["cat-file", "-e", `${remoteBase}:${definition.path}`],
+          timeoutMs,
+          signal
+        );
+        if (presentOnBase.exitCode === 0) {
+          managedChange = true;
+        } else if (presentOnBase.exitCode !== 1 && presentOnBase.exitCode !== 128) {
+          requireSuccess3(
+            presentOnBase,
+            `Could not inspect ${definition.path} on the base branch`
+          );
+        }
+      }
+      if (managedChange) paths.push(definition.path);
+      continue;
+    }
+    requireSuccess3(
+      changedByBase,
+      `Could not inspect preparation conflict for ${definition.path}`
+    );
+  }
+  return paths;
+}
+
+// src/handlers/worktrees.ts
 var successfulProcess8 = {
   exitCode: 0,
   signal: null,
@@ -14995,7 +15702,7 @@ function statusChangeState(value) {
 }
 async function rebaseInProgress(folder, timeoutMs, signal) {
   for (const name of ["rebase-merge", "rebase-apply"]) {
-    const pathResult = await git3(
+    const pathResult = await git4(
       folder,
       ["rev-parse", "--git-path", name],
       timeoutMs,
@@ -15005,7 +15712,7 @@ async function rebaseInProgress(folder, timeoutMs, signal) {
     const candidate = pathResult.stdout.trim();
     if (!candidate) continue;
     try {
-      await stat10(isAbsolute6(candidate) ? candidate : join13(folder, candidate));
+      await stat10(isAbsolute7(candidate) ? candidate : join14(folder, candidate));
       return true;
     } catch {
     }
@@ -15014,7 +15721,7 @@ async function rebaseInProgress(folder, timeoutMs, signal) {
 }
 async function rebaseBranch(folder, timeoutMs, signal) {
   for (const name of ["rebase-merge/head-name", "rebase-apply/head-name"]) {
-    const pathResult = await git3(
+    const pathResult = await git4(
       folder,
       ["rev-parse", "--git-path", name],
       timeoutMs,
@@ -15024,8 +15731,8 @@ async function rebaseBranch(folder, timeoutMs, signal) {
     const candidate = pathResult.stdout.trim();
     if (!candidate) continue;
     try {
-      const headName = (await readFile8(
-        isAbsolute6(candidate) ? candidate : join13(folder, candidate),
+      const headName = (await readFile9(
+        isAbsolute7(candidate) ? candidate : join14(folder, candidate),
         "utf8"
       )).trim();
       if (headName.startsWith("refs/heads/")) {
@@ -15059,7 +15766,7 @@ async function flushWorktreeActivity(entry) {
   try {
     const signal = new AbortController().signal;
     const [status2, branchResult, headResult, codeStateHash, rebasing] = await Promise.all([
-      git3(
+      git4(
         entry.folder,
         [
           "--no-optional-locks",
@@ -15071,13 +15778,13 @@ async function flushWorktreeActivity(entry) {
         entry.timeoutMs,
         signal
       ),
-      git3(
+      git4(
         entry.folder,
         ["symbolic-ref", "--short", "-q", "HEAD"],
         entry.timeoutMs,
         signal
       ),
-      git3(entry.folder, ["rev-parse", "HEAD"], entry.timeoutMs, signal),
+      git4(entry.folder, ["rev-parse", "HEAD"], entry.timeoutMs, signal),
       worktreeCodeStateHash(entry.folder, entry.timeoutMs, signal),
       rebaseInProgress(entry.folder, entry.timeoutMs, signal)
     ]);
@@ -15106,7 +15813,7 @@ async function flushWorktreeActivity(entry) {
       observedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
     if (headIdentity && headIdentity !== entry.headIdentity) {
-      const upstreamResult = branch ? await git3(
+      const upstreamResult = branch ? await git4(
         entry.folder,
         [
           "rev-parse",
@@ -15164,24 +15871,24 @@ function scheduleWorktreeActivity(entry) {
   }, WATCH_DEBOUNCE_MS);
   entry.timer.unref();
 }
-function cleanError3(value) {
+function cleanError4(value) {
   return (value instanceof Error ? value.message : String(value)).replace(/([a-z][a-z0-9+.-]*:\/\/)[^\s/@]+@/gi, "$1").slice(0, 2e3);
 }
 async function command2(executable, args, timeoutMs, signal, env = process.env) {
   return captureCommand({ command: executable, args, timeoutMs, signal, env });
 }
-async function git3(folder, args, timeoutMs, signal) {
+async function git4(folder, args, timeoutMs, signal) {
   return command2("git", ["-C", folder, ...args], timeoutMs, signal, {
     ...process.env,
     GIT_TERMINAL_PROMPT: "0",
     GIT_OPTIONAL_LOCKS: "0"
   });
 }
-function requireSuccess3(result, fallback) {
+function requireSuccess4(result, fallback) {
   if (result.cancelled) throw new Error("Worktree operation was cancelled");
   if (result.timedOut) throw new Error("Worktree operation timed out");
   if (result.exitCode !== 0)
-    throw new Error(cleanError3(result.stderr || fallback));
+    throw new Error(cleanError4(result.stderr || fallback));
   return result;
 }
 function parseWorktreeList(value) {
@@ -15199,8 +15906,8 @@ function parseWorktreeList(value) {
   }).filter((entry) => Boolean(entry.folder));
 }
 async function gitDirectory(folder, timeoutMs, signal) {
-  const result = requireSuccess3(
-    await git3(
+  const result = requireSuccess4(
+    await git4(
       folder,
       ["rev-parse", "--path-format=absolute", "--git-dir"],
       timeoutMs,
@@ -15208,17 +15915,17 @@ async function gitDirectory(folder, timeoutMs, signal) {
     ),
     "Could not resolve the worktree Git directory"
   );
-  return realpath8(result.stdout.trim());
+  return realpath9(result.stdout.trim());
 }
 async function origin(folder, timeoutMs, signal) {
-  const result = requireSuccess3(
-    await git3(folder, ["remote", "get-url", "origin"], timeoutMs, signal),
+  const result = requireSuccess4(
+    await git4(folder, ["remote", "get-url", "origin"], timeoutMs, signal),
     "Repository does not have an origin remote"
   );
   return normalizeGitOrigin(result.stdout.trim()).canonicalOrigin;
 }
 async function validateWorktree2(input, timeoutMs, signal) {
-  const folder = await realpath8(input.folder);
+  const folder = await realpath9(input.folder);
   if (!(await stat10(folder)).isDirectory())
     throw new Error("Worktree is missing");
   const observedGitDirectory = await gitDirectory(folder, timeoutMs, signal);
@@ -15231,7 +15938,7 @@ async function validateWorktree2(input, timeoutMs, signal) {
   return folder;
 }
 async function counts(folder, range, timeoutMs, signal) {
-  const result = await git3(
+  const result = await git4(
     folder,
     ["rev-list", "--left-right", "--count", range],
     timeoutMs,
@@ -15265,17 +15972,17 @@ async function worktreePushStatus(folder, branch, changes, timeoutMs, signal) {
 async function inspectWorktreeItem(folderValue2, rootFolder, baseBranch, primary, timeoutMs, signal) {
   const checkedAt = (/* @__PURE__ */ new Date()).toISOString();
   try {
-    const folder = await realpath8(folderValue2);
+    const folder = await realpath9(folderValue2);
     const [gitDir, branchResult, headResult, statusResult, rebasing] = await Promise.all([
       gitDirectory(folder, timeoutMs, signal),
-      git3(
+      git4(
         folder,
         ["symbolic-ref", "--short", "-q", "HEAD"],
         timeoutMs,
         signal
       ),
-      git3(folder, ["rev-parse", "HEAD"], timeoutMs, signal),
-      git3(
+      git4(folder, ["rev-parse", "HEAD"], timeoutMs, signal),
+      git4(
         folder,
         [
           "--no-optional-locks",
@@ -15291,7 +15998,7 @@ async function inspectWorktreeItem(folderValue2, rootFolder, baseBranch, primary
     ]);
     const symbolicBranch = branchResult.exitCode === 0 ? branchResult.stdout.trim() : null;
     const branch = symbolicBranch ?? (rebasing ? await rebaseBranch(folder, timeoutMs, signal) : null);
-    const upstreamResult = branch ? await git3(
+    const upstreamResult = branch ? await git4(
       folder,
       ["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{upstream}"],
       timeoutMs,
@@ -15314,7 +16021,7 @@ async function inspectWorktreeItem(folderValue2, rootFolder, baseBranch, primary
     return {
       gitDirectory: gitDir,
       folder,
-      relativePath: relative7(rootFolder, folder) || ".",
+      relativePath: relative8(rootFolder, folder) || ".",
       primary,
       branch,
       headSha: headResult.exitCode === 0 ? headResult.stdout.trim() : null,
@@ -15342,7 +16049,7 @@ async function inspectWorktreeItem(folderValue2, rootFolder, baseBranch, primary
     return {
       gitDirectory: folderValue2,
       folder: folderValue2,
-      relativePath: relative7(rootFolder, folderValue2) || ".",
+      relativePath: relative8(rootFolder, folderValue2) || ".",
       primary,
       branch: null,
       headSha: null,
@@ -15359,15 +16066,15 @@ async function inspectWorktreeItem(folderValue2, rootFolder, baseBranch, primary
       hasConflicts: false,
       pushStatus: "UNKNOWN",
       availability: "ERROR",
-      error: cleanError3(error),
+      error: cleanError4(error),
       checkedAt
     };
   }
 }
 async function discoverWorktrees(rootFolderValue, baseOverrides, knownDefaultBranch, timeoutMs, signal) {
-  const rootFolder = await realpath8(rootFolderValue);
-  const list = requireSuccess3(
-    await git3(
+  const rootFolder = await realpath9(rootFolderValue);
+  const list = requireSuccess4(
+    await git4(
       rootFolder,
       ["worktree", "list", "--porcelain"],
       timeoutMs,
@@ -15375,14 +16082,14 @@ async function discoverWorktrees(rootFolderValue, baseOverrides, knownDefaultBra
     ),
     "Could not list Git worktrees"
   );
-  const remoteHead = await git3(
+  const remoteHead = await git4(
     rootFolder,
     ["ls-remote", "--symref", "origin", "HEAD"],
     timeoutMs,
     signal
   );
   let defaultBranch = remoteHead.stdout.match(/^ref:\s+refs\/heads\/([^\s]+)\s+HEAD/m)?.[1] ?? null;
-  const defaultResult = await git3(
+  const defaultResult = await git4(
     rootFolder,
     ["symbolic-ref", "--short", "refs/remotes/origin/HEAD"],
     timeoutMs,
@@ -15393,13 +16100,13 @@ async function discoverWorktrees(rootFolderValue, baseOverrides, knownDefaultBra
     defaultBranch = localDefaultBranch || knownDefaultBranch;
   }
   const [localBranchesResult, remoteBranchesResult] = await Promise.all([
-    git3(
+    git4(
       rootFolder,
       ["for-each-ref", "--format=%(refname:strip=2)", "refs/heads"],
       timeoutMs,
       signal
     ),
-    git3(
+    git4(
       rootFolder,
       ["for-each-ref", "--format=%(refname:strip=3)", "refs/remotes/origin"],
       timeoutMs,
@@ -15462,7 +16169,7 @@ async function untrackedLines(folder, path) {
   try {
     const file = await stat10(`${folder}/${path}`);
     if (!file.isFile() || file.size > 1024 * 1024) return null;
-    const contents = await readFile8(`${folder}/${path}`);
+    const contents = await readFile9(`${folder}/${path}`);
     if (contents.includes(0)) return null;
     const text2 = contents.toString("utf8");
     return text2 ? text2.split("\n").length - (text2.endsWith("\n") ? 1 : 0) : 0;
@@ -15472,16 +16179,16 @@ async function untrackedLines(folder, path) {
 }
 async function inspectChanges(folder, timeoutMs, signal) {
   const [statusResult, stagedResult, unstagedResult] = await Promise.all([
-    git3(
+    git4(
       folder,
       ["status", "--porcelain=v1", "-z", "--untracked-files=all"],
       timeoutMs,
       signal
     ),
-    git3(folder, ["diff", "--cached", "--numstat", "-z"], timeoutMs, signal),
-    git3(folder, ["diff", "--numstat", "-z"], timeoutMs, signal)
+    git4(folder, ["diff", "--cached", "--numstat", "-z"], timeoutMs, signal),
+    git4(folder, ["diff", "--numstat", "-z"], timeoutMs, signal)
   ]);
-  requireSuccess3(statusResult, "Could not inspect worktree changes");
+  requireSuccess4(statusResult, "Could not inspect worktree changes");
   const stagedCounts = parseNumstat(stagedResult.stdout);
   const unstagedCounts = parseNumstat(unstagedResult.stdout);
   const values = statusResult.stdout.split("\0").filter(Boolean);
@@ -15541,11 +16248,11 @@ function parseNameStatus(value) {
 }
 async function diffFiles(folder, range, timeoutMs, signal) {
   const [status2, counts2] = await Promise.all([
-    git3(folder, ["diff", "--name-status", "-z", range], timeoutMs, signal),
-    git3(folder, ["diff", "--numstat", "-z", range], timeoutMs, signal)
+    git4(folder, ["diff", "--name-status", "-z", range], timeoutMs, signal),
+    git4(folder, ["diff", "--numstat", "-z", range], timeoutMs, signal)
   ]);
-  requireSuccess3(status2, "Could not inspect changed files");
-  requireSuccess3(counts2, "Could not inspect changed line counts");
+  requireSuccess4(status2, "Could not inspect changed files");
+  requireSuccess4(counts2, "Could not inspect changed line counts");
   const numstat = parseNumstat(counts2.stdout);
   return parseNameStatus(status2.stdout).map((file) => {
     const [additions, deletions] = numstat.get(file.path) ?? [null, null];
@@ -15559,8 +16266,8 @@ async function diffFiles(folder, range, timeoutMs, signal) {
   });
 }
 async function inspectBranchChanges(folder, baseBranch, timeoutMs, signal) {
-  const mergeBase = requireSuccess3(
-    await git3(
+  const mergeBase = requireSuccess4(
+    await git4(
       folder,
       ["merge-base", `refs/remotes/origin/${baseBranch}`, "HEAD"],
       timeoutMs,
@@ -15577,8 +16284,8 @@ async function inspectBranchChanges(folder, baseBranch, timeoutMs, signal) {
   return { changes: files.slice(0, 500), truncated: files.length > 500 };
 }
 async function inspectCommits(folder, baseBranch, timeoutMs, signal) {
-  const result = requireSuccess3(
-    await git3(
+  const result = requireSuccess4(
+    await git4(
       folder,
       [
         "log",
@@ -15611,7 +16318,7 @@ async function inspectWorktreeDetail(folder, baseBranch, timeoutMs, signal) {
     inspectCommits(folder, baseBranch, timeoutMs, signal),
     inspectChanges(folder, timeoutMs, signal),
     inspectBranchChanges(folder, baseBranch, timeoutMs, signal),
-    git3(
+    git4(
       folder,
       ["config", "--bool", "--get", "commit.gpgsign"],
       timeoutMs,
@@ -15629,8 +16336,8 @@ async function inspectWorktreeDetail(folder, baseBranch, timeoutMs, signal) {
   };
 }
 async function baseMergeCommit(folder, baseBranch, timeoutMs, signal) {
-  return requireSuccess3(
-    await git3(
+  return requireSuccess4(
+    await git4(
       folder,
       ["merge-base", `refs/remotes/origin/${baseBranch}`, "HEAD"],
       timeoutMs,
@@ -15645,13 +16352,13 @@ async function validateDisplayedCommit(folder, baseBranch, commitSha, timeoutMs,
   }
   const base = await baseMergeCommit(folder, baseBranch, timeoutMs, signal);
   const [afterBase, beforeHead] = await Promise.all([
-    git3(
+    git4(
       folder,
       ["merge-base", "--is-ancestor", base, commitSha],
       timeoutMs,
       signal
     ),
-    git3(
+    git4(
       folder,
       ["merge-base", "--is-ancestor", commitSha, "HEAD"],
       timeoutMs,
@@ -15663,7 +16370,7 @@ async function validateDisplayedCommit(folder, baseBranch, commitSha, timeoutMs,
   }
 }
 async function parentCommit(folder, commitSha, timeoutMs, signal) {
-  const result = await git3(
+  const result = await git4(
     folder,
     ["rev-parse", `${commitSha}^`],
     timeoutMs,
@@ -15672,13 +16379,13 @@ async function parentCommit(folder, commitSha, timeoutMs, signal) {
   return result.exitCode === 0 ? result.stdout.trim() : null;
 }
 async function gitObjectExists(folder, specification, timeoutMs, signal) {
-  return (await git3(folder, ["cat-file", "-e", specification], timeoutMs, signal)).exitCode === 0;
+  return (await git4(folder, ["cat-file", "-e", specification], timeoutMs, signal)).exitCode === 0;
 }
 async function comparisonSides(input, folder, timeoutMs, signal) {
   if (!input.path) return { before: null, after: null };
   const path = input.path;
   const previousPath = input.previousPath ?? path;
-  const currentPath = join13(folder, path);
+  const currentPath = join14(folder, path);
   if (input.scope === "UNTRACKED") {
     return { before: null, after: { kind: "FILE", path: currentPath } };
   }
@@ -15780,8 +16487,8 @@ async function availableSide(side, folder, timeoutMs, signal) {
     return gitObjectExists(folder, side.specification, timeoutMs, signal);
   }
   try {
-    const resolved = await realpath8(side.path);
-    const difference = relative7(folder, resolved);
+    const resolved = await realpath9(side.path);
+    const difference = relative8(folder, resolved);
     return difference !== ".." && !difference.startsWith("../") && (await stat10(resolved)).isFile();
   } catch {
     return false;
@@ -15853,7 +16560,7 @@ async function inspectRequestedDiff(input, folder, timeoutMs, signal) {
   let patch;
   if (input.scope === "UNTRACKED") {
     const bounded = await readBoundedFile(
-      join13(folder, input.path),
+      join14(folder, input.path),
       MAX_DIFF_BYTES
     );
     const contents = bounded.contents;
@@ -15864,8 +16571,8 @@ async function inspectRequestedDiff(input, folder, timeoutMs, signal) {
       patch = untrackedTextPatch(input.path, contents);
     }
   } else {
-    patch = requireSuccess3(
-      await git3(folder, args, timeoutMs, signal),
+    patch = requireSuccess4(
+      await git4(folder, args, timeoutMs, signal),
       "Could not load the file diff"
     ).stdout;
   }
@@ -15888,7 +16595,7 @@ async function validateChangedPath(input, folder, timeoutMs, signal) {
   if (!input.path) throw new Error("A changed file path is required");
   let result;
   if (input.scope === "UNTRACKED") {
-    result = await git3(
+    result = await git4(
       folder,
       ["ls-files", "--others", "--exclude-standard", "-z", "--", input.path],
       timeoutMs,
@@ -15919,9 +16626,9 @@ async function validateChangedPath(input, folder, timeoutMs, signal) {
       );
     }
     args.push("--", ...requestedDiffPaths(input));
-    result = await git3(folder, args, timeoutMs, signal);
+    result = await git4(folder, args, timeoutMs, signal);
   }
-  requireSuccess3(result, "Could not validate the changed file");
+  requireSuccess4(result, "Could not validate the changed file");
   const requested = input.scope === "UNTRACKED" ? result.stdout.split("\0").filter(Boolean).includes(input.path) : parseNameStatus(result.stdout).some(
     (file) => file.path === input.path && (!input.previousPath || file.previousPath === input.previousPath)
   );
@@ -15986,7 +16693,7 @@ async function writeGitObject(folder, specification, destination, timeoutMs, sig
       signal.removeEventListener("abort", abort);
       if (settled) return;
       if (code !== 0) {
-        fail(new Error(cleanError3(stderr || "Could not extract image")));
+        fail(new Error(cleanError4(stderr || "Could not extract image")));
         return;
       }
       output.end(() => {
@@ -16017,14 +16724,14 @@ var downloadWorktreeDiffAsset = async (payload, timeoutMs, signal, _onLog, conte
   let temporaryDirectory = null;
   try {
     if (selected.kind === "FILE") {
-      uploadPath = await realpath8(selected.path);
-      const difference = relative7(folder, uploadPath);
+      uploadPath = await realpath9(selected.path);
+      const difference = relative8(folder, uploadPath);
       if (difference === ".." || difference.startsWith("../")) {
         throw new Error("Diff image resolves outside the worktree");
       }
     } else {
-      const size = requireSuccess3(
-        await git3(
+      const size = requireSuccess4(
+        await git4(
           folder,
           ["cat-file", "-s", selected.specification],
           timeoutMs,
@@ -16035,8 +16742,8 @@ var downloadWorktreeDiffAsset = async (payload, timeoutMs, signal, _onLog, conte
       if (!/^\d+$/.test(size) || Number(size) > 20 * 1024 * 1024) {
         throw new Error("Diff image exceeds the 20 MiB limit");
       }
-      temporaryDirectory = await mkdtemp6(join13(tmpdir6(), "ade-diff-image-"));
-      uploadPath = join13(temporaryDirectory, basename5(input.path));
+      temporaryDirectory = await mkdtemp6(join14(tmpdir6(), "ade-diff-image-"));
+      uploadPath = join14(temporaryDirectory, basename5(input.path));
       await writeGitObject(
         folder,
         selected.specification,
@@ -16058,7 +16765,7 @@ var downloadWorktreeDiffAsset = async (payload, timeoutMs, signal, _onLog, conte
     return successfulProcess8;
   } finally {
     if (temporaryDirectory) {
-      await rm9(temporaryDirectory, { recursive: true, force: true });
+      await rm10(temporaryDirectory, { recursive: true, force: true });
     }
   }
 };
@@ -16154,7 +16861,7 @@ var inspectWorktreeGit = async (payload, timeoutMs, signal) => {
 var commitWorktree = async (payload, timeoutMs, signal) => {
   const input = worktreeCommitJobPayload(payload);
   const folder = await validateWorktree2(input, timeoutMs, signal);
-  const runGit = async (args, fallback) => requireSuccess3(await git3(folder, args, timeoutMs, signal), fallback);
+  const runGit = async (args, fallback) => requireSuccess4(await git4(folder, args, timeoutMs, signal), fallback);
   if (input.stageAll) {
     await runGit(["add", "--all"], "Could not stage worktree changes");
   } else {
@@ -16167,7 +16874,7 @@ var commitWorktree = async (payload, timeoutMs, signal) => {
       if (!change) throw new Error(`Worktree change no longer exists: ${path}`);
       return change;
     });
-    const head = await git3(
+    const head = await git4(
       folder,
       ["rev-parse", "--verify", "HEAD"],
       timeoutMs,
@@ -16196,7 +16903,7 @@ var commitWorktree = async (payload, timeoutMs, signal) => {
       "Could not stage selected worktree changes"
     );
   }
-  const staged = await git3(
+  const staged = await git4(
     folder,
     ["diff", "--cached", "--quiet", "--exit-code"],
     timeoutMs,
@@ -16204,10 +16911,10 @@ var commitWorktree = async (payload, timeoutMs, signal) => {
   );
   if (staged.exitCode === 0) throw new Error("No staged changes to commit");
   if (staged.exitCode !== 1)
-    requireSuccess3(staged, "Could not inspect staged changes");
+    requireSuccess4(staged, "Could not inspect staged changes");
   let signed = input.signed;
   if (signed === null) {
-    const configured = await git3(
+    const configured = await git4(
       folder,
       ["config", "--bool", "--get", "commit.gpgsign"],
       timeoutMs,
@@ -16264,7 +16971,7 @@ var operateWorktreeGit = async (payload, timeoutMs, signal) => {
   };
 };
 async function refExists(folder, ref, timeoutMs, signal) {
-  const result = await git3(
+  const result = await git4(
     folder,
     ["show-ref", "--verify", "--quiet", ref],
     timeoutMs,
@@ -16273,13 +16980,13 @@ async function refExists(folder, ref, timeoutMs, signal) {
   return result.exitCode === 0;
 }
 async function resolveHead(folder, ref, timeoutMs, signal) {
-  return requireSuccess3(
-    await git3(folder, ["rev-parse", ref], timeoutMs, signal),
+  return requireSuccess4(
+    await git4(folder, ["rev-parse", ref], timeoutMs, signal),
     `Could not resolve ${ref}`
   ).stdout.trim();
 }
 async function isAncestor(folder, ancestor, descendant, timeoutMs, signal) {
-  const result = await git3(
+  const result = await git4(
     folder,
     ["merge-base", "--is-ancestor", ancestor, descendant],
     timeoutMs,
@@ -16287,12 +16994,12 @@ async function isAncestor(folder, ancestor, descendant, timeoutMs, signal) {
   );
   if (result.exitCode === 0) return true;
   if (result.exitCode === 1) return false;
-  requireSuccess3(result, "Could not compare Git history");
+  requireSuccess4(result, "Could not compare Git history");
   return false;
 }
 async function statusState(folder, timeoutMs, signal) {
-  const result = requireSuccess3(
-    await git3(
+  const result = requireSuccess4(
+    await git4(
       folder,
       ["status", "--porcelain=v1", "-z", "--untracked-files=all"],
       timeoutMs,
@@ -16306,7 +17013,7 @@ function hasChanges(changes) {
   return changes.hasStagedChanges || changes.hasUnstagedChanges;
 }
 async function currentBranch(folder, timeoutMs, signal) {
-  const result = await git3(
+  const result = await git4(
     folder,
     ["symbolic-ref", "--short", "-q", "HEAD"],
     timeoutMs,
@@ -16326,7 +17033,7 @@ async function chooseNewBranch(folder, candidates, allowedCurrentBranch, timeout
   throw new Error("Every generated ticket branch name is already taken");
 }
 async function validateBranchRoot(input, timeoutMs, signal) {
-  const rootFolder = await realpath8(input.rootFolder);
+  const rootFolder = await realpath9(input.rootFolder);
   if (!(await stat10(rootFolder)).isDirectory()) {
     throw new Error("Base repository is missing");
   }
@@ -16390,8 +17097,8 @@ var branchWorktree = async (payload, timeoutMs, signal) => {
     timeoutMs,
     signal
   ) : input.candidates[0];
-  const targetFolder = input.action === "CREATE" ? join13(
-    dirname7(rootFolder),
+  const targetFolder = input.action === "CREATE" ? join14(
+    dirname8(rootFolder),
     `${basename5(rootFolder)}-${branch.replaceAll("/", "-")}`
   ) : changeFolder;
   if (input.action === "CREATE") {
@@ -16436,40 +17143,89 @@ var branchWorktree = async (payload, timeoutMs, signal) => {
     ];
   }
   let stashed = false;
-  if (args.length > 0) {
-    let switched = await git3(
-      input.action === "CREATE" ? rootFolder : targetFolder,
-      args,
+  let preparationsSuspended = false;
+  const reapplyPreparations = () => executeWorktreePreparations(
+    targetFolder,
+    input.preparations,
+    "APPLY",
+    timeoutMs,
+    signal
+  );
+  if (args.length > 0 && input.action === "CHANGE" && input.preparations.length > 0) {
+    const suspended = await suspendWorktreePreparations(
+      targetFolder,
+      input.preparations,
       timeoutMs,
-      signal
+      signal,
+      true
     );
-    if (switched.exitCode !== 0 && input.action === "CHANGE" && input.stashOnFailure) {
-      const stash = requireSuccess3(
-        await git3(
-          targetFolder,
-          [
-            "stash",
-            "push",
-            "--include-untracked",
-            "-m",
-            `Automatic stash before switching to ${branch}`
-          ],
-          timeoutMs,
-          signal
-        ),
-        "Could not stash worktree changes"
+    preparationsSuspended = true;
+    const failed = suspended.filter((item) => item.state === "ERROR");
+    if (failed.length > 0) {
+      await reapplyPreparations();
+      throw new Error(
+        failed.map((item) => item.message ?? "Preparation failed").join("; ")
       );
-      stashed = !stash.stdout.toLowerCase().includes("no local changes");
-      switched = await git3(targetFolder, args, timeoutMs, signal);
-      if (switched.exitCode !== 0) {
-        throw new Error(
-          `${cleanError3(switched.stderr || "Branch switch failed after stashing")}. The stash was preserved.`
+    }
+  }
+  if (args.length > 0) {
+    try {
+      let switched = await git4(
+        input.action === "CREATE" ? rootFolder : targetFolder,
+        args,
+        timeoutMs,
+        signal
+      );
+      if (switched.exitCode !== 0 && input.action === "CHANGE" && input.stashOnFailure) {
+        const stash = requireSuccess4(
+          await git4(
+            targetFolder,
+            [
+              "stash",
+              "push",
+              "--include-untracked",
+              "-m",
+              `Automatic stash before switching to ${branch}`
+            ],
+            timeoutMs,
+            signal
+          ),
+          "Could not stash worktree changes"
+        );
+        stashed = !stash.stdout.toLowerCase().includes("no local changes");
+        switched = await git4(targetFolder, args, timeoutMs, signal);
+        if (switched.exitCode !== 0) {
+          throw new Error(
+            `${cleanError4(switched.stderr || "Branch switch failed after stashing")}. The stash was preserved.`
+          );
+        }
+      } else {
+        requireSuccess4(
+          switched,
+          input.action === "CREATE" ? "Could not create the worktree" : "Could not change the worktree branch"
         );
       }
-    } else {
-      requireSuccess3(
-        switched,
-        input.action === "CREATE" ? "Could not create the worktree" : "Could not change the worktree branch"
+    } catch (error) {
+      if (preparationsSuspended) await reapplyPreparations();
+      throw error;
+    }
+  }
+  let preparations = [];
+  if (input.preparations.length > 0) {
+    preparations = await reapplyPreparations();
+    const failed = preparations.filter((item) => item.state === "ERROR");
+    if (failed.length > 0 && input.action === "CREATE") {
+      await git4(
+        rootFolder,
+        ["worktree", "remove", "--force", targetFolder],
+        timeoutMs,
+        signal
+      );
+      if (input.mode === "NEW") {
+        await git4(rootFolder, ["branch", "-D", branch], timeoutMs, signal);
+      }
+      throw new Error(
+        failed.map((item) => item.message ?? "Preparation failed").join("; ")
       );
     }
   }
@@ -16489,7 +17245,9 @@ var branchWorktree = async (payload, timeoutMs, signal) => {
     worktree,
     branch,
     baseBranch: input.baseBranch,
-    stashed
+    stashed,
+    checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    preparations
   };
 };
 var pushMovedWorktree = async (payload, timeoutMs, signal) => {
@@ -16516,8 +17274,8 @@ var pushMovedWorktree = async (payload, timeoutMs, signal) => {
   if (hasChanges(changes)) {
     throw new Error("Commit or discard source changes before moving");
   }
-  requireSuccess3(
-    await git3(folder, ["fetch", "origin"], timeoutMs, signal),
+  requireSuccess4(
+    await git4(folder, ["fetch", "origin"], timeoutMs, signal),
     "Could not fetch origin before moving"
   );
   const remoteRef = `refs/remotes/origin/${branch}`;
@@ -16526,8 +17284,8 @@ var pushMovedWorktree = async (payload, timeoutMs, signal) => {
       "The origin branch contains commits that must be pulled before moving"
     );
   }
-  requireSuccess3(
-    await git3(
+  requireSuccess4(
+    await git4(
       folder,
       ["push", "--set-upstream", "origin", `HEAD:refs/heads/${branch}`],
       timeoutMs,
@@ -16562,8 +17320,8 @@ async function updateLocalBranchForMove(rootFolder, branch, expectedHeadSha, tim
       `Local branch ${branch} has commits that are not on origin; move them before retrying`
     );
   }
-  requireSuccess3(
-    await git3(
+  requireSuccess4(
+    await git4(
       rootFolder,
       ["branch", "-f", branch, expectedHeadSha],
       timeoutMs,
@@ -16574,8 +17332,8 @@ async function updateLocalBranchForMove(rootFolder, branch, expectedHeadSha, tim
   return true;
 }
 async function checkedOutBranchFolder(rootFolder, branch, timeoutMs, signal) {
-  const result = requireSuccess3(
-    await git3(
+  const result = requireSuccess4(
+    await git4(
       rootFolder,
       ["worktree", "list", "--porcelain"],
       timeoutMs,
@@ -16591,8 +17349,8 @@ var checkoutMovedWorktree = async (payload, timeoutMs, signal) => {
   const input = worktreeMoveCheckoutJobPayload(payload);
   const rootFolder = await validateBranchRoot(input, timeoutMs, signal);
   const remoteRef = `refs/remotes/origin/${input.branch}`;
-  requireSuccess3(
-    await git3(
+  requireSuccess4(
+    await git4(
       rootFolder,
       [
         "fetch",
@@ -16617,6 +17375,7 @@ var checkoutMovedWorktree = async (payload, timeoutMs, signal) => {
     );
   }
   let targetFolder;
+  let createdLocalBranch = false;
   let stashed = false;
   const occupiedFolder = await checkedOutBranchFolder(
     rootFolder,
@@ -16630,8 +17389,8 @@ var checkoutMovedWorktree = async (payload, timeoutMs, signal) => {
         `Branch ${input.branch} is already checked out in ${occupiedFolder}`
       );
     }
-    targetFolder = join13(
-      dirname7(rootFolder),
+    targetFolder = join14(
+      dirname8(rootFolder),
       `${basename5(rootFolder)}-${input.branch.replaceAll("/", "-")}`
     );
     try {
@@ -16649,8 +17408,9 @@ var checkoutMovedWorktree = async (payload, timeoutMs, signal) => {
       timeoutMs,
       signal
     );
-    requireSuccess3(
-      await git3(
+    createdLocalBranch = !local;
+    requireSuccess4(
+      await git4(
         rootFolder,
         local ? ["worktree", "add", targetFolder, input.branch] : [
           "worktree",
@@ -16681,7 +17441,7 @@ var checkoutMovedWorktree = async (payload, timeoutMs, signal) => {
     const targetBranch = await currentBranch(targetFolder, timeoutMs, signal);
     const targetChanges = await statusState(targetFolder, timeoutMs, signal);
     if (occupiedFolder) {
-      const occupied = await realpath8(occupiedFolder);
+      const occupied = await realpath9(occupiedFolder);
       if (occupied !== targetFolder) {
         throw new Error(
           `Branch ${input.branch} is checked out in another destination worktree`
@@ -16719,8 +17479,8 @@ var checkoutMovedWorktree = async (payload, timeoutMs, signal) => {
       switchArgs = local ? ["switch", input.branch] : ["switch", "--track", "-c", input.branch, remoteRef];
     }
     if (input.stashOnFailure && hasChanges(targetChanges)) {
-      const stash = requireSuccess3(
-        await git3(
+      const stash = requireSuccess4(
+        await git4(
           targetFolder,
           [
             "stash",
@@ -16736,25 +17496,25 @@ var checkoutMovedWorktree = async (payload, timeoutMs, signal) => {
       );
       stashed = !stash.stdout.toLowerCase().includes("no local changes");
     }
-    const switched = await git3(targetFolder, switchArgs, timeoutMs, signal);
+    const switched = await git4(targetFolder, switchArgs, timeoutMs, signal);
     if (switched.exitCode !== 0) {
       if (!input.stashOnFailure && hasChanges(targetChanges)) {
         return {
           ...successfulProcess8,
           moveId: input.moveId,
           outcome: "NEEDS_STASH",
-          message: cleanError3(
+          message: cleanError4(
             switched.stderr || "Destination changes block the branch switch"
           )
         };
       }
       throw new Error(
-        `${cleanError3(switched.stderr || "Could not check out the moved branch")}${stashed ? ". The destination stash was preserved." : ""}`
+        `${cleanError4(switched.stderr || "Could not check out the moved branch")}${stashed ? ". The destination stash was preserved." : ""}`
       );
     }
   }
-  requireSuccess3(
-    await git3(
+  requireSuccess4(
+    await git4(
       targetFolder,
       ["branch", "--set-upstream-to", `origin/${input.branch}`, input.branch],
       timeoutMs,
@@ -16771,6 +17531,30 @@ var checkoutMovedWorktree = async (payload, timeoutMs, signal) => {
   if (checkedOutHead !== input.expectedHeadSha) {
     throw new Error("The destination did not check out the pushed commit");
   }
+  const preparations = await executeWorktreePreparations(
+    targetFolder,
+    input.preparations,
+    "APPLY",
+    timeoutMs,
+    signal
+  );
+  const preparationErrors = preparations.filter(
+    (item) => item.state === "ERROR"
+  );
+  if (preparationErrors.length > 0 && input.mode === "NEW") {
+    await git4(
+      rootFolder,
+      ["worktree", "remove", "--force", targetFolder],
+      timeoutMs,
+      signal
+    );
+    if (createdLocalBranch) {
+      await git4(rootFolder, ["branch", "-D", input.branch], timeoutMs, signal);
+    }
+    throw new Error(
+      preparationErrors.map((item) => item.message ?? "Preparation failed").join("; ")
+    );
+  }
   const worktree = await inspectWorktreeItem(
     targetFolder,
     rootFolder,
@@ -16790,12 +17574,72 @@ var checkoutMovedWorktree = async (payload, timeoutMs, signal) => {
     outcome: "CHECKED_OUT",
     worktree,
     baseBranch: input.baseBranch,
-    stashed
+    stashed,
+    checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    preparations
+  };
+};
+var prepareWorktree = async (payload, timeoutMs, signal) => {
+  const input = worktreePreparationJobPayload(payload);
+  if ("worktrees" in input) {
+    const worktrees = [];
+    for (const target2 of input.worktrees) {
+      try {
+        const folder2 = await validateWorktree2(
+          {
+            codebaseId: input.codebaseId,
+            folder: target2.folder,
+            gitDirectory: target2.gitDirectory,
+            expectedOrigin: input.expectedOrigin,
+            baseBranch: null
+          },
+          timeoutMs,
+          signal
+        );
+        const preparations2 = await executeWorktreePreparations(
+          folder2,
+          input.preparations,
+          input.action,
+          timeoutMs,
+          signal
+        );
+        worktrees.push({
+          worktreeId: target2.worktreeId,
+          checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          preparations: preparations2
+        });
+      } catch (error) {
+        worktrees.push({
+          worktreeId: target2.worktreeId,
+          checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          preparations: input.preparations.map((definition) => ({
+            id: definition.id,
+            definitionHash: definition.definitionHash,
+            state: "ERROR",
+            message: cleanError4(error)
+          }))
+        });
+      }
+    }
+    return { ...successfulProcess8, worktrees };
+  }
+  const folder = await validateWorktree2(input, timeoutMs, signal);
+  const preparations = await executeWorktreePreparations(
+    folder,
+    input.preparations,
+    input.action,
+    timeoutMs,
+    signal
+  );
+  return {
+    ...successfulProcess8,
+    checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    preparations
   };
 };
 var deleteWorktree = async (payload, timeoutMs, signal) => {
   const input = worktreeDeleteJobPayload(payload);
-  const rootFolder = await realpath8(input.rootFolder);
+  const rootFolder = await realpath9(input.rootFolder);
   if (!(await stat10(rootFolder)).isDirectory()) {
     throw new Error("Base repository is missing");
   }
@@ -16816,8 +17660,8 @@ var deleteWorktree = async (payload, timeoutMs, signal) => {
   if (folder === rootFolder)
     throw new Error("The primary worktree cannot be deleted");
   const listed = parseWorktreeList(
-    requireSuccess3(
-      await git3(
+    requireSuccess4(
+      await git4(
         rootFolder,
         ["worktree", "list", "--porcelain"],
         timeoutMs,
@@ -16847,15 +17691,15 @@ var deleteWorktree = async (payload, timeoutMs, signal) => {
     if (branch === input.defaultBranch) {
       throw new Error("The default remote branch cannot be deleted");
     }
-    const remote = await git3(
+    const remote = await git4(
       rootFolder,
       ["ls-remote", "--exit-code", "--heads", "origin", `refs/heads/${branch}`],
       timeoutMs,
       signal
     );
     if (remote.exitCode === 0) {
-      requireSuccess3(
-        await git3(
+      requireSuccess4(
+        await git4(
           rootFolder,
           ["push", "origin", "--delete", branch],
           timeoutMs,
@@ -16864,11 +17708,11 @@ var deleteWorktree = async (payload, timeoutMs, signal) => {
         `Could not delete origin/${branch}`
       );
     } else if (remote.exitCode !== 2) {
-      requireSuccess3(remote, `Could not inspect origin/${branch}`);
+      requireSuccess4(remote, `Could not inspect origin/${branch}`);
     }
   }
-  requireSuccess3(
-    await git3(
+  requireSuccess4(
+    await git4(
       rootFolder,
       ["worktree", "remove", "--force", folder],
       timeoutMs,
@@ -16877,8 +17721,8 @@ var deleteWorktree = async (payload, timeoutMs, signal) => {
     "Could not remove the worktree"
   );
   if (branch && await refExists(rootFolder, `refs/heads/${branch}`, timeoutMs, signal)) {
-    requireSuccess3(
-      await git3(rootFolder, ["branch", "-D", branch], timeoutMs, signal),
+    requireSuccess4(
+      await git4(rootFolder, ["branch", "-D", branch], timeoutMs, signal),
       `Worktree removed, but local branch ${branch} could not be deleted`
     );
   }
@@ -16894,28 +17738,53 @@ var operateWorktree = async (payload, timeoutMs, signal) => {
   const input = worktreeJobPayload(payload);
   const folder = await validateWorktree2(input, timeoutMs, signal);
   if (!input.operation) throw new Error("A worktree operation is required");
-  const branchResult = await git3(
+  const branchResult = await git4(
     folder,
     ["symbolic-ref", "--short", "-q", "HEAD"],
     timeoutMs,
     signal
   );
   const branch = branchResult.exitCode === 0 ? branchResult.stdout.trim() : null;
-  const upstreamResult = branch ? await git3(
+  const upstreamResult = branch ? await git4(
     folder,
     ["rev-parse", "--abbrev-ref", "@{upstream}"],
     timeoutMs,
     signal
   ) : null;
   const upstream = upstreamResult?.exitCode === 0 ? upstreamResult.stdout.trim() : null;
-  const runGit = async (args, fallback) => requireSuccess3(await git3(folder, args, timeoutMs, signal), fallback);
+  const runGit = async (args, fallback) => requireSuccess4(await git4(folder, args, timeoutMs, signal), fallback);
+  let operationOutcome = "COMPLETED";
+  let preparationConflictPathList = [];
+  let preparationResults = [];
+  const inspectPreparations = () => executeWorktreePreparations(
+    folder,
+    input.preparations,
+    "INSPECT",
+    timeoutMs,
+    signal
+  );
+  const reapplyPreparations = () => executeWorktreePreparations(
+    folder,
+    input.preparations,
+    "APPLY",
+    timeoutMs,
+    signal
+  );
+  const worktreeResult = async () => inspectWorktreeItem(
+    folder,
+    folder,
+    input.baseBranch,
+    false,
+    Math.min(timeoutMs, 3e4),
+    signal
+  );
   switch (input.operation) {
     case "OPEN_EDITOR": {
       if (input.editorVariant === "NONE" || !input.editorVariant) {
         throw new Error("VS Code is disabled in Settings");
       }
       const app = input.editorVariant === "CODE_INSIDERS" ? "Visual Studio Code - Insiders" : "Visual Studio Code";
-      requireSuccess3(
+      requireSuccess4(
         await command2("open", ["-a", app, folder], timeoutMs, signal),
         `${app} could not be opened`
       );
@@ -16937,26 +17806,105 @@ var operateWorktree = async (payload, timeoutMs, signal) => {
       if (statusResult.stdout.trim())
         throw new Error("Stash or commit changes before syncing");
       await runGit(["fetch", "origin"], "Could not fetch origin");
-      const rebase = await git3(
+      const remoteBase = `refs/remotes/origin/${input.baseBranch}`;
+      const isCurrent = await git4(
         folder,
-        ["rebase", `refs/remotes/origin/${input.baseBranch}`],
+        ["merge-base", "--is-ancestor", remoteBase, "HEAD"],
         timeoutMs,
         signal
       );
-      if (rebase.exitCode !== 0) {
-        const status2 = await git3(
+      if (isCurrent.exitCode !== 0 && isCurrent.exitCode !== 1) {
+        requireSuccess4(isCurrent, "Could not compare the base branch");
+      }
+      if (isCurrent.exitCode === 1) {
+        preparationConflictPathList = await preparationConflictPaths(
+          folder,
+          input.preparations,
+          remoteBase,
+          timeoutMs,
+          signal
+        );
+        if (preparationConflictPathList.length > 0 && !input.forcePreparations) {
+          operationOutcome = "PREPARATION_CONFLICT";
+          preparationResults = await inspectPreparations();
+          return {
+            ...successfulProcess8,
+            outcome: operationOutcome,
+            preparationConflictPaths: preparationConflictPathList,
+            checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            preparations: preparationResults,
+            worktree: await worktreeResult()
+          };
+        }
+        if (input.forcePreparations) {
+          preparationResults = await suspendWorktreePreparations(
+            folder,
+            input.preparations,
+            timeoutMs,
+            signal
+          );
+          if (preparationResults.some((item) => item.state === "ERROR")) {
+            return {
+              ...successfulProcess8,
+              exitCode: 1,
+              checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+              preparations: preparationResults
+            };
+          }
+        }
+      }
+      const rebase = isCurrent.exitCode === 0 ? null : await git4(folder, ["rebase", remoteBase], timeoutMs, signal);
+      if (rebase && rebase.exitCode !== 0) {
+        const status2 = await git4(
           folder,
           ["status", "--porcelain=v1", "-z"],
           timeoutMs,
           signal
         );
         const conflicts = status2.exitCode === 0 && statusChangeState(status2.stdout).hasConflicts;
-        if (!(conflicts && await rebaseInProgress(folder, timeoutMs, signal))) {
-          await git3(folder, ["rebase", "--abort"], timeoutMs, signal);
+        if (conflicts && await rebaseInProgress(folder, timeoutMs, signal)) {
+          operationOutcome = "REBASE_CONFLICT";
+          const conflictsResult = await git4(
+            folder,
+            ["diff", "--name-only", "--diff-filter=U"],
+            timeoutMs,
+            signal
+          );
+          preparationConflictPathList = conflictsResult.exitCode === 0 ? conflictsResult.stdout.split("\n").filter(Boolean) : [];
+          preparationResults = input.preparations.map((definition) => ({
+            id: definition.id,
+            definitionHash: definition.definitionHash,
+            state: "SUSPENDED"
+          }));
+          return {
+            ...successfulProcess8,
+            outcome: operationOutcome,
+            preparationConflictPaths: preparationConflictPathList,
+            checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            preparations: preparationResults,
+            worktree: await worktreeResult()
+          };
+        } else {
+          await git4(folder, ["rebase", "--abort"], timeoutMs, signal);
+        }
+        if (input.forcePreparations) {
+          preparationResults = await reapplyPreparations();
         }
-        throw new Error(cleanError3(rebase.stderr || "Rebase failed"));
+        throw new Error(cleanError4(rebase.stderr || "Rebase failed"));
       }
-      await runGit(["push", "--force-with-lease"], "Sync push failed");
+      const push = await git4(
+        folder,
+        ["push", "--force-with-lease"],
+        timeoutMs,
+        signal
+      );
+      if (push.exitCode !== 0) {
+        if (input.forcePreparations) {
+          preparationResults = await reapplyPreparations();
+        }
+        requireSuccess4(push, "Sync push failed");
+      }
+      preparationResults = input.forcePreparations ? await reapplyPreparations() : await inspectPreparations();
       break;
     }
     case "REBASE": {
@@ -16969,25 +17917,93 @@ var operateWorktree = async (payload, timeoutMs, signal) => {
       if (statusResult.stdout.trim())
         throw new Error("Stash or commit changes before rebasing");
       await runGit(["fetch", "origin"], "Could not fetch origin");
-      const rebase = await git3(
+      const remoteBase = `refs/remotes/origin/${input.baseBranch}`;
+      const isCurrent = await git4(
         folder,
-        ["rebase", `refs/remotes/origin/${input.baseBranch}`],
+        ["merge-base", "--is-ancestor", remoteBase, "HEAD"],
         timeoutMs,
         signal
       );
-      if (rebase.exitCode !== 0) {
-        const status2 = await git3(
+      if (isCurrent.exitCode !== 0 && isCurrent.exitCode !== 1) {
+        requireSuccess4(isCurrent, "Could not compare the base branch");
+      }
+      if (isCurrent.exitCode === 1) {
+        preparationConflictPathList = await preparationConflictPaths(
+          folder,
+          input.preparations,
+          remoteBase,
+          timeoutMs,
+          signal
+        );
+        if (preparationConflictPathList.length > 0 && !input.forcePreparations) {
+          operationOutcome = "PREPARATION_CONFLICT";
+          preparationResults = await inspectPreparations();
+          return {
+            ...successfulProcess8,
+            outcome: operationOutcome,
+            preparationConflictPaths: preparationConflictPathList,
+            checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            preparations: preparationResults,
+            worktree: await worktreeResult()
+          };
+        }
+        if (input.forcePreparations) {
+          preparationResults = await suspendWorktreePreparations(
+            folder,
+            input.preparations,
+            timeoutMs,
+            signal
+          );
+          if (preparationResults.some((item) => item.state === "ERROR")) {
+            return {
+              ...successfulProcess8,
+              exitCode: 1,
+              checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+              preparations: preparationResults
+            };
+          }
+        }
+      }
+      const rebase = isCurrent.exitCode === 0 ? null : await git4(folder, ["rebase", remoteBase], timeoutMs, signal);
+      if (rebase && rebase.exitCode !== 0) {
+        const status2 = await git4(
           folder,
           ["status", "--porcelain=v1", "-z"],
           timeoutMs,
           signal
         );
         const conflicts = status2.exitCode === 0 && statusChangeState(status2.stdout).hasConflicts;
-        if (!(conflicts && await rebaseInProgress(folder, timeoutMs, signal))) {
-          await git3(folder, ["rebase", "--abort"], timeoutMs, signal);
+        if (conflicts && await rebaseInProgress(folder, timeoutMs, signal)) {
+          operationOutcome = "REBASE_CONFLICT";
+          const conflictsResult = await git4(
+            folder,
+            ["diff", "--name-only", "--diff-filter=U"],
+            timeoutMs,
+            signal
+          );
+          preparationConflictPathList = conflictsResult.exitCode === 0 ? conflictsResult.stdout.split("\n").filter(Boolean) : [];
+          preparationResults = input.preparations.map((definition) => ({
+            id: definition.id,
+            definitionHash: definition.definitionHash,
+            state: "SUSPENDED"
+          }));
+          return {
+            ...successfulProcess8,
+            outcome: operationOutcome,
+            preparationConflictPaths: preparationConflictPathList,
+            checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            preparations: preparationResults,
+            worktree: await worktreeResult()
+          };
+        } else {
+          await git4(folder, ["rebase", "--abort"], timeoutMs, signal);
         }
-        throw new Error(cleanError3(rebase.stderr || "Rebase failed"));
+        if (input.forcePreparations) {
+          preparationResults = await reapplyPreparations();
+        }
+        throw new Error(cleanError4(rebase.stderr || "Rebase failed"));
       }
+      preparationResults = input.forcePreparations ? await reapplyPreparations() : await inspectPreparations();
       break;
     }
     case "CANCEL_REBASE": {
@@ -16995,6 +18011,7 @@ var operateWorktree = async (payload, timeoutMs, signal) => {
         throw new Error("No rebase is in progress");
       }
       await runGit(["rebase", "--abort"], "Could not cancel rebase");
+      preparationResults = await reapplyPreparations();
       break;
     }
     case "PULL": {
@@ -17021,6 +18038,9 @@ var operateWorktree = async (payload, timeoutMs, signal) => {
       await runGit(["clean", "-fd"], "Could not remove untracked files");
       break;
     }
+    case "CLEAR_LOCK":
+      await rm10(join14(input.gitDirectory, "index.lock"), { force: true });
+      break;
     case "STASH_ALL":
       await runGit(["stash", "push", "--include-untracked"], "Stash failed");
       break;
@@ -17033,21 +18053,37 @@ var operateWorktree = async (payload, timeoutMs, signal) => {
   }
   return {
     ...successfulProcess8,
-    worktree: await inspectWorktreeItem(
-      folder,
-      folder,
-      input.baseBranch,
-      false,
-      Math.min(timeoutMs, 3e4),
-      signal
-    )
+    outcome: operationOutcome,
+    preparationConflictPaths: preparationConflictPathList,
+    checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    preparations: preparationResults,
+    worktree: await worktreeResult()
   };
 };
 var autoSyncWorktree = async (payload, timeoutMs, signal) => {
   const input = worktreeAutoSyncJobPayload(payload);
   const folder = await validateWorktree2(input, timeoutMs, signal);
-  const runGit = async (args, fallback) => requireSuccess3(await git3(folder, args, timeoutMs, signal), fallback);
-  const branchResult = await git3(
+  const runGit = async (args, fallback) => requireSuccess4(await git4(folder, args, timeoutMs, signal), fallback);
+  const inspectPreparations = () => executeWorktreePreparations(
+    folder,
+    input.preparations,
+    "INSPECT",
+    timeoutMs,
+    signal
+  );
+  const reapplyPreparations = () => executeWorktreePreparations(
+    folder,
+    input.preparations,
+    "APPLY",
+    timeoutMs,
+    signal
+  );
+  const suspendedPreparations = () => input.preparations.map((definition) => ({
+    id: definition.id,
+    definitionHash: definition.definitionHash,
+    state: "SUSPENDED"
+  }));
+  const branchResult = await git4(
     folder,
     ["symbolic-ref", "--short", "-q", "HEAD"],
     timeoutMs,
@@ -17060,7 +18096,7 @@ var autoSyncWorktree = async (payload, timeoutMs, signal) => {
       `Auto Sync expected branch ${input.expectedBranch}, but found ${branch ?? "detached HEAD"}`
     );
   }
-  const upstreamResult = branch ? await git3(
+  const upstreamResult = branch ? await git4(
     folder,
     ["rev-parse", "--abbrev-ref", "@{upstream}"],
     timeoutMs,
@@ -17081,6 +18117,8 @@ var autoSyncWorktree = async (payload, timeoutMs, signal) => {
       return {
         ...successfulProcess8,
         outcome: "UNRESOLVED",
+        checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        preparations: suspendedPreparations(),
         worktree: await inspectWorktreeItem(
           folder,
           folder,
@@ -17109,6 +18147,8 @@ var autoSyncWorktree = async (payload, timeoutMs, signal) => {
         return {
           ...successfulProcess8,
           outcome: "UNRESOLVED",
+          checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          preparations: suspendedPreparations(),
           worktree: await inspectWorktreeItem(
             folder,
             folder,
@@ -17129,6 +18169,8 @@ var autoSyncWorktree = async (payload, timeoutMs, signal) => {
       return {
         ...successfulProcess8,
         outcome: "UNRESOLVED",
+        checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        preparations: suspendedPreparations(),
         worktree: await inspectWorktreeItem(
           folder,
           folder,
@@ -17139,13 +18181,13 @@ var autoSyncWorktree = async (payload, timeoutMs, signal) => {
         )
       };
     }
-    const finalBranch = await git3(
+    const finalBranch = await git4(
       folder,
       ["symbolic-ref", "--short", "-q", "HEAD"],
       timeoutMs,
       signal
     );
-    const finalUpstream = finalBranch.exitCode === 0 ? await git3(
+    const finalUpstream = finalBranch.exitCode === 0 ? await git4(
       folder,
       ["rev-parse", "--abbrev-ref", "@{upstream}"],
       timeoutMs,
@@ -17156,10 +18198,22 @@ var autoSyncWorktree = async (payload, timeoutMs, signal) => {
         `Auto Sync expected branch ${input.expectedBranch} with an upstream`
       );
     }
-    await runGit(["push", "--force-with-lease"], "Auto Sync push failed");
+    const push2 = await git4(
+      folder,
+      ["push", "--force-with-lease"],
+      timeoutMs,
+      signal
+    );
+    if (push2.exitCode !== 0) {
+      await reapplyPreparations();
+      requireSuccess4(push2, "Auto Sync push failed");
+    }
+    const preparations = await reapplyPreparations();
     return {
       ...successfulProcess8,
       outcome: "SYNCED",
+      checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      preparations,
       worktree: await inspectWorktreeItem(
         folder,
         folder,
@@ -17179,14 +18233,14 @@ var autoSyncWorktree = async (payload, timeoutMs, signal) => {
   }
   await runGit(["fetch", "origin"], "Could not fetch origin");
   const remoteBase = `refs/remotes/origin/${input.baseBranch}`;
-  const isCurrent = await git3(
+  const isCurrent = await git4(
     folder,
     ["merge-base", "--is-ancestor", remoteBase, "HEAD"],
     timeoutMs,
     signal
   );
   if (isCurrent.exitCode === 0) {
-    const upstreamContainsHead = await git3(
+    const upstreamContainsHead = await git4(
       folder,
       ["merge-base", "--is-ancestor", "HEAD", "@{upstream}"],
       timeoutMs,
@@ -17194,7 +18248,7 @@ var autoSyncWorktree = async (payload, timeoutMs, signal) => {
     );
     if (upstreamContainsHead.exitCode !== 0 && upstreamContainsHead.exitCode !== 1) {
       throw new Error(
-        cleanError3(
+        cleanError4(
           upstreamContainsHead.stderr || "Could not compare the upstream branch"
         )
       );
@@ -17204,6 +18258,8 @@ var autoSyncWorktree = async (payload, timeoutMs, signal) => {
       return {
         ...successfulProcess8,
         outcome: "SYNCED",
+        checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        preparations: await inspectPreparations(),
         worktree: await inspectWorktreeItem(
           folder,
           folder,
@@ -17217,6 +18273,32 @@ var autoSyncWorktree = async (payload, timeoutMs, signal) => {
     return {
       ...successfulProcess8,
       outcome: "NO_CHANGE",
+      checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      preparations: await inspectPreparations(),
+      worktree: await inspectWorktreeItem(
+        folder,
+        folder,
+        input.baseBranch,
+        false,
+        Math.min(timeoutMs, 3e4),
+        signal
+      )
+    };
+  }
+  const preparationConflictPathList = await preparationConflictPaths(
+    folder,
+    input.preparations,
+    remoteBase,
+    timeoutMs,
+    signal
+  );
+  if (preparationConflictPathList.length > 0 && !input.forcePreparations) {
+    return {
+      ...successfulProcess8,
+      outcome: "PREPARATION_CONFLICT",
+      preparationConflictPaths: preparationConflictPathList,
+      checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      preparations: await inspectPreparations(),
       worktree: await inspectWorktreeItem(
         folder,
         folder,
@@ -17227,9 +18309,26 @@ var autoSyncWorktree = async (payload, timeoutMs, signal) => {
       )
     };
   }
-  const rebase = await git3(folder, ["rebase", remoteBase], timeoutMs, signal);
+  let preparationResults = [];
+  if (input.forcePreparations) {
+    preparationResults = await suspendWorktreePreparations(
+      folder,
+      input.preparations,
+      timeoutMs,
+      signal
+    );
+    if (preparationResults.some((item) => item.state === "ERROR")) {
+      return {
+        ...successfulProcess8,
+        exitCode: 1,
+        checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        preparations: preparationResults
+      };
+    }
+  }
+  const rebase = await git4(folder, ["rebase", remoteBase], timeoutMs, signal);
   if (rebase.exitCode !== 0) {
-    const conflictStatus = await git3(
+    const conflictStatus = await git4(
       folder,
       ["status", "--porcelain=v1", "-z"],
       timeoutMs,
@@ -17240,6 +18339,8 @@ var autoSyncWorktree = async (payload, timeoutMs, signal) => {
       return {
         ...successfulProcess8,
         outcome: "CONFLICT",
+        checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        preparations: suspendedPreparations(),
         worktree: await inspectWorktreeItem(
           folder,
           folder,
@@ -17250,13 +18351,26 @@ var autoSyncWorktree = async (payload, timeoutMs, signal) => {
         )
       };
     }
-    await git3(folder, ["rebase", "--abort"], timeoutMs, signal);
-    throw new Error(cleanError3(rebase.stderr || "Auto Sync rebase failed"));
+    await git4(folder, ["rebase", "--abort"], timeoutMs, signal);
+    if (input.forcePreparations) await reapplyPreparations();
+    throw new Error(cleanError4(rebase.stderr || "Auto Sync rebase failed"));
   }
-  await runGit(["push", "--force-with-lease"], "Auto Sync push failed");
+  const push = await git4(
+    folder,
+    ["push", "--force-with-lease"],
+    timeoutMs,
+    signal
+  );
+  if (push.exitCode !== 0) {
+    if (input.forcePreparations) await reapplyPreparations();
+    requireSuccess4(push, "Auto Sync push failed");
+  }
+  preparationResults = input.forcePreparations ? await reapplyPreparations() : await inspectPreparations();
   return {
     ...successfulProcess8,
     outcome: "SYNCED",
+    checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    preparations: preparationResults,
     worktree: await inspectWorktreeItem(
       folder,
       folder,
@@ -17290,6 +18404,7 @@ var handlers = {
   [WORKTREE_MOVE_CHECKOUT_JOB_KIND]: checkoutMovedWorktree,
   [WORKTREE_DELETE_JOB_KIND]: deleteWorktree,
   [WORKTREE_OPERATION_JOB_KIND]: operateWorktree,
+  [WORKTREE_PREPARATION_JOB_KIND]: prepareWorktree,
   [WORKTREE_GIT_INSPECT_JOB_KIND]: inspectWorktreeGit,
   [WORKTREE_GIT_OPERATION_JOB_KIND]: operateWorktreeGit,
   [WORKTREE_WATCH_JOB_KIND]: watchWorktree,
@@ -17328,8 +18443,8 @@ var RepositoryCoordinator = class {
   async run(key, task) {
     const previous = this.tails.get(key) ?? Promise.resolve();
     let release2;
-    const current = new Promise((resolve8) => {
-      release2 = resolve8;
+    const current = new Promise((resolve9) => {
+      release2 = resolve9;
     });
     const tail = previous.then(() => current);
     this.tails.set(key, tail);
@@ -17433,7 +18548,7 @@ var JobExecutor = class {
         );
         if (this.stopping) return;
         const delay = Math.min(3e4, 1e3 * 2 ** Math.min(retry++, 5));
-        await new Promise((resolve8) => setTimeout(resolve8, delay));
+        await new Promise((resolve9) => setTimeout(resolve9, delay));
       }
     }
   }
@@ -17580,21 +18695,21 @@ var CodebaseMonitor = class {
 
 // src/runs/run-manager.ts
 import { execFile as execFile4 } from "node:child_process";
-import { mkdir as mkdir6, rm as rm13 } from "node:fs/promises";
-import { dirname as dirname10, join as join17 } from "node:path";
+import { mkdir as mkdir7, rm as rm14 } from "node:fs/promises";
+import { dirname as dirname11, join as join18 } from "node:path";
 import { promisify as promisify4 } from "node:util";
 
 // src/runs/journal.ts
 import { randomUUID as randomUUID4 } from "node:crypto";
 import {
   appendFile,
-  mkdir as mkdir5,
-  readFile as readFile9,
+  mkdir as mkdir6,
+  readFile as readFile10,
   rename as rename4,
-  rm as rm10,
-  writeFile as writeFile7
+  rm as rm11,
+  writeFile as writeFile8
 } from "node:fs/promises";
-import { dirname as dirname8, join as join14 } from "node:path";
+import { dirname as dirname9, join as join15 } from "node:path";
 var RunJournal = class {
   constructor(runId, attemptId) {
     this.runId = runId;
@@ -17613,13 +18728,13 @@ var RunJournal = class {
     this.attemptId = attemptId;
   }
   get directory() {
-    return join14(dirname8(configPath()), "runs", this.runId);
+    return join15(dirname9(configPath()), "runs", this.runId);
   }
   get eventsPath() {
-    return join14(this.directory, "events.jsonl");
+    return join15(this.directory, "events.jsonl");
   }
   get statePath() {
-    return join14(this.directory, "state.json");
+    return join15(this.directory, "state.json");
   }
   async load() {
     if (this.loaded) return;
@@ -17631,9 +18746,9 @@ var RunJournal = class {
     await this.loading;
   }
   async loadState() {
-    await mkdir5(this.directory, { recursive: true, mode: 448 });
+    await mkdir6(this.directory, { recursive: true, mode: 448 });
     try {
-      const state = JSON.parse(await readFile9(this.statePath, "utf8"));
+      const state = JSON.parse(await readFile10(this.statePath, "utf8"));
       this.acknowledged = state.acknowledged ?? -1;
       this.nextSequence = state.nextSequence ?? 0;
     } catch {
@@ -17708,7 +18823,7 @@ var RunJournal = class {
   }
   async readEvents() {
     try {
-      return (await readFile9(this.eventsPath, "utf8")).split("\n").filter(Boolean).map((line) => JSON.parse(line));
+      return (await readFile10(this.eventsPath, "utf8")).split("\n").filter(Boolean).map((line) => JSON.parse(line));
     } catch (error) {
       if (error.code === "ENOENT") return [];
       throw error;
@@ -17720,10 +18835,10 @@ var RunJournal = class {
     const operation = this.saving.then(async () => {
       const temporary = `${this.statePath}.${process.pid}.${randomUUID4()}.tmp`;
       try {
-        await writeFile7(temporary, contents, { mode: 384 });
+        await writeFile8(temporary, contents, { mode: 384 });
         await rename4(temporary, this.statePath);
       } catch (error) {
-        await rm10(temporary, { force: true }).catch(() => void 0);
+        await rm11(temporary, { force: true }).catch(() => void 0);
         throw error;
       }
     });
@@ -26897,7 +28012,7 @@ function Yy(e) {
 var l = {};
 lt(l, { xid: () => u9, void: () => I9, uuidv7: () => n9, uuidv6: () => r9, uuidv4: () => t9, uuid: () => e9, url: () => o9, uppercase: () => Fl, unknown: () => Ke, union: () => $e, undefined: () => C9, ulid: () => l9, uint64: () => A9, uint32: () => w9, tuple: () => L9, trim: () => Wl, treeifyError: () => Yd, transform: () => jv, toUpperCase: () => Zl, toLowerCase: () => Kl, toJSONSchema: () => Js, templateLiteral: () => q9, symbol: () => O9, superRefine: () => ER, success: () => B9, stringbool: () => W9, stringFormat: () => x9, string: () => k, strictObject: () => N9, startsWith: () => Hl, size: () => $l, setErrorMap: () => J9, set: () => $9, safeParseAsync: () => gv, safeParse: () => mv, registry: () => hl, regexes: () => wo, regex: () => jl, refine: () => SR, record: () => je, readonly: () => hR, property: () => iv, promise: () => G9, prettifyError: () => Xd, preprocess: () => Km, prefault: () => lR, positive: () => tv, pipe: () => Fm, partialRecord: () => M9, parseAsync: () => fv, parse: () => dv, overwrite: () => Vn, optional: () => Ve, object: () => G, number: () => Ce, nullish: () => F9, nullable: () => zm, null: () => Bm, normalize: () => Vl, nonpositive: () => nv, nonoptional: () => uR, nonnegative: () => ov, never: () => Hm, negative: () => rv, nativeEnum: () => j9, nanoid: () => s9, nan: () => H9, multipleOf: () => wi, minSize: () => Ti, minLength: () => Ao, mime: () => Gl, maxSize: () => Ws, maxLength: () => Ks, map: () => U9, lte: () => Ur, lt: () => qn, lowercase: () => zl, looseObject: () => Bt, locales: () => Gs, literal: () => Z, length: () => Zs, lazy: () => bR, ksuid: () => p9, keyof: () => D9, jwt: () => b9, json: () => K9, iso: () => Ys, ipv6: () => f9, ipv4: () => d9, intersection: () => ru, int64: () => k9, int32: () => E9, int: () => hv, instanceof: () => V9, includes: () => Bl, guid: () => QZ, gte: () => ar, gt: () => Gn, globalRegistry: () => sr, getErrorMap: () => Y9, function: () => Dm, formatError: () => js, float64: () => S9, float32: () => v9, flattenError: () => $s, file: () => z9, enum: () => Jt, endsWith: () => ql, emoji: () => i9, email: () => XZ, e164: () => y9, discriminatedUnion: () => Vm, date: () => P9, custom: () => Hv, cuid2: () => c9, cuid: () => a9, core: () => Qr, config: () => ut, coerce: () => qv, clone: () => Ft, cidrv6: () => g9, cidrv4: () => m9, check: () => vR, catch: () => fR, boolean: () => ht, bigint: () => T9, base64url: () => _9, base64: () => h9, array: () => he, any: () => R9, _default: () => aR, _ZodString: () => _v, ZodXID: () => Tv, ZodVoid: () => JC, ZodUnknown: () => KC, ZodUnion: () => Mv, ZodUndefined: () => GC, ZodUUID: () => Wn, ZodURL: () => bv, ZodULID: () => wv, ZodType: () => de, ZodTuple: () => eR, ZodTransform: () => $v, ZodTemplateLiteral: () => _R, ZodSymbol: () => qC, ZodSuccess: () => pR, ZodStringFormat: () => Ge, ZodString: () => Xl, ZodSet: () => rR, ZodRecord: () => Uv, ZodRealError: () => Xs, ZodReadonly: () => gR, ZodPromise: () => xR, ZodPrefault: () => cR, ZodPipe: () => Bv, ZodOptional: () => zv, ZodObject: () => Gm, ZodNumberFormat: () => Qs, ZodNumber: () => Ql, ZodNullable: () => iR, ZodNull: () => VC, ZodNonOptional: () => Fv, ZodNever: () => ZC, ZodNanoID: () => vv, ZodNaN: () => mR, ZodMap: () => tR, ZodLiteral: () => nR, ZodLazy: () => yR, ZodKSUID: () => kv, ZodJWT: () => Nv, ZodIssueCode: () => Z9, ZodIntersection: () => QC, ZodISOTime: () => Um, ZodISODuration: () => $m, ZodISODateTime: () => Lm, ZodISODate: () => Mm, ZodIPv6: () => Ov, ZodIPv4: () => Av, ZodGUID: () => jm, ZodFile: () => oR, ZodError: () => JZ, ZodEnum: () => Yl, ZodEmoji: () => xv, ZodEmail: () => yv, ZodE164: () => Dv, ZodDiscriminatedUnion: () => XC, ZodDefault: () => sR, ZodDate: () => qm, ZodCustomStringFormat: () => HC, ZodCustom: () => Wm, ZodCatch: () => dR, ZodCUID2: () => Ev, ZodCUID: () => Sv, ZodCIDRv6: () => Rv, ZodCIDRv4: () => Cv, ZodBoolean: () => eu, ZodBigIntFormat: () => Lv, ZodBigInt: () => tu, ZodBase64URL: () => Pv, ZodBase64: () => Iv, ZodArray: () => YC, ZodAny: () => WC, TimePrecision: () => lm, NEVER: () => Kd, $output: () => sm, $input: () => am, $brand: () => Zd });
 var Qr = {};
-lt(Qr, { version: () => tx, util: () => M, treeifyError: () => Yd, toJSONSchema: () => Js, toDotPath: () => yC, safeParseAsync: () => Eo, safeParse: () => So, registry: () => hl, regexes: () => wo, prettifyError: () => Xd, parseAsync: () => xi, parse: () => bi, locales: () => Gs, isValidJWT: () => MC, isValidBase64URL: () => LC, isValidBase64: () => ax, globalRegistry: () => sr, globalConfig: () => tl, function: () => Dm, formatError: () => js, flattenError: () => $s, config: () => ut, clone: () => Ft, _xid: () => Ol, _void: () => Tm, _uuidv7: () => vl, _uuidv6: () => xl, _uuidv4: () => bl, _uuid: () => yl, _url: () => Sl, _uppercase: () => Fl, _unknown: () => Ei, _union: () => OZ, _undefined: () => vm, _ulid: () => Al, _uint64: () => bm, _uint32: () => gm, _tuple: () => sv, _trim: () => Wl, _transform: () => UZ, _toUpperCase: () => Zl, _toLowerCase: () => Kl, _templateLiteral: () => VZ, _symbol: () => xm, _success: () => BZ, _stringbool: () => Im, _stringFormat: () => Pm, _string: () => cm, _startsWith: () => Hl, _size: () => $l, _set: () => DZ, _safeParseAsync: () => rf, _safeParse: () => tf, _regex: () => jl, _refine: () => Rm, _record: () => IZ, _readonly: () => GZ, _property: () => iv, _promise: () => KZ, _positive: () => tv, _pipe: () => qZ, _parseAsync: () => ef, _parse: () => Qd, _overwrite: () => Vn, _optional: () => $Z, _number: () => um, _nullable: () => jZ, _null: () => Sm, _normalize: () => Vl, _nonpositive: () => nv, _nonoptional: () => FZ, _nonnegative: () => ov, _never: () => wm, _negative: () => rv, _nativeEnum: () => LZ, _nanoid: () => wl, _nan: () => Am, _multipleOf: () => wi, _minSize: () => Ti, _minLength: () => Ao, _min: () => ar, _mime: () => Gl, _maxSize: () => Ws, _maxLength: () => Ks, _max: () => Ur, _map: () => PZ, _lte: () => Ur, _lt: () => qn, _lowercase: () => zl, _literal: () => MZ, _length: () => Zs, _lazy: () => WZ, _ksuid: () => Cl, _jwt: () => Ul, _isoTime: () => Zx, _isoDuration: () => Jx, _isoDateTime: () => Wx, _isoDate: () => Kx, _ipv6: () => Il, _ipv4: () => Rl, _intersection: () => RZ, _int64: () => ym, _int32: () => mm, _int: () => pm, _includes: () => Bl, _guid: () => Vs, _gte: () => ar, _gt: () => Gn, _float64: () => fm, _float32: () => dm, _file: () => Om, _enum: () => NZ, _endsWith: () => ql, _emoji: () => El, _email: () => _l, _e164: () => Ml, _discriminatedUnion: () => CZ, _default: () => zZ, _date: () => km, _custom: () => Cm, _cuid2: () => kl, _cuid: () => Tl, _coercedString: () => Vx, _coercedNumber: () => Yx, _coercedDate: () => ev, _coercedBoolean: () => Xx, _coercedBigint: () => Qx, _cidrv6: () => Dl, _cidrv4: () => Pl, _catch: () => HZ, _boolean: () => hm, _bigint: () => _m, _base64url: () => Ll, _base64: () => Nl, _array: () => Jl, _any: () => Em, TimePrecision: () => lm, NEVER: () => Kd, JSONSchemaGenerator: () => Nm, JSONSchema: () => zC, Doc: () => af, $output: () => sm, $input: () => am, $constructor: () => S, $brand: () => Zd, $ZodXID: () => bf, $ZodVoid: () => Uf, $ZodUnknown: () => Si, $ZodUnion: () => fl, $ZodUndefined: () => Df, $ZodUUID: () => pf, $ZodURL: () => ff, $ZodULID: () => yf, $ZodType: () => ie, $ZodTuple: () => ko, $ZodTransform: () => Hs, $ZodTemplateLiteral: () => rm11, $ZodSymbol: () => Pf, $ZodSuccess: () => Xf, $ZodStringFormat: () => Ue, $ZodString: () => To, $ZodSet: () => Hf, $ZodRegistry: () => gl, $ZodRecord: () => Ff, $ZodRealError: () => Us, $ZodReadonly: () => tm, $ZodPromise: () => nm, $ZodPrefault: () => Jf, $ZodPipe: () => qs, $ZodOptional: () => Wf, $ZodObject: () => dl, $ZodNumberFormat: () => Rf, $ZodNumber: () => ul, $ZodNullable: () => Kf, $ZodNull: () => Nf, $ZodNonOptional: () => Yf, $ZodNever: () => Mf, $ZodNanoID: () => gf, $ZodNaN: () => em, $ZodMap: () => Bf, $ZodLiteral: () => Gf, $ZodLazy: () => om, $ZodKSUID: () => xf, $ZodJWT: () => Of, $ZodIntersection: () => zf, $ZodISOTime: () => ix, $ZodISODuration: () => sx, $ZodISODateTime: () => nx, $ZodISODate: () => ox, $ZodIPv6: () => Sf, $ZodIPv4: () => vf, $ZodGUID: () => uf, $ZodFunction: () => av, $ZodFile: () => Vf, $ZodError: () => ll, $ZodEnum: () => qf, $ZodEmoji: () => mf, $ZodEmail: () => df, $ZodE164: () => Af, $ZodDiscriminatedUnion: () => jf, $ZodDefault: () => Zf, $ZodDate: () => $f, $ZodCustomStringFormat: () => Cf, $ZodCustom: () => im, $ZodCheckUpperCase: () => Kb, $ZodCheckStringFormat: () => zs, $ZodCheckStartsWith: () => Jb, $ZodCheckSizeEquals: () => Bb, $ZodCheckRegex: () => Vb, $ZodCheckProperty: () => Xb, $ZodCheckOverwrite: () => ex, $ZodCheckNumberFormat: () => $b, $ZodCheckMultipleOf: () => Ub, $ZodCheckMinSize: () => Fb, $ZodCheckMinLength: () => qb, $ZodCheckMimeType: () => Qb, $ZodCheckMaxSize: () => zb, $ZodCheckMaxLength: () => Hb, $ZodCheckLowerCase: () => Wb, $ZodCheckLessThan: () => of, $ZodCheckLengthEquals: () => Gb, $ZodCheckIncludes: () => Zb, $ZodCheckGreaterThan: () => sf, $ZodCheckEndsWith: () => Yb, $ZodCheckBigIntFormat: () => jb, $ZodCheck: () => Xe, $ZodCatch: () => Qf, $ZodCUID2: () => _f, $ZodCUID: () => hf, $ZodCIDRv6: () => wf, $ZodCIDRv4: () => Ef, $ZodBoolean: () => Fs, $ZodBigIntFormat: () => If, $ZodBigInt: () => pl, $ZodBase64URL: () => kf, $ZodBase64: () => Tf, $ZodAsyncError: () => Bn, $ZodArray: () => Bs, $ZodAny: () => Lf });
+lt(Qr, { version: () => tx, util: () => M, treeifyError: () => Yd, toJSONSchema: () => Js, toDotPath: () => yC, safeParseAsync: () => Eo, safeParse: () => So, registry: () => hl, regexes: () => wo, prettifyError: () => Xd, parseAsync: () => xi, parse: () => bi, locales: () => Gs, isValidJWT: () => MC, isValidBase64URL: () => LC, isValidBase64: () => ax, globalRegistry: () => sr, globalConfig: () => tl, function: () => Dm, formatError: () => js, flattenError: () => $s, config: () => ut, clone: () => Ft, _xid: () => Ol, _void: () => Tm, _uuidv7: () => vl, _uuidv6: () => xl, _uuidv4: () => bl, _uuid: () => yl, _url: () => Sl, _uppercase: () => Fl, _unknown: () => Ei, _union: () => OZ, _undefined: () => vm, _ulid: () => Al, _uint64: () => bm, _uint32: () => gm, _tuple: () => sv, _trim: () => Wl, _transform: () => UZ, _toUpperCase: () => Zl, _toLowerCase: () => Kl, _templateLiteral: () => VZ, _symbol: () => xm, _success: () => BZ, _stringbool: () => Im, _stringFormat: () => Pm, _string: () => cm, _startsWith: () => Hl, _size: () => $l, _set: () => DZ, _safeParseAsync: () => rf, _safeParse: () => tf, _regex: () => jl, _refine: () => Rm, _record: () => IZ, _readonly: () => GZ, _property: () => iv, _promise: () => KZ, _positive: () => tv, _pipe: () => qZ, _parseAsync: () => ef, _parse: () => Qd, _overwrite: () => Vn, _optional: () => $Z, _number: () => um, _nullable: () => jZ, _null: () => Sm, _normalize: () => Vl, _nonpositive: () => nv, _nonoptional: () => FZ, _nonnegative: () => ov, _never: () => wm, _negative: () => rv, _nativeEnum: () => LZ, _nanoid: () => wl, _nan: () => Am, _multipleOf: () => wi, _minSize: () => Ti, _minLength: () => Ao, _min: () => ar, _mime: () => Gl, _maxSize: () => Ws, _maxLength: () => Ks, _max: () => Ur, _map: () => PZ, _lte: () => Ur, _lt: () => qn, _lowercase: () => zl, _literal: () => MZ, _length: () => Zs, _lazy: () => WZ, _ksuid: () => Cl, _jwt: () => Ul, _isoTime: () => Zx, _isoDuration: () => Jx, _isoDateTime: () => Wx, _isoDate: () => Kx, _ipv6: () => Il, _ipv4: () => Rl, _intersection: () => RZ, _int64: () => ym, _int32: () => mm, _int: () => pm, _includes: () => Bl, _guid: () => Vs, _gte: () => ar, _gt: () => Gn, _float64: () => fm, _float32: () => dm, _file: () => Om, _enum: () => NZ, _endsWith: () => ql, _emoji: () => El, _email: () => _l, _e164: () => Ml, _discriminatedUnion: () => CZ, _default: () => zZ, _date: () => km, _custom: () => Cm, _cuid2: () => kl, _cuid: () => Tl, _coercedString: () => Vx, _coercedNumber: () => Yx, _coercedDate: () => ev, _coercedBoolean: () => Xx, _coercedBigint: () => Qx, _cidrv6: () => Dl, _cidrv4: () => Pl, _catch: () => HZ, _boolean: () => hm, _bigint: () => _m, _base64url: () => Ll, _base64: () => Nl, _array: () => Jl, _any: () => Em, TimePrecision: () => lm, NEVER: () => Kd, JSONSchemaGenerator: () => Nm, JSONSchema: () => zC, Doc: () => af, $output: () => sm, $input: () => am, $constructor: () => S, $brand: () => Zd, $ZodXID: () => bf, $ZodVoid: () => Uf, $ZodUnknown: () => Si, $ZodUnion: () => fl, $ZodUndefined: () => Df, $ZodUUID: () => pf, $ZodURL: () => ff, $ZodULID: () => yf, $ZodType: () => ie, $ZodTuple: () => ko, $ZodTransform: () => Hs, $ZodTemplateLiteral: () => rm12, $ZodSymbol: () => Pf, $ZodSuccess: () => Xf, $ZodStringFormat: () => Ue, $ZodString: () => To, $ZodSet: () => Hf, $ZodRegistry: () => gl, $ZodRecord: () => Ff, $ZodRealError: () => Us, $ZodReadonly: () => tm, $ZodPromise: () => nm, $ZodPrefault: () => Jf, $ZodPipe: () => qs, $ZodOptional: () => Wf, $ZodObject: () => dl, $ZodNumberFormat: () => Rf, $ZodNumber: () => ul, $ZodNullable: () => Kf, $ZodNull: () => Nf, $ZodNonOptional: () => Yf, $ZodNever: () => Mf, $ZodNanoID: () => gf, $ZodNaN: () => em, $ZodMap: () => Bf, $ZodLiteral: () => Gf, $ZodLazy: () => om, $ZodKSUID: () => xf, $ZodJWT: () => Of, $ZodIntersection: () => zf, $ZodISOTime: () => ix, $ZodISODuration: () => sx, $ZodISODateTime: () => nx, $ZodISODate: () => ox, $ZodIPv6: () => Sf, $ZodIPv4: () => vf, $ZodGUID: () => uf, $ZodFunction: () => av, $ZodFile: () => Vf, $ZodError: () => ll, $ZodEnum: () => qf, $ZodEmoji: () => mf, $ZodEmail: () => df, $ZodE164: () => Af, $ZodDiscriminatedUnion: () => jf, $ZodDefault: () => Zf, $ZodDate: () => $f, $ZodCustomStringFormat: () => Cf, $ZodCustom: () => im, $ZodCheckUpperCase: () => Kb, $ZodCheckStringFormat: () => zs, $ZodCheckStartsWith: () => Jb, $ZodCheckSizeEquals: () => Bb, $ZodCheckRegex: () => Vb, $ZodCheckProperty: () => Xb, $ZodCheckOverwrite: () => ex, $ZodCheckNumberFormat: () => $b, $ZodCheckMultipleOf: () => Ub, $ZodCheckMinSize: () => Fb, $ZodCheckMinLength: () => qb, $ZodCheckMimeType: () => Qb, $ZodCheckMaxSize: () => zb, $ZodCheckMaxLength: () => Hb, $ZodCheckLowerCase: () => Wb, $ZodCheckLessThan: () => of, $ZodCheckLengthEquals: () => Gb, $ZodCheckIncludes: () => Zb, $ZodCheckGreaterThan: () => sf, $ZodCheckEndsWith: () => Yb, $ZodCheckBigIntFormat: () => jb, $ZodCheck: () => Xe, $ZodCatch: () => Qf, $ZodCUID2: () => _f, $ZodCUID: () => hf, $ZodCIDRv6: () => wf, $ZodCIDRv4: () => Ef, $ZodBoolean: () => Fs, $ZodBigIntFormat: () => If, $ZodBigInt: () => pl, $ZodBase64URL: () => kf, $ZodBase64: () => Tf, $ZodAsyncError: () => Bn, $ZodArray: () => Bs, $ZodAny: () => Lf });
 var Kd = Object.freeze({ status: "aborted" });
 function S(e, t, r) {
   function n(a, c) {
@@ -28445,7 +29560,7 @@ var tm = S("$ZodReadonly", (e, t) => {
 function DC(e) {
   return e.value = Object.freeze(e.value), e;
 }
-var rm11 = S("$ZodTemplateLiteral", (e, t) => {
+var rm12 = S("$ZodTemplateLiteral", (e, t) => {
   ie.init(e, t);
   let r = [];
   for (let n of t.parts) if (n instanceof ie) {
@@ -32252,7 +33367,7 @@ function hR(e) {
   return new gR({ type: "readonly", innerType: e });
 }
 var _R = S("ZodTemplateLiteral", (e, t) => {
-  rm11.init(e, t), de.init(e, t);
+  rm12.init(e, t), de.init(e, t);
 });
 function q9(e, t) {
   return new _R({ type: "template_literal", parts: e, ...M.normalizeParams(t) });
@@ -43579,7 +44694,7 @@ var MessageQueue = class {
         if (value) return Promise.resolve({ value, done: false });
         if (this.closed)
           return Promise.resolve({ value: void 0, done: true });
-        return new Promise((resolve8) => this.waiters.push(resolve8));
+        return new Promise((resolve9) => this.waiters.push(resolve9));
       }
     };
   }
@@ -43749,8 +44864,8 @@ var ClaudeAdapter = class {
           const requestId = options.toolUseID || randomUUID5();
           const questions = questionsFromInput(toolInput);
           await callbacks.onQuestion(requestId, questions);
-          const answers = await new Promise((resolve8) => {
-            pendingQuestions.set(requestId, { input: toolInput, resolve: resolve8 });
+          const answers = await new Promise((resolve9) => {
+            pendingQuestions.set(requestId, { input: toolInput, resolve: resolve9 });
           });
           return {
             behavior: "allow",
@@ -43893,9 +45008,9 @@ import {
   execFile as execFile3,
   spawn as spawn8
 } from "node:child_process";
-import { mkdtemp as mkdtemp7, rm as rm12, writeFile as writeFile8 } from "node:fs/promises";
+import { mkdtemp as mkdtemp7, rm as rm13, writeFile as writeFile9 } from "node:fs/promises";
 import { tmpdir as tmpdir7 } from "node:os";
-import { join as join16 } from "node:path";
+import { join as join17 } from "node:path";
 import { createInterface } from "node:readline";
 import { promisify as promisify3 } from "node:util";
 var SUPPORTED_CODEX_APP_SERVER_MINORS = ["0.144", "0.145"];
@@ -44006,8 +45121,8 @@ var CodexAppServer = class {
     });
     const lines = createInterface({ input: child.stdout });
     lines.on("line", (line) => this.receive(line));
-    await new Promise((resolve8, reject) => {
-      child.once("spawn", resolve8);
+    await new Promise((resolve9, reject) => {
+      child.once("spawn", resolve9);
       child.once("error", reject);
     });
     const initialized = asRecord(
@@ -44049,7 +45164,7 @@ var CodexAppServer = class {
     }
   }
   async createBundledModelCatalog(executable) {
-    const directory = await mkdtemp7(join16(tmpdir7(), "aide-codex-models-"));
+    const directory = await mkdtemp7(join17(tmpdir7(), "aide-codex-models-"));
     try {
       const { stdout } = await execFileAsync2(
         executable,
@@ -44059,12 +45174,12 @@ var CodexAppServer = class {
           maxBuffer: 16 * 1024 * 1024
         }
       );
-      const catalogPath = join16(directory, "models.json");
-      await writeFile8(catalogPath, stdout, "utf8");
+      const catalogPath = join17(directory, "models.json");
+      await writeFile9(catalogPath, stdout, "utf8");
       this.modelCatalogDirectory = directory;
       return catalogPath;
     } catch (error) {
-      await rm12(directory, { recursive: true, force: true }).catch(
+      await rm13(directory, { recursive: true, force: true }).catch(
         () => void 0
       );
       throw error;
@@ -44075,7 +45190,7 @@ var CodexAppServer = class {
     if (this.modelCatalogDirectory === directory) {
       this.modelCatalogDirectory = void 0;
     }
-    await rm12(directory, { recursive: true, force: true }).catch(
+    await rm13(directory, { recursive: true, force: true }).catch(
       () => void 0
     );
   }
@@ -44115,8 +45230,8 @@ var CodexAppServer = class {
   }
   requestDirect(method, params) {
     const id2 = this.nextId++;
-    return new Promise((resolve8, reject) => {
-      this.pending.set(id2, { resolve: resolve8, reject });
+    return new Promise((resolve9, reject) => {
+      this.pending.set(id2, { resolve: resolve9, reject });
       this.write({ id: id2, method, params });
     });
   }
@@ -44279,8 +45394,8 @@ var CodexAdapter = class {
     let lastUsageSignature = "";
     const pendingQuestions = /* @__PURE__ */ new Map();
     let resolveCompletion;
-    const completion = new Promise((resolve8) => {
-      resolveCompletion = resolve8;
+    const completion = new Promise((resolve9) => {
+      resolveCompletion = resolve9;
     });
     const unsubscribe = this.server.listen(nativeId, (message) => {
       void (async () => {
@@ -44490,13 +45605,13 @@ var CodexAdapter = class {
 };
 
 // src/runs/opencode-adapter.ts
-import { dirname as dirname9 } from "node:path";
+import { dirname as dirname10 } from "node:path";
 import { pathToFileURL } from "node:url";
 
 // ../../node_modules/@opencode-ai/sdk/dist/v2/gen/core/serverSentEvents.gen.js
 var createSseClient = ({ onRequest, onSseError, onSseEvent, responseTransformer, responseValidator, sseDefaultRetryDelay, sseMaxRetryAttempts, sseMaxRetryDelay, sseSleepFn, url, ...options }) => {
   let lastEventId;
-  const sleep = sseSleepFn ?? ((ms) => new Promise((resolve8) => setTimeout(resolve8, ms)));
+  const sleep = sseSleepFn ?? ((ms) => new Promise((resolve9) => setTimeout(resolve9, ms)));
   const createStream = async function* () {
     let retryDelay = sseDefaultRetryDelay ?? 3e3;
     let attempt = 0;
@@ -49948,7 +51063,7 @@ async function createOpencodeServer(options) {
   });
   let clear = () => {
   };
-  const url = await new Promise((resolve8, reject) => {
+  const url = await new Promise((resolve9, reject) => {
     const id2 = setTimeout(() => {
       clear();
       stop(proc);
@@ -49973,7 +51088,7 @@ async function createOpencodeServer(options) {
           }
           clearTimeout(id2);
           resolved = true;
-          resolve8(match[1]);
+          resolve9(match[1]);
           return;
         }
       }
@@ -50138,11 +51253,11 @@ function responseItems(value) {
 }
 function waitForPoll(signal) {
   if (signal.aborted) return Promise.resolve();
-  return new Promise((resolve8) => {
+  return new Promise((resolve9) => {
     const finish = () => {
       clearTimeout(timer);
       signal.removeEventListener("abort", finish);
-      resolve8();
+      resolve9();
     };
     const timer = setTimeout(finish, QUESTION_RECONCILIATION_INTERVAL_MS);
     timer.unref();
@@ -50171,7 +51286,7 @@ var OpenCodeAdapter = class {
           "opencode was not found. Install it (brew install sst/tap/opencode, or npm install -g opencode-ai) or set CONTROL_AGENT_OPENCODE_EXECUTABLE to its full path."
         );
       }
-      prependPathDirectory(dirname9(executable));
+      prependPathDirectory(dirname10(executable));
       this.runtime = await createOpencode({ port: 0 });
     }
     return this.runtime.client;
@@ -50795,7 +51910,7 @@ var RunManager = class {
         5
       );
       await this.completeCommand(command3.id, "SUCCEEDED");
-      await rm13(join17(dirname10(configPath()), "runs", run.id, "attachments"), {
+      await rm14(join18(dirname11(configPath()), "runs", run.id, "attachments"), {
         recursive: true,
         force: true
       }).catch(() => void 0);
@@ -50977,7 +52092,7 @@ var RunManager = class {
         this.active.delete(run.id);
       this.interruptionRequests.delete(run.id);
       this.executingCommands.delete(command3.id);
-      await rm13(join17(dirname10(configPath()), "runs", run.id, "attachments"), {
+      await rm14(join18(dirname11(configPath()), "runs", run.id, "attachments"), {
         recursive: true,
         force: true
       }).catch(() => void 0);
@@ -51205,11 +52320,11 @@ var RunManager = class {
   }
   async stageAttachments(runId, attachments) {
     if (!attachments.length) return [];
-    const directory = join17(dirname10(configPath()), "runs", runId, "attachments");
-    await mkdir6(directory, { recursive: true, mode: 448 });
+    const directory = join18(dirname11(configPath()), "runs", runId, "attachments");
+    await mkdir7(directory, { recursive: true, mode: 448 });
     return Promise.all(
       attachments.map(async (attachment) => {
-        const path = join17(
+        const path = join18(
           directory,
           `${attachment.id}-${safeFilename(attachment.filename)}`
         );
@@ -51301,7 +52416,7 @@ var RunManager = class {
         return await operation();
       } catch (error) {
         if (this.stopped || attempt >= attempts) throw error;
-        await new Promise((resolve8) => setTimeout(resolve8, delay));
+        await new Promise((resolve9) => setTimeout(resolve9, delay));
         delay = Math.min(delay * 2, 3e4);
       }
     }
@@ -51581,9 +52696,9 @@ async function runAgentSession(config, signal, onUnhealthy) {
       }
     }
   );
-  await new Promise((resolve8) => {
-    if (signal.aborted) resolve8();
-    else signal.addEventListener("abort", () => resolve8(), { once: true });
+  await new Promise((resolve9) => {
+    if (signal.aborted) resolve9();
+    else signal.addEventListener("abort", () => resolve9(), { once: true });
   });
   if (heartbeatTimer) clearTimeout(heartbeatTimer);
   if (jobReconciliationTimer) clearTimeout(jobReconciliationTimer);
@@ -51650,7 +52765,7 @@ var defaultDependencies = {
   inventory: collectInventory,
   load: loadConfig,
   save: saveConfig,
-  wait: (milliseconds, signal) => new Promise((resolve8, reject) => {
+  wait: (milliseconds, signal) => new Promise((resolve9, reject) => {
     if (signal.aborted) {
       reject(new Error("Development agent startup was cancelled"));
       return;
@@ -51661,7 +52776,7 @@ var defaultDependencies = {
     };
     const timer = setTimeout(() => {
       signal.removeEventListener("abort", onAbort);
-      resolve8();
+      resolve9();
     }, milliseconds);
     signal.addEventListener("abort", onAbort, { once: true });
   })
@@ -51905,7 +53020,7 @@ async function unenroll() {
     config = await loadConfig(path);
   } catch {
   }
-  await rm14(path, { force: true });
+  await rm15(path, { force: true });
   console.log(
     config ? `Removed the enrollment for ${config.name} (${config.agentId}) from ${path}` : `Removed ${path}`
   );