@solaqua/gji 0.12.0 → 0.12.2

package/dist/gji-bundle.mjs

@@ -3462,7 +3462,7 @@ var require_commander = __commonJS({
 // node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/polyfills.js
 var require_polyfills = __commonJS({
   "node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/polyfills.js"(exports, module) {
-    var constants9 = __require("constants");
+    var constants10 = __require("constants");
     var origCwd = process.cwd;
     var cwd = null;
     var platform3 = process.env.GRACEFUL_FS_PLATFORM || process.platform;
@@ -3486,7 +3486,7 @@ var require_polyfills = __commonJS({
     var chdir;
     module.exports = patch;
     function patch(fs5) {
-      if (constants9.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
+      if (constants10.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
         patchLchmod(fs5);
       }
       if (!fs5.lutimes) {
@@ -3526,7 +3526,7 @@ var require_polyfills = __commonJS({
       }
       if (platform3 === "win32") {
         fs5.rename = typeof fs5.rename !== "function" ? fs5.rename : (function(fs$rename) {
-          function rename5(from, to, cb) {
+          function rename4(from, to, cb) {
             var start = Date.now();
             var backoff = 0;
             fs$rename(from, to, function CB(er) {
@@ -3546,8 +3546,8 @@ var require_polyfills = __commonJS({
               if (cb) cb(er);
             });
           }
-          if (Object.setPrototypeOf) Object.setPrototypeOf(rename5, fs$rename);
-          return rename5;
+          if (Object.setPrototypeOf) Object.setPrototypeOf(rename4, fs$rename);
+          return rename4;
         })(fs5.rename);
       }
       fs5.read = typeof fs5.read !== "function" ? fs5.read : (function(fs$read) {
@@ -3588,7 +3588,7 @@ var require_polyfills = __commonJS({
         fs6.lchmod = function(path9, mode, callback) {
           fs6.open(
             path9,
-            constants9.O_WRONLY | constants9.O_SYMLINK,
+            constants10.O_WRONLY | constants10.O_SYMLINK,
             mode,
             function(err, fd) {
               if (err) {
@@ -3604,7 +3604,7 @@ var require_polyfills = __commonJS({
           );
         };
         fs6.lchmodSync = function(path9, mode) {
-          var fd = fs6.openSync(path9, constants9.O_WRONLY | constants9.O_SYMLINK, mode);
+          var fd = fs6.openSync(path9, constants10.O_WRONLY | constants10.O_SYMLINK, mode);
           var threw = true;
           var ret;
           try {
@@ -3624,9 +3624,9 @@ var require_polyfills = __commonJS({
         };
       }
       function patchLutimes(fs6) {
-        if (constants9.hasOwnProperty("O_SYMLINK") && fs6.futimes) {
+        if (constants10.hasOwnProperty("O_SYMLINK") && fs6.futimes) {
           fs6.lutimes = function(path9, at, mt, cb) {
-            fs6.open(path9, constants9.O_SYMLINK, function(er, fd) {
+            fs6.open(path9, constants10.O_SYMLINK, function(er, fd) {
               if (er) {
                 if (cb) cb(er);
                 return;
@@ -3639,7 +3639,7 @@ var require_polyfills = __commonJS({
             });
           };
           fs6.lutimesSync = function(path9, at, mt) {
-            var fd = fs6.openSync(path9, constants9.O_SYMLINK);
+            var fd = fs6.openSync(path9, constants10.O_SYMLINK);
             var ret;
             var threw = true;
             try {
@@ -3951,8 +3951,8 @@ var require_graceful_fs = __commonJS({
       fs6.createReadStream = createReadStream;
       fs6.createWriteStream = createWriteStream;
       var fs$readFile = fs6.readFile;
-      fs6.readFile = readFile12;
-      function readFile12(path9, options, cb) {
+      fs6.readFile = readFile11;
+      function readFile11(path9, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
         return go$readFile(path9, options, cb);
@@ -3968,8 +3968,8 @@ var require_graceful_fs = __commonJS({
         }
       }
       var fs$writeFile = fs6.writeFile;
-      fs6.writeFile = writeFile12;
-      function writeFile12(path9, data, options, cb) {
+      fs6.writeFile = writeFile11;
+      function writeFile11(path9, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
         return go$writeFile(path9, data, options, cb);
@@ -4128,7 +4128,7 @@ var require_graceful_fs = __commonJS({
       }
       function ReadStream$open() {
         var that = this;
-        open3(that.path, that.flags, that.mode, function(err, fd) {
+        open4(that.path, that.flags, that.mode, function(err, fd) {
           if (err) {
             if (that.autoClose)
               that.destroy();
@@ -4148,7 +4148,7 @@ var require_graceful_fs = __commonJS({
       }
       function WriteStream$open() {
         var that = this;
-        open3(that.path, that.flags, that.mode, function(err, fd) {
+        open4(that.path, that.flags, that.mode, function(err, fd) {
           if (err) {
             that.destroy();
             that.emit("error", err);
@@ -4165,8 +4165,8 @@ var require_graceful_fs = __commonJS({
         return new fs6.WriteStream(path9, options);
       }
       var fs$open = fs6.open;
-      fs6.open = open3;
-      function open3(path9, flags, mode, cb) {
+      fs6.open = open4;
+      function open4(path9, flags, mode, cb) {
         if (typeof mode === "function")
           cb = mode, mode = null;
         return go$open(path9, flags, mode, cb);
@@ -5386,7 +5386,7 @@ var require_minimist = __commonJS({
 var require_rc = __commonJS({
   "node_modules/.pnpm/rc@1.2.8/node_modules/rc/index.js"(exports, module) {
     var cc = require_utils();
-    var join19 = __require("path").join;
+    var join18 = __require("path").join;
     var deepExtend = require_deep_extend();
     var etc = "/etc";
     var win = process.platform === "win32";
@@ -5411,15 +5411,15 @@ var require_rc = __commonJS({
       }
       if (!win)
         [
-          join19(etc, name, "config"),
-          join19(etc, name + "rc")
+          join18(etc, name, "config"),
+          join18(etc, name + "rc")
         ].forEach(addConfigFile);
       if (home)
         [
-          join19(home, ".config", name, "config"),
-          join19(home, ".config", name),
-          join19(home, "." + name, "config"),
-          join19(home, "." + name + "rc")
+          join18(home, ".config", name, "config"),
+          join18(home, ".config", name),
+          join18(home, "." + name, "config"),
+          join18(home, "." + name + "rc")
         ].forEach(addConfigFile);
       addConfigFile(cc.find("." + name + "rc"));
       if (env5.config) addConfigFile(env5.config);
@@ -5436,7 +5436,7 @@ var require_rc = __commonJS({
 // node_modules/.pnpm/graceful-fs@4.2.10/node_modules/graceful-fs/polyfills.js
 var require_polyfills2 = __commonJS({
   "node_modules/.pnpm/graceful-fs@4.2.10/node_modules/graceful-fs/polyfills.js"(exports, module) {
-    var constants9 = __require("constants");
+    var constants10 = __require("constants");
     var origCwd = process.cwd;
     var cwd = null;
     var platform3 = process.env.GRACEFUL_FS_PLATFORM || process.platform;
@@ -5460,7 +5460,7 @@ var require_polyfills2 = __commonJS({
     var chdir;
     module.exports = patch;
     function patch(fs5) {
-      if (constants9.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
+      if (constants10.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
         patchLchmod(fs5);
       }
       if (!fs5.lutimes) {
@@ -5500,7 +5500,7 @@ var require_polyfills2 = __commonJS({
       }
       if (platform3 === "win32") {
         fs5.rename = typeof fs5.rename !== "function" ? fs5.rename : (function(fs$rename) {
-          function rename5(from, to, cb) {
+          function rename4(from, to, cb) {
             var start = Date.now();
             var backoff = 0;
             fs$rename(from, to, function CB(er) {
@@ -5520,8 +5520,8 @@ var require_polyfills2 = __commonJS({
               if (cb) cb(er);
             });
           }
-          if (Object.setPrototypeOf) Object.setPrototypeOf(rename5, fs$rename);
-          return rename5;
+          if (Object.setPrototypeOf) Object.setPrototypeOf(rename4, fs$rename);
+          return rename4;
         })(fs5.rename);
       }
       fs5.read = typeof fs5.read !== "function" ? fs5.read : (function(fs$read) {
@@ -5562,7 +5562,7 @@ var require_polyfills2 = __commonJS({
         fs6.lchmod = function(path9, mode, callback) {
           fs6.open(
             path9,
-            constants9.O_WRONLY | constants9.O_SYMLINK,
+            constants10.O_WRONLY | constants10.O_SYMLINK,
             mode,
             function(err, fd) {
               if (err) {
@@ -5578,7 +5578,7 @@ var require_polyfills2 = __commonJS({
           );
         };
         fs6.lchmodSync = function(path9, mode) {
-          var fd = fs6.openSync(path9, constants9.O_WRONLY | constants9.O_SYMLINK, mode);
+          var fd = fs6.openSync(path9, constants10.O_WRONLY | constants10.O_SYMLINK, mode);
           var threw = true;
           var ret;
           try {
@@ -5598,9 +5598,9 @@ var require_polyfills2 = __commonJS({
         };
       }
       function patchLutimes(fs6) {
-        if (constants9.hasOwnProperty("O_SYMLINK") && fs6.futimes) {
+        if (constants10.hasOwnProperty("O_SYMLINK") && fs6.futimes) {
           fs6.lutimes = function(path9, at, mt, cb) {
-            fs6.open(path9, constants9.O_SYMLINK, function(er, fd) {
+            fs6.open(path9, constants10.O_SYMLINK, function(er, fd) {
               if (er) {
                 if (cb) cb(er);
                 return;
@@ -5613,7 +5613,7 @@ var require_polyfills2 = __commonJS({
             });
           };
           fs6.lutimesSync = function(path9, at, mt) {
-            var fd = fs6.openSync(path9, constants9.O_SYMLINK);
+            var fd = fs6.openSync(path9, constants10.O_SYMLINK);
             var ret;
             var threw = true;
             try {
@@ -5925,8 +5925,8 @@ var require_graceful_fs2 = __commonJS({
       fs6.createReadStream = createReadStream;
       fs6.createWriteStream = createWriteStream;
       var fs$readFile = fs6.readFile;
-      fs6.readFile = readFile12;
-      function readFile12(path9, options, cb) {
+      fs6.readFile = readFile11;
+      function readFile11(path9, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
         return go$readFile(path9, options, cb);
@@ -5942,8 +5942,8 @@ var require_graceful_fs2 = __commonJS({
         }
       }
       var fs$writeFile = fs6.writeFile;
-      fs6.writeFile = writeFile12;
-      function writeFile12(path9, data, options, cb) {
+      fs6.writeFile = writeFile11;
+      function writeFile11(path9, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
         return go$writeFile(path9, data, options, cb);
@@ -6102,7 +6102,7 @@ var require_graceful_fs2 = __commonJS({
       }
       function ReadStream$open() {
         var that = this;
-        open3(that.path, that.flags, that.mode, function(err, fd) {
+        open4(that.path, that.flags, that.mode, function(err, fd) {
           if (err) {
             if (that.autoClose)
               that.destroy();
@@ -6122,7 +6122,7 @@ var require_graceful_fs2 = __commonJS({
       }
       function WriteStream$open() {
         var that = this;
-        open3(that.path, that.flags, that.mode, function(err, fd) {
+        open4(that.path, that.flags, that.mode, function(err, fd) {
           if (err) {
             that.destroy();
             that.emit("error", err);
@@ -6139,8 +6139,8 @@ var require_graceful_fs2 = __commonJS({
         return new fs6.WriteStream(path9, options);
       }
       var fs$open = fs6.open;
-      fs6.open = open3;
-      function open3(path9, flags, mode, cb) {
+      fs6.open = open4;
+      function open4(path9, flags, mode, cb) {
         if (typeof mode === "function")
           cb = mode, mode = null;
         return go$open(path9, flags, mode, cb);
@@ -6990,12 +6990,12 @@ var require_conf = __commonJS({
         Object.defineProperty(this, "prefix", {
           enumerable: true,
           set: (prefix) => {
-            const g = this.get("global");
-            this[g ? "globalPrefix" : "localPrefix"] = prefix;
+            const g2 = this.get("global");
+            this[g2 ? "globalPrefix" : "localPrefix"] = prefix;
           },
           get: () => {
-            const g = this.get("global");
-            return g ? this.globalPrefix : this.localPrefix;
+            const g2 = this.get("global");
+            return g2 ? this.globalPrefix : this.localPrefix;
           }
         });
         Object.defineProperty(this, "globalPrefix", {
@@ -8729,7 +8729,7 @@ var require_semver2 = __commonJS({
   "node_modules/.pnpm/semver@7.7.4/node_modules/semver/index.js"(exports, module) {
     "use strict";
     var internalRe = require_re();
-    var constants9 = require_constants();
+    var constants10 = require_constants();
     var SemVer = require_semver();
     var identifiers = require_identifiers();
     var parse = require_parse();
@@ -8811,8 +8811,8 @@ var require_semver2 = __commonJS({
       re: internalRe.re,
       src: internalRe.src,
       tokens: internalRe.t,
-      SEMVER_SPEC_VERSION: constants9.SEMVER_SPEC_VERSION,
-      RELEASE_TYPES: constants9.RELEASE_TYPES,
+      SEMVER_SPEC_VERSION: constants10.SEMVER_SPEC_VERSION,
+      RELEASE_TYPES: constants10.RELEASE_TYPES,
       compareIdentifiers: identifiers.compareIdentifiers,
       rcompareIdentifiers: identifiers.rcompareIdentifiers
     };
@@ -9356,9 +9356,9 @@ var require_picocolors = __commonJS({
     var argv = p2.argv || [];
     var env5 = p2.env || {};
     var isColorSupported = !(!!env5.NO_COLOR || argv.includes("--no-color")) && (!!env5.FORCE_COLOR || argv.includes("--color") || p2.platform === "win32" || (p2.stdout || {}).isTTY && env5.TERM !== "dumb" || !!env5.CI);
-    var formatter = (open3, close, replace = open3) => (input) => {
-      let string = "" + input, index = string.indexOf(close, open3.length);
-      return ~index ? open3 + replaceClose(string, close, replace, index) + close : open3 + string + close;
+    var formatter = (open4, close, replace = open4) => (input) => {
+      let string = "" + input, index = string.indexOf(close, open4.length);
+      return ~index ? open4 + replaceClose(string, close, replace, index) + close : open4 + string + close;
     };
     var replaceClose = (string, close, replace, index) => {
       let result = "", cursor = 0;
@@ -9422,7 +9422,7 @@ var require_picocolors = __commonJS({
 });
 
 // src/index.ts
-import { homedir as homedir11 } from "node:os";
+import { homedir as homedir10 } from "node:os";
 
 // src/cli.ts
 import { createRequire } from "node:module";
@@ -9781,14 +9781,14 @@ var Temp = {
     }
   },
   truncate: (filePath) => {
-    const basename12 = path2.basename(filePath);
-    if (basename12.length <= LIMIT_BASENAME_LENGTH)
+    const basename13 = path2.basename(filePath);
+    if (basename13.length <= LIMIT_BASENAME_LENGTH)
       return filePath;
-    const truncable = /^(\.?)(.*?)((?:\.[^.]+)?(?:\.tmp-\d{10}[a-f0-9]{6})?)$/.exec(basename12);
+    const truncable = /^(\.?)(.*?)((?:\.[^.]+)?(?:\.tmp-\d{10}[a-f0-9]{6})?)$/.exec(basename13);
     if (!truncable)
       return filePath;
-    const truncationLength = basename12.length - LIMIT_BASENAME_LENGTH;
-    return `${filePath.slice(0, -basename12.length)}${truncable[1]}${truncable[2].slice(0, -truncationLength)}${truncable[3]}`;
+    const truncationLength = basename13.length - LIMIT_BASENAME_LENGTH;
+    return `${filePath.slice(0, -basename13.length)}${truncable[1]}${truncable[2].slice(0, -truncationLength)}${truncable[3]}`;
   }
 };
 node_default(Temp.purgeSyncAll);
@@ -10617,18 +10617,18 @@ var proto = Object.defineProperties(() => {
     }
   }
 });
-var createStyler = (open3, close, parent) => {
+var createStyler = (open4, close, parent) => {
   let openAll;
   let closeAll;
   if (parent === void 0) {
-    openAll = open3;
+    openAll = open4;
     closeAll = close;
   } else {
-    openAll = parent.openAll + open3;
+    openAll = parent.openAll + open4;
     closeAll = close + parent.closeAll;
   }
   return {
-    open: open3,
+    open: open4,
     close,
     openAll,
     closeAll,
@@ -12319,9 +12319,9 @@ var NEWLINE = "\n";
 var PAD = " ";
 var NONE = "none";
 var terminalColumns = () => {
-  const { env: env5, stdout: stdout2, stderr } = process9;
-  if (stdout2?.columns) {
-    return stdout2.columns;
+  const { env: env5, stdout: stdout3, stderr } = process9;
+  if (stdout3?.columns) {
+    return stdout3.columns;
   }
   if (stderr?.columns) {
     return stderr.columns;
@@ -13205,15 +13205,15 @@ function isHistoryEntry(value) {
 
 // src/hooks.ts
 import { spawn as spawn2 } from "node:child_process";
-async function runHook(hookCmd, cwd, context, stderr, stdout2 = (chunk) => process.stdout.write(chunk)) {
+async function runHook(hookCmd, cwd, context, stderr, stdout3 = (chunk) => process.stdout.write(chunk)) {
   if (!hookCmd) return;
   if (Array.isArray(hookCmd)) {
-    await runArgvHook(hookCmd, cwd, context, stderr, stdout2);
+    await runArgvHook(hookCmd, cwd, context, stderr, stdout3);
     return;
   }
-  await runShellHook(hookCmd, cwd, context, stderr, stdout2);
+  await runShellHook(hookCmd, cwd, context, stderr, stdout3);
 }
-async function runArgvHook(hookCmd, cwd, context, stderr, stdout2) {
+async function runArgvHook(hookCmd, cwd, context, stderr, stdout3) {
   const [command, ...args] = hookCmd.map((arg) => interpolate(arg, context));
   if (!command) {
     stderr("gji: hook argv command must include a non-empty command\n");
@@ -13227,7 +13227,7 @@ async function runArgvHook(hookCmd, cwd, context, stderr, stdout2) {
       env: hookEnvironment(context)
     });
     child.stdout.on("data", (chunk) => {
-      stdout2(chunk.toString());
+      stdout3(chunk.toString());
     });
     child.stderr.on("data", (chunk) => {
       stderr(chunk.toString());
@@ -13248,7 +13248,7 @@ async function runArgvHook(hookCmd, cwd, context, stderr, stdout2) {
     });
   });
 }
-async function runShellHook(hookCmd, cwd, context, stderr, stdout2) {
+async function runShellHook(hookCmd, cwd, context, stderr, stdout3) {
   const interpolated = interpolate(hookCmd, context);
   await new Promise((resolve13) => {
     const child = spawn2(interpolated, {
@@ -13258,7 +13258,7 @@ async function runShellHook(hookCmd, cwd, context, stderr, stdout2) {
       env: hookEnvironment(context)
     });
     child.stdout.on("data", (chunk) => {
-      stdout2(chunk.toString());
+      stdout3(chunk.toString());
     });
     child.stderr.on("data", (chunk) => {
       stderr(chunk.toString());
@@ -13338,20 +13338,20 @@ import { promisify as promisify2 } from "node:util";
 var execFileAsync = promisify2(execFile);
 async function runGit(cwd, args) {
   try {
-    const { stdout: stdout2 } = await execFileAsync("git", args, { cwd });
-    return stdout2.trim();
+    const { stdout: stdout3 } = await execFileAsync("git", args, { cwd });
+    return stdout3.trim();
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     throw new Error(`Git command failed in '${cwd}': ${message}`);
   }
 }
 async function readWorktreeHealth(cwd) {
-  const { stdout: stdout2 } = await execFileAsync(
+  const { stdout: stdout3 } = await execFileAsync(
     "git",
     ["status", "--porcelain=v2", "--branch"],
     { cwd }
   );
-  return parseWorktreeHealth(stdout2);
+  return parseWorktreeHealth(stdout3);
 }
 async function isDirtyWorktree(cwd) {
   const health = await readWorktreeHealth(cwd);
@@ -13371,12 +13371,12 @@ async function isBranchMergedInto(cwd, branch, base = "HEAD") {
   }
 }
 async function resolveRemoteDefaultBranch(cwd, remote) {
-  const { stdout: stdout2 } = await execFileAsync(
+  const { stdout: stdout3 } = await execFileAsync(
     "git",
     ["ls-remote", "--symref", remote, "HEAD"],
     { cwd }
   );
-  const refLine = stdout2.split("\n").find((line) => line.startsWith("ref: refs/heads/"));
+  const refLine = stdout3.split("\n").find((line) => line.startsWith("ref: refs/heads/"));
   if (!refLine) {
     return null;
   }
@@ -13428,12 +13428,12 @@ async function resolveCachedRemoteDefaultBranch(cwd, remote) {
 }
 async function readBranchLastCommitTimestamp(cwd, branch) {
   try {
-    const { stdout: stdout2 } = await execFileAsync(
+    const { stdout: stdout3 } = await execFileAsync(
       "git",
       ["log", "-1", "--format=%ct", branch],
       { cwd }
     );
-    const timestamp = Number(stdout2.trim());
+    const timestamp = Number(stdout3.trim());
     return Number.isFinite(timestamp) ? timestamp : null;
   } catch {
     return null;
@@ -13629,14 +13629,14 @@ function findOptionalPorcelainValue(block, key) {
 
 // src/shell-handoff.ts
 import { writeFile as writeFile3 } from "node:fs/promises";
-async function writeShellOutput(envVar, value, stdout2) {
+async function writeShellOutput(envVar, value, stdout3) {
   const output = `${value}
 `;
   if (process.env[envVar]) {
     await writeFile3(process.env[envVar], output, "utf8");
     return;
   }
-  stdout2(output);
+  stdout3(output);
 }
 
 // src/back.ts
@@ -13752,8 +13752,9 @@ function formatAge(timestamp) {
 
 // node_modules/.pnpm/@clack+core@0.5.0/node_modules/@clack/core/dist/index.mjs
 var import_sisteransi = __toESM(require_src(), 1);
-import { stdin as j, stdout as M } from "node:process";
 var import_picocolors = __toESM(require_picocolors(), 1);
+import { stdin as j, stdout as M } from "node:process";
+import * as g from "node:readline";
 import O from "node:readline";
 import { Writable as X } from "node:stream";
 function DD({ onlyFirst: e2 = false } = {}) {
@@ -13965,6 +13966,27 @@ function m(e2, u2) {
   const t = e2;
   t.isTTY && t.setRawMode(u2);
 }
+function fD({ input: e2 = j, output: u2 = M, overwrite: t = true, hideCursor: F2 = true } = {}) {
+  const s = g.createInterface({ input: e2, output: u2, prompt: "", tabSize: 1 });
+  g.emitKeypressEvents(e2, s), e2.isTTY && e2.setRawMode(true);
+  const i = (D2, { name: C2, sequence: n }) => {
+    const E = String(D2);
+    if ($([E, C2, n], "cancel")) {
+      F2 && u2.write(import_sisteransi.cursor.show), process.exit(0);
+      return;
+    }
+    if (!t) return;
+    const a = C2 === "return" ? 0 : -1, o2 = C2 === "return" ? -1 : 0;
+    g.moveCursor(u2, a, o2, () => {
+      g.clearLine(u2, 1, () => {
+        e2.once("keypress", i);
+      });
+    });
+  };
+  return F2 && u2.write(import_sisteransi.cursor.hide), e2.once("keypress", i), () => {
+    e2.off("keypress", i), F2 && u2.write(import_sisteransi.cursor.show), e2.isTTY && !AD && e2.setRawMode(false), s.terminal = false, s.close();
+  };
+}
 var gD = Object.defineProperty;
 var vD = (e2, u2, t) => u2 in e2 ? gD(e2, u2, { enumerable: true, configurable: true, writable: true, value: t }) : e2[u2] = t;
 var h = (e2, u2, t) => (vD(e2, typeof u2 != "symbol" ? u2 + "" : u2, t), t);
@@ -14167,9 +14189,9 @@ var G2 = (t) => {
   const { cursor: n, options: r2, style: i } = t, s = t.maxItems ?? Number.POSITIVE_INFINITY, c = Math.max(process.stdout.rows - 4, 0), a = Math.min(c, Math.max(s, 5));
   let l2 = 0;
   n >= l2 + a - 3 ? l2 = Math.max(Math.min(n - a + 3, r2.length - a), 0) : n < l2 + 2 && (l2 = Math.max(n - 2, 0));
-  const $2 = a < r2.length && l2 > 0, g = a < r2.length && l2 + a < r2.length;
+  const $2 = a < r2.length && l2 > 0, g2 = a < r2.length && l2 + a < r2.length;
   return r2.slice(l2, l2 + a).map((p2, v2, f) => {
-    const j2 = v2 === 0 && $2, E = v2 === f.length - 1 && g;
+    const j2 = v2 === 0 && $2, E = v2 === f.length - 1 && g2;
     return j2 || E ? import_picocolors2.default.dim("...") : i(p2, v2 + l2 === n);
   });
 };
@@ -14279,6 +14301,53 @@ var M2 = { message: (t = "", { symbol: n = import_picocolors2.default.gray(o) }
   M2.message(t, { symbol: import_picocolors2.default.red(K2) });
 } };
 var J2 = `${import_picocolors2.default.gray(o)}  `;
+var Y2 = ({ indicator: t = "dots" } = {}) => {
+  const n = V2 ? ["\u25D2", "\u25D0", "\u25D3", "\u25D1"] : ["\u2022", "o", "O", "0"], r2 = V2 ? 80 : 120, i = process.env.CI === "true";
+  let s, c, a = false, l2 = "", $2, g2 = performance.now();
+  const p2 = (m2) => {
+    const h2 = m2 > 1 ? "Something went wrong" : "Canceled";
+    a && N2(h2, m2);
+  }, v2 = () => p2(2), f = () => p2(1), j2 = () => {
+    process.on("uncaughtExceptionMonitor", v2), process.on("unhandledRejection", v2), process.on("SIGINT", f), process.on("SIGTERM", f), process.on("exit", p2);
+  }, E = () => {
+    process.removeListener("uncaughtExceptionMonitor", v2), process.removeListener("unhandledRejection", v2), process.removeListener("SIGINT", f), process.removeListener("SIGTERM", f), process.removeListener("exit", p2);
+  }, B2 = () => {
+    if ($2 === void 0) return;
+    i && process.stdout.write(`
+`);
+    const m2 = $2.split(`
+`);
+    process.stdout.write(import_sisteransi2.cursor.move(-999, m2.length - 1)), process.stdout.write(import_sisteransi2.erase.down(m2.length));
+  }, R2 = (m2) => m2.replace(/\.+$/, ""), O2 = (m2) => {
+    const h2 = (performance.now() - m2) / 1e3, w2 = Math.floor(h2 / 60), I2 = Math.floor(h2 % 60);
+    return w2 > 0 ? `[${w2}m ${I2}s]` : `[${I2}s]`;
+  }, H = (m2 = "") => {
+    a = true, s = fD(), l2 = R2(m2), g2 = performance.now(), process.stdout.write(`${import_picocolors2.default.gray(o)}
+`);
+    let h2 = 0, w2 = 0;
+    j2(), c = setInterval(() => {
+      if (i && l2 === $2) return;
+      B2(), $2 = l2;
+      const I2 = import_picocolors2.default.magenta(n[h2]);
+      if (i) process.stdout.write(`${I2}  ${l2}...`);
+      else if (t === "timer") process.stdout.write(`${I2}  ${l2} ${O2(g2)}`);
+      else {
+        const z2 = ".".repeat(Math.floor(w2)).slice(0, 3);
+        process.stdout.write(`${I2}  ${l2}${z2}`);
+      }
+      h2 = h2 + 1 < n.length ? h2 + 1 : 0, w2 = w2 < n.length ? w2 + 0.125 : 0;
+    }, r2);
+  }, N2 = (m2 = "", h2 = 0) => {
+    a = false, clearInterval(c), B2();
+    const w2 = h2 === 0 ? import_picocolors2.default.green(C) : h2 === 1 ? import_picocolors2.default.red(L2) : import_picocolors2.default.red(W2);
+    l2 = R2(m2 ?? l2), t === "timer" ? process.stdout.write(`${w2}  ${l2} ${O2(g2)}
+`) : process.stdout.write(`${w2}  ${l2}
+`), E(), s();
+  };
+  return { start: H, stop: N2, message: (m2 = "") => {
+    l2 = R2(m2 ?? l2);
+  } };
+};
 
 // src/headless.ts
 function isHeadless() {
@@ -15263,8 +15332,8 @@ function providerRepositoryCoordinate(remote) {
   const coordinate = `${remote.namespace}/${remote.repository}`;
   return remote.host === "github.com" || remote.host === "bitbucket.org" ? coordinate : `${remote.host}/${coordinate}`;
 }
-function parseProviderOutput(remote, stdout2, query) {
-  const payload = JSON.parse(stdout2);
+function parseProviderOutput(remote, stdout3, query) {
+  const payload = JSON.parse(stdout3);
   const values = remote.forge === "bitbucket" && isRecord(payload) ? Array.isArray(payload.values) ? payload.values : [] : Array.isArray(payload) ? payload : [payload];
   return values.map((value) => normalizePullRequest(value, query)).filter((value) => value !== null).filter(
     (value) => query.kind === "branch" ? value.sourceBranch === query.sourceBranch : query.kind === "number" ? value.number === query.number : true
@@ -15416,6 +15485,18 @@ function isWideCodePoint(codePoint) {
 var MAX_PULL_REQUEST_REPOSITORY_QUERY_CONCURRENCY = 4;
 var MAX_TASK_READ_CONCURRENCY = 8;
 async function buildWorktreePromptEntries(sources, dependencies = {}) {
+  const loading = stdin.isTTY === true && stdout.isTTY === true ? Y2({ indicator: "timer" }) : null;
+  loading?.start("Loading worktrees");
+  try {
+    return await buildWorktreePromptEntriesWithoutLoading(
+      sources,
+      dependencies
+    );
+  } finally {
+    loading?.stop();
+  }
+}
+async function buildWorktreePromptEntriesWithoutLoading(sources, dependencies) {
   const metadataMode = dependencies.metadata ?? "full";
   const includeMetadata = metadataMode === "full";
   const pullRequestQuery = createPullRequestQuery();
@@ -16113,9 +16194,9 @@ function red(value) {
 function yellow(value) {
   return color("\x1B[33m", "\x1B[39m", value);
 }
-function color(open3, close, value) {
+function color(open4, close, value) {
   if (env4.NO_COLOR !== void 0) return value;
-  return `${open3}${value}${close}`;
+  return `${open4}${value}${close}`;
 }
 function supportsUnicode() {
   if (platform !== "win32") {
@@ -17581,8 +17662,8 @@ async function runConfigCommand(options) {
     `Invalid config arguments: ${[options.action, options.key, options.value].filter(Boolean).join(" ")}`
   );
 }
-function writeJson(stdout2, value) {
-  stdout2(`${JSON.stringify(value, null, 2)}
+function writeJson(stdout3, value) {
+  stdout3(`${JSON.stringify(value, null, 2)}
 `);
 }
 
@@ -18084,8 +18165,8 @@ function expandTilde2(path9, home) {
 }
 async function checkGitVersion() {
   try {
-    const { stdout: stdout2 } = await execFileAsync4("git", ["--version"]);
-    const version = parseGitVersion(stdout2);
+    const { stdout: stdout3 } = await execFileAsync4("git", ["--version"]);
+    const version = parseGitVersion(stdout3);
     if (!version) {
       return failedCheck(
         "git-version",
@@ -18604,7 +18685,7 @@ function toMessage3(error) {
 }
 
 // src/go.ts
-import { basename as basename9 } from "node:path";
+import { basename as basename10 } from "node:path";
 
 // src/context-card.ts
 async function renderContextCard(worktreePath) {
@@ -18632,7 +18713,7 @@ function formatLastCommit2(info) {
 
 // src/pr.ts
 import { execFile as execFile7 } from "node:child_process";
-import { mkdir as mkdir9 } from "node:fs/promises";
+import { mkdir as mkdir8 } from "node:fs/promises";
 import { dirname as dirname11 } from "node:path";
 import { promisify as promisify8 } from "node:util";
 
@@ -18653,7 +18734,6 @@ function formatBytes(bytes) {
 // src/bootstrap-output.ts
 function createBootstrapReporter(write, json, measureCloneSize = false) {
   return {
-    emitCachedFailureWarnings: !json,
     measureCloneSize: measureCloneSize && !json,
     write,
     cloned: (directory) => {
@@ -18682,248 +18762,22 @@ function formatDuration(ms) {
 
 // src/dependency-bootstrap.ts
 import { execFile as execFile6 } from "node:child_process";
-import { lstat as lstat4, readFile as readFile10, realpath as realpath3, rm as rm5 } from "node:fs/promises";
-import { join as join13, relative as relative2, resolve as resolve9, sep as sep2 } from "node:path";
-import { promisify as promisify7 } from "node:util";
-
-// src/clone-failure-store.ts
-import { randomUUID as randomUUID2 } from "node:crypto";
+import { constants as constants6 } from "node:fs";
+import { lstat as lstat4, open as open3, readdir as readdir2, readFile as readFile9, realpath as realpath3, rm as rm4 } from "node:fs/promises";
 import {
-  mkdir as mkdir6,
-  mkdtemp,
-  readdir,
-  readFile as readFile8,
-  rename as rename3,
-  rm as rm3,
-  rmdir,
-  stat as stat2,
-  unlink as unlink3,
-  utimes,
-  writeFile as writeFile8
-} from "node:fs/promises";
-import { homedir as homedir8 } from "node:os";
-import { dirname as dirname8, join as join10, resolve as resolve7 } from "node:path";
-var STATE_FILE_NAME = "state.json";
-var STATE_LOCK_SUFFIX = ".lock";
-var CLONE_FAILURE_TTL_MS = 24 * 60 * 60 * 1e3;
-var STATE_LOCK_TTL_MS = 30 * 1e3;
-var FileCloneFailureStore = class {
-  updateQueue = Promise.resolve();
-  async isCached(repoRoot, directory, scope) {
-    const state = await this.readState();
-    const repoState = state.syncDirs?.[repoRoot];
-    const key = failureKey(directory, scope);
-    if (!repoState || !Object.hasOwn(repoState, key)) return false;
-    const failure = repoState[key];
-    return isPlainObject2(failure) && typeof failure.failedAt === "number" && Date.now() - failure.failedAt < CLONE_FAILURE_TTL_MS;
-  }
-  async cache(repoRoot, directory, reason, scope) {
-    await this.update(async () => {
-      const state = await this.readState();
-      const syncDirs = state.syncDirs ?? {};
-      const repoState = syncDirs[repoRoot] ?? {};
-      const key = failureKey(directory, scope);
-      syncDirs[repoRoot] = {
-        ...repoState,
-        [key]: { failedAt: Date.now(), reason }
-      };
-      await this.writeState({ ...state, syncDirs });
-    });
-  }
-  async clear(repoRoot, directory, scope) {
-    await this.update(async () => {
-      const state = await this.readState();
-      const repoState = state.syncDirs?.[repoRoot];
-      const key = failureKey(directory, scope);
-      if (!repoState || !Object.hasOwn(repoState, key)) return;
-      const nextRepoState = { ...repoState };
-      delete nextRepoState[key];
-      const syncDirs = { ...state.syncDirs };
-      if (Object.keys(nextRepoState).length === 0) delete syncDirs[repoRoot];
-      else syncDirs[repoRoot] = nextRepoState;
-      await this.writeState({ ...state, syncDirs });
-    });
-  }
-  async update(operation) {
-    const next = this.updateQueue.then(
-      () => this.withStateLock(operation),
-      () => this.withStateLock(operation)
-    );
-    this.updateQueue = next.then(
-      () => void 0,
-      () => void 0
-    );
-    await next;
-  }
-  async withStateLock(operation) {
-    const lockPath = `${this.stateFilePath()}${STATE_LOCK_SUFFIX}`;
-    const lockToken = await acquireStateLock(lockPath);
-    if (lockToken === void 0) return;
-    const stopHeartbeat = startStateLockHeartbeat(lockPath, lockToken);
-    try {
-      await operation();
-    } finally {
-      stopHeartbeat();
-      await releaseStateLock(lockPath, lockToken);
-    }
-  }
-  async readState() {
-    try {
-      const raw = await readFile8(this.stateFilePath(), "utf8");
-      const parsed = JSON.parse(raw);
-      if (!isPlainObject2(parsed)) return {};
-      return isPlainObject2(parsed.syncDirs) ? parsed : { ...parsed, syncDirs: {} };
-    } catch {
-      return {};
-    }
-  }
-  async writeState(state) {
-    try {
-      const path9 = this.stateFilePath();
-      const directory = dirname8(path9);
-      await mkdir6(directory, { recursive: true });
-      const temporaryDirectory = await mkdtemp(
-        join10(directory, `.gji-state-${randomUUID2()}-`)
-      );
-      const temporaryPath = join10(temporaryDirectory, STATE_FILE_NAME);
-      try {
-        await writeFile8(
-          temporaryPath,
-          `${JSON.stringify(state, null, 2)}
-`,
-          "utf8"
-        );
-        await rename3(temporaryPath, path9);
-      } finally {
-        await rm3(temporaryDirectory, { force: true, recursive: true });
-      }
-    } catch {
-    }
-  }
-  stateFilePath(home = homedir8()) {
-    const configuredDirectory = process.env.GJI_CONFIG_DIR;
-    const directory = configuredDirectory ? resolve7(configuredDirectory) : join10(home, GLOBAL_CONFIG_DIRECTORY);
-    return join10(directory, STATE_FILE_NAME);
-  }
-};
-async function acquireStateLock(lockPath) {
-  const lockToken = randomUUID2();
-  await mkdir6(dirname8(lockPath), { recursive: true }).catch(() => void 0);
-  for (let attempt = 0; attempt < 200; attempt += 1) {
-    try {
-      await mkdir6(lockPath);
-    } catch (error) {
-      if (!isErrorCode(error, "EEXIST")) return void 0;
-      try {
-        const freshnessPath = await lockFreshnessPath(lockPath);
-        const lockStats = await stat2(freshnessPath);
-        if (Date.now() - lockStats.mtimeMs >= STATE_LOCK_TTL_MS) {
-          const stalePath = `${lockPath}.stale-${randomUUID2()}`;
-          try {
-            await rename3(lockPath, stalePath);
-          } catch (renameError) {
-            if (isErrorCode(renameError, "ENOENT")) continue;
-            return void 0;
-          }
-          await rm3(stalePath, { force: true, recursive: true });
-          continue;
-        }
-      } catch (lockError) {
-        if (!isErrorCode(lockError, "ENOENT")) return void 0;
-      }
-      await new Promise((resolve13) => setTimeout(resolve13, 25));
-      continue;
-    }
-    try {
-      await writeFile8(
-        join10(lockPath, ownerFileName(lockToken)),
-        `${lockToken}
-`,
-        {
-          flag: "wx"
-        }
-      );
-      return lockToken;
-    } catch {
-      await rm3(lockPath, { force: true, recursive: true }).catch(
-        () => void 0
-      );
-      return void 0;
-    }
-  }
-  return void 0;
-}
-async function lockFreshnessPath(lockPath) {
-  try {
-    const owner = (await readdir(lockPath)).find(
-      (entry) => entry.startsWith("owner-")
-    );
-    return owner ? join10(lockPath, owner) : lockPath;
-  } catch (error) {
-    if (isErrorCode(error, "ENOENT")) throw error;
-    return lockPath;
-  }
-}
-function startStateLockHeartbeat(lockPath, lockToken) {
-  const timer = setInterval(() => {
-    void refreshStateLock(lockPath, lockToken);
-  }, STATE_LOCK_TTL_MS / 3);
-  timer.unref?.();
-  return () => clearInterval(timer);
-}
-async function refreshStateLock(lockPath, lockToken) {
-  try {
-    const ownerPath = join10(lockPath, ownerFileName(lockToken));
-    await readFile8(ownerPath, "utf8");
-    const now = /* @__PURE__ */ new Date();
-    await utimes(ownerPath, now, now);
-  } catch {
-  }
-}
-async function releaseStateLock(lockPath, lockToken) {
-  try {
-    const ownerPath = join10(lockPath, ownerFileName(lockToken));
-    await unlink3(ownerPath);
-    await rmdir(lockPath);
-  } catch (error) {
-    if (!isErrorCode(error, "ENOENT") && !isErrorCode(error, "ENOTEMPTY")) {
-      return;
-    }
-  }
-}
-function ownerFileName(lockToken) {
-  return `owner-${lockToken}`;
-}
-var defaultCloneFailureStore = new FileCloneFailureStore();
-async function cloneFailureScope(source, destination) {
-  const sourcePath = resolve7(source);
-  const destinationParent = resolve7(dirname8(destination));
-  const [sourceDevice, destinationDevice] = await Promise.all([
-    readDevice(sourcePath),
-    readDevice(destinationParent)
-  ]);
-  return JSON.stringify([sourcePath, sourceDevice, destinationDevice]);
-}
-async function readDevice(path9) {
-  try {
-    return (await stat2(path9)).dev;
-  } catch {
-    return void 0;
-  }
-}
-function failureKey(directory, scope) {
-  return scope === void 0 ? directory : JSON.stringify([scope, directory]);
-}
-function isPlainObject2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isErrorCode(error, code) {
-  return error instanceof Error && "code" in error && error.code === code;
-}
+  basename as basename7,
+  dirname as dirname9,
+  isAbsolute as isAbsolute4,
+  join as join12,
+  relative as relative3,
+  resolve as resolve9,
+  sep as sep3
+} from "node:path";
+import { promisify as promisify7 } from "node:util";
 
 // src/command-runner.ts
 import { spawn as spawn4 } from "node:child_process";
-var runCommand = async (command, cwd, stderr, stdout2 = (chunk) => process.stdout.write(chunk), options) => {
+var runCommand = async (command, cwd, stderr, stdout3 = (chunk) => process.stdout.write(chunk), options) => {
   await new Promise((resolve13, reject) => {
     const shell = options?.shell ?? true;
     const [executable, args] = shell ? [command, []] : splitCommand(command);
@@ -18934,7 +18788,7 @@ var runCommand = async (command, cwd, stderr, stdout2 = (chunk) => process.stdou
       stdio: ["ignore", "pipe", "pipe"]
     });
     child.stdout.on("data", (chunk) => {
-      stdout2(chunk.toString());
+      stdout3(chunk.toString());
     });
     child.stderr.on("data", (chunk) => {
       stderr(chunk.toString());
@@ -18961,28 +18815,28 @@ function splitCommand(command) {
 
 // src/dir-clone.ts
 import { execFile as execFile5 } from "node:child_process";
-import { randomUUID as randomUUID3 } from "node:crypto";
+import { randomUUID as randomUUID2 } from "node:crypto";
 import { constants as constants5 } from "node:fs";
 import {
   chmod,
   cp,
   lstat as lstat3,
-  mkdir as mkdir8,
-  mkdtemp as mkdtemp2,
+  mkdir as mkdir7,
+  mkdtemp,
   opendir,
-  readdir as readdir2,
-  readFile as readFile9,
+  readdir,
+  readFile as readFile8,
   readlink,
   realpath as realpath2,
-  rename as rename4,
-  rm as rm4,
-  rmdir as rmdir2,
+  rename as rename3,
+  rm as rm3,
+  rmdir,
   symlink,
-  unlink as unlink4,
-  utimes as utimes2,
-  writeFile as writeFile9
+  unlink as unlink3,
+  utimes,
+  writeFile as writeFile8
 } from "node:fs/promises";
-import { basename as basename6, dirname as dirname9, join as join12 } from "node:path";
+import { basename as basename6, dirname as dirname8, join as join11, relative as relative2, resolve as resolve8, sep as sep2 } from "node:path";
 import { promisify as promisify6 } from "node:util";
 
 // src/fs-utils.ts
@@ -19011,20 +18865,30 @@ function hasErrorCode(error, code) {
 
 // src/safe-destination.ts
 import { constants as constants4 } from "node:fs";
-import { lstat as lstat2, mkdir as mkdir7, open as open2 } from "node:fs/promises";
-import { isAbsolute as isAbsolute3, join as join11, relative, resolve as resolve8, sep } from "node:path";
+import { lstat as lstat2, mkdir as mkdir6, open as open2 } from "node:fs/promises";
+import { isAbsolute as isAbsolute3, join as join10, relative, resolve as resolve7, sep } from "node:path";
 async function openDestinationDirectory(root, path9) {
   const segments = destinationSegments(root, path9);
+  if (process.platform === "darwin") {
+    await ensureDestinationDirectory(root, path9);
+    const handle2 = await open2(path9, destinationDirectoryFlags());
+    return {
+      path: resolve7(path9),
+      close: async () => handle2.close()
+    };
+  }
   if (process.platform !== "linux") {
     await ensureDestinationDirectory(root, path9);
-    return { path: resolve8(path9), close: async () => void 0 };
+    const handle2 = await open2(path9, destinationDirectoryFlags());
+    await handle2.close();
+    return { path: resolve7(path9), close: async () => void 0 };
   }
   let handle = await open2(root, destinationDirectoryFlags());
   try {
     for (const segment of segments) {
-      const childPath = join11(fileDescriptorPath(handle.fd), segment);
+      const childPath = join10(fileDescriptorPath(handle.fd), segment);
       try {
-        await mkdir7(childPath);
+        await mkdir6(childPath);
       } catch (error) {
         if (!isAlreadyExistsError(error)) throw error;
       }
@@ -19042,8 +18906,8 @@ async function openDestinationDirectory(root, path9) {
   }
 }
 async function inspectDestination(root, path9) {
-  const resolvedPath = resolve8(path9);
-  const resolvedRoot = resolve8(root);
+  const resolvedPath = resolve7(path9);
+  const resolvedRoot = resolve7(root);
   const distance = relative(resolvedRoot, resolvedPath);
   if (isAbsolute3(distance) || distance === ".." || distance.startsWith(`..${sep}`)) {
     return { kind: "unsafe", reason: "destination escapes the worktree" };
@@ -19060,7 +18924,7 @@ async function inspectDestination(root, path9) {
   }
   const segments = distance.split(sep).filter(Boolean);
   for (const [index, segment] of segments.entries()) {
-    current = resolve8(current, segment);
+    current = resolve7(current, segment);
     try {
       const stats = await lstat2(current);
       if (stats.isSymbolicLink()) {
@@ -19101,8 +18965,8 @@ async function inspectDestination(root, path9) {
   }
 }
 function destinationSegments(root, path9) {
-  const resolvedRoot = resolve8(root);
-  const resolvedPath = resolve8(path9);
+  const resolvedRoot = resolve7(root);
+  const resolvedPath = resolve7(path9);
   const distance = relative(resolvedRoot, resolvedPath);
   if (isAbsolute3(distance) || distance === ".." || distance.startsWith(`..${sep}`)) {
     throw new Error("destination escapes the worktree");
@@ -19120,8 +18984,8 @@ function fileDescriptorPath(fd) {
   );
 }
 async function ensureDestinationDirectory(root, path9) {
-  const resolvedRoot = resolve8(root);
-  const resolvedPath = resolve8(path9);
+  const resolvedRoot = resolve7(root);
+  const resolvedPath = resolve7(path9);
   const distance = relative(resolvedRoot, resolvedPath);
   if (isAbsolute3(distance) || distance === ".." || distance.startsWith(`..${sep}`)) {
     throw new Error("destination escapes the worktree");
@@ -19132,7 +18996,7 @@ async function ensureDestinationDirectory(root, path9) {
     throw new Error("worktree root is not a directory");
   }
   for (const segment of distance.split(sep).filter(Boolean)) {
-    current = resolve8(current, segment);
+    current = resolve7(current, segment);
     try {
       const stats = await lstat2(current);
       if (stats.isSymbolicLink() || !stats.isDirectory()) {
@@ -19141,7 +19005,7 @@ async function ensureDestinationDirectory(root, path9) {
     } catch (error) {
       if (!isNotFoundError(error)) throw error;
       try {
-        await mkdir7(current);
+        await mkdir6(current);
       } catch (mkdirError) {
         if (!isAlreadyExistsError(mkdirError)) throw mkdirError;
       }
@@ -19155,13 +19019,13 @@ async function ensureDestinationDirectory(root, path9) {
 
 // src/dir-clone.ts
 var execFileAsync5 = promisify6(execFile5);
-var CLONE_LOCK_TTL_MS = 24 * 60 * 60 * 1e3;
+var CLONE_LOCK_TTL_MS = 5 * 60 * 1e3;
+var CLONE_GUARD_TTL_MS = 30 * 1e3;
 var CLONE_LOCK_SUFFIX = ".gji-clone-lock";
 var SIZE_ESTIMATE_MAX_ENTRIES = 1e6;
 var SIZE_ESTIMATE_MAX_MS = 5e3;
 async function cloneDir(source, destination, options = {}) {
   const platform3 = options.platform ?? process.platform;
-  const strategy = cloneStrategy(platform3);
   if (!isClonePlatformSupported(platform3)) {
     throw new CloneUnsupportedError(`platform ${platform3} has no CoW strategy`);
   }
@@ -19170,11 +19034,13 @@ async function cloneDir(source, destination, options = {}) {
   if (!sourceStats.isDirectory()) {
     throw new Error("source is not a directory");
   }
-  if (await destinationExists(destination)) {
-    throw new CloneDestinationExistsError(destination);
+  const destinationPath = await resolveProspectivePath(destination);
+  const destinationDistance = relative2(sourcePath, destinationPath);
+  if (destinationDistance === "" || destinationDistance !== ".." && !destinationDistance.startsWith(`..${sep2}`)) {
+    throw new Error("clone destination must not be inside its source");
   }
   const startedAt = Date.now();
-  const parent = dirname9(destination);
+  const parent = dirname8(destination);
   let safeParent;
   try {
     if (options.destinationRoot) {
@@ -19190,37 +19056,36 @@ async function cloneDir(source, destination, options = {}) {
         parent
       );
     } else {
-      await mkdir8(parent, { recursive: true });
+      await mkdir7(parent, { recursive: true });
     }
     const operationParent = safeParent?.path ?? parent;
-    const operationDestination = join12(operationParent, basename6(destination));
-    if (await destinationExists(operationDestination)) {
-      throw new CloneDestinationExistsError(destination);
-    }
-    const lockPath = `${destination}${CLONE_LOCK_SUFFIX}`;
-    const lockToken = await acquireCloneLock(lockPath, destination);
-    const stopLockHeartbeat = startLockHeartbeat(lockPath, lockToken);
+    const operationDestination = join11(operationParent, basename6(destination));
+    const cloneLock = await acquireCloneLock(
+      `${operationDestination}${CLONE_LOCK_SUFFIX}`,
+      destination
+    );
+    const stopLockHeartbeat = startLockHeartbeat(cloneLock);
     let temporaryRoot;
-    let reservationPath;
-    const reservationEntries = [];
+    let reservation;
+    const publishedEntries = [];
     try {
-      reservationPath = await reserveDestination(operationDestination);
-      temporaryRoot = await mkdtemp2(
-        join12(operationParent, `.${basename6(destination)}.gji-clone-`)
+      if (await destinationExists(operationDestination)) {
+        throw new CloneDestinationExistsError(destination);
+      }
+      reservation = await reserveDestination(operationDestination);
+      temporaryRoot = await mkdtemp(
+        join11(operationParent, `.${basename6(destination)}.gji-clone-`)
       );
-      const temporaryDestination = join12(temporaryRoot, basename6(destination));
-      const copyDirectory = options.copyDirectory ?? (platformIsDarwin(platform3) ? runNativeCloneDirectory : async (source2, target) => {
-        if (!strategy) {
-          throw new CloneUnsupportedError(
-            `platform ${platform3} has no CoW strategy`
-          );
-        }
-        const runCommand2 = options.runCommand ?? runCloneCommand;
-        await runCommand2("cp", strategy(source2, target));
-      });
+      const temporaryDestination = join11(temporaryRoot, basename6(destination));
       try {
-        await copyDirectory(sourcePath, temporaryDestination);
+        await (options.copyDirectory ?? ((sourcePath2, targetPath) => copyDirectoryWithCow(
+          sourcePath2,
+          targetPath,
+          platform3,
+          options.runLinuxCommand
+        )))(sourcePath, temporaryDestination);
       } catch (error) {
+        if (error instanceof CloneUnsupportedError) throw error;
         if (isUnsupportedCloneError(error)) {
           throw new CloneUnsupportedError(toErrorMessage(error));
         }
@@ -19229,45 +19094,70 @@ async function cloneDir(source, destination, options = {}) {
       await publishCloneContents(
         temporaryDestination,
         operationDestination,
-        reservationPath,
-        (entry) => reservationEntries.push(entry),
+        reservation.path,
+        (entry) => publishedEntries.push(entry),
         options.copyFile ?? runForcedCloneFileCopy
       );
-      reservationPath = void 0;
+      reservation = void 0;
     } finally {
       stopLockHeartbeat();
-      if (reservationPath) {
+      if (reservation) {
         await cleanupReservedDestination(
           operationDestination,
-          reservationPath,
-          reservationEntries
+          reservation,
+          publishedEntries
         );
       }
-      try {
-        if (temporaryRoot) {
-          await rm4(temporaryRoot, { force: true, recursive: true });
-        }
-      } catch {
-      }
-      try {
-        await releaseCloneLock(lockPath, lockToken);
-      } catch {
+      if (temporaryRoot) {
+        await rm3(temporaryRoot, { force: true, recursive: true }).catch(
+          () => void 0
+        );
       }
+      await releaseCloneLock(cloneLock).catch(() => void 0);
     }
-    const bytes = options.measureBytes === false ? void 0 : await estimateCloneBytes(sourcePath);
-    return { bytes, ms: Date.now() - startedAt };
+    return cloneResult(sourcePath, startedAt, options.measureBytes);
   } finally {
     await safeParent?.close().catch(() => void 0);
   }
 }
-async function runNativeCloneDirectory(source, destination) {
-  await cp(source, destination, {
-    errorOnExist: true,
-    force: false,
-    mode: constants5.COPYFILE_FICLONE_FORCE,
-    preserveTimestamps: true,
-    recursive: true
-  });
+async function copyDirectoryWithCow(source, destination, platform3, runLinuxCommand) {
+  if (platform3 === "darwin") {
+    await cp(source, destination, {
+      errorOnExist: true,
+      force: false,
+      mode: constants5.COPYFILE_FICLONE_FORCE,
+      preserveTimestamps: true,
+      recursive: true
+    });
+    return;
+  }
+  const strategy = cloneStrategy(platform3);
+  if (!strategy) {
+    throw new CloneUnsupportedError(`platform ${platform3} has no CoW strategy`);
+  }
+  await (runLinuxCommand ?? runCloneCommand)(
+    "cp",
+    strategy(source, destination)
+  );
+}
+async function resolveProspectivePath(path9) {
+  let current = resolve8(path9);
+  const missing = [];
+  while (true) {
+    try {
+      return join11(await realpath2(current), ...missing);
+    } catch (error) {
+      if (!isNotFoundError(error)) throw error;
+      const parent = dirname8(current);
+      if (parent === current) throw error;
+      missing.unshift(basename6(current));
+      current = parent;
+    }
+  }
+}
+async function cloneResult(source, startedAt, measureBytes) {
+  const bytes = measureBytes === false ? void 0 : await estimateCloneBytes(source);
+  return { bytes, ms: Date.now() - startedAt };
 }
 var CloneDestinationExistsError = class extends Error {
   code = "GJI_CLONE_DESTINATION_EXISTS";
@@ -19293,9 +19183,6 @@ var CloneInProgressError = class extends Error {
 function isCloneDestinationExistsError(error) {
   return error instanceof CloneDestinationExistsError;
 }
-function isCloneUnsupportedError(error) {
-  return error instanceof CloneUnsupportedError || isUnsupportedCloneError(error);
-}
 function isCloneInProgressError(error) {
   return error instanceof CloneInProgressError;
 }
@@ -19316,7 +19203,7 @@ async function directorySize(path9) {
         if (entryCount > SIZE_ESTIMATE_MAX_ENTRIES || Date.now() - startedAt > SIZE_ESTIMATE_MAX_MS) {
           throw new Error("directory size estimate exceeded its safety limit");
         }
-        const entryPath = join12(current, entry.name);
+        const entryPath = join11(current, entry.name);
         if (entry.isDirectory()) pending.push(entryPath);
         else total += (await lstat3(entryPath)).size;
       }
@@ -19358,119 +19245,231 @@ async function runCloneCommand(command, args) {
   }
 }
 async function acquireCloneLock(lockPath, destination) {
-  const lockToken = randomUUID3();
+  const releaseGuard = await acquireCloneLockGuard(lockPath, destination);
+  try {
+    return await acquireCloneLockWithGuard(lockPath, destination);
+  } finally {
+    await releaseGuard();
+  }
+}
+async function acquireCloneLockWithGuard(lockPath, destination) {
+  const lockToken = randomUUID2();
   for (let attempt = 0; attempt < 3; attempt += 1) {
+    const published = await publishCloneLock(lockPath, lockToken);
+    if (published) return published;
+    let staleLock;
     try {
-      await mkdir8(lockPath);
-      try {
-        await writeFile9(
-          join12(lockPath, ownerFileName2(lockToken)),
-          `${lockToken}
-`,
-          {
-            flag: "wx"
-          }
-        );
-      } catch (error) {
-        await rm4(lockPath, { force: true, recursive: true });
-        throw error;
-      }
-      return lockToken;
-    } catch (error) {
-      if (!isAlreadyExistsError(error)) throw error;
-    }
-    let lockStats;
-    try {
-      lockStats = await lstat3(await lockFreshnessPath2(lockPath));
+      staleLock = await inspectCloneLock(lockPath);
     } catch (error) {
       if (isNotFoundError(error)) continue;
       throw error;
     }
-    if (Date.now() - lockStats.mtimeMs < CLONE_LOCK_TTL_MS) {
+    if (staleLock.kind === "invalid" || Date.now() - staleLock.mtimeMs < CLONE_LOCK_TTL_MS) {
       throw new CloneInProgressError(destination);
     }
-    const stalePath = `${lockPath}.stale-${randomUUID3()}`;
+    const stalePath = `${lockPath}.stale-${randomUUID2()}`;
     try {
-      await rename4(lockPath, stalePath);
+      await rename3(lockPath, stalePath);
     } catch (error) {
       if (isNotFoundError(error)) continue;
       throw error;
     }
     try {
-      await mkdir8(lockPath);
-      try {
-        await writeFile9(
-          join12(lockPath, ownerFileName2(lockToken)),
-          `${lockToken}
-`,
-          {
-            flag: "wx"
-          }
-        );
-      } catch (error) {
-        await rm4(lockPath, { force: true, recursive: true });
-        throw error;
+      const replacement = await publishCloneLock(lockPath, lockToken);
+      if (!replacement) {
+        await cleanupStaleCloneLock(stalePath, staleLock);
+        continue;
       }
       try {
-        await rm4(stalePath, { force: true, recursive: true });
+        await cleanupStaleCloneLock(stalePath, staleLock);
       } catch (cleanupError) {
-        await releaseCloneLock(lockPath, lockToken).catch(() => void 0);
+        await releaseCloneLockWithGuard(replacement).catch(() => void 0);
         throw cleanupError;
       }
-      return lockToken;
+      return replacement;
     } catch (error) {
-      await rm4(stalePath, { force: true, recursive: true }).catch(
-        () => void 0
-      );
+      await cleanupStaleCloneLock(stalePath, staleLock).catch(() => void 0);
       if (isAlreadyExistsError(error)) continue;
       throw error;
     }
   }
   throw new CloneInProgressError(destination);
 }
-async function lockFreshnessPath2(lockPath) {
+async function acquireCloneLockGuard(lockPath, destination) {
+  const guardPath = `${lockPath}.guard`;
+  const deadline = Date.now() + 5e3;
+  while (true) {
+    try {
+      await mkdir7(guardPath, { mode: 448 });
+      const markerName = `${process.pid}-${randomUUID2()}`;
+      const markerPath = join11(guardPath, markerName);
+      try {
+        await writeFile8(markerPath, `${markerName}
+`, {
+          flag: "wx",
+          mode: 384
+        });
+      } catch (error) {
+        await rmdir(guardPath).catch(() => void 0);
+        throw error;
+      }
+      return async () => {
+        await unlink3(markerPath).catch((error) => {
+          if (!isNotFoundError(error)) throw error;
+        });
+        await rmdir(guardPath).catch((error) => {
+          if (!isNotFoundError(error)) throw error;
+        });
+      };
+    } catch (error) {
+      if (!isAlreadyExistsError(error)) throw error;
+      if (await reclaimAbandonedCloneGuard(guardPath)) continue;
+      if (Date.now() >= deadline) {
+        throw new CloneInProgressError(destination);
+      }
+      await new Promise((resolve13) => setTimeout(resolve13, 10));
+    }
+  }
+}
+async function reclaimAbandonedCloneGuard(guardPath) {
+  let expectedMarker;
   try {
-    const entries = await readdir2(lockPath);
-    const owner = entries.find((entry) => entry.startsWith("owner-"));
-    return owner ? join12(lockPath, owner) : lockPath;
+    const entries = await readdir(guardPath);
+    if (entries.length > 1) return false;
+    expectedMarker = entries[0];
+    const freshnessPath = expectedMarker ? join11(guardPath, expectedMarker) : guardPath;
+    const stats = await lstat3(freshnessPath);
+    if (Date.now() - stats.mtimeMs < CLONE_GUARD_TTL_MS) return false;
+    if (expectedMarker) {
+      const ownerPid = Number(expectedMarker.split("-", 1)[0]);
+      if (!Number.isSafeInteger(ownerPid) || ownerPid <= 0) return false;
+      if (processIsAlive(ownerPid)) return false;
+    }
+  } catch (error) {
+    return isNotFoundError(error);
+  }
+  const stalePath = `${guardPath}.stale-${randomUUID2()}`;
+  try {
+    await rename3(guardPath, stalePath);
+  } catch (error) {
+    if (isNotFoundError(error)) return true;
+    throw error;
+  }
+  const movedEntries = await readdir(stalePath).catch(() => []);
+  if (movedEntries.length !== (expectedMarker ? 1 : 0) || expectedMarker && movedEntries[0] !== expectedMarker) {
+    await rename3(stalePath, guardPath).catch(() => void 0);
+    return false;
+  }
+  if (expectedMarker) await unlink3(join11(stalePath, expectedMarker));
+  await rmdir(stalePath);
+  return true;
+}
+function processIsAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+async function publishCloneLock(lockPath, lockToken) {
+  try {
+    await mkdir7(lockPath, { mode: 448 });
+  } catch (error) {
+    if (isAlreadyExistsError(error)) return void 0;
+    throw error;
+  }
+  const markerPath = join11(lockPath, lockToken);
+  try {
+    await writeFile8(markerPath, `${lockToken}
+`, { flag: "wx", mode: 384 });
+    return {
+      lockPath,
+      markerName: lockToken,
+      markerPath,
+      token: lockToken
+    };
+  } catch (error) {
+    await rmdir(lockPath).catch(() => void 0);
+    throw error;
+  }
+}
+async function inspectCloneLock(lockPath) {
+  try {
+    const stats = await lstat3(lockPath);
+    if (!stats.isDirectory() || stats.isSymbolicLink()) {
+      return { kind: "invalid", mtimeMs: stats.mtimeMs };
+    }
+    const entries = await readdir(lockPath);
+    if (entries.length === 0) return { kind: "empty", mtimeMs: stats.mtimeMs };
+    if (entries.length !== 1) {
+      return { kind: "invalid", mtimeMs: stats.mtimeMs };
+    }
+    const markerName = entries[0];
+    const token = markerName?.startsWith("owner-") ? markerName.slice("owner-".length) : markerName;
+    if (!token || !/^[\da-f]{8}(?:-[\da-f]{4}){3}-[\da-f]{12}$/iu.test(token)) {
+      return { kind: "invalid", mtimeMs: stats.mtimeMs };
+    }
+    const markerPath = join11(lockPath, markerName);
+    const markerStats = await lstat3(markerPath);
+    if (!markerStats.isFile() || markerStats.isSymbolicLink()) {
+      return { kind: "invalid", mtimeMs: markerStats.mtimeMs };
+    }
+    if ((await readFile8(markerPath, "utf8")).trim() !== token) {
+      return { kind: "invalid", mtimeMs: markerStats.mtimeMs };
+    }
+    return {
+      kind: "owned",
+      lockPath,
+      markerName,
+      markerPath,
+      mtimeMs: markerStats.mtimeMs,
+      token
+    };
   } catch (error) {
     if (isNotFoundError(error)) throw error;
-    return lockPath;
+    return { kind: "invalid", mtimeMs: Date.now() };
+  }
+}
+async function cleanupStaleCloneLock(lockPath, inspection) {
+  if (inspection.kind === "owned") {
+    await unlink3(join11(lockPath, inspection.markerName));
   }
+  await rmdir(lockPath);
 }
 async function publishCloneContents(temporaryDestination, destination, reservationPath, onEntryPublished, copyFileEntry) {
   const reservationName = basename6(reservationPath);
-  const destinationEntries = await readdir2(destination);
+  const destinationEntries = await readdir(destination);
   if (destinationEntries.length !== 1 || destinationEntries[0] !== reservationName) {
     throw new CloneDestinationExistsError(destination);
   }
-  const temporaryEntries = await readdir2(temporaryDestination);
+  const temporaryEntries = await readdir(temporaryDestination);
   for (const entry of temporaryEntries) {
     await publishCloneEntry(
-      join12(temporaryDestination, entry),
-      join12(destination, entry),
-      () => onEntryPublished(entry),
+      join11(temporaryDestination, entry),
+      join11(destination, entry),
+      (entry2) => onEntryPublished(entry2),
       copyFileEntry
     );
   }
-  await unlink4(reservationPath);
+  await unlink3(reservationPath);
 }
 async function publishCloneEntry(source, destination, onCreated, copyFileEntry) {
   const sourceStats = await lstat3(source);
   if (sourceStats.isDirectory()) {
     try {
-      await mkdir8(destination);
+      await mkdir7(destination);
     } catch (error) {
       if (isAlreadyExistsError(error)) {
         throw new CloneDestinationExistsError(destination);
       }
       throw error;
     }
-    onCreated();
-    for (const entry of await readdir2(source)) {
+    onCreated(await inspectOwnedCloneEntry(destination, "directory"));
+    for (const entry of await readdir(source)) {
       await publishCloneEntry(
-        join12(source, entry),
-        join12(destination, entry),
+        join11(source, entry),
+        join11(destination, entry),
         () => void 0,
         copyFileEntry
       );
@@ -19487,7 +19486,7 @@ async function publishCloneEntry(source, destination, onCreated, copyFileEntry)
       }
       throw error;
     }
-    onCreated();
+    onCreated(await inspectOwnedCloneEntry(destination, "symlink"));
     return;
   }
   if (!sourceStats.isFile()) {
@@ -19504,7 +19503,7 @@ async function publishCloneEntry(source, destination, onCreated, copyFileEntry)
     }
     throw error;
   }
-  onCreated();
+  onCreated(await inspectOwnedCloneEntry(destination, "file"));
   await copyCloneMetadata(sourceStats, destination);
 }
 async function runForcedCloneFileCopy(source, destination) {
@@ -19517,41 +19516,47 @@ async function runForcedCloneFileCopy(source, destination) {
 }
 async function copyCloneMetadata(sourceStats, destination) {
   await chmod(destination, Number(sourceStats.mode) & 4095);
-  await utimes2(destination, sourceStats.atime, sourceStats.mtime);
+  await utimes(destination, sourceStats.atime, sourceStats.mtime);
 }
 async function reserveDestination(destination) {
   try {
-    await mkdir8(destination);
+    await mkdir7(destination);
   } catch (error) {
     if (isAlreadyExistsError(error)) {
       throw new CloneDestinationExistsError(destination);
     }
     throw error;
   }
-  const reservationPath = join12(
+  const reservationPath = join11(
     destination,
-    `.gji-clone-reservation-${randomUUID3()}`
+    `.gji-clone-reservation-${randomUUID2()}`
   );
   try {
-    await writeFile9(reservationPath, "gji clone reservation\n", {
+    await writeFile8(reservationPath, "gji clone reservation\n", {
       flag: "wx"
     });
-    return reservationPath;
+    return await inspectOwnedCloneEntry(reservationPath, "file");
   } catch (error) {
-    await rmdir2(destination).catch(() => void 0);
+    await rmdir(destination).catch(() => void 0);
     throw error;
   }
 }
-async function cleanupReservedDestination(destination, reservationPath, reservationEntries) {
+async function cleanupReservedDestination(destination, reservation, publishedEntries) {
+  for (const entry of [...publishedEntries, reservation].reverse()) {
+    await removeOwnedCloneEntry(entry);
+  }
+  await rmdir(destination).catch(() => void 0);
+}
+async function inspectOwnedCloneEntry(path9, kind) {
+  const stats = await lstat3(path9, { bigint: true });
+  return { dev: stats.dev, ino: stats.ino, kind, path: path9 };
+}
+async function removeOwnedCloneEntry(entry) {
   try {
-    const entries = await readdir2(destination);
-    const ownedEntries = /* @__PURE__ */ new Set([
-      basename6(reservationPath),
-      ...reservationEntries
-    ]);
-    if (entries.every((entry) => ownedEntries.has(entry))) {
-      await rm4(destination, { force: true, recursive: true });
-    }
+    const current = await lstat3(entry.path, { bigint: true });
+    if (current.dev !== entry.dev || current.ino !== entry.ino) return;
+    if (entry.kind === "directory") await rmdir(entry.path);
+    else await unlink3(entry.path);
   } catch {
   }
 }
@@ -19564,57 +19569,65 @@ async function destinationExists(path9) {
     throw error;
   }
 }
-function startLockHeartbeat(lockPath, lockToken) {
+function startLockHeartbeat(lock) {
   const timer = setInterval(() => {
-    void refreshCloneLock(lockPath, lockToken);
+    void refreshCloneLock(lock);
   }, CLONE_LOCK_TTL_MS / 3);
   timer.unref?.();
   return () => clearInterval(timer);
 }
-async function refreshCloneLock(lockPath, lockToken) {
+async function refreshCloneLock(lock) {
   try {
-    const ownerPath = join12(lockPath, ownerFileName2(lockToken));
-    await readFile9(ownerPath, "utf8");
     const now = /* @__PURE__ */ new Date();
-    await utimes2(ownerPath, now, now);
+    await utimes(lock.markerPath, now, now);
   } catch {
   }
 }
-async function releaseCloneLock(lockPath, lockToken) {
+async function releaseCloneLock(lock) {
+  const releaseGuard = await acquireCloneLockGuard(
+    lock.lockPath,
+    lock.lockPath
+  );
+  try {
+    await releaseCloneLockWithGuard(lock);
+  } finally {
+    await releaseGuard();
+  }
+}
+async function releaseCloneLockWithGuard(lock) {
+  try {
+    await unlink3(join11(lock.lockPath, lock.token));
+  } catch (error) {
+    if (!isNotFoundError(error)) throw error;
+  }
   try {
-    const ownerPath = join12(lockPath, ownerFileName2(lockToken));
-    await unlink4(ownerPath);
-    await rmdir2(lockPath);
+    await rmdir(lock.lockPath);
   } catch (error) {
-    if (!isNotFoundError(error) && !isDirectoryNotEmptyError(error))
+    const code = "code" in error ? error.code : void 0;
+    if (!isNotFoundError(error) && code !== "ENOTEMPTY" && code !== "EEXIST") {
       throw error;
+    }
   }
 }
-function ownerFileName2(lockToken) {
-  return `owner-${lockToken}`;
-}
 function isUnsupportedCloneError(error) {
   if (!(error instanceof Error)) return false;
   const code = "code" in error ? error.code : "";
   if (["EINVAL", "ENOSYS", "ENOTSUP", "EOPNOTSUPP", "EXDEV"].includes(code ?? "")) {
     return true;
   }
-  return /clonefile|reflink|unsupported|operation not supported|not supported|invalid cross-device|cross-device/iu.test(
+  return /reflink|unsupported|operation not supported|not supported|invalid cross-device|cross-device/iu.test(
     error.message
   );
 }
-function isDirectoryNotEmptyError(error) {
-  return error instanceof Error && "code" in error && error.code === "ENOTEMPTY";
-}
 function toErrorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
-function platformIsDarwin(platform3) {
-  return platform3 === "darwin";
-}
 
 // src/dependency-bootstrap.ts
 var execFileAsync6 = promisify7(execFile6);
+var UV_VALIDATION_MAX_ENTRIES = 1e4;
+var UV_VALIDATION_MAX_FILE_BYTES = 1024 * 1024;
+var UV_VALIDATION_MAX_TOTAL_BYTES = 16 * 1024 * 1024;
 async function prepareDependencyBootstrap(mode, context) {
   if (mode === "off") return { mode, targets: [] };
   const adapters = createBootstrapAdapters(
@@ -19634,7 +19647,7 @@ async function prepareDependencyBootstrap(mode, context) {
   const plannedRelativePaths = /* @__PURE__ */ new Set();
   for (const adapter of adapters) {
     if (plannedRelativePaths.has(adapter.relativePath)) continue;
-    let fallback;
+    let firstDetected;
     let selected;
     for (const sourceRoot of sourceRoots) {
       const target = await adapter.detect({
@@ -19644,14 +19657,14 @@ async function prepareDependencyBootstrap(mode, context) {
       });
       if (!target) continue;
       const seedable = mode !== "install-only" && await adapter.canSeed(target);
-      const candidate = { adapter, target, seedable };
-      fallback ??= candidate;
+      const candidate = { target, seedable };
+      firstDetected ??= candidate;
       if (mode === "install-only" || seedable) {
         selected = candidate;
         break;
       }
     }
-    const plannedTarget = selected ?? fallback;
+    const plannedTarget = selected ?? firstDetected;
     if (plannedTarget) {
       targets.push(plannedTarget);
       plannedRelativePaths.add(adapter.relativePath);
@@ -19664,9 +19677,9 @@ async function detectDependencyBootstrapCandidate(context) {
   const planned = plan.targets[0];
   if (!planned) return null;
   return {
-    adapter: planned.adapter.name,
-    kind: planned.adapter.kind,
-    lockfile: planned.adapter.lockfile,
+    adapter: planned.target.adapter,
+    kind: planned.target.kind,
+    lockfile: adapterForTarget(planned.target).lockfile,
     target: planned.target.relativePath,
     repairCommand: planned.target.repairCommand,
     seedable: planned.seedable
@@ -19675,10 +19688,10 @@ async function detectDependencyBootstrapCandidate(context) {
 function previewDependencyBootstrap(plan) {
   return {
     mode: plan.mode,
-    targets: plan.targets.map(({ adapter, target, seedable }) => ({
-      adapter: adapter.output(target).adapter,
-      kind: adapter.kind,
-      target: adapter.output(target).target,
+    targets: plan.targets.map(({ target, seedable }) => ({
+      adapter: target.adapter,
+      kind: target.kind,
+      target: target.relativePath,
       repairCommand: target.repairCommand,
       seedable,
       strategy: bootstrapStrategy(plan.mode, target, seedable)
@@ -19688,7 +19701,6 @@ function previewDependencyBootstrap(plan) {
 async function executeDependencyBootstrap(plan, options) {
   if (plan.mode === "off") return { mode: plan.mode, ready: true, events: [] };
   const events = [];
-  const failureStore = options.failureStore ?? defaultCloneFailureStore;
   const cloneDirectory = options.cloneDirectory ?? cloneDir;
   const execution = {
     runCommand: options.runCommand ?? runCommand,
@@ -19707,19 +19719,18 @@ async function executeDependencyBootstrap(plan, options) {
     });
     return { mode: plan.mode, ready: true, events };
   }
-  for (const { adapter, target, seedable } of plan.targets) {
+  for (const { target, seedable } of plan.targets) {
+    const adapter = adapterForTarget(target);
     await executeBootstrapTarget(
       adapter,
       target,
       seedable,
       plan.mode,
       cloneDirectory,
-      failureStore,
       execution,
       seededDirectories.has(target.relativePath),
       events,
-      options.reporter,
-      options.repoRoot
+      options.reporter
     );
   }
   return {
@@ -19728,7 +19739,7 @@ async function executeDependencyBootstrap(plan, options) {
     events
   };
 }
-async function executeBootstrapTarget(adapter, target, seedable, mode, cloneDirectory, failureStore, execution, seededBySyncDirs, events, reporter, repoRoot) {
+async function executeBootstrapTarget(adapter, target, seedable, mode, cloneDirectory, execution, seededBySyncDirs, events, reporter) {
   const destinationInspection = await inspectDestination(
     target.worktreePath,
     target.targetPath
@@ -19749,18 +19760,15 @@ async function executeBootstrapTarget(adapter, target, seedable, mode, cloneDire
       adapter,
       target,
       execution,
-      false,
-      target.existingBeforeBootstrap ? "preserve" : "empty",
+      destinationInspection.kind === "exists" ? "preserve" : "clean",
       events,
       reporter
     );
     return;
   }
-  let seeded = false;
-  const failureScope = seedable ? await cloneFailureScope(adapter.seedPath(target), target.targetPath) : void 0;
-  let ownership = target.existingBeforeBootstrap ? "preserve" : "empty";
+  let input = destinationInspection.kind === "exists" ? "preserve" : "clean";
   const destinationExistsNow = destinationInspection.kind === "exists";
-  if (target.existingBeforeBootstrap) {
+  if (target.initialInput === "preserve" && destinationExistsNow) {
     recordBootstrapEvent(events, reporter, {
       adapter: adapter.name,
       kind: adapter.kind,
@@ -19771,8 +19779,7 @@ async function executeBootstrapTarget(adapter, target, seedable, mode, cloneDire
     });
   } else if (seededBySyncDirs && destinationExistsNow) {
     if (seedable) {
-      seeded = true;
-      ownership = "syncDirs";
+      input = "seed";
       recordBootstrapEvent(events, reporter, {
         adapter: adapter.name,
         kind: adapter.kind,
@@ -19782,18 +19789,18 @@ async function executeBootstrapTarget(adapter, target, seedable, mode, cloneDire
         message: "reusing a seed created by syncDirs"
       });
     } else {
-      ownership = "preserve";
+      input = "preserve";
       recordBootstrapEvent(events, reporter, {
         adapter: adapter.name,
         kind: adapter.kind,
         reason: "generic-seed",
-        state: "fallback",
+        state: "repair-only",
         target: target.relativePath,
         message: "syncDirs created a generic target; this adapter uses repair without CoW"
       });
     }
   } else if (destinationExistsNow) {
-    ownership = "preserve";
+    input = "preserve";
     recordBootstrapEvent(events, reporter, {
       adapter: adapter.name,
       kind: adapter.kind,
@@ -19802,24 +19809,13 @@ async function executeBootstrapTarget(adapter, target, seedable, mode, cloneDire
       target: target.relativePath,
       message: "target appeared during bootstrap; preserving it as the repair input"
     });
-  } else if (seedable && await failureStore.isCached(repoRoot, target.relativePath, failureScope)) {
-    recordBootstrapEvent(events, reporter, {
-      adapter: adapter.name,
-      kind: adapter.kind,
-      reason: "cow-failure-cached",
-      state: "fallback",
-      target: target.relativePath,
-      message: "previous CoW failure is cached; repairing from an empty target"
-    });
   } else if (seedable) {
     try {
       await cloneDirectory(adapter.seedPath(target), target.targetPath, {
         destinationRoot: target.worktreePath,
         measureBytes: reporter.measureCloneSize
       });
-      await failureStore.clear(repoRoot, target.relativePath, failureScope);
-      seeded = true;
-      ownership = "adapter";
+      input = "seed";
       recordBootstrapEvent(events, reporter, {
         adapter: adapter.name,
         kind: adapter.kind,
@@ -19829,7 +19825,7 @@ async function executeBootstrapTarget(adapter, target, seedable, mode, cloneDire
       });
     } catch (error) {
       if (isCloneDestinationExistsError(error)) {
-        ownership = "preserve";
+        input = "preserve";
         recordBootstrapEvent(events, reporter, {
           adapter: adapter.name,
           kind: adapter.kind,
@@ -19837,15 +19833,7 @@ async function executeBootstrapTarget(adapter, target, seedable, mode, cloneDire
           target: target.relativePath,
           message: "target appeared during CoW seeding; preserving it as the repair input"
         });
-        await repairTarget(
-          adapter,
-          target,
-          execution,
-          false,
-          ownership,
-          events,
-          reporter
-        );
+        await repairTarget(adapter, target, execution, input, events, reporter);
         return;
       }
       if (isCloneInProgressError(error)) {
@@ -19859,21 +19847,30 @@ async function executeBootstrapTarget(adapter, target, seedable, mode, cloneDire
         );
         return;
       }
-      if (isCloneUnsupportedError(error)) {
-        await failureStore.cache(
-          repoRoot,
-          target.relativePath,
-          toErrorMessage2(error),
-          failureScope
+      const failedCloneInspection = await inspectDestination(
+        target.worktreePath,
+        target.targetPath
+      );
+      if (failedCloneInspection.kind === "unsafe") {
+        recordBootstrapFailure(
+          events,
+          reporter,
+          adapter,
+          target,
+          failedCloneInspection.reason,
+          "destination-unsafe"
         );
+        return;
       }
+      input = failedCloneInspection.kind === "exists" ? "preserve" : "clean";
+      const repairInput = input === "preserve" ? "the preserved target" : "an empty target";
       recordBootstrapEvent(events, reporter, {
         adapter: adapter.name,
         kind: adapter.kind,
-        reason: "cow-unsupported",
-        state: "fallback",
+        reason: "cow-seed-failed",
+        state: "repair-only",
         target: target.relativePath,
-        message: `CoW seed failed; repairing from an empty target (${toErrorMessage2(error)})`
+        message: `CoW seed failed; repairing from ${repairInput} (${toErrorMessage2(error)})`
       });
     }
   } else {
@@ -19881,22 +19878,14 @@ async function executeBootstrapTarget(adapter, target, seedable, mode, cloneDire
       adapter: adapter.name,
       kind: adapter.kind,
       reason: "seed-unavailable",
-      state: "fallback",
+      state: "repair-only",
       target: target.relativePath,
       message: "CoW seed is unavailable; repairing from an empty target"
     });
   }
-  await repairTarget(
-    adapter,
-    target,
-    execution,
-    seeded,
-    ownership,
-    events,
-    reporter
-  );
+  await repairTarget(adapter, target, execution, input, events, reporter);
 }
-async function repairTarget(adapter, target, execution, seeded, ownership, events, reporter) {
+async function repairTarget(adapter, target, execution, input, events, reporter) {
   const beforeRepairInspection = await inspectDestination(
     target.worktreePath,
     target.targetPath
@@ -19912,21 +19901,20 @@ async function repairTarget(adapter, target, execution, seeded, ownership, event
     );
     return;
   }
-  const presentBeforeRepair = beforeRepairInspection.kind === "exists";
+  const effectiveInput = beforeRepairInspection.kind === "exists" ? input === "seed" ? "seed" : "preserve" : "clean";
   try {
-    await adapter.repair(target, execution);
+    await adapter.repair(target, { ...execution, input: effectiveInput });
     recordBootstrapEvent(events, reporter, {
       adapter: adapter.name,
       kind: adapter.kind,
       state: target.repairState,
       target: target.relativePath,
-      message: seeded ? "reused and repaired" : "installed or repaired from a clean target"
+      message: repairSuccessMessage(target, effectiveInput)
     });
   } catch (firstError) {
     const firstFailureContext = {
-      target,
-      ownership,
-      targetExistedBeforeRepair: presentBeforeRepair
+      input: effectiveInput,
+      target
     };
     const cleanupError = await adapter.cleanupAfterRepairFailure(firstFailureContext).then(() => void 0).catch((error) => toErrorMessage2(error));
     if (!adapter.shouldRetryAfterRepairFailure(firstFailureContext)) {
@@ -19958,7 +19946,7 @@ async function repairTarget(adapter, target, execution, seeded, ownership, event
       adapter: adapter.name,
       kind: adapter.kind,
       reason: "seed-repair-failed",
-      state: "fallback",
+      state: "repair-only",
       target: target.relativePath,
       message: `seed repair failed; removed the seed and retrying clean (${toErrorMessage2(firstError)})`
     });
@@ -19977,22 +19965,21 @@ async function repairTarget(adapter, target, execution, seeded, ownership, event
       );
       return;
     }
-    const presentBeforeRetry = beforeRetryInspection.kind === "exists";
+    const retryInput = beforeRetryInspection.kind === "exists" ? "preserve" : "clean";
     try {
-      await adapter.repair(target, execution);
+      await adapter.repair(target, { ...execution, input: retryInput });
       recordBootstrapEvent(events, reporter, {
         adapter: adapter.name,
         kind: adapter.kind,
         reason: "repair-retry",
         state: target.repairState,
         target: target.relativePath,
-        message: "installed or repaired from a clean target"
+        message: repairSuccessMessage(target, retryInput)
       });
     } catch (secondError) {
       const cleanupError2 = await adapter.cleanupAfterRepairFailure({
-        target,
-        ownership,
-        targetExistedBeforeRepair: presentBeforeRetry
+        input: retryInput,
+        target
       }).then(() => void 0).catch((error) => toErrorMessage2(error));
       recordBootstrapFailure(
         events,
@@ -20005,6 +19992,11 @@ async function repairTarget(adapter, target, execution, seeded, ownership, event
     }
   }
 }
+function repairSuccessMessage(target, input) {
+  if (input === "seed") return "reused and repaired";
+  if (input === "preserve") return "repaired the existing target";
+  return target.repairState === "installed" ? "installed from a clean target" : "repaired from a clean target";
+}
 function recordBootstrapFailure(events, reporter, adapter, target, message, reason) {
   recordBootstrapEvent(events, reporter, {
     adapter: adapter.name,
@@ -20029,6 +20021,14 @@ function bootstrapStrategy(mode, target, seedable) {
   }
   return seedable ? "cow-then-repair" : "repair-only";
 }
+function adapterForTarget(target) {
+  const adapter = createBootstrapAdapters(defaultCheckUvRuntime).find(
+    (candidate) => candidate.name === target.adapter
+  );
+  if (!adapter)
+    throw new Error(`unsupported bootstrap adapter: ${target.adapter}`);
+  return adapter;
+}
 function createBootstrapAdapters(checkUvRuntime, cargoBuildCommand) {
   return [
     new LockfileBootstrapAdapter({
@@ -20038,9 +20038,9 @@ function createBootstrapAdapters(checkUvRuntime, cargoBuildCommand) {
       relativePath: "node_modules",
       repairCommand: "pnpm install --frozen-lockfile",
       shell: false,
-      beforeRepair: async (target) => {
-        if (!target.existingBeforeBootstrap) {
-          await rm5(join13(target.targetPath, ".modules.yaml"), {
+      beforeRepair: async (target, context) => {
+        if (context.input === "seed") {
+          await rm4(join12(target.targetPath, ".modules.yaml"), {
             force: true
           });
         }
@@ -20052,7 +20052,14 @@ function createBootstrapAdapters(checkUvRuntime, cargoBuildCommand) {
       lockfile: "yarn.lock",
       relativePath: "node_modules",
       repairCommand: "yarn install --immutable",
-      shell: false
+      shell: false,
+      beforeRepair: async (target, context) => {
+        if (context.input === "seed") {
+          await rm4(join12(target.targetPath, ".yarn-state.yml"), {
+            force: true
+          });
+        }
+      }
     }),
     new LockfileBootstrapAdapter({
       name: "npm",
@@ -20062,7 +20069,7 @@ function createBootstrapAdapters(checkUvRuntime, cargoBuildCommand) {
       repairCommand: "npm ci",
       shell: false,
       seedPolicy: "never",
-      repairCommandOverride: (target) => target.existingBeforeBootstrap ? "npm install" : "npm ci",
+      selectRepairCommand: (_target, input) => input === "preserve" ? "npm install" : "npm ci",
       repairState: "installed"
     }),
     new LockfileBootstrapAdapter({
@@ -20074,7 +20081,12 @@ function createBootstrapAdapters(checkUvRuntime, cargoBuildCommand) {
       shell: false,
       commandOptions: () => ({
         env: { BUNDLE_PATH: "vendor/bundle" }
-      })
+      }),
+      beforeRepair: async (target, context) => {
+        if (context.input === "seed") {
+          await removeBundlerExtensionMarkers(target.targetPath);
+        }
+      }
     }),
     new LockfileBootstrapAdapter({
       name: "uv",
@@ -20083,7 +20095,9 @@ function createBootstrapAdapters(checkUvRuntime, cargoBuildCommand) {
       relativePath: ".venv",
       repairCommand: "uv sync --locked",
       shell: false,
-      canSeedOverride: checkUvRuntime
+      canSeedOverride: checkUvRuntime,
+      beforeRepair: validateUvStructure,
+      afterRepair: validateUvRelocation
     }),
     new LockfileBootstrapAdapter({
       name: "cargo",
@@ -20091,7 +20105,7 @@ function createBootstrapAdapters(checkUvRuntime, cargoBuildCommand) {
       lockfile: "Cargo.lock",
       relativePath: "target",
       repairCommand: cargoBuildCommand?.trim() || "cargo check",
-      shell: cargoBuildCommand ? void 0 : false
+      shell: Boolean(cargoBuildCommand)
     })
   ];
 }
@@ -20105,8 +20119,9 @@ var LockfileBootstrapAdapter = class {
   seedPolicy;
   canSeedOverride;
   beforeRepair;
+  afterRepair;
   commandOptions;
-  repairCommandOverride;
+  selectRepairCommand;
   repairState;
   constructor(spec) {
     this.name = spec.name;
@@ -20118,19 +20133,21 @@ var LockfileBootstrapAdapter = class {
     this.seedPolicy = spec.seedPolicy ?? "always";
     this.canSeedOverride = spec.canSeedOverride;
     this.beforeRepair = spec.beforeRepair;
+    this.afterRepair = spec.afterRepair;
     this.commandOptions = spec.commandOptions;
-    this.repairCommandOverride = spec.repairCommandOverride;
+    this.selectRepairCommand = spec.selectRepairCommand;
     this.repairState = spec.repairState ?? "repaired";
   }
   async detect(context) {
     const detectionRoot = context.detectionRoot ?? context.sourceRoot;
-    if (!await pathExists2(join13(detectionRoot, this.lockfile))) return null;
-    const sourcePath = join13(context.sourceRoot, this.relativePath);
-    const targetPath = join13(context.worktreePath, this.relativePath);
+    if (!await pathExists2(join12(detectionRoot, this.lockfile))) return null;
+    const sourcePath = join12(context.sourceRoot, this.relativePath);
+    const targetPath = join12(context.worktreePath, this.relativePath);
     const destinationInspection = await inspectDestination(
       context.worktreePath,
       targetPath
     );
+    const initialInput = destinationInspection.kind === "exists" ? "preserve" : "clean";
     const target = {
       adapter: this.name,
       kind: this.kind,
@@ -20141,56 +20158,43 @@ var LockfileBootstrapAdapter = class {
       targetPath,
       repairCommand: this.defaultRepairCommand,
       repairState: this.repairState,
-      existingBeforeBootstrap: destinationInspection.kind === "exists"
+      shell: this.shell,
+      initialInput
     };
     return {
       ...target,
-      repairCommand: this.repairCommandOverride?.(target) ?? target.repairCommand
+      repairCommand: this.selectRepairCommand?.(target, initialInput) ?? target.repairCommand
     };
   }
   seedPath(target) {
     return target.sourcePath;
   }
   async repair(target, context) {
-    await this.beforeRepair?.(target);
+    await this.beforeRepair?.(target, context);
+    const repairCommand = this.selectRepairCommand?.(target, context.input) ?? target.repairCommand;
     await context.runCommand(
-      target.repairCommand,
+      repairCommand,
       target.worktreePath,
       context.stderr,
       context.stdout,
       {
         ...this.commandOptions?.(target),
-        shell: this.shell
+        shell: target.shell
       }
     );
+    await this.afterRepair?.(target, context);
   }
   async canSeed(target) {
     if (this.seedPolicy === "never") return false;
     if (!await safeSourceDirectory(target)) return false;
     return await this.canSeedOverride?.(target) ?? true;
   }
-  output(target) {
-    return {
-      adapter: this.name,
-      kind: this.kind,
-      target: target.relativePath,
-      repairCommand: target.repairCommand
-    };
-  }
   shouldRetryAfterRepairFailure(context) {
-    return context.ownership === "adapter" || context.ownership === "syncDirs";
+    return context.input === "seed";
   }
   async cleanupAfterRepairFailure(context) {
-    if (context.target.existingBeforeBootstrap) {
-      return;
-    }
-    if (context.ownership === "adapter" || context.ownership === "syncDirs") {
-      await rm5(context.target.targetPath, { force: true, recursive: true });
-      return;
-    }
-    if (context.ownership === "empty" && !context.targetExistedBeforeRepair) {
-      await rm5(context.target.targetPath, { force: true, recursive: true });
-    }
+    if (context.input !== "seed") return;
+    await rm4(context.target.targetPath, { force: true, recursive: true });
   }
 };
 async function safeSourceDirectory(target) {
@@ -20207,28 +20211,247 @@ async function safeSourceDirectory(target) {
 }
 async function defaultCheckUvRuntime(target) {
   try {
-    const config = await readFile10(
-      join13(target.sourcePath, "pyvenv.cfg"),
+    const config = await readFile9(
+      join12(target.sourcePath, "pyvenv.cfg"),
       "utf8"
     );
-    const expected = config.match(/^version\s*=\s*(\d+\.\d+)/mu)?.[1];
+    const expected = config.match(/^version(?:_info)?\s*=\s*(\d+\.\d+)/mu)?.[1];
     if (!expected) return false;
-    const sourceInterpreter = join13(
+    const expectedImplementation = config.match(/^implementation\s*=\s*([^\s#]+)/imu)?.[1]?.toLowerCase();
+    const sourceInterpreter = join12(
       target.sourcePath,
       process.platform === "win32" ? "Scripts/python.exe" : "bin/python"
     );
-    const fingerprintScript = "import platform, sys; print(f'{sys.version_info.major}.{sys.version_info.minor}|{platform.machine()}|{sys.implementation.cache_tag}')";
-    const [source, current] = await Promise.all([
-      execFileAsync6(sourceInterpreter, ["-c", fingerprintScript]),
-      execFileAsync6("python3", ["-c", fingerprintScript])
+    const fingerprintScript = "import platform, sys; print(f'{sys.version_info.major}.{sys.version_info.minor}|{platform.machine()}|{sys.implementation.name}')";
+    const source = await execFileAsync6(sourceInterpreter, [
+      "-c",
+      fingerprintScript
     ]);
     const sourceFingerprint = source.stdout.trim();
-    const currentFingerprint = current.stdout.trim();
-    return sourceFingerprint === currentFingerprint && sourceFingerprint.startsWith(`${expected}|`);
+    const [sourceVersion, sourceMachine, sourceImplementation, extra] = sourceFingerprint.split("|");
+    return extra === void 0 && sourceVersion === expected && Boolean(sourceMachine) && Boolean(sourceImplementation) && (expectedImplementation === void 0 || sourceImplementation.toLowerCase() === expectedImplementation);
   } catch {
     return false;
   }
 }
+function virtualEnvironmentPrefixes(text) {
+  const prefixes = [];
+  for (const line of text.split(/\r?\n/u)) {
+    if (!/\bVIRTUAL_ENV\b/u.test(line)) continue;
+    const quotedAssignment = line.match(
+      /\bVIRTUAL_ENV(?:\s*=|\s+)\s*(?:"([^"]+)"|'([^']+)')/u
+    );
+    const quotedPrefix = quotedAssignment?.[1] ?? quotedAssignment?.[2];
+    if (quotedPrefix && isAbsolute4(quotedPrefix)) prefixes.push(quotedPrefix);
+    const unquoted = line.match(/\bVIRTUAL_ENV(?:\s*=|\s+)\s*([^\s"']+)/u)?.[1];
+    if (unquoted && isAbsolute4(unquoted)) prefixes.push(unquoted);
+  }
+  return uniquePaths(prefixes);
+}
+function pythonPrefixFromShebang(text) {
+  const command = text.match(/^#!\s*([^\r\n]+)/u)?.[1]?.trim().split(/\s+/u)[0];
+  if (!command || !isAbsolute4(command)) return void 0;
+  if (!/^python(?:\d+(?:\.\d+)?)?(?:\.exe)?$/iu.test(
+    command.split(sep3).at(-1) ?? ""
+  )) {
+    return void 0;
+  }
+  return dirname9(dirname9(command));
+}
+function pythonPrefixesFromText(text) {
+  const interpreters = [];
+  for (const match of text.matchAll(/["'](\/[^"']+)["']/gu)) {
+    if (match[1]) interpreters.push(match[1]);
+  }
+  for (const match of text.matchAll(/(?:^|\s)(\/[^\s"']+)/gmu)) {
+    if (match[1]) interpreters.push(match[1]);
+  }
+  return uniquePaths(
+    interpreters.flatMap((interpreter) => {
+      const name = interpreter.split(sep3).at(-1) ?? "";
+      return /^python(?:\d+(?:\.\d+)?)?(?:\.exe)?$/iu.test(name) ? [dirname9(dirname9(interpreter))] : [];
+    })
+  );
+}
+async function validateUvRelocation(target, context) {
+  if (context.input === "preserve") return;
+  const scriptsDirectory = join12(
+    target.targetPath,
+    process.platform === "win32" ? "Scripts" : "bin"
+  );
+  const interpreter = join12(
+    scriptsDirectory,
+    process.platform === "win32" ? "python.exe" : "python"
+  );
+  const { stdout: stdout3 } = await execFileAsync6(interpreter, [
+    "-c",
+    "import os, sys; print(os.path.realpath(sys.prefix))"
+  ]);
+  const [actualPrefix, expectedPrefix] = await Promise.all([
+    realpath3(stdout3.trim()),
+    realpath3(target.targetPath)
+  ]);
+  if (actualPrefix !== expectedPrefix) {
+    throw new Error(
+      `uv environment still points to its source prefix: ${actualPrefix}`
+    );
+  }
+  const sourcePaths = uniquePaths([
+    target.sourcePath,
+    await realpath3(target.sourcePath).catch(() => void 0)
+  ]);
+  const entries = await readdir2(scriptsDirectory, { withFileTypes: true });
+  assertSafeUvScriptEntries(entries);
+  const environmentName = basename7(target.targetPath);
+  const acceptedPrefixes = /* @__PURE__ */ new Set([
+    resolve9(target.targetPath),
+    await realpath3(target.targetPath)
+  ]);
+  let validatedBytes = 0;
+  for (const path9 of [
+    join12(target.targetPath, "pyvenv.cfg"),
+    ...entries.filter((entry) => entry.isFile()).map((entry) => join12(scriptsDirectory, entry.name))
+  ]) {
+    const validated = await readBoundedUvTextFile(
+      path9,
+      UV_VALIDATION_MAX_TOTAL_BYTES - validatedBytes
+    );
+    if (!validated) continue;
+    validatedBytes += validated.bytes;
+    if (validated.text === void 0) continue;
+    const { text } = validated;
+    if (sourcePaths.some((sourcePath) => text.includes(sourcePath))) {
+      throw new Error(`uv environment contains a stale source path: ${path9}`);
+    }
+    const shebangPrefix = pythonPrefixFromShebang(text);
+    if (shebangPrefix && basename7(shebangPrefix) === environmentName && !acceptedPrefixes.has(resolve9(shebangPrefix))) {
+      throw new Error(`uv launcher points outside its environment: ${path9}`);
+    }
+    if (pythonPrefixesFromText(text).filter((prefix) => basename7(prefix) === environmentName).some((prefix) => !acceptedPrefixes.has(resolve9(prefix)))) {
+      throw new Error(`uv launcher points outside its environment: ${path9}`);
+    }
+    if (virtualEnvironmentPrefixes(text).some(
+      (prefix) => !acceptedPrefixes.has(resolve9(prefix))
+    )) {
+      throw new Error(
+        `uv activation script points outside its environment: ${path9}`
+      );
+    }
+  }
+}
+async function validateUvStructure(target, context) {
+  if (context.input === "preserve") return;
+  const targetStats = await lstat4(target.targetPath).catch(() => void 0);
+  if (!targetStats) return;
+  if (!targetStats.isDirectory() || targetStats.isSymbolicLink()) {
+    throw new Error("uv environment must be a real directory");
+  }
+  const configStats = await lstat4(join12(target.targetPath, "pyvenv.cfg")).catch(
+    () => void 0
+  );
+  if (configStats && (!configStats.isFile() || configStats.isSymbolicLink())) {
+    throw new Error("uv pyvenv.cfg must be a regular file");
+  }
+  const scriptsDirectory = join12(
+    target.targetPath,
+    process.platform === "win32" ? "Scripts" : "bin"
+  );
+  const scriptsStats = await lstat4(scriptsDirectory).catch(() => void 0);
+  if (!scriptsStats) return;
+  if (!scriptsStats.isDirectory() || scriptsStats.isSymbolicLink()) {
+    throw new Error("uv scripts path must be a real directory");
+  }
+  assertSafeUvScriptEntries(
+    await readdir2(scriptsDirectory, { withFileTypes: true })
+  );
+}
+function assertSafeUvScriptEntries(entries) {
+  if (entries.length > UV_VALIDATION_MAX_ENTRIES) {
+    throw new Error("uv scripts directory exceeds the validation entry limit");
+  }
+  for (const entry of entries) {
+    if (entry.isSymbolicLink() && !isUvInterpreterName(entry.name)) {
+      throw new Error(`uv script must not be a symbolic link: ${entry.name}`);
+    }
+  }
+}
+async function readBoundedUvTextFile(path9, remainingBytes) {
+  let handle;
+  try {
+    handle = await open3(
+      path9,
+      constants6.O_RDONLY | (process.platform === "win32" ? 0 : constants6.O_NOFOLLOW)
+    );
+  } catch (error) {
+    if (isNotFoundError(error)) return void 0;
+    throw error;
+  }
+  try {
+    const stats = await handle.stat();
+    if (!stats.isFile()) return void 0;
+    if (stats.size > UV_VALIDATION_MAX_FILE_BYTES) {
+      throw new Error(`uv launcher exceeds the validation size limit: ${path9}`);
+    }
+    if (stats.size > remainingBytes) {
+      throw new Error("uv launchers exceed the total validation size limit");
+    }
+    const readLimit = Math.min(UV_VALIDATION_MAX_FILE_BYTES, remainingBytes);
+    const contents = await readFilePrefix(handle, readLimit + 1);
+    if (contents.byteLength > UV_VALIDATION_MAX_FILE_BYTES) {
+      throw new Error(`uv launcher exceeds the validation size limit: ${path9}`);
+    }
+    if (contents.byteLength > remainingBytes) {
+      throw new Error("uv launchers exceed the total validation size limit");
+    }
+    const text = contents.toString("utf8");
+    return Buffer.from(text, "utf8").equals(contents) ? { bytes: contents.byteLength, text } : { bytes: contents.byteLength };
+  } finally {
+    await handle.close();
+  }
+}
+async function readFilePrefix(handle, maxBytes) {
+  const contents = Buffer.allocUnsafe(maxBytes);
+  let offset = 0;
+  while (offset < contents.byteLength) {
+    const { bytesRead } = await handle.read(
+      contents,
+      offset,
+      contents.byteLength - offset,
+      offset
+    );
+    if (bytesRead === 0) break;
+    offset += bytesRead;
+  }
+  return contents.subarray(0, offset);
+}
+function isUvInterpreterName(name) {
+  return /^python(?:\d+(?:\.\d+)?)?(?:\.exe)?$/iu.test(name);
+}
+async function removeBundlerExtensionMarkers(root) {
+  const pending = [root];
+  while (pending.length > 0) {
+    const current = pending.pop();
+    if (!current) continue;
+    let entries;
+    try {
+      entries = await readdir2(current, { withFileTypes: true });
+    } catch (error) {
+      if (isNotFoundError(error)) continue;
+      throw error;
+    }
+    for (const entry of entries) {
+      const path9 = join12(current, entry.name);
+      if (entry.isDirectory()) pending.push(path9);
+      else if (entry.isFile() && isBundlerExtensionMarker(root, path9)) {
+        await rm4(path9, { force: true });
+      }
+    }
+  }
+}
+function isBundlerExtensionMarker(root, path9) {
+  const segments = relative3(root, path9).split(sep3);
+  return segments.length >= 7 && segments[0] === "ruby" && segments[2] === "extensions" && segments.at(-1) === "gem.build_complete";
+}
 function uniquePaths(paths) {
   return [...new Set(paths.filter((path9) => Boolean(path9)))];
 }
@@ -20239,11 +20462,11 @@ async function isAllowedSourceRoot(repoRoot, sourceRoot) {
       realpath3(sourceRoot)
     ]);
     if (resolvedRepoRoot === resolvedSourceRoot) return true;
-    const gitFile = await readFile10(join13(resolvedSourceRoot, ".git"), "utf8");
+    const gitFile = await readFile9(join12(resolvedSourceRoot, ".git"), "utf8");
     const gitDirectory = gitFile.match(/^gitdir:\s*(.+)$/mu)?.[1];
     if (!gitDirectory) return false;
     return isWithin(
-      join13(resolvedRepoRoot, ".git", "worktrees"),
+      join12(resolvedRepoRoot, ".git", "worktrees"),
       resolve9(resolvedSourceRoot, gitDirectory)
     );
   } catch {
@@ -20251,8 +20474,8 @@ async function isAllowedSourceRoot(repoRoot, sourceRoot) {
   }
 }
 function isWithin(root, candidate) {
-  const distance = relative2(root, candidate);
-  return distance === "" || distance !== ".." && !distance.startsWith(`..${sep2}`);
+  const distance = relative3(root, candidate);
+  return distance === "" || distance !== ".." && !distance.startsWith(`..${sep3}`);
 }
 function toErrorMessage2(error) {
   return error instanceof Error ? error.message : String(error);
@@ -20283,11 +20506,11 @@ function formatBootstrapStrategy(strategy) {
 }
 
 // src/conflict.ts
-import { constants as constants6 } from "node:fs";
+import { constants as constants7 } from "node:fs";
 import { access as access7 } from "node:fs/promises";
 async function pathExists3(path9) {
   try {
-    await access7(path9, constants6.F_OK);
+    await access7(path9, constants7.F_OK);
     return true;
   } catch {
     return false;
@@ -20419,12 +20642,12 @@ function toErrorMessage3(error) {
 
 // src/sync-plan.ts
 import { lstat as lstat5, realpath as realpath4 } from "node:fs/promises";
-import { isAbsolute as isAbsolute4, join as join14, relative as relative3, resolve as resolve10, sep as sep3 } from "node:path";
+import { isAbsolute as isAbsolute5, join as join13, relative as relative4, resolve as resolve10, sep as sep4 } from "node:path";
 async function prepareSyncDirectoryPlan(repoRoot, worktreePath, directories) {
   const normalizedDirectories = directories.map(validateSyncDirPattern).sort(directoryDepthAscending);
   const plan = [];
   for (const directory of normalizedDirectories) {
-    const destination = join14(worktreePath, directory);
+    const destination = join13(worktreePath, directory);
     const destinationState = await inspectDestination(
       worktreePath,
       destination
@@ -20498,7 +20721,7 @@ async function estimateSyncDirectories(repoRoot, worktreePath, directories) {
   return estimateSyncDirectoryPlan(plan);
 }
 async function resolveSyncDirectorySource(repoRoot, directory) {
-  const source = join14(repoRoot, directory);
+  const source = join13(repoRoot, directory);
   let resolvedSource;
   try {
     resolvedSource = await realpath4(source);
@@ -20524,35 +20747,35 @@ function directoryDepthAscending(left, right) {
   return left.split(/[\\/]+/u).length - right.split(/[\\/]+/u).length;
 }
 function isPathInside2(parent, child) {
-  const relativePath = relative3(resolve10(parent), resolve10(child));
-  return relativePath !== "" && !isAbsolute4(relativePath) && relativePath !== ".." && !relativePath.startsWith(`..${sep3}`);
+  const relativePath = relative4(resolve10(parent), resolve10(child));
+  return relativePath !== "" && !isAbsolute5(relativePath) && relativePath !== ".." && !relativePath.startsWith(`..${sep4}`);
 }
 function toErrorMessage4(error) {
   return error instanceof Error ? error.message : String(error);
 }
 
 // src/worktree-bootstrap.ts
-import { basename as basename8 } from "node:path";
+import { basename as basename9 } from "node:path";
 
 // src/file-sync.ts
-import { constants as constants7 } from "node:fs";
+import { constants as constants8 } from "node:fs";
 import { copyFile, lstat as lstat6, realpath as realpath5 } from "node:fs/promises";
 import {
-  basename as basename7,
+  basename as basename8,
   dirname as dirname10,
-  isAbsolute as isAbsolute5,
-  join as join15,
+  isAbsolute as isAbsolute6,
+  join as join14,
   normalize as normalize2,
-  relative as relative4,
+  relative as relative5,
   resolve as resolve11,
-  sep as sep4
+  sep as sep5
 } from "node:path";
 async function syncFiles(mainRoot, targetPath, patterns) {
   for (const pattern of patterns) {
     const normalized = validateSyncFilePattern(pattern);
     const sourcePath = await resolveSyncFileSource(mainRoot, normalized);
     if (!sourcePath) continue;
-    const destPath = join15(targetPath, normalized);
+    const destPath = join14(targetPath, normalized);
     const existingDestination = await readDestinationEntry(destPath);
     if (existingDestination?.isSymbolicLink()) {
       throw new Error(`destination is a symbolic link: ${destPath}`);
@@ -20573,14 +20796,14 @@ async function syncFiles(mainRoot, targetPath, patterns) {
       destinationParent
     );
     try {
-      const safeDestination = join15(safeParent.path, basename7(destPath));
+      const safeDestination = join14(safeParent.path, basename8(destPath));
       const safeExistingDestination = await readDestinationEntry(safeDestination);
       if (safeExistingDestination?.isSymbolicLink()) {
         throw new Error(`destination is a symbolic link: ${destPath}`);
       }
       if (safeExistingDestination) continue;
       try {
-        await copyFile(sourcePath, safeDestination, constants7.COPYFILE_EXCL);
+        await copyFile(sourcePath, safeDestination, constants8.COPYFILE_EXCL);
       } catch (error) {
         if (!isAlreadyExistsError(error)) throw error;
       }
@@ -20590,7 +20813,7 @@ async function syncFiles(mainRoot, targetPath, patterns) {
   }
 }
 function validateSyncFilePattern(pattern) {
-  if (isAbsolute5(pattern)) {
+  if (isAbsolute6(pattern)) {
     throw new Error(
       `syncFiles: pattern must be a relative path, got: ${pattern}`
     );
@@ -20609,7 +20832,7 @@ async function resolveSyncFileSource(mainRoot, pattern) {
   try {
     [resolvedRoot, resolvedSource] = await Promise.all([
       realpath5(mainRoot),
-      realpath5(join15(mainRoot, pattern))
+      realpath5(join14(mainRoot, pattern))
     ]);
   } catch (error) {
     if (isNotFoundError(error)) return void 0;
@@ -20623,7 +20846,7 @@ async function resolveSyncFileSource(mainRoot, pattern) {
   const sourceStats = await lstat6(resolvedSource);
   if (!sourceStats.isFile()) {
     throw new Error(
-      `syncFiles: source is not a file: ${join15(mainRoot, pattern)}`
+      `syncFiles: source is not a file: ${join14(mainRoot, pattern)}`
     );
   }
   return resolvedSource;
@@ -20637,13 +20860,13 @@ async function readDestinationEntry(path9) {
   }
 }
 function isPathInside3(root, candidate) {
-  const distance = relative4(resolve11(root), resolve11(candidate));
-  return distance === "" || !isAbsolute5(distance) && distance !== ".." && !distance.startsWith(`..${sep4}`);
+  const distance = relative5(resolve11(root), resolve11(candidate));
+  return distance === "" || !isAbsolute6(distance) && distance !== ".." && !distance.startsWith(`..${sep5}`);
 }
 
 // src/package-manager.ts
 import { access as access8, readdir as readdir3 } from "node:fs/promises";
-import { join as join16 } from "node:path";
+import { join as join15 } from "node:path";
 var ENTRIES = [
   // JavaScript / TypeScript
   { name: "pnpm", signals: ["pnpm-lock.yaml"], command: "pnpm install" },
@@ -20773,7 +20996,7 @@ async function detectPackageManager(repoRoot) {
 async function matchesExact(repoRoot, signals) {
   for (const signal of signals) {
     try {
-      await access8(join16(repoRoot, signal));
+      await access8(join15(repoRoot, signal));
       return true;
     } catch {
     }
@@ -20888,9 +21111,9 @@ async function defaultWriteGlobalRepoConfigKey(repoRoot, key, value) {
 }
 async function loadExistingGlobalRepoHooks(repoRoot) {
   const { config: globalConfig } = await loadGlobalConfig();
-  const repos = isPlainObject3(globalConfig.repos) ? globalConfig.repos : {};
-  const perRepo = isPlainObject3(repos[repoRoot]) ? repos[repoRoot] : {};
-  return isPlainObject3(perRepo.hooks) ? perRepo.hooks : {};
+  const repos = isPlainObject2(globalConfig.repos) ? globalConfig.repos : {};
+  const perRepo = isPlainObject2(repos[repoRoot]) ? repos[repoRoot] : {};
+  return isPlainObject2(perRepo.hooks) ? perRepo.hooks : {};
 }
 async function defaultPromptForInstallChoice(pm) {
   const choice = await ve({
@@ -20911,13 +21134,12 @@ async function defaultPromptForInstallChoice(pm) {
   }
   return choice;
 }
-function isPlainObject3(value) {
+function isPlainObject2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
 // src/sync-directories.ts
 async function executeSyncDirectoryPlan(plan, options) {
-  const failureStore = options.failureStore ?? defaultCloneFailureStore;
   const outcomes = [];
   for (const entry of plan) {
     if (entry.destinationWarning) {
@@ -20960,37 +21182,6 @@ async function executeSyncDirectoryPlan(plan, options) {
       );
       continue;
     }
-    const failureScope = await cloneFailureScope(
-      entry.source,
-      entry.destination
-    );
-    if (await failureStore.isCached(
-      options.repoRoot,
-      entry.directory,
-      failureScope
-    )) {
-      if (options.reporter.emitCachedFailureWarnings || options.reporter.skipped) {
-        recordSkipped(
-          outcomes,
-          options.reporter,
-          entry.directory,
-          "copy-on-write failure cached"
-        );
-      } else {
-        options.reporter.write(
-          `syncDirs: previous copy-on-write failure cached, skipped ${entry.directory}
-`
-        );
-        recordSkipped(
-          outcomes,
-          options.reporter,
-          entry.directory,
-          "copy-on-write failure cached",
-          false
-        );
-      }
-      continue;
-    }
     const refreshedDestinationState = await inspectDestination(
       entry.worktreePath,
       entry.destination
@@ -21031,18 +21222,9 @@ async function executeSyncDirectoryPlan(plan, options) {
         continue;
       }
       const reason = toErrorMessage5(error);
-      if (isCloneUnsupportedError(error)) {
-        await failureStore.cache(
-          options.repoRoot,
-          entry.directory,
-          reason,
-          failureScope
-        );
-      }
       recordSkipped(outcomes, options.reporter, entry.directory, reason);
       continue;
     }
-    await failureStore.clear(options.repoRoot, entry.directory, failureScope);
     const clonedDirectory = {
       bytes: result.bytes,
       dir: entry.directory,
@@ -21054,13 +21236,11 @@ async function executeSyncDirectoryPlan(plan, options) {
   }
   return outcomes;
 }
-function recordSkipped(outcomes, reporter, dir, reason, notify = true) {
+function recordSkipped(outcomes, reporter, dir, reason) {
   outcomes.push({ kind: "skipped", dir, reason });
-  if (notify) {
-    if (reporter.skipped) reporter.skipped({ dir, reason });
-    else reporter.write(`syncDirs: ${reason}, skipped ${dir}
+  if (reporter.skipped) reporter.skipped({ dir, reason });
+  else reporter.write(`syncDirs: ${reason}, skipped ${dir}
 `);
-  }
 }
 function toErrorMessage5(error) {
   return error instanceof Error ? error.message : String(error);
@@ -21083,7 +21263,6 @@ async function bootstrapWorktree(options) {
   );
   const outcomes = await executeSyncDirectoryPlan(syncPlan, {
     cloneDirectory: options.cloneDirectory ?? cloneDir,
-    repoRoot: options.repoRoot,
     reporter: options.reporter
   });
   const clonedDirs = outcomes.flatMap(
@@ -21115,7 +21294,6 @@ async function bootstrapWorktree(options) {
   }
   const dependencyBootstrap = syncFileFailures.length > 0 ? { mode: dependencyMode, ready: false, events: [] } : await executeDependencyBootstrap(dependencyPlan, {
     cloneDirectory: options.cloneDirectory,
-    repoRoot: options.repoRoot,
     reporter: options.reporter,
     stderr: options.commandStderr ?? options.reporter.write,
     stdout: options.commandStdout,
@@ -21151,7 +21329,7 @@ async function bootstrapWorktree(options) {
     {
       branch: options.branch,
       path: options.worktreePath,
-      repo: basename8(options.repoRoot),
+      repo: basename9(options.repoRoot),
       slot
     },
     options.reporter.write,
@@ -21348,7 +21526,7 @@ ${dryRunSyncDirs.map(({ dir, bytes }) => `Would clone ${dir} (${formatBytes(byte
       }
       return 1;
     }
-    await mkdir9(dirname11(worktreePath), { recursive: true });
+    await mkdir8(dirname11(worktreePath), { recursive: true });
     const branchAlreadyExists = await localBranchExists(
       repository.repoRoot,
       branchName
@@ -21507,8 +21685,8 @@ function sourceRefForForge(forge, prNumber) {
       return `refs/merge-requests/${prNumber}/head`;
   }
 }
-async function writeOutput(worktreePath, stdout2, outputEnv) {
-  await writeShellOutput(outputEnv ?? PR_OUTPUT_FILE_ENV, worktreePath, stdout2);
+async function writeOutput(worktreePath, stdout3, outputEnv) {
+  await writeShellOutput(outputEnv ?? PR_OUTPUT_FILE_ENV, worktreePath, stdout3);
 }
 
 // src/worktree-sources.ts
@@ -21765,7 +21943,7 @@ function normalizeRemoteUrl(value) {
 
 // src/new.ts
 import { execFile as execFile8 } from "node:child_process";
-import { access as access9, mkdir as mkdir10 } from "node:fs/promises";
+import { access as access9, mkdir as mkdir9 } from "node:fs/promises";
 import { dirname as dirname12, resolve as resolve12 } from "node:path";
 import { promisify as promisify9 } from "node:util";
 var execFileAsync8 = promisify9(execFile8);
@@ -22020,7 +22198,7 @@ ${dryRunSyncDirs.map(({ dir, bytes }) => `Would clone ${dir} (${formatBytes(byte
       }
       return 0;
     }
-    await mkdir10(dirname12(worktreePath), { recursive: true });
+    await mkdir9(dirname12(worktreePath), { recursive: true });
     const startPoint = options.fromCurrent && !options.detached ? await resolveCurrentWorktreeHead(options.cwd) : void 0;
     const takeStartPoint = options.take ? await resolveCurrentWorktreeHead(options.cwd) : void 0;
     const changedTakeFiles = options.take ? await listTakeFiles(options.cwd) : [];
@@ -22417,7 +22595,7 @@ async function localBranchExists2(repoRoot, branchName) {
 }
 async function resolveCurrentWorktreeHead(cwd) {
   return execFileAsync8("git", ["rev-parse", "--verify", "HEAD"], { cwd }).then(
-    ({ stdout: stdout2 }) => stdout2.trim()
+    ({ stdout: stdout3 }) => stdout3.trim()
   );
 }
 async function createTakeStash(cwd, worktreeName) {
@@ -22427,12 +22605,12 @@ async function createTakeStash(cwd, worktreeName) {
     ["stash", "push", "--include-untracked", "-m", message],
     { cwd }
   );
-  const { stdout: stdout2 } = await execFileAsync8(
+  const { stdout: stdout3 } = await execFileAsync8(
     "git",
     ["stash", "list", "--format=%H%x00%s"],
     { cwd }
   );
-  const line = stdout2.split("\n").map((candidate) => candidate.split("\0")).find(([, subject]) => subject?.endsWith(message));
+  const line = stdout3.split("\n").map((candidate) => candidate.split("\0")).find(([, subject]) => subject?.endsWith(message));
   if (!line?.[0])
     throw new Error("could not identify the stash created for --take");
   return line[0];
@@ -22448,23 +22626,23 @@ async function detectInProgressGitState(cwd) {
   ];
   for (const [marker, name] of markers) {
     try {
-      const { stdout: stdout2 } = await execFileAsync8(
+      const { stdout: stdout3 } = await execFileAsync8(
         "git",
         ["rev-parse", "--git-path", marker],
         { cwd }
       );
-      await access9(resolve12(cwd, stdout2.trim()));
+      await access9(resolve12(cwd, stdout3.trim()));
       return name;
     } catch {
     }
   }
   return null;
 }
-async function writeOutput2(worktreePath, stdout2, outputEnv) {
+async function writeOutput2(worktreePath, stdout3, outputEnv) {
   await writeShellOutput(
     outputEnv ?? NEW_OUTPUT_FILE_ENV,
     worktreePath,
-    stdout2
+    stdout3
   );
 }
 function isNotRegisteredWorktreeError(error) {
@@ -22500,24 +22678,24 @@ async function openWorktree(worktreePath, editorCli, spawnFn, stderr) {
 }
 async function listTakeFiles(cwd) {
   try {
-    const { stdout: stdout2 } = await execFileAsync8(
+    const { stdout: stdout3 } = await execFileAsync8(
       "git",
       ["status", "--porcelain=v1"],
       { cwd }
     );
-    return stdout2.split("\n").filter((line) => line.length > 3).map((line) => line.slice(3).replace(/^"|"$/g, ""));
+    return stdout3.split("\n").filter((line) => line.length > 3).map((line) => line.slice(3).replace(/^"|"$/g, ""));
   } catch {
     return [];
   }
 }
 async function listIgnoredFiles(cwd) {
   try {
-    const { stdout: stdout2 } = await execFileAsync8(
+    const { stdout: stdout3 } = await execFileAsync8(
       "git",
       ["status", "--porcelain=v1", "--ignored", "--untracked-files=all"],
       { cwd }
     );
-    return stdout2.split("\n").filter((line) => line.startsWith("!! ")).map((line) => line.slice(3).replace(/^"|"$/g, ""));
+    return stdout3.split("\n").filter((line) => line.startsWith("!! ")).map((line) => line.slice(3).replace(/^"|"$/g, ""));
   } catch {
     return [];
   }
@@ -22525,11 +22703,11 @@ async function listIgnoredFiles(cwd) {
 async function listSubmoduleFiles(cwd, changedFiles) {
   if (changedFiles.length === 0) return [];
   try {
-    const { stdout: stdout2 } = await execFileAsync8("git", ["ls-files", "--stage"], {
+    const { stdout: stdout3 } = await execFileAsync8("git", ["ls-files", "--stage"], {
       cwd
     });
     const submodules = new Set(
-      stdout2.split("\n").filter((line) => line.startsWith("160000 ")).map((line) => line.slice(line.indexOf("	") + 1))
+      stdout3.split("\n").filter((line) => line.startsWith("160000 ")).map((line) => line.slice(line.indexOf("	") + 1))
     );
     return changedFiles.filter((file) => submodules.has(file));
   } catch {
@@ -22538,12 +22716,12 @@ async function listSubmoduleFiles(cwd, changedFiles) {
 }
 async function countUntrackedFiles(cwd) {
   try {
-    const { stdout: stdout2 } = await execFileAsync8(
+    const { stdout: stdout3 } = await execFileAsync8(
       "git",
       ["status", "--porcelain=v1", "--untracked-files=all"],
       { cwd }
     );
-    return stdout2.split("\n").filter((line) => line.startsWith("?? ")).length;
+    return stdout3.split("\n").filter((line) => line.startsWith("?? ")).length;
   } catch {
     return 0;
   }
@@ -22573,12 +22751,12 @@ async function applyTakeStash(worktreePath, sourcePath, stashSha, copy, stderr)
     }
   }
   try {
-    const { stdout: stdout2 } = await execFileAsync8(
+    const { stdout: stdout3 } = await execFileAsync8(
       "git",
       ["stash", "list", "--format=%H %gd"],
       { cwd: sourcePath }
     );
-    const line = stdout2.split("\n").find((candidate) => candidate.startsWith(stashSha));
+    const line = stdout3.split("\n").find((candidate) => candidate.startsWith(stashSha));
     const ref = line?.trim().split(/\s+/).at(1);
     if (ref)
       await execFileAsync8("git", ["stash", "drop", ref], { cwd: sourcePath });
@@ -22867,7 +23045,7 @@ async function navigateToExistingWorktree(options, path9, worktree) {
     {
       branch: worktree?.branch ?? void 0,
       path: path9,
-      repo: basename9(repository.repoRoot),
+      repo: basename10(repository.repoRoot),
       slot: await getWorktreeSlot(path9)
     },
     options.stderr
@@ -23005,7 +23183,8 @@ async function runHistoryCommand(options) {
 }
 
 // src/hub.ts
-import { basename as basename10 } from "node:path";
+import { basename as basename11 } from "node:path";
+import { stdin as stdin2, stdout as stdout2 } from "node:process";
 var MAX_HUB_REPOSITORY_CONCURRENCY = 4;
 var defaultDependencies = {
   queryRepositoryPullRequests: createPullRequestQuery().listOpenPullRequestsForRepository
@@ -23027,7 +23206,7 @@ async function buildHubData(cwd, dependencies = {}) {
       existing.sources.push(source);
     } else {
       groups.set(repoRoot, {
-        name: source.repoName || basename10(repoRoot),
+        name: source.repoName || basename11(repoRoot),
         sources: [source]
       });
     }
@@ -23070,7 +23249,14 @@ async function buildHubData(cwd, dependencies = {}) {
   };
 }
 async function runHubCommand(options, dependencies = {}) {
-  const data = await buildHubData(options.cwd, dependencies);
+  const loading = !options.json && stdin2.isTTY === true && stdout2.isTTY === true ? Y2({ indicator: "timer" }) : null;
+  loading?.start("Loading worktrees");
+  let data;
+  try {
+    data = await buildHubData(options.cwd, dependencies);
+  } finally {
+    loading?.stop();
+  }
   if (options.json) {
     options.stdout(`${JSON.stringify(data, null, 2)}
 `);
@@ -23282,9 +23468,9 @@ async function mapWithConcurrency4(items, limit, mapper) {
 }
 
 // src/init.ts
-import { constants as constants8 } from "node:fs";
-import { access as access10, mkdir as mkdir11, readFile as readFile11, writeFile as writeFile10 } from "node:fs/promises";
-import { homedir as homedir9 } from "node:os";
+import { constants as constants9 } from "node:fs";
+import { access as access10, mkdir as mkdir10, readFile as readFile10, writeFile as writeFile9 } from "node:fs/promises";
+import { homedir as homedir8 } from "node:os";
 import { dirname as dirname13 } from "node:path";
 var ZSH_COMPLETION_PATH_LINE = "fpath=(~/.zsh/completions $fpath)";
 var SHELL_WRAPPED_COMMANDS = [
@@ -23355,7 +23541,7 @@ async function runOnboardingInitCommand(options) {
   if (options.json || isHeadless() || !canRunOnboarding(options)) {
     return writeNonInteractiveInitError(options);
   }
-  const home = options.home ?? homedir9();
+  const home = options.home ?? homedir8();
   const context = {
     detectedShell: resolveSupportedShell(void 0, process.env.SHELL),
     home
@@ -23409,8 +23595,8 @@ async function runDefaultOnboarding(context) {
   const installCompletion = await promptForCompletion(shell, completionPath);
   if (installCompletion === null) return abortDefaultOnboarding();
   if (installCompletion) {
-    await mkdir11(dirname13(completionPath), { recursive: true });
-    await writeFile10(completionPath, renderShellCompletion(shell), "utf8");
+    await mkdir10(dirname13(completionPath), { recursive: true });
+    await writeFile9(completionPath, renderShellCompletion(shell), "utf8");
   }
   if (shell === "zsh" && (completionAlreadyInstalled || installCompletion)) {
     await ensureZshCompletionPath(rcPath);
@@ -23502,8 +23688,8 @@ async function applyOnboardingResult(result, home) {
   const completionAlreadyInstalled = await fileExists(completionPath);
   await applyShellIntegration(result.shell, result.shellIntegration, home);
   if (result.installCompletion) {
-    await mkdir11(dirname13(completionPath), { recursive: true });
-    await writeFile10(
+    await mkdir10(dirname13(completionPath), { recursive: true });
+    await writeFile9(
       completionPath,
       renderShellCompletion(result.shell),
       "utf8"
@@ -23518,17 +23704,17 @@ async function applyOnboardingResult(result, home) {
 }
 async function installOnboardingShellIntegration(shell, home) {
   const rcPath = resolveShellConfigPath(shell, home);
-  await mkdir11(dirname13(rcPath), { recursive: true });
+  await mkdir10(dirname13(rcPath), { recursive: true });
   const current = await readExistingConfig(rcPath);
   if (shell === "fish") {
-    await writeFile10(
+    await writeFile9(
       rcPath,
       upsertShellIntegration(current, renderShellIntegration(shell)),
       "utf8"
     );
     return;
   }
-  await writeFile10(
+  await writeFile9(
     rcPath,
     upsertOnboardingShellIntegration(current, shell),
     "utf8"
@@ -23562,7 +23748,7 @@ async function ensureZshCompletionPath(rcPath) {
   const current = await readExistingConfig(rcPath);
   const next = upsertZshCompletionPath(current);
   if (next !== current) {
-    await writeFile10(rcPath, next, "utf8");
+    await writeFile9(rcPath, next, "utf8");
   }
 }
 function upsertZshCompletionPath(existingConfig) {
@@ -23585,7 +23771,7 @@ ${suffix}`
 }
 async function fileExists(path9) {
   try {
-    await access10(path9, constants8.F_OK);
+    await access10(path9, constants9.F_OK);
     return true;
   } catch {
     return false;
@@ -23593,7 +23779,7 @@ async function fileExists(path9) {
 }
 async function runLegacyInitCommand(options) {
   const shell = resolveSupportedShell(options.shell, process.env.SHELL);
-  const home = options.home ?? homedir9();
+  const home = options.home ?? homedir8();
   if (!shell) {
     options.stderr?.(
       "Unable to detect a supported shell. Specify one explicitly: bash, fish, or zsh.\n"
@@ -23606,10 +23792,10 @@ async function runLegacyInitCommand(options) {
     return 0;
   }
   const rcPath = resolveShellConfigPath(shell, home);
-  await mkdir11(dirname13(rcPath), { recursive: true });
+  await mkdir10(dirname13(rcPath), { recursive: true });
   const current = await readExistingConfig(rcPath);
   const next = upsertShellIntegration(current, script);
-  await writeFile10(rcPath, next, "utf8");
+  await writeFile9(rcPath, next, "utf8");
   options.stdout(`${rcPath}
 `);
   const { config: globalConfig } = await loadGlobalConfig(home);
@@ -23700,7 +23886,7 @@ async function saveWizardConfig(result, cwd, home) {
 }
 async function readExistingConfig(path9) {
   try {
-    return await readFile11(path9, "utf8");
+    return await readFile10(path9, "utf8");
   } catch (error) {
     if (isMissingFileError3(error)) {
       return "";
@@ -23950,8 +24136,8 @@ function sortWorktrees(worktrees) {
 
 // src/open.ts
 import { execFile as execFile9 } from "node:child_process";
-import { access as access11, writeFile as writeFile11 } from "node:fs/promises";
-import { join as join17 } from "node:path";
+import { access as access11, writeFile as writeFile10 } from "node:fs/promises";
+import { join as join16 } from "node:path";
 import { promisify as promisify10 } from "node:util";
 var execFileAsync9 = promisify10(execFile9);
 function createOpenCommand(dependencies = {}) {
@@ -24118,14 +24304,14 @@ async function defaultPromptForEditor(editors) {
   return choice;
 }
 async function ensureWorkspaceFile(worktreePath, repoName) {
-  const workspacePath = join17(worktreePath, `${repoName}.code-workspace`);
+  const workspacePath = join16(worktreePath, `${repoName}.code-workspace`);
   try {
     await access11(workspacePath);
     return workspacePath;
   } catch {
   }
   const workspace = { folders: [{ path: "." }], settings: {} };
-  await writeFile11(
+  await writeFile10(
     workspacePath,
     `${JSON.stringify(workspace, null, 2)}
 `,
@@ -24533,7 +24719,7 @@ function formatError(error) {
 }
 
 // src/remove.ts
-import { basename as basename11 } from "node:path";
+import { basename as basename12 } from "node:path";
 var REMOVE_OUTPUT_FILE_ENV = "GJI_REMOVE_OUTPUT_FILE";
 function createRemoveCommand(dependencies = {}) {
   const promptForWorktree2 = dependencies.promptForWorktree ?? defaultPromptForWorktree3;
@@ -24639,7 +24825,7 @@ function createRemoveCommand(dependencies = {}) {
       {
         branch: worktree.branch ?? void 0,
         path: worktree.path,
-        repo: basename11(repository.repoRoot)
+        repo: basename12(repository.repoRoot)
       },
       options.stderr
     );
@@ -24717,8 +24903,8 @@ async function defaultConfirmRemoval2(worktree) {
   });
   return !pD(choice) && choice;
 }
-async function writeOutput3(repoRoot, stdout2) {
-  await writeShellOutput(REMOVE_OUTPUT_FILE_ENV, repoRoot, stdout2);
+async function writeOutput3(repoRoot, stdout3) {
+  await writeShellOutput(REMOVE_OUTPUT_FILE_ENV, repoRoot, stdout3);
 }
 function emitError3(options, message) {
   if (options.json) {
@@ -25037,11 +25223,11 @@ function resolveConfiguredString2(value) {
 }
 
 // src/sync-files-command.ts
-import { homedir as homedir10 } from "node:os";
-import { join as join18 } from "node:path";
+import { homedir as homedir9 } from "node:os";
+import { join as join17 } from "node:path";
 async function runSyncFilesCommand(options) {
   const repository = await detectRepository(options.cwd);
-  const home = options.home ?? homedir10();
+  const home = options.home ?? homedir9();
   const loaded = await loadGlobalConfig(home);
   const repoEntry = findRepoConfigEntry(
     loaded.config,
@@ -25085,9 +25271,9 @@ async function runSyncFilesCommand(options) {
 }
 function findRepoConfigEntry(config, repoRoot, home) {
   const repos = config.repos;
-  if (!isPlainObject4(repos)) return null;
+  if (!isPlainObject3(repos)) return null;
   for (const [key, value] of Object.entries(repos)) {
-    if (expandTilde3(key, home) === repoRoot && isPlainObject4(value)) {
+    if (expandTilde3(key, home) === repoRoot && isPlainObject3(value)) {
       return { config: value, key };
     }
   }
@@ -25098,17 +25284,17 @@ function readSyncFiles(config) {
   if (!Array.isArray(syncFiles2)) return [];
   return syncFiles2.filter((item) => typeof item === "string");
 }
-function writeSyncFiles(stdout2, files, json) {
+function writeSyncFiles(stdout3, files, json) {
   if (json) {
-    stdout2(`${JSON.stringify(files, null, 2)}
+    stdout3(`${JSON.stringify(files, null, 2)}
 `);
     return;
   }
   if (files.length === 0) {
-    stdout2("No sync files configured for this repo.\n");
+    stdout3("No sync files configured for this repo.\n");
     return;
   }
-  stdout2(`${files.join("\n")}
+  stdout3(`${files.join("\n")}
 `);
 }
 function validatePaths(paths, options) {
@@ -25144,8 +25330,8 @@ function removeSyncFiles(existing, removals) {
   return existing.filter((path9) => !removalSet.has(path9));
 }
 async function saveRepoSyncFiles(config, repoKey, syncFiles2, home) {
-  const repos = isPlainObject4(config.repos) ? { ...config.repos } : {};
-  const repoConfig = isPlainObject4(repos[repoKey]) ? repos[repoKey] : {};
+  const repos = isPlainObject3(config.repos) ? { ...config.repos } : {};
+  const repoConfig = isPlainObject3(repos[repoKey]) ? repos[repoKey] : {};
   const nextRepoConfig = { ...repoConfig };
   if (syncFiles2.length > 0) {
     nextRepoConfig.syncFiles = syncFiles2;
@@ -25159,7 +25345,7 @@ async function saveRepoSyncFiles(config, repoKey, syncFiles2, home) {
   }
   await saveGlobalConfig({ ...config, repos }, home);
 }
-function isPlainObject4(value) {
+function isPlainObject3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function writeError(options, message) {
@@ -25173,7 +25359,7 @@ function writeError(options, message) {
 }
 function expandTilde3(value, home) {
   if (value === "~") return home;
-  if (value.startsWith("~/")) return join18(home, value.slice(2));
+  if (value.startsWith("~/")) return join17(home, value.slice(2));
   return value;
 }
 
@@ -25353,7 +25539,7 @@ function readPackageMetadata() {
 async function runCli(argv, options = {}) {
   await maybeNotifyForUpdates(argv);
   const cwd = options.cwd ?? process.cwd();
-  const stdout2 = options.stdout ?? (() => void 0);
+  const stdout3 = options.stdout ?? (() => void 0);
   const stderr = options.stderr ?? (() => void 0);
   if (shouldRegisterCurrentRepo(argv) || isHubInvocation(argv)) {
     await maybeRegisterCurrentRepo(cwd);
@@ -25361,7 +25547,7 @@ async function runCli(argv, options = {}) {
   const program2 = createProgram();
   program2.configureOutput({
     writeErr: stderr,
-    writeOut: stdout2
+    writeOut: stdout3
   });
   program2.exitOverride();
   if (isHubInvocation(argv)) {
@@ -25372,7 +25558,7 @@ async function runCli(argv, options = {}) {
         json: argv.includes("--json"),
         now: options.now,
         stderr,
-        stdout: stdout2
+        stdout: stdout3
       },
       options.hubDependencies
     );
@@ -25383,7 +25569,7 @@ async function runCli(argv, options = {}) {
       cwd,
       prOpenDependencies: options.prOpenDependencies,
       stderr,
-      stdout: stdout2
+      stdout: stdout3
     });
     await program2.parseAsync(["node", "gji", ...argv], { from: "node" });
     return { exitCode: 0 };
@@ -25992,7 +26178,7 @@ async function main() {
 }
 async function warnIfMissingShellIntegration() {
   try {
-    const { config } = await loadGlobalConfig(homedir11());
+    const { config } = await loadGlobalConfig(homedir10());
     if (!config.shellIntegration) {
       const setupCommand = isHeadless() ? legacyShellSetupCommand() : "gji init";
       process.stderr.write(