@solaqua/gji 0.15.0 → 0.16.0

package/dist/gji-bundle.mjs

@@ -3526,7 +3526,7 @@ var require_polyfills = __commonJS({
       }
       if (platform3 === "win32") {
         fs5.rename = typeof fs5.rename !== "function" ? fs5.rename : (function(fs$rename) {
-          function rename3(from, to, cb) {
+          function rename2(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(rename3, fs$rename);
-          return rename3;
+          if (Object.setPrototypeOf) Object.setPrototypeOf(rename2, fs$rename);
+          return rename2;
         })(fs5.rename);
       }
       fs5.read = typeof fs5.read !== "function" ? fs5.read : (function(fs$read) {
@@ -3968,8 +3968,8 @@ var require_graceful_fs = __commonJS({
         }
       }
       var fs$writeFile = fs6.writeFile;
-      fs6.writeFile = writeFile10;
-      function writeFile10(path9, data, options, cb) {
+      fs6.writeFile = writeFile7;
+      function writeFile7(path9, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
         return go$writeFile(path9, data, options, cb);
@@ -5500,7 +5500,7 @@ var require_polyfills2 = __commonJS({
       }
       if (platform3 === "win32") {
         fs5.rename = typeof fs5.rename !== "function" ? fs5.rename : (function(fs$rename) {
-          function rename3(from, to, cb) {
+          function rename2(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(rename3, fs$rename);
-          return rename3;
+          if (Object.setPrototypeOf) Object.setPrototypeOf(rename2, fs$rename);
+          return rename2;
         })(fs5.rename);
       }
       fs5.read = typeof fs5.read !== "function" ? fs5.read : (function(fs$read) {
@@ -5942,8 +5942,8 @@ var require_graceful_fs2 = __commonJS({
         }
       }
       var fs$writeFile = fs6.writeFile;
-      fs6.writeFile = writeFile10;
-      function writeFile10(path9, data, options, cb) {
+      fs6.writeFile = writeFile7;
+      function writeFile7(path9, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
         return go$writeFile(path9, data, options, cb);
@@ -6757,11 +6757,11 @@ var require_util = __commonJS({
           if (files.includes("node_modules") || files.includes("package.json") || files.includes("package.json5") || files.includes("package.yaml") || files.includes("pnpm-workspace.yaml")) {
             return name2;
           }
-          const dirname15 = path9.dirname(name2);
-          if (dirname15 === name2) {
+          const dirname12 = path9.dirname(name2);
+          if (dirname12 === name2) {
             return original;
           }
-          return find(dirname15, original);
+          return find(dirname12, original);
         } catch (error) {
           if (name2 === original) {
             if (error.code === "ENOENT") {
@@ -9517,9 +9517,9 @@ var retryifyAsync = (fn, options) => {
           throw error;
         if (Date.now() >= timestamp)
           throw error;
-        const delay2 = Math.round(interval * Math.random());
-        if (delay2 > 0) {
-          const delayPromise = new Promise((resolve13) => setTimeout(resolve13, delay2));
+        const delay3 = Math.round(interval * Math.random());
+        if (delay3 > 0) {
+          const delayPromise = new Promise((resolve13) => setTimeout(resolve13, delay3));
           return delayPromise.then(() => attempt.apply(void 0, args));
         } else {
           return attempt.apply(void 0, args);
@@ -12810,8 +12810,8 @@ function updateNotifier(options) {
 // package.json
 var package_default = {
   name: "@solaqua/gji",
-  version: "0.15.0",
-  description: "Git worktree CLI for fast context switching.",
+  version: "0.16.0",
+  description: "Git worktree CLI for switching tasks without disturbing your work.",
   license: "MIT",
   author: "sjquant",
   type: "module",
@@ -12875,6 +12875,7 @@ var package_default = {
   devDependencies: {
     "@biomejs/biome": "^2.4.15",
     "@j178/prek": "^0.3.13",
+    "@resvg/resvg-js": "^2.6.2",
     "@types/node": "^24.6.0",
     "@vitest/coverage-v8": "3.2.4",
     esbuild: "^0.27.0",
@@ -13859,18 +13860,44 @@ import { promisify as promisify5 } from "node:util";
 import { execFile as execFile3 } from "node:child_process";
 import { promisify as promisify4 } from "node:util";
 var execFileAsync3 = promisify4(execFile3);
+var CONTENTION_RETRY_TIMEOUT_MS = 1e4;
+var CONTENTION_RETRY_MAX_DELAY_MS = 1e3;
+var GIT_ENV = { ...process.env, LC_ALL: "C" };
 async function runGit(cwd, args) {
   return (await runGitRaw(cwd, args)).trim();
 }
 async function runGitRaw(cwd, args) {
+  return execGit(cwd, args);
+}
+async function runGitRetryingContention(cwd, args) {
+  return (await retryGitContention(() => execGit(cwd, args, GIT_ENV))).trim();
+}
+async function retryGitContention(operation, timeoutMs = CONTENTION_RETRY_TIMEOUT_MS) {
+  const deadline = Date.now() + timeoutMs;
+  for (let delayMs = 25; ; delayMs *= 2) {
+    try {
+      return await operation();
+    } catch (error) {
+      if (!isTransientGitError(error) || Date.now() >= deadline) throw error;
+    }
+    const jitteredDelayMs = Math.min(delayMs, CONTENTION_RETRY_MAX_DELAY_MS) * (0.5 + Math.random() / 2);
+    await new Promise((resolve13) => setTimeout(resolve13, jitteredDelayMs));
+  }
+}
+async function execGit(cwd, args, env5) {
   try {
-    const { stdout: stdout3 } = await execFileAsync3("git", args, { cwd });
+    const { stdout: stdout3 } = await execFileAsync3("git", args, { cwd, env: env5 });
     return stdout3;
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     throw new Error(`Git command failed in '${cwd}': ${message}`);
   }
 }
+function isTransientGitError(error) {
+  return error instanceof Error && /(could not lock config file .*|Unable to create '.*\.lock'): File exists|cannot lock ref .*: is at .* but expected |failed to read .*\/commondir|Invalid path '.*\/worktrees\//.test(
+    error.message
+  );
+}
 
 // src/infrastructure/git/refs.ts
 var execFileAsync4 = promisify5(execFile4);
@@ -14690,9 +14717,72 @@ function levenshtein(a, b3) {
 }
 
 // src/infrastructure/persistence/history.ts
-import { mkdir as mkdir3, readFile as readFile3, writeFile as writeFile3 } from "node:fs/promises";
+import { readFile as readFile3 } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
-import { dirname as dirname4, join as join6, resolve as resolve6 } from "node:path";
+import { join as join6, resolve as resolve6 } from "node:path";
+
+// src/infrastructure/filesystem/locked-file.ts
+import { randomUUID } from "node:crypto";
+import {
+  mkdir as mkdir3,
+  open as open3,
+  rename,
+  rm,
+  stat,
+  unlink,
+  writeFile as writeFile3
+} from "node:fs/promises";
+import { dirname as dirname4 } from "node:path";
+import { setTimeout as delay2 } from "node:timers/promises";
+var LOCK_STALE_AFTER_MS = 1e4;
+var LOCK_RETRY_DELAY_MS = 5;
+var LOCK_WAIT_TIMEOUT_MS = LOCK_STALE_AFTER_MS + LOCK_RETRY_DELAY_MS;
+async function withFileLock(path9, operation) {
+  await mkdir3(dirname4(path9), { recursive: true });
+  const release = await acquireFileLock(path9);
+  try {
+    return await operation();
+  } finally {
+    await release();
+  }
+}
+async function writeJsonAtomic(path9, value) {
+  const temporaryPath = `${path9}.tmp-${process.pid}-${randomUUID()}`;
+  try {
+    await writeFile3(
+      temporaryPath,
+      `${JSON.stringify(value, null, 2)}
+`,
+      "utf8"
+    );
+    await rename(temporaryPath, path9);
+  } catch (error) {
+    await rm(temporaryPath, { force: true }).catch(() => void 0);
+    throw error;
+  }
+}
+async function acquireFileLock(path9) {
+  const lockPath = `${path9}.lock`;
+  const deadline = Date.now() + LOCK_WAIT_TIMEOUT_MS;
+  while (Date.now() < deadline) {
+    try {
+      const handle = await open3(lockPath, "wx");
+      return async () => {
+        await handle.close();
+        await unlink(lockPath).catch(() => void 0);
+      };
+    } catch (error) {
+      if (!isAlreadyExistsError(error)) throw error;
+      const lockStat = await stat(lockPath).catch(() => null);
+      if (lockStat && Date.now() - lockStat.mtimeMs > LOCK_STALE_AFTER_MS)
+        await unlink(lockPath).catch(() => void 0);
+      await delay2(LOCK_RETRY_DELAY_MS);
+    }
+  }
+  throw new Error(`timed out waiting for the lock on ${path9}`);
+}
+
+// src/infrastructure/persistence/history.ts
 var HISTORY_FILE_NAME = "history.json";
 var MAX_HISTORY_ENTRIES = 50;
 function HISTORY_FILE_PATH(home = homedir2()) {
@@ -14715,15 +14805,15 @@ async function loadHistory(home = homedir2()) {
 }
 async function appendHistory(path9, branch, home = homedir2()) {
   const historyPath = HISTORY_FILE_PATH(home);
-  const existing = await loadHistory(home);
-  const entry = { branch, path: path9, timestamp: Date.now() };
-  const next = [
-    entry,
-    ...existing.filter((existingEntry) => existingEntry.path !== path9)
-  ].slice(0, MAX_HISTORY_ENTRIES);
-  await mkdir3(dirname4(historyPath), { recursive: true });
-  await writeFile3(historyPath, `${JSON.stringify(next, null, 2)}
-`, "utf8");
+  await withFileLock(historyPath, async () => {
+    const existing = await loadHistory(home);
+    const entry = { branch, path: path9, timestamp: Date.now() };
+    const next = [
+      entry,
+      ...existing.filter((existingEntry) => existingEntry.path !== path9)
+    ].slice(0, MAX_HISTORY_ENTRIES);
+    await writeJsonAtomic(historyPath, next);
+  });
 }
 async function recordWorktreeUsage(path9, branch, home = homedir2()) {
   try {
@@ -14736,9 +14826,9 @@ function isHistoryEntry(value) {
 }
 
 // src/infrastructure/persistence/slots.ts
-import { mkdir as mkdir4, readFile as readFile4, writeFile as writeFile4 } from "node:fs/promises";
+import { readFile as readFile4 } from "node:fs/promises";
 import { homedir as homedir3 } from "node:os";
-import { dirname as dirname5, join as join7, resolve as resolve7 } from "node:path";
+import { join as join7, resolve as resolve7 } from "node:path";
 function SLOTS_FILE_PATH(home = homedir3()) {
   const configDir = process.env.GJI_CONFIG_DIR;
   return configDir ? join7(resolve7(configDir), "slots.json") : join7(home, GLOBAL_CONFIG_DIRECTORY, "slots.json");
@@ -14755,32 +14845,33 @@ async function loadSlots(home = homedir3()) {
   }
 }
 async function assignWorktreeSlot(repoRoot, worktreePath, home = homedir3()) {
-  const slots = await loadSlots(home);
-  const existing = slots[worktreePath];
-  if (existing !== void 0) return existing;
-  if (worktreePath !== repoRoot && slots[repoRoot] === void 0)
-    slots[repoRoot] = 0;
-  const used = new Set(Object.values(slots));
-  const slot = worktreePath === repoRoot ? 0 : nextAvailableSlot(used);
-  slots[worktreePath] = slot;
-  await saveSlots(slots, home);
-  return slot;
+  return withFileLock(SLOTS_FILE_PATH(home), async () => {
+    const slots = await loadSlots(home);
+    const existing = slots[worktreePath];
+    if (existing !== void 0) return existing;
+    if (worktreePath !== repoRoot && slots[repoRoot] === void 0)
+      slots[repoRoot] = 0;
+    const used = new Set(Object.values(slots));
+    const slot = worktreePath === repoRoot ? 0 : nextAvailableSlot(used);
+    slots[worktreePath] = slot;
+    await saveSlots(slots, home);
+    return slot;
+  });
 }
 async function getWorktreeSlot(worktreePath, home = homedir3()) {
   const slot = (await loadSlots(home))[worktreePath];
   return slot === void 0 ? null : slot;
 }
 async function releaseWorktreeSlot(worktreePath, home = homedir3()) {
-  const slots = await loadSlots(home);
-  if (!(worktreePath in slots)) return;
-  delete slots[worktreePath];
-  await saveSlots(slots, home);
+  await withFileLock(SLOTS_FILE_PATH(home), async () => {
+    const slots = await loadSlots(home);
+    if (!(worktreePath in slots)) return;
+    delete slots[worktreePath];
+    await saveSlots(slots, home);
+  });
 }
 async function saveSlots(slots, home) {
-  const path9 = SLOTS_FILE_PATH(home);
-  await mkdir4(dirname5(path9), { recursive: true });
-  await writeFile4(path9, `${JSON.stringify(slots, null, 2)}
-`, "utf8");
+  await writeJsonAtomic(SLOTS_FILE_PATH(home), slots);
 }
 function nextAvailableSlot(used) {
   let slot = 1;
@@ -14792,16 +14883,16 @@ function isSlotStore(value) {
 }
 
 // src/infrastructure/persistence/task.ts
-import { readFile as readFile5, unlink, writeFile as writeFile5 } from "node:fs/promises";
+import { readFile as readFile5, unlink as unlink2, writeFile as writeFile4 } from "node:fs/promises";
 import { join as join8 } from "node:path";
 
 // src/infrastructure/repository/context.ts
-import { basename as basename3, dirname as dirname6, isAbsolute as isAbsolute4, resolve as resolve8 } from "node:path";
+import { basename as basename3, dirname as dirname5, isAbsolute as isAbsolute4, resolve as resolve8 } from "node:path";
 async function detectRepository(cwd) {
   const currentRoot = await runGit(cwd, ["rev-parse", "--show-toplevel"]);
   const rawCommonDir = await runGit(cwd, ["rev-parse", "--git-common-dir"]);
   const gitCommonDir = isAbsolute4(rawCommonDir) ? rawCommonDir : resolve8(currentRoot, rawCommonDir);
-  const repoRoot = dirname6(gitCommonDir);
+  const repoRoot = dirname5(gitCommonDir);
   return {
     currentRoot,
     isWorktree: currentRoot !== repoRoot,
@@ -14828,13 +14919,13 @@ async function readTask(worktreePath) {
 async function writeTask(worktreePath, task, source = "manual") {
   const metadata = { source, task, updatedAt: Date.now() };
   const path9 = await taskPath(worktreePath);
-  await writeFile5(path9, `${JSON.stringify(metadata, null, 2)}
+  await writeFile4(path9, `${JSON.stringify(metadata, null, 2)}
 `, "utf8");
   return metadata;
 }
 async function clearTask(worktreePath) {
   try {
-    await unlink(await taskPath(worktreePath));
+    await unlink2(await taskPath(worktreePath));
   } catch {
   }
 }
@@ -14946,10 +15037,16 @@ function extractHooks(config) {
   }
   const hooks = raw;
   return {
+    "after-branch-create": parseHookCommand(
+      hooks["after-branch-create"] ?? hooks.afterBranchCreate
+    ),
     "after-create": parseHookCommand(
       hooks["after-create"] ?? hooks.afterCreate
     ),
     "after-enter": parseHookCommand(hooks["after-enter"] ?? hooks.afterEnter),
+    "after-switch": parseHookCommand(
+      hooks["after-switch"] ?? hooks.afterSwitch
+    ),
     "before-remove": parseHookCommand(
       hooks["before-remove"] ?? hooks.beforeRemove
     )
@@ -14999,22 +15096,12 @@ async function getRepositoryRemoteUrl(repoRoot, remote) {
 }
 
 // src/infrastructure/repository/registry.ts
-import { randomUUID } from "node:crypto";
 import { constants as constants4 } from "node:fs";
-import {
-  access,
-  mkdir as mkdir5,
-  readFile as readFile6,
-  realpath as realpath4,
-  rename,
-  rm,
-  writeFile as writeFile6
-} from "node:fs/promises";
+import { access, readFile as readFile6, realpath as realpath4 } from "node:fs/promises";
 import { homedir as homedir4 } from "node:os";
-import { basename as basename4, dirname as dirname7, join as join9, resolve as resolve9 } from "node:path";
+import { basename as basename4, join as join9, resolve as resolve9 } from "node:path";
 var REGISTRY_FILE_NAME = "repos.json";
 var MAX_REGISTRY_ENTRIES = 100;
-var registryLocks = /* @__PURE__ */ new Map();
 function REGISTRY_FILE_PATH(home = homedir4()) {
   const configDir = process.env.GJI_CONFIG_DIR;
   if (configDir) {
@@ -15042,9 +15129,10 @@ async function canonicalizeRepoPath(repoPath) {
 }
 async function registerRepo(repoPath, home = homedir4()) {
   const registryPath = REGISTRY_FILE_PATH(home);
-  await withRegistryLock(registryPath, async () => {
+  const canonicalRepoPath = await canonicalizeRepoPath(repoPath);
+  if ((await loadRegistry(home))[0]?.path === canonicalRepoPath) return;
+  await withFileLock(registryPath, async () => {
     const existing = await normalizeRegistryForWrite(await loadRegistry(home));
-    const canonicalRepoPath = await canonicalizeRepoPath(repoPath);
     if (existing.length > 0 && existing[0].path === canonicalRepoPath) return;
     const entry = {
       lastUsed: Date.now(),
@@ -15053,13 +15141,13 @@ async function registerRepo(repoPath, home = homedir4()) {
     };
     const filtered = existing.filter((e2) => e2.path !== canonicalRepoPath);
     const next = [entry, ...filtered].slice(0, MAX_REGISTRY_ENTRIES);
-    await writeRegistry(next, registryPath);
+    await writeJsonAtomic(registryPath, next);
   });
 }
 async function removeMissingRegistryEntries(paths, home = homedir4()) {
   if (paths.size === 0) return { removedPaths: [], skippedPaths: [] };
   const registryPath = REGISTRY_FILE_PATH(home);
-  return withRegistryLock(registryPath, async () => {
+  return withFileLock(registryPath, async () => {
     const entries = await loadRegistry(home);
     const candidates = entries.filter((entry) => paths.has(entry.path));
     const status = await Promise.all(
@@ -15071,31 +15159,14 @@ async function removeMissingRegistryEntries(paths, home = homedir4()) {
     const removedPaths = status.filter(({ missing }) => missing).map(({ entry }) => entry.path);
     const skippedPaths = status.filter(({ missing }) => !missing).map(({ entry }) => entry.path);
     if (removedPaths.length > 0) {
-      await writeRegistry(
-        entries.filter((entry) => !removedPaths.includes(entry.path)),
-        registryPath
+      await writeJsonAtomic(
+        registryPath,
+        entries.filter((entry) => !removedPaths.includes(entry.path))
       );
     }
     return { removedPaths, skippedPaths };
   });
 }
-async function withRegistryLock(registryPath, operation) {
-  const previous = registryLocks.get(registryPath);
-  let release;
-  const current = new Promise((resolve13) => {
-    release = resolve13;
-  });
-  registryLocks.set(registryPath, current);
-  if (previous) await previous;
-  try {
-    return await operation();
-  } finally {
-    release();
-    if (registryLocks.get(registryPath) === current) {
-      registryLocks.delete(registryPath);
-    }
-  }
-}
 async function isMissingPath(path9) {
   try {
     await access(path9, constants4.F_OK);
@@ -15109,22 +15180,6 @@ function isMissingPathError(error) {
   const code = error.code;
   return code === "ENOENT" || code === "ENOTDIR";
 }
-async function writeRegistry(entries, registryPath) {
-  await mkdir5(dirname7(registryPath), { recursive: true });
-  const temporaryPath = `${registryPath}.tmp-${process.pid}-${randomUUID()}`;
-  try {
-    await writeFile6(
-      temporaryPath,
-      `${JSON.stringify(entries, null, 2)}
-`,
-      "utf8"
-    );
-    await rename(temporaryPath, registryPath);
-  } catch (error) {
-    await rm(temporaryPath, { force: true }).catch(() => void 0);
-    throw error;
-  }
-}
 async function normalizeRegistryForWrite(entries) {
   const normalized = [];
   const seenPaths = /* @__PURE__ */ new Set();
@@ -15368,15 +15423,93 @@ function serializeWorktreeInfo(info) {
 
 // src/infrastructure/worktree/lifecycle.ts
 import { execFile as execFile7 } from "node:child_process";
-import { rm as rm2 } from "node:fs/promises";
+import { mkdir as mkdir4, rm as rm2, rmdir } from "node:fs/promises";
 import { promisify as promisify8 } from "node:util";
 var execFileAsync7 = promisify8(execFile7);
-var GIT_ENV = { ...process.env, LC_ALL: "C" };
+var BRANCH_CONFIG_CLEANUP_TIMEOUT_MS = 1e3;
+async function addWorktree(repoRoot, worktreePath, target) {
+  await claimWorktreePath(worktreePath);
+  if ("create" in target) {
+    try {
+      await createBranch(repoRoot, target.branch, target.create);
+    } catch (error) {
+      await rmdir(worktreePath).catch(() => void 0);
+      throw error;
+    }
+  }
+  const args = "branch" in target ? [target.branch] : ["--detach", ...target.detachedAt ? [target.detachedAt] : []];
+  try {
+    await retryGitContention(
+      () => execFileAsync7("git", ["worktree", "add", worktreePath, ...args], {
+        cwd: repoRoot
+      })
+    );
+  } catch (error) {
+    await removeCreatedWorktree(
+      repoRoot,
+      worktreePath,
+      "create" in target ? target.branch : void 0
+    );
+    throw error;
+  }
+}
+async function removeCreatedWorktree(repoRoot, worktreePath, createdBranch) {
+  await runLifecycleGit(repoRoot, [
+    "worktree",
+    "remove",
+    "--force",
+    worktreePath
+  ]).catch(() => void 0);
+  await rmdir(worktreePath).catch(() => void 0);
+  if (createdBranch) await deleteCreatedBranch(repoRoot, createdBranch);
+}
+async function claimWorktreePath(worktreePath) {
+  try {
+    await mkdir4(worktreePath);
+  } catch (error) {
+    if (!isAlreadyExistsError(error)) throw error;
+    throw new Error(`target worktree path already exists: ${worktreePath}`);
+  }
+}
+async function createBranch(repoRoot, branch, options = {}) {
+  const args = [
+    "branch",
+    ...options.track ? ["--track"] : [],
+    branch,
+    ...options.startPoint ? [options.startPoint] : []
+  ];
+  try {
+    await retryGitContention(async () => {
+      try {
+        await execFileAsync7("git", args, { cwd: repoRoot, env: GIT_ENV });
+      } catch (error) {
+        if (isGitConfigLockError(error))
+          await forceDeleteBranch(repoRoot, branch);
+        throw error;
+      }
+    });
+  } catch (error) {
+    if (isGitConfigLockError(error))
+      await removeBranchConfig(repoRoot, branch).catch(() => void 0);
+    throw error;
+  }
+}
+async function deleteCreatedBranch(repoRoot, branch) {
+  try {
+    await forceDeleteBranch(repoRoot, branch);
+    await removeBranchConfig(repoRoot, branch);
+  } catch {
+  }
+}
+async function removeBranchConfig(repoRoot, branch) {
+  await runLifecycleGit(
+    repoRoot,
+    ["config", "--remove-section", `branch.${branch}`],
+    BRANCH_CONFIG_CLEANUP_TIMEOUT_MS
+  );
+}
 async function removeWorktree(repoRoot, worktreePath) {
-  await execFileAsync7("git", ["worktree", "remove", worktreePath], {
-    cwd: repoRoot,
-    env: GIT_ENV
-  });
+  await runLifecycleGit(repoRoot, ["worktree", "remove", worktreePath]);
 }
 async function forceRemoveWorktree(repoRoot, worktreePath) {
   try {
@@ -15397,10 +15530,12 @@ async function forceRemoveWorktree(repoRoot, worktreePath) {
   }
 }
 async function removeWorktreeWithForce(repoRoot, worktreePath) {
-  await execFileAsync7("git", ["worktree", "remove", "--force", worktreePath], {
-    cwd: repoRoot,
-    env: GIT_ENV
-  });
+  await runLifecycleGit(repoRoot, [
+    "worktree",
+    "remove",
+    "--force",
+    worktreePath
+  ]);
 }
 async function deinitializeSubmodules(worktreePath) {
   await execFileAsync7("git", ["submodule", "deinit", "--force", "--all"], {
@@ -15409,16 +15544,10 @@ async function deinitializeSubmodules(worktreePath) {
   });
 }
 async function deleteBranch(repoRoot, branch) {
-  await execFileAsync7("git", ["branch", "-d", branch], {
-    cwd: repoRoot,
-    env: GIT_ENV
-  });
+  await runLifecycleGit(repoRoot, ["branch", "-d", branch]);
 }
 async function forceDeleteBranch(repoRoot, branch) {
-  await execFileAsync7("git", ["branch", "-D", branch], {
-    cwd: repoRoot,
-    env: GIT_ENV
-  });
+  await runLifecycleGit(repoRoot, ["branch", "-D", branch]);
 }
 function isWorktreeForceRemovalError(error) {
   if (!hasStderr(error)) {
@@ -15440,6 +15569,15 @@ function isBranchUnmergedError(error) {
 function hasStderr(error) {
   return error instanceof Error && "stderr" in error && typeof error.stderr === "string";
 }
+async function runLifecycleGit(repoRoot, args, timeoutMs) {
+  await retryGitContention(
+    () => execFileAsync7("git", args, { cwd: repoRoot, env: GIT_ENV }),
+    timeoutMs
+  );
+}
+function isGitConfigLockError(error) {
+  return error instanceof Error && error.message.includes("could not lock config file");
+}
 
 // src/presentation/worktree/format.ts
 function formatUpstreamState(upstream) {
@@ -15507,6 +15645,11 @@ function createCliDependencies() {
     git: {
       runGit,
       runGitRaw,
+      runGitRetryingContention,
+      addWorktree,
+      createBranch,
+      deleteCreatedBranch,
+      removeCreatedWorktree,
       isDirtyWorktree,
       readWorktreeHealth,
       isBranchMergedInto,
@@ -15650,7 +15793,8 @@ async function runBackCommand(options) {
       {
         branch: target.branch ?? void 0,
         path: target.path,
-        repo: basename6(repository.repoRoot)
+        repo: basename6(repository.repoRoot),
+        slot: await runtime.slots.getWorktreeSlot(target.path)
       },
       options.stderr
     );
@@ -15692,7 +15836,7 @@ function formatAge(timestamp) {
 
 // src/cli/commands/clean.ts
 import { realpath as realpath5 } from "node:fs/promises";
-import { basename as basename8, dirname as dirname10, join as join12, resolve as resolve11 } from "node:path";
+import { basename as basename8, dirname as dirname7, join as join12, resolve as resolve11 } from "node:path";
 
 // node_modules/.pnpm/@clack+core@0.5.0/node_modules/@clack/core/dist/index.mjs
 var import_sisteransi = __toESM(require_src(), 1);
@@ -16544,7 +16688,7 @@ function globToRegExp(pattern) {
 
 // src/domain/worktree/policy.ts
 import { homedir as homedir5 } from "node:os";
-import { basename as basename7, dirname as dirname8, join as join10 } from "node:path";
+import { basename as basename7, dirname as dirname6, join as join10 } from "node:path";
 function resolveWorktreePath(repoRoot, branch, basePath) {
   const segments = branch.split("/").filter(Boolean);
   if (segments.length === 0) {
@@ -16555,7 +16699,7 @@ function resolveWorktreePath(repoRoot, branch, basePath) {
       `Branch name '${branch}' contains an invalid path segment.`
     );
   }
-  const base = basePath ? expandTildeInPath(basePath) : join10(dirname8(repoRoot), "worktrees", basename7(repoRoot));
+  const base = basePath ? expandTildeInPath(basePath) : join10(dirname6(repoRoot), "worktrees", basename7(repoRoot));
   return join10(base, ...segments);
 }
 function validateBranchName(name) {
@@ -17594,27 +17738,14 @@ async function defaultConfirmForceDeleteBranch(branch) {
 
 // src/cli/runtime/headless.ts
 function isHeadless() {
-  return process.env.GJI_NO_TUI === "1";
+  return process.env.GJI_NO_TUI === "1" || process.stdin.isTTY !== true || process.stdout.isTTY !== true;
 }
 
 // src/cli/commands/undo.ts
-import {
-  access as access4,
-  mkdir as mkdir6,
-  open as open3,
-  readFile as readFile7,
-  rename as rename2,
-  stat,
-  unlink as unlink2,
-  writeFile as writeFile7
-} from "node:fs/promises";
+import { access as access4, readFile as readFile7 } from "node:fs/promises";
 import { homedir as homedir6 } from "node:os";
-import { dirname as dirname9, join as join11, resolve as resolve10 } from "node:path";
+import { join as join11, resolve as resolve10 } from "node:path";
 var MAX_UNDO_RECORDS = 20;
-var UNDO_LOCK_STALE_AFTER_MS = 6e4;
-var UNDO_LOCK_RETRY_DELAY_MS = 5;
-var UNDO_LOCK_WAIT_TIMEOUT_MS = UNDO_LOCK_STALE_AFTER_MS + UNDO_LOCK_RETRY_DELAY_MS;
-var undoLogQueues = /* @__PURE__ */ new Map();
 function undoLogPath(home = homedir6(), globalConfigDirectory = defaultCliDependencies.configStore.GLOBAL_CONFIG_DIRECTORY) {
   const configured = process.env.GJI_CONFIG_DIR;
   return join11(
@@ -17668,39 +17799,31 @@ async function recordUndoOperation(op, repoRoot, worktrees, home = homedir6(), r
     timestamp,
     entries
   };
-  return enqueueUndoLogWrite(
-    home,
-    async () => {
-      const existing = await loadUndoRecords(home, globalConfigDirectory);
-      await writeUndoRecords(
-        home,
-        [record, ...existing].slice(0, MAX_UNDO_RECORDS),
-        globalConfigDirectory
-      );
-      return record;
-    },
-    globalConfigDirectory
-  );
+  return withFileLock(undoLogPath(home, globalConfigDirectory), async () => {
+    const existing = await loadUndoRecords(home, globalConfigDirectory);
+    await writeUndoRecords(
+      home,
+      [record, ...existing].slice(0, MAX_UNDO_RECORDS),
+      globalConfigDirectory
+    );
+    return record;
+  });
 }
 async function finalizeUndoOperation(record, removedWorktrees, home = homedir6(), globalConfigDirectory = defaultCliDependencies.configStore.GLOBAL_CONFIG_DIRECTORY) {
   const removedPaths = new Set(
     removedWorktrees.map((worktree) => worktree.path)
   );
-  await enqueueUndoLogWrite(
-    home,
-    async () => {
-      const records = await loadUndoRecords(home, globalConfigDirectory);
-      const remaining = records.flatMap((candidate) => {
-        if (candidate.id !== record.id) return [candidate];
-        const entries = candidate.entries.filter(
-          (entry) => removedPaths.has(entry.path)
-        );
-        return entries.length === 0 ? [] : [{ ...candidate, entries }];
-      });
-      await writeUndoRecords(home, remaining, globalConfigDirectory);
-    },
-    globalConfigDirectory
-  );
+  await withFileLock(undoLogPath(home, globalConfigDirectory), async () => {
+    const records = await loadUndoRecords(home, globalConfigDirectory);
+    const remaining = records.flatMap((candidate) => {
+      if (candidate.id !== record.id) return [candidate];
+      const entries = candidate.entries.filter(
+        (entry) => removedPaths.has(entry.path)
+      );
+      return entries.length === 0 ? [] : [{ ...candidate, entries }];
+    });
+    await writeUndoRecords(home, remaining, globalConfigDirectory);
+  });
 }
 async function restoreUndoRecord(record, home = homedir6(), runtime = defaultCliDependencies) {
   const globalConfigDirectory = runtime.configStore.GLOBAL_CONFIG_DIRECTORY;
@@ -17724,19 +17847,15 @@ async function restoreUndoRecord(record, home = homedir6(), runtime = defaultCli
       unresolved.push(entry);
     }
   }
-  await enqueueUndoLogWrite(
-    home,
-    async () => {
-      const records = await loadUndoRecords(home, globalConfigDirectory);
-      const remaining = records.flatMap((candidate) => {
-        if (candidate.id !== record.id) return [candidate];
-        if (unresolved.length === 0) return [];
-        return [{ ...candidate, entries: unresolved }];
-      });
-      await writeUndoRecords(home, remaining, globalConfigDirectory);
-    },
-    globalConfigDirectory
-  );
+  await withFileLock(undoLogPath(home, globalConfigDirectory), async () => {
+    const records = await loadUndoRecords(home, globalConfigDirectory);
+    const remaining = records.flatMap((candidate) => {
+      if (candidate.id !== record.id) return [candidate];
+      if (unresolved.length === 0) return [];
+      return [{ ...candidate, entries: unresolved }];
+    });
+    await writeUndoRecords(home, remaining, globalConfigDirectory);
+  });
   return { restored, failed };
 }
 async function runUndoCommand(options) {
@@ -17912,69 +18031,8 @@ async function assertCommitExists(repoRoot, headSha, runGit2) {
     throw new Error("commit no longer exists (gc'd) \u2014 cannot restore");
   }
 }
-async function enqueueUndoLogWrite(home, operation, globalConfigDirectory = defaultCliDependencies.configStore.GLOBAL_CONFIG_DIRECTORY) {
-  const path9 = undoLogPath(home, globalConfigDirectory);
-  await mkdir6(dirname9(path9), { recursive: true });
-  const previous = undoLogQueues.get(path9) ?? Promise.resolve();
-  const runLocked = async () => {
-    const release = await acquireUndoLogLock(path9);
-    try {
-      return await operation();
-    } finally {
-      await release();
-    }
-  };
-  const current = previous.then(runLocked, runLocked);
-  const settled = current.then(
-    () => void 0,
-    () => void 0
-  );
-  undoLogQueues.set(path9, settled);
-  try {
-    return await current;
-  } finally {
-    if (undoLogQueues.get(path9) === settled) undoLogQueues.delete(path9);
-  }
-}
-async function acquireUndoLogLock(path9) {
-  const lockPath = `${path9}.lock`;
-  const deadline = Date.now() + UNDO_LOCK_WAIT_TIMEOUT_MS;
-  while (Date.now() < deadline) {
-    try {
-      const handle = await open3(lockPath, "wx");
-      return async () => {
-        await handle.close();
-        await unlink2(lockPath).catch(() => void 0);
-      };
-    } catch (error) {
-      if (!(error instanceof Error && "code" in error && error.code === "EEXIST"))
-        throw error;
-      const lockStat = await stat(lockPath).catch(() => null);
-      if (lockStat && Date.now() - lockStat.mtimeMs > UNDO_LOCK_STALE_AFTER_MS)
-        await unlink2(lockPath).catch(() => void 0);
-      const remainingMs = deadline - Date.now();
-      if (remainingMs > 0)
-        await new Promise(
-          (resolve13) => setTimeout(resolve13, Math.min(UNDO_LOCK_RETRY_DELAY_MS, remainingMs))
-        );
-    }
-  }
-  throw new Error("timed out waiting for the undo journal lock");
-}
 async function writeUndoRecords(home, records, globalConfigDirectory = defaultCliDependencies.configStore.GLOBAL_CONFIG_DIRECTORY) {
-  const path9 = undoLogPath(home, globalConfigDirectory);
-  await mkdir6(dirname9(path9), { recursive: true });
-  const temporaryPath = `${path9}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
-  try {
-    await writeFile7(temporaryPath, `${JSON.stringify(records, null, 2)}
-`, {
-      encoding: "utf8",
-      flag: "wx"
-    });
-    await rename2(temporaryPath, path9);
-  } finally {
-    await unlink2(temporaryPath).catch(() => void 0);
-  }
+  await writeJsonAtomic(undoLogPath(home, globalConfigDirectory), records);
 }
 function isUndoRecord(value) {
   if (!value || typeof value !== "object") return false;
@@ -18029,7 +18087,8 @@ function createCleanCommand(dependencies = {}) {
       runGit: runGit2
     } = runtime.git;
     const { loadEffectiveConfig: loadEffectiveConfig2 } = runtime.config;
-    const { releaseWorktreeSlot: releaseWorktreeSlot2 } = runtime.slots;
+    const { getWorktreeSlot: getWorktreeSlot2, releaseWorktreeSlot: releaseWorktreeSlot2 } = runtime.slots;
+    const { extractHooks: extractHooks2, runHook: runHook2 } = runtime.hooks;
     const sourceDependencies = {
       ...runtime.repositoryContext,
       ...runtime.repositoryRegistry,
@@ -18170,9 +18229,10 @@ function createCleanCommand(dependencies = {}) {
       if (options.json) {
         emitError(options, message);
       } else {
+        options.stderr(`gji clean: ${message} in non-interactive mode
+`);
         options.stderr(
-          `gji clean: ${message} in non-interactive mode (GJI_NO_TUI=1)
-`
+          "Hint: --force removes every candidate; use --dry-run to preview them first\n"
         );
       }
       return 1;
@@ -18277,6 +18337,19 @@ function createCleanCommand(dependencies = {}) {
         );
         continue;
       }
+      const hooks = extractHooks2(await loadEffectiveConfig2(repoRoot));
+      await runHook2(
+        hooks["before-remove"],
+        worktree.path,
+        {
+          branch: worktree.branch ?? void 0,
+          path: worktree.path,
+          repo: basename8(repoRoot),
+          slot: await getWorktreeSlot2(worktree.path)
+        },
+        options.stderr,
+        options.json ? () => void 0 : options.stdout
+      );
       try {
         await removeWorktree2(repoRoot, worktree.path);
       } catch (error) {
@@ -18399,7 +18472,7 @@ async function canonicalizePathPatterns(cwd, patterns) {
 }
 async function canonicalizeLiteralPrefix(pattern) {
   const globIndex = findGlobIndex(pattern);
-  let prefix = globIndex === -1 ? pattern : dirname10(`${pattern.slice(0, globIndex)}x`);
+  let prefix = globIndex === -1 ? pattern : dirname7(`${pattern.slice(0, globIndex)}x`);
   let suffix = pattern.slice(prefix.length);
   for (; ; ) {
     try {
@@ -18408,7 +18481,7 @@ async function canonicalizeLiteralPrefix(pattern) {
       );
       return `${canonicalPrefix}${suffix}`.replace(/^\/\//, "/");
     } catch {
-      const parent = dirname10(prefix);
+      const parent = dirname7(prefix);
       if (parent === prefix) return pattern;
       suffix = join12("/", basename8(prefix), suffix);
       prefix = parent;
@@ -18727,23 +18800,20 @@ var TOP_LEVEL_COMMANDS = [
   },
   { name: "ls", description: "list active worktrees" },
   { name: "clean", description: "interactively prune linked worktrees" },
-  {
-    name: "remove",
-    description: "deprecated: use done for one worktree or clean for bulk cleanup"
-  },
-  { name: "rm", description: "deprecated alias of remove" },
   {
     name: "run-hook",
     description: "run a named hook in the current worktree"
   },
-  {
-    name: "warp",
-    description: "deprecated: use go (press Tab for all known repos)"
-  },
   { name: "config", description: "manage global config defaults" }
 ];
 var SHELL_NAMES = ["bash", "fish", "zsh"];
-var HOOK_NAMES = ["after-create", "after-enter", "before-remove"];
+var HOOK_NAMES = [
+  "after-branch-create",
+  "after-create",
+  "after-enter",
+  "after-switch",
+  "before-remove"
+];
 var CONFIG_KEYS = Array.from(KNOWN_GLOBAL_CONFIG_KEYS);
 function renderShellCompletion(shell) {
   switch (shell) {
@@ -18922,15 +18992,9 @@ _gji_completion() {
         COMPREPLY=( $(compgen -W "-f --force --stale --path --dry-run --json --help" -- "$cur") )
       fi
       ;;
-    remove|rm)
-      COMPREPLY=( $(compgen -W "$(__gji_worktree_branches) -f --force --dry-run --json --help" -- "$cur") )
-      ;;
     run-hook)
       COMPREPLY=( $(compgen -W "${hooks} --help" -- "$cur") )
       ;;
-    warp)
-      COMPREPLY=( $(compgen -W "--print --json --help" -- "$cur") )
-      ;;
     config)
       if [ "$COMP_CWORD" -eq 2 ]; then
         COMPREPLY=( $(compgen -W "get set unset" -- "$cur") )
@@ -19167,18 +19231,10 @@ complete -c gji -n '__fish_seen_subcommand_from clean' -l path -r -F -d 'only ta
 complete -c gji -n '__fish_seen_subcommand_from clean' -l dry-run -d 'show what would be deleted without removing anything'
 complete -c gji -n '__fish_seen_subcommand_from clean' -l json -d 'emit JSON on success or error instead of human-readable output'
 
-complete -c gji -n '__fish_seen_subcommand_from remove rm' -s f -l force -d 'bypass prompts, force-remove a dirty worktree, and force-delete an unmerged branch'
-complete -c gji -n '__fish_seen_subcommand_from remove rm' -l dry-run -d 'show what would be deleted without removing anything'
-complete -c gji -n '__fish_seen_subcommand_from remove rm' -l json -d 'emit JSON on success or error instead of human-readable output'
-complete -c gji -n '__fish_seen_subcommand_from remove rm' -a '(__gji_worktree_branches)' -d 'worktree branch'
-
 ${hookLines}
 
 complete -c gji -n '__fish_use_subcommand' -l json -d 'emit the repository hub as JSON'
 
-complete -c gji -n '__fish_seen_subcommand_from warp' -l print -d 'print the resolved worktree path without changing directory'
-complete -c gji -n '__fish_seen_subcommand_from warp' -l json -d 'emit JSON on success or error instead of human-readable output'
-
 complete -c gji -n '__fish_seen_subcommand_from config; and __gji_should_complete_config_action' -a 'get set unset' -d 'config action'
 ${configKeyLines}`;
 }
@@ -19326,15 +19382,9 @@ case "\${words[2]}" in
   clean)
     _arguments '(-f --force)'{-f,--force}'[bypass prompts, force-remove dirty worktrees, and force-delete unmerged branches]' '--stale[only target clean worktrees whose upstream is gone and branch is merged into the default branch]' '*--path[only target worktrees under a directory or matching a path glob]:pattern:_files' '--dry-run[show what would be deleted without removing anything]' '--json[emit JSON on success or error instead of human-readable output]'
     ;;
-  remove|rm)
-    _arguments '(-f --force)'{-f,--force}'[bypass prompts, force-remove a dirty worktree, and force-delete an unmerged branch]' '--dry-run[show what would be deleted without removing anything]' '--json[emit JSON on success or error instead of human-readable output]' '2:branch:->worktrees'
-    ;;
   run-hook)
     _arguments "2:hook:(${hooks})"
     ;;
-  warp)
-    _arguments '--print[print the resolved worktree path without changing directory]' '--json[emit JSON on success or error instead of human-readable output]' '2:branch: '
-    ;;
   config)
     if (( CURRENT == 3 )); then
       _values 'config action' get set unset
@@ -19462,7 +19512,7 @@ import { execFile as execFile8 } from "node:child_process";
 import { constants as constants6 } from "node:fs";
 import { access as access6, readFile as readFile8 } from "node:fs/promises";
 import { homedir as homedir7 } from "node:os";
-import { basename as basename9, dirname as dirname11, join as join14 } from "node:path";
+import { basename as basename9, dirname as dirname8, join as join14 } from "node:path";
 import { promisify as promisify9 } from "node:util";
 
 // src/presentation/shell/setup.ts
@@ -19911,7 +19961,7 @@ function resolveWorktreeBase(repoRoot, config, home) {
   if (typeof configuredPath === "string" && (configuredPath.startsWith("/") || configuredPath.startsWith("~"))) {
     return expandTilde2(configuredPath, home);
   }
-  return join14(dirname11(repoRoot), "worktrees", basename9(repoRoot));
+  return join14(dirname8(repoRoot), "worktrees", basename9(repoRoot));
 }
 async function findNearestExistingPath(path9) {
   let candidate = path9;
@@ -19920,7 +19970,7 @@ async function findNearestExistingPath(path9) {
       await access6(candidate, constants6.F_OK);
       return candidate;
     } catch {
-      const parent = dirname11(candidate);
+      const parent = dirname8(candidate);
       if (parent === candidate) return null;
       candidate = parent;
     }
@@ -20083,7 +20133,7 @@ async function runDoneCommand(options) {
   } = runtime.git;
   const { loadEffectiveConfig: loadEffectiveConfig2, resolveConfigString: resolveConfigString2 } = runtime.config;
   const { loadHistory: loadHistory2 } = runtime.historyStore;
-  const { releaseWorktreeSlot: releaseWorktreeSlot2 } = runtime.slots;
+  const { getWorktreeSlot: getWorktreeSlot2, releaseWorktreeSlot: releaseWorktreeSlot2 } = runtime.slots;
   const { extractHooks: extractHooks2, runHook: runHook2 } = runtime.hooks;
   const { detectRepository: detectRepository2 } = runtime.repositoryContext;
   const { listWorktrees: listWorktrees2 } = runtime.worktrees;
@@ -20179,9 +20229,11 @@ async function runDoneCommand(options) {
     {
       branch: target.branch ?? void 0,
       path: target.path,
-      repo: basename10(repository.repoRoot)
+      repo: basename10(repository.repoRoot),
+      slot: await getWorktreeSlot2(target.path)
     },
-    options.stderr
+    options.stderr,
+    options.json ? () => void 0 : options.stdout
   );
   try {
     await removeWorktree2(repository.repoRoot, target.path);
@@ -20370,7 +20422,7 @@ function toMessage3(error) {
 }
 
 // src/cli/commands/go.ts
-import { basename as basename11 } from "node:path";
+import { basename as basename12 } from "node:path";
 
 // src/application/worktree/context-card.ts
 async function loadContextCardModel(worktreePath, dependencies) {
@@ -20696,12 +20748,12 @@ function formatState(info) {
   return `${info.status}${info.upstream.kind === "tracked" ? ` \xB7 \u2191${info.upstream.ahead} \u2193${info.upstream.behind}` : ""}`;
 }
 function formatLastCommit2(info) {
-  return new Date(info.lastCommitTimestamp).toISOString();
+  return new Date(info.lastCommitTimestamp * 1e3).toISOString();
 }
 
 // src/cli/commands/new.ts
-import { access as access8, mkdir as mkdir7 } from "node:fs/promises";
-import { dirname as dirname12, resolve as resolve12 } from "node:path";
+import { access as access8, mkdir as mkdir5, rmdir as rmdir2 } from "node:fs/promises";
+import { basename as basename11, dirname as dirname9, resolve as resolve12 } from "node:path";
 
 // src/presentation/bootstrap/output.ts
 function createBootstrapReporter(write, json) {
@@ -20816,10 +20868,8 @@ function createNewCommand(dependencies = {}) {
         options.stderr(`${JSON.stringify({ error: message }, null, 2)}
 `);
       } else {
-        options.stderr(
-          `gji new: ${message} in non-interactive mode (GJI_NO_TUI=1)
-`
-        );
+        options.stderr(`gji new: ${message} in non-interactive mode
+`);
       }
       return 1;
     }
@@ -20870,13 +20920,14 @@ function createNewCommand(dependencies = {}) {
       if (options.force) {
         if (!options.dryRun) {
           try {
-            await runtime.git.runGit(repository.repoRoot, [
+            await runtime.git.runGitRetryingContention(repository.repoRoot, [
               "worktree",
               "remove",
               "--force",
               worktreePath
             ]);
           } catch (err) {
+            await rmdir2(worktreePath).catch(() => void 0);
             if (!isNotRegisteredWorktreeError(err)) {
               const msg = `could not remove existing worktree at ${worktreePath}: ${toExecMessage(err)}`;
               if (options.json) {
@@ -20907,10 +20958,8 @@ function createNewCommand(dependencies = {}) {
           options.stderr(`${JSON.stringify({ error: message }, null, 2)}
 `);
         } else {
-          options.stderr(
-            `gji new: ${message} in non-interactive mode (GJI_NO_TUI=1)
-`
-          );
+          options.stderr(`gji new: ${message} in non-interactive mode
+`);
           options.stderr(
             `Hint: Use 'gji done ${worktreeName}' or 'gji clean' to remove the existing worktree
 `
@@ -21011,7 +21060,7 @@ ${formatDependencyBootstrapPreview(dryRunDependencyBootstrap)}`
       }
       return 0;
     }
-    await mkdir7(dirname12(worktreePath), { recursive: true });
+    await mkdir5(dirname9(worktreePath), { recursive: true });
     const startPoint = options.fromCurrent && !options.detached ? await resolveCurrentWorktreeHead(options.cwd, runtime.git.runGit) : void 0;
     const takeStartPoint = options.take ? await resolveCurrentWorktreeHead(options.cwd, runtime.git.runGit) : void 0;
     const changedTakeFiles = options.take ? await listTakeFiles(options.cwd, runtime.git.runGitRaw) : [];
@@ -21039,7 +21088,8 @@ ${formatDependencyBootstrapPreview(dryRunDependencyBootstrap)}`
       worktreeName,
       runtime
     );
-    const shouldRefreshBase = !options.noFetch && !options.detached && !options.fromCurrent && !options.take && options.mode !== "track" && options.mode !== "checkout" && !existingLocalBranch;
+    const createsBranch = !options.detached && options.mode !== "track" && options.mode !== "checkout" && !existingLocalBranch;
+    const shouldRefreshBase = createsBranch && !options.noFetch && !options.fromCurrent && !options.take;
     const freshBaseRef = shouldRefreshBase ? await resolveFreshBaseRef(
       repository.repoRoot,
       config,
@@ -21072,30 +21122,19 @@ ${formatDependencyBootstrapPreview(dryRunDependencyBootstrap)}`
         );
       }
     }
-    const gitArgs = options.detached ? [
-      "worktree",
-      "add",
-      "--detach",
-      worktreePath,
-      ...takeStartPoint ? [takeStartPoint] : []
-    ] : options.mode === "track" ? [
-      "worktree",
-      "add",
-      "--track",
-      "-b",
-      worktreeName,
-      worktreePath,
-      `${options.remote ?? "origin"}/${worktreeName}`
-    ] : options.mode === "checkout" || existingLocalBranch ? ["worktree", "add", worktreePath, worktreeName] : [
-      "worktree",
-      "add",
-      "-b",
-      worktreeName,
-      worktreePath,
-      ...takeStartPoint ? [takeStartPoint] : startPoint ? [startPoint] : freshBaseRef ? [freshBaseRef] : []
-    ];
+    const addsNewBranch = createsBranch || !options.detached && options.mode === "track";
     try {
-      await runtime.git.runGit(repository.repoRoot, gitArgs);
+      await runtime.git.addWorktree(
+        repository.repoRoot,
+        worktreePath,
+        options.detached ? { detachedAt: takeStartPoint } : addsNewBranch ? {
+          branch: worktreeName,
+          create: {
+            startPoint: options.mode === "track" ? `${options.remote ?? "origin"}/${worktreeName}` : takeStartPoint ?? startPoint ?? freshBaseRef,
+            track: options.mode === "track"
+          }
+        } : { branch: worktreeName }
+      );
     } catch (error) {
       if (stashSha)
         await restoreTakeStash(
@@ -21117,15 +21156,11 @@ ${formatDependencyBootstrapPreview(dryRunDependencyBootstrap)}`
       options.stderr,
       runtime.git.runGit
     )) {
-      try {
-        await runtime.git.runGit(repository.repoRoot, [
-          "worktree",
-          "remove",
-          "--force",
-          worktreePath
-        ]);
-      } catch {
-      }
+      await runtime.git.removeCreatedWorktree(
+        repository.repoRoot,
+        worktreePath,
+        addsNewBranch ? worktreeName : void 0
+      );
       return emitNewError(
         options,
         `could not apply taken changes; your changes are safe in stash: ${stashSha}`
@@ -21161,6 +21196,17 @@ ${formatDependencyBootstrapPreview(dryRunDependencyBootstrap)}`
         syncFiles: bootstrap.syncFileFailures
       });
     }
+    if (createsBranch) {
+      await runNewHooks({
+        branch: worktreeName,
+        config,
+        hookNames: ["after-branch-create"],
+        options,
+        path: worktreePath,
+        repository,
+        runtime
+      });
+    }
     if (options.json) {
       const navigation = createNavigationTarget(
         createNavigationRepository(repository.repoName, repository.repoRoot),
@@ -21293,7 +21339,7 @@ async function runBranchOnly(options, runtime, repository, config, rawBranch) {
   try {
     let startPoint = baseBranch;
     if (!options.noFetch) {
-      await runtime.git.runGit(repository.repoRoot, [
+      await runtime.git.runGitRetryingContention(repository.repoRoot, [
         "fetch",
         "--prune",
         remote,
@@ -21301,19 +21347,31 @@ async function runBranchOnly(options, runtime, repository, config, rawBranch) {
       ]);
       startPoint = `${remote}/${baseBranch}`;
     }
-    await runtime.git.runGit(options.cwd, [
-      "switch",
-      "-c",
-      branchName,
+    await runtime.git.createBranch(repository.repoRoot, branchName, {
       startPoint
-    ]);
+    });
+    try {
+      await runtime.git.runGit(options.cwd, ["switch", branchName]);
+    } catch (error) {
+      await runtime.git.deleteCreatedBranch(repository.repoRoot, branchName);
+      throw error;
+    }
   } catch (error) {
     return emitNewError(
       options,
       `failed to create branch in the current worktree: ${toExecMessage(error)}`
     );
   }
-  if (options.json) {
+  await runNewHooks({
+    branch: branchName,
+    config,
+    hookNames: ["after-branch-create", "after-switch"],
+    options,
+    path: repository.currentRoot,
+    repository,
+    runtime
+  });
+  if (options.json) {
     const navigation = createNavigationTarget(
       createNavigationRepository(repository.repoName, repository.repoRoot),
       repository.currentRoot,
@@ -21340,6 +21398,32 @@ async function runBranchOnly(options, runtime, repository, config, rawBranch) {
   }
   return 0;
 }
+async function runNewHooks({
+  branch,
+  config,
+  hookNames,
+  options,
+  path: path9,
+  repository,
+  runtime
+}) {
+  const hooks = runtime.hooks.extractHooks(config);
+  const context = {
+    branch,
+    path: path9,
+    repo: basename11(repository.repoRoot),
+    slot: await runtime.slots.getWorktreeSlot(path9)
+  };
+  for (const hookName of hookNames) {
+    await runtime.hooks.runHook(
+      hooks[hookName],
+      path9,
+      context,
+      options.json ? () => void 0 : options.stderr,
+      options.json ? () => void 0 : options.stdout
+    );
+  }
+}
 var runNewCommand = createNewCommand();
 async function resolveFreshBaseRef(repoRoot, config, options, promptForFetchFailure, runtime) {
   const remote = runtime.config.resolveConfigString(config, "syncRemote") ?? "origin";
@@ -21362,7 +21446,7 @@ async function resolveFreshBaseRef(repoRoot, config, options, promptForFetchFail
       throw new Error("the remote default branch is unknown");
     }
     baseBranch = remoteBase.branch;
-    await runtime.git.runGit(repoRoot, [
+    await runtime.git.runGitRetryingContention(repoRoot, [
       "fetch",
       "--prune",
       remote,
@@ -21754,8 +21838,8 @@ function emitNewError(options, message, details) {
 }
 
 // src/cli/commands/pr.ts
-import { mkdir as mkdir8 } from "node:fs/promises";
-import { dirname as dirname13 } from "node:path";
+import { mkdir as mkdir6 } from "node:fs/promises";
+import { dirname as dirname10 } from "node:path";
 var PR_OUTPUT_FILE_ENV = "GJI_PR_OUTPUT_FILE";
 function createPrCommand(dependencies = {}) {
   const prompt = dependencies.promptForPathConflict ?? promptForPathConflict;
@@ -21813,10 +21897,8 @@ function createPrCommand(dependencies = {}) {
           options.stderr(`${JSON.stringify({ error: message }, null, 2)}
 `);
         } else {
-          options.stderr(
-            `gji pr: ${message} in non-interactive mode (GJI_NO_TUI=1)
-`
-          );
+          options.stderr(`gji pr: ${message} in non-interactive mode
+`);
           options.stderr(
             `Hint: Use 'gji done pr/${prNumber}' or 'gji clean' to remove the existing worktree
 `
@@ -21894,14 +21976,29 @@ ${formatDependencyBootstrapPreview(dryRunDependencyBootstrap)}`
       }
       return 1;
     }
-    await mkdir8(dirname13(worktreePath), { recursive: true });
+    await mkdir6(dirname10(worktreePath), { recursive: true });
     const branchAlreadyExists = await localBranchExists2(
       repository.repoRoot,
       branchName,
       runtime
     );
-    const worktreeArgs = branchAlreadyExists ? ["worktree", "add", worktreePath, branchName] : ["worktree", "add", "-b", branchName, worktreePath, remoteRef];
-    await runtime.git.runGit(repository.repoRoot, worktreeArgs);
+    try {
+      await runtime.git.addWorktree(
+        repository.repoRoot,
+        worktreePath,
+        branchAlreadyExists ? { branch: branchName } : { branch: branchName, create: { startPoint: remoteRef } }
+      );
+    } catch (error) {
+      const message = `failed to create worktree: ${error instanceof Error ? error.message : String(error)}`;
+      if (options.json) {
+        options.stderr(`${JSON.stringify({ error: message }, null, 2)}
+`);
+      } else {
+        options.stderr(`gji pr: ${message}
+`);
+      }
+      return 1;
+    }
     const bootstrap = await runtime.bootstrap.bootstrapWorktree({
       branch: branchName,
       config,
@@ -21974,7 +22071,7 @@ var runPrCommand = createPrCommand();
 async function fetchPullRequestRef(repoRoot, input, prNumber, remoteRef, runtime) {
   for (const sourceRef of listPullRequestSourceRefs(input, prNumber)) {
     try {
-      await runtime.git.runGit(repoRoot, [
+      await runtime.git.runGitRetryingContention(repoRoot, [
         "fetch",
         "origin",
         `${sourceRef}:${remoteRef}`
@@ -22062,7 +22159,7 @@ function createGoCommand(dependencies = {}) {
       if (options.json || isHeadless()) {
         return emitError2(
           options,
-          "branch argument is required in non-interactive mode (GJI_NO_TUI=1)"
+          "branch argument is required in non-interactive mode"
         );
       }
       let skippedRegisteredRepos = 0;
@@ -22206,10 +22303,10 @@ async function handleGoBranchResolution(options, resolution, confirmBranchCreati
         runtime
       );
     case "pull-request":
-      if (options.json || isHeadless() || options.print) {
+      if (options.json || options.print) {
         return emitError2(
           options,
-          "PR navigation creates a worktree; use `gji pr <ref>` in an interactive shell"
+          "PR navigation creates a worktree; use `gji pr <ref>`"
         );
       }
       return runPrCommand({
@@ -22254,9 +22351,16 @@ function deduplicateSources(sources) {
 }
 async function createExistingBranchWorktree(options, confirmBranchCreation, repository, branch, mode, remote, runtime) {
   if (options.json || isHeadless() || options.print) {
+    const command = await resolveNonInteractiveCreateCommand(
+      repository,
+      branch,
+      mode,
+      remote,
+      runtime ?? defaultCliDependencies
+    );
     return emitError2(
       options,
-      `branch "${branch}" exists but has no worktree; use interactive gji go ${branch} to create one`
+      `branch "${branch}" exists but has no worktree; run ${command} to create one`
     );
   }
   if (!await confirmBranchCreation(branch)) {
@@ -22274,6 +22378,13 @@ async function createExistingBranchWorktree(options, confirmBranchCreation, repo
     runtime
   });
 }
+async function resolveNonInteractiveCreateCommand(repository, branch, mode, remote, runtime) {
+  if (mode === "track") {
+    return `git worktree add --track -b ${branch} <path> ${remote ?? "origin"}/${branch}`;
+  }
+  const config = await runtime.config.loadEffectiveConfig(repository.repoRoot).catch(() => null);
+  return applyConfiguredBranchPrefix(branch, config?.branchPrefix) === branch ? `gji new ${branch}` : `git worktree add <path> ${branch}`;
+}
 async function navigateToExistingWorktree(options, path9, worktree, runtime) {
   const repository = await runtime.repositoryContext.detectRepository(path9);
   if (options.json) {
@@ -22303,7 +22414,7 @@ async function navigateToExistingWorktree(options, path9, worktree, runtime) {
     {
       branch: worktree?.branch ?? void 0,
       path: path9,
-      repo: basename11(repository.repoRoot),
+      repo: basename12(repository.repoRoot),
       slot: await runtime.slots.getWorktreeSlot(path9)
     },
     options.stderr
@@ -22443,7 +22554,7 @@ async function runHistoryCommand(options) {
 }
 
 // src/cli/commands/hub.ts
-import { basename as basename12 } from "node:path";
+import { basename as basename13 } from "node:path";
 import { stdin as stdin2, stdout as stdout2 } from "node:process";
 var MAX_HUB_REPOSITORY_CONCURRENCY = 4;
 async function buildHubData(cwd, dependencies = {}, runtime = defaultCliDependencies) {
@@ -22468,7 +22579,7 @@ async function buildHubData(cwd, dependencies = {}, runtime = defaultCliDependen
       existing.sources.push(source);
     } else {
       groups.set(repoRoot, {
-        name: source.repoName || basename12(repoRoot),
+        name: source.repoName || basename13(repoRoot),
         sources: [source]
       });
     }
@@ -22717,9 +22828,9 @@ function formatHumanText(value, maxLength) {
 
 // src/cli/commands/init.ts
 import { constants as constants8 } from "node:fs";
-import { access as access9, mkdir as mkdir9, readFile as readFile9, writeFile as writeFile8 } from "node:fs/promises";
+import { access as access9, mkdir as mkdir7, readFile as readFile9, writeFile as writeFile5 } from "node:fs/promises";
 import { homedir as homedir8 } from "node:os";
-import { dirname as dirname14 } from "node:path";
+import { dirname as dirname11 } from "node:path";
 var ZSH_COMPLETION_PATH_LINE = "fpath=(~/.zsh/completions $fpath)";
 var SHELL_WRAPPED_COMMANDS = [
   {
@@ -22757,26 +22868,12 @@ var SHELL_WRAPPED_COMMANDS = [
     names: ["root"],
     tempPrefix: "gji-root"
   },
-  {
-    bypassOptions: ["--help", "-h", "--json"],
-    commandName: "remove",
-    envVar: "GJI_REMOVE_OUTPUT_FILE",
-    names: ["remove", "rm"],
-    tempPrefix: "gji-remove"
-  },
   {
     bypassOptions: ["--help", "-h", "--json"],
     commandName: "done",
     envVar: "GJI_DONE_OUTPUT_FILE",
     names: ["done"],
     tempPrefix: "gji-done"
-  },
-  {
-    bypassOptions: ["--print", "--json", "--help", "-h"],
-    commandName: "warp",
-    envVar: "GJI_WARP_OUTPUT_FILE",
-    names: ["warp"],
-    tempPrefix: "gji-warp"
   }
 ];
 async function runInitCommand(options) {
@@ -22844,8 +22941,8 @@ async function runDefaultOnboarding(context, runtime) {
   const installCompletion = await promptForCompletion(shell, completionPath);
   if (installCompletion === null) return abortDefaultOnboarding();
   if (installCompletion) {
-    await mkdir9(dirname14(completionPath), { recursive: true });
-    await writeFile8(completionPath, renderShellCompletion(shell), "utf8");
+    await mkdir7(dirname11(completionPath), { recursive: true });
+    await writeFile5(completionPath, renderShellCompletion(shell), "utf8");
   }
   if (shell === "zsh" && (completionAlreadyInstalled || installCompletion)) {
     await ensureZshCompletionPath(rcPath);
@@ -22950,8 +23047,8 @@ async function applyOnboardingResult(result, home, runtime) {
     runtime
   );
   if (result.installCompletion) {
-    await mkdir9(dirname14(completionPath), { recursive: true });
-    await writeFile8(
+    await mkdir7(dirname11(completionPath), { recursive: true });
+    await writeFile5(
       completionPath,
       renderShellCompletion(result.shell),
       "utf8"
@@ -22970,17 +23067,17 @@ async function applyOnboardingResult(result, home, runtime) {
 }
 async function installOnboardingShellIntegration(shell, home) {
   const rcPath = resolveShellConfigPath(shell, home);
-  await mkdir9(dirname14(rcPath), { recursive: true });
+  await mkdir7(dirname11(rcPath), { recursive: true });
   const current = await readExistingConfig(rcPath);
   if (shell === "fish") {
-    await writeFile8(
+    await writeFile5(
       rcPath,
       upsertShellIntegration(current, renderShellIntegration(shell)),
       "utf8"
     );
     return;
   }
-  await writeFile8(
+  await writeFile5(
     rcPath,
     upsertOnboardingShellIntegration(current, shell),
     "utf8"
@@ -23014,7 +23111,7 @@ async function ensureZshCompletionPath(rcPath) {
   const current = await readExistingConfig(rcPath);
   const next = upsertZshCompletionPath(current);
   if (next !== current) {
-    await writeFile8(rcPath, next, "utf8");
+    await writeFile5(rcPath, next, "utf8");
   }
 }
 function upsertZshCompletionPath(existingConfig) {
@@ -23058,10 +23155,10 @@ async function runLegacyInitCommand(options, runtime) {
     return 0;
   }
   const rcPath = resolveShellConfigPath(shell, home);
-  await mkdir9(dirname14(rcPath), { recursive: true });
+  await mkdir7(dirname11(rcPath), { recursive: true });
   const current = await readExistingConfig(rcPath);
   const next = upsertShellIntegration(current, script);
-  await writeFile8(rcPath, next, "utf8");
+  await writeFile5(rcPath, next, "utf8");
   options.stdout(`${rcPath}
 `);
   const { config: globalConfig } = await runtime.configStore.loadGlobalConfig(home);
@@ -23415,7 +23512,7 @@ function sortWorktrees(worktrees) {
 
 // src/cli/commands/open.ts
 import { execFile as execFile9 } from "node:child_process";
-import { access as access10, writeFile as writeFile9 } from "node:fs/promises";
+import { access as access10, writeFile as writeFile6 } from "node:fs/promises";
 import { join as join15 } from "node:path";
 import { promisify as promisify10 } from "node:util";
 var execFileAsync9 = promisify10(execFile9);
@@ -23438,7 +23535,7 @@ function createOpenCommand(dependencies = {}) {
     }
     if (options.select && isHeadless()) {
       options.stderr(
-        "gji open --select: selector is unavailable in non-interactive mode (GJI_NO_TUI=1)\n"
+        "gji open --select: selector is unavailable in non-interactive mode; pass a branch instead\n"
       );
       return 1;
     }
@@ -23602,7 +23699,7 @@ async function ensureWorkspaceFile(worktreePath, repoName) {
   } catch {
   }
   const workspace = { folders: [{ path: "." }], settings: {} };
-  await writeFile9(
+  await writeFile6(
     workspacePath,
     `${JSON.stringify(workspace, null, 2)}
 `,
@@ -23630,7 +23727,7 @@ function createPrOpenCommand(dependencies = {}) {
     }
     if (options.select && isHeadless()) {
       options.stderr(
-        "gji pr open --select: selector is unavailable in non-interactive mode (GJI_NO_TUI=1)\n"
+        "gji pr open --select: selector is unavailable in non-interactive mode; pass a branch or PR number instead\n"
       );
       return 1;
     }
@@ -23930,7 +24027,7 @@ async function openPullRequests(pullRequests, options, promptForPullRequest, ope
   }
   if (pullRequests.length > 1 && isHeadless()) {
     options.stderr(
-      "gji pr open: multiple open PRs found; pass an explicit PR number in non-interactive mode (GJI_NO_TUI=1)\n"
+      "gji pr open: multiple open PRs found; pass an explicit PR number in non-interactive mode\n"
     );
     return 1;
   }
@@ -23981,250 +24078,6 @@ function formatError(error) {
   return error instanceof Error ? error.message : String(error);
 }
 
-// src/cli/commands/remove.ts
-import { basename as basename13 } from "node:path";
-var REMOVE_OUTPUT_FILE_ENV = "GJI_REMOVE_OUTPUT_FILE";
-function createRemoveCommand(dependencies = {}) {
-  const promptForWorktree2 = dependencies.promptForWorktree ?? defaultPromptForWorktree3;
-  const confirmRemoval = dependencies.confirmRemoval ?? defaultConfirmRemoval2;
-  const confirmForceRemoveWorktree = dependencies.confirmForceRemoveWorktree ?? defaultConfirmForceRemoveWorktree;
-  const confirmForceDeleteBranch = dependencies.confirmForceDeleteBranch ?? defaultConfirmForceDeleteBranch;
-  return async function runRemoveCommand2(options) {
-    const runtime = options.runtime ?? defaultCliDependencies;
-    const { loadEffectiveConfig: loadEffectiveConfig2 } = runtime.config;
-    const { releaseWorktreeSlot: releaseWorktreeSlot2 } = runtime.slots;
-    const { extractHooks: extractHooks2, runHook: runHook2 } = runtime.hooks;
-    const sourceDependencies = {
-      ...runtime.repositoryContext,
-      ...runtime.repositoryRegistry,
-      ...runtime.worktrees
-    };
-    const {
-      deleteBranch: deleteBranch2,
-      forceDeleteBranch: forceDeleteBranch2,
-      forceRemoveWorktree: forceRemoveWorktree2,
-      isBranchUnmergedError: isBranchUnmergedError2,
-      isWorktreeForceRemovalError: isWorktreeForceRemovalError2,
-      removeWorktree: removeWorktree2
-    } = runtime.worktreeLifecycle;
-    const { linkedWorktrees, repository } = await loadLinkedWorktrees(
-      options.cwd,
-      sourceDependencies
-    );
-    if (linkedWorktrees.length === 0) {
-      emitError3(options, "No linked worktrees to finish");
-      return 1;
-    }
-    if (!options.branch && (options.json || isHeadless())) {
-      const message = "branch argument is required";
-      if (options.json) {
-        emitError3(options, message);
-      } else {
-        options.stderr(
-          `gji remove: ${message} in non-interactive mode (GJI_NO_TUI=1)
-`
-        );
-      }
-      return 1;
-    }
-    const selection = options.branch ?? await promptForWorktree2(
-      await buildWorktreePromptEntries(
-        linkedWorktrees.map((worktree2) => ({
-          repoName: repository.repoName,
-          worktree: worktree2
-        })),
-        { catalog: runtime.worktreeCatalog }
-      )
-    );
-    if (!selection) {
-      options.stderr("Aborted\n");
-      return 1;
-    }
-    const worktree = linkedWorktrees.find(
-      (entry) => entry.branch === selection || entry.path === selection
-    );
-    if (!worktree) {
-      emitError3(options, `No linked worktree found for branch: ${selection}`);
-      return 1;
-    }
-    if (!options.dryRun && !options.force && (options.json || isHeadless())) {
-      const message = "--force is required";
-      if (options.json) {
-        emitError3(options, message);
-      } else {
-        options.stderr(
-          `gji remove: ${message} in non-interactive mode (GJI_NO_TUI=1)
-`
-        );
-      }
-      return 1;
-    }
-    if (!options.dryRun && !options.force && !await confirmRemoval(worktree)) {
-      options.stderr("Aborted\n");
-      return 1;
-    }
-    if (options.dryRun) {
-      if (options.json) {
-        options.stdout(
-          `${JSON.stringify({ branch: worktree.branch, path: worktree.path, dryRun: true }, null, 2)}
-`
-        );
-      } else {
-        const desc = worktree.branch ? `branch: ${worktree.branch}` : "detached";
-        options.stdout(`Would remove worktree at ${worktree.path} (${desc})
-`);
-      }
-      return 0;
-    }
-    const config = await loadEffectiveConfig2(
-      repository.repoRoot,
-      void 0,
-      options.stderr
-    );
-    const hooks = extractHooks2(config);
-    let journal;
-    try {
-      journal = await recordUndoOperation(
-        "remove",
-        repository.repoRoot,
-        [worktree],
-        void 0,
-        runtime
-      );
-    } catch (error) {
-      emitError3(
-        options,
-        `could not write undo journal; no worktree was removed: ${toMessage4(error)}`
-      );
-      return 1;
-    }
-    if (!journal) {
-      emitError3(
-        options,
-        "could not capture undo state; no worktree was removed"
-      );
-      return 1;
-    }
-    await runHook2(
-      hooks["before-remove"],
-      worktree.path,
-      {
-        branch: worktree.branch ?? void 0,
-        path: worktree.path,
-        repo: basename13(repository.repoRoot)
-      },
-      options.stderr
-    );
-    try {
-      await removeWorktree2(repository.repoRoot, worktree.path);
-    } catch (error) {
-      if (!isWorktreeForceRemovalError2(error)) {
-        await finalizeUndoOperation(
-          journal,
-          [],
-          void 0,
-          runtime.configStore.GLOBAL_CONFIG_DIRECTORY
-        );
-        throw error;
-      }
-      if (!options.force && !await confirmForceRemoveWorktree(worktree.path)) {
-        await finalizeUndoOperation(
-          journal,
-          [],
-          void 0,
-          runtime.configStore.GLOBAL_CONFIG_DIRECTORY
-        );
-        options.stderr("Aborted\n");
-        return 1;
-      }
-      try {
-        await forceRemoveWorktree2(repository.repoRoot, worktree.path);
-      } catch (forceError) {
-        await finalizeUndoOperation(
-          journal,
-          [],
-          void 0,
-          runtime.configStore.GLOBAL_CONFIG_DIRECTORY
-        );
-        emitError3(
-          options,
-          `Failed to remove worktree at ${worktree.path}: ${toMessage4(forceError)}`
-        );
-        return 1;
-      }
-    }
-    await finalizeUndoOperation(
-      journal,
-      [worktree],
-      void 0,
-      runtime.configStore.GLOBAL_CONFIG_DIRECTORY
-    );
-    await releaseWorktreeSlot2(worktree.path);
-    if (worktree.branch) {
-      try {
-        await deleteBranch2(repository.repoRoot, worktree.branch);
-      } catch (error) {
-        if (!isBranchUnmergedError2(error)) {
-          throw error;
-        }
-        if (options.force || await confirmForceDeleteBranch(worktree.branch)) {
-          try {
-            await forceDeleteBranch2(repository.repoRoot, worktree.branch);
-          } catch (forceError) {
-            options.stderr(
-              `Failed to delete branch ${worktree.branch}: ${toMessage4(forceError)}
-`
-            );
-          }
-        } else {
-          options.stderr(
-            `Branch ${worktree.branch} was not deleted (has unmerged commits)
-`
-          );
-        }
-      }
-    }
-    if (options.json) {
-      options.stdout(
-        `${JSON.stringify({ branch: worktree.branch, path: worktree.path, deleted: true }, null, 2)}
-`
-      );
-    } else {
-      options.stderr("undo: gji undo\n");
-      await writeOutput3(repository.repoRoot, options.stdout);
-    }
-    return 0;
-  };
-}
-var runRemoveCommand = createRemoveCommand();
-async function defaultPromptForWorktree3(worktrees) {
-  return promptForSingleWorktree("Choose a worktree to finish", worktrees);
-}
-async function defaultConfirmRemoval2(worktree) {
-  const choice = await ye({
-    message: worktree.branch ? `Remove worktree and delete branch ${worktree.branch}?` : `Remove detached worktree ${worktree.path}?`,
-    active: "Yes",
-    inactive: "No",
-    initialValue: true
-  });
-  return !pD(choice) && choice;
-}
-async function writeOutput3(repoRoot, stdout3) {
-  await writeShellOutput(REMOVE_OUTPUT_FILE_ENV, repoRoot, stdout3);
-}
-function emitError3(options, message) {
-  if (options.json) {
-    options.stderr(`${JSON.stringify({ error: message }, null, 2)}
-`);
-  } else {
-    options.stderr(`${message}
-`);
-  }
-}
-function toMessage4(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-
 // src/cli/commands/root.ts
 var ROOT_OUTPUT_FILE_ENV = "GJI_ROOT_OUTPUT_FILE";
 async function runRootCommand(options) {
@@ -24245,13 +24098,17 @@ async function runRootCommand(options) {
 
 // src/cli/commands/run-hook.ts
 var VALID_HOOKS = [
+  "after-branch-create",
   "after-create",
   "after-enter",
+  "after-switch",
   "before-remove"
 ];
 var CAMEL_ALIASES = {
+  afterBranchCreate: "after-branch-create",
   afterCreate: "after-create",
   afterEnter: "after-enter",
+  afterSwitch: "after-switch",
   beforeRemove: "before-remove"
 };
 function isValidHook(hook) {
@@ -24448,7 +24305,7 @@ async function runSyncCommand(options) {
       resolveConfiguredString2(config.syncDefaultBranch) ?? void 0
     );
   } catch {
-    emitError4(options, `Unable to reach remote '${remote}'`);
+    emitError3(options, `Unable to reach remote '${remote}'`);
     if (!options.json) {
       options.stderr(
         `Hint: Add the remote with: git remote add ${remote} <url>
@@ -24458,7 +24315,7 @@ async function runSyncCommand(options) {
     return 1;
   }
   if (!remoteBase) {
-    emitError4(options, "Unable to determine the default branch for sync.");
+    emitError3(options, "Unable to determine the default branch for sync.");
     if (!options.json) {
       options.stderr(
         `Hint: Add the remote with: git remote add ${remote} <url>
@@ -24473,7 +24330,7 @@ async function runSyncCommand(options) {
     options.all
   );
   if (targetWorktrees === "detached") {
-    emitError4(
+    emitError3(
       options,
       `Cannot sync detached worktree: ${repository.currentRoot}`
     );
@@ -24481,14 +24338,14 @@ async function runSyncCommand(options) {
   }
   for (const worktree of targetWorktrees) {
     if (await isDirtyWorktree2(worktree.path)) {
-      emitError4(options, `Cannot sync dirty worktree: ${worktree.path}`);
+      emitError3(options, `Cannot sync dirty worktree: ${worktree.path}`);
       return 1;
     }
   }
   try {
     await runGit2(repository.repoRoot, ["fetch", "--prune", remote]);
   } catch {
-    emitError4(options, `Failed to fetch from remote '${remote}'`);
+    emitError3(options, `Failed to fetch from remote '${remote}'`);
     if (!options.json) {
       options.stderr(
         `Hint: Add the remote with: git remote add ${remote} <url>
@@ -24520,7 +24377,7 @@ async function runSyncCommand(options) {
   }
   return 0;
 }
-function emitError4(options, message) {
+function emitError3(options, message) {
   if (options.json) {
     options.stderr(`${JSON.stringify({ error: message }, null, 2)}
 `);
@@ -24741,144 +24598,6 @@ function emitTaskError(options, message) {
   return 1;
 }
 
-// src/cli/commands/warp.ts
-var WARP_OUTPUT_FILE_ENV = "GJI_WARP_OUTPUT_FILE";
-async function runWarpCommand(options) {
-  return runWarpNavigate(options);
-}
-async function runWarpNavigate(options) {
-  const runtime = options.runtime ?? defaultCliDependencies;
-  const { recordWorktreeUsage: recordWorktreeUsage2 } = runtime.history;
-  if ((isHeadless() || options.json) && !options.branch) {
-    const message = "branch argument is required";
-    if (options.json) {
-      options.stderr(`${JSON.stringify({ error: message }, null, 2)}
-`);
-    } else {
-      options.stderr(
-        "gji warp: branch argument is required in non-interactive mode (GJI_NO_TUI=1)\n"
-      );
-    }
-    return 1;
-  }
-  const target = await resolveWarpTarget({
-    ...options,
-    commandName: "gji warp",
-    json: options.json,
-    queryPullRequests: options.queryPullRequests,
-    runtime
-  });
-  if (!target) return 1;
-  if (options.json) {
-    options.stdout(
-      `${JSON.stringify(
-        createNavigationTarget(target.repository, target.path, target.branch),
-        null,
-        2
-      )}
-`
-    );
-    return 0;
-  }
-  await recordWorktreeUsage2(target.path, target.branch);
-  await writeShellOutput(WARP_OUTPUT_FILE_ENV, target.path, options.stdout);
-  return 0;
-}
-async function resolveWarpTarget(options) {
-  const cmd = options.commandName ?? "gji";
-  const runtime = options.runtime ?? defaultCliDependencies;
-  const { detectRepository: detectRepository2 } = runtime.repositoryContext;
-  const { loadRegistry: loadRegistry2 } = runtime.repositoryRegistry;
-  const sourceDependencies = {
-    ...runtime.repositoryContext,
-    ...runtime.repositoryRegistry,
-    ...runtime.worktrees
-  };
-  const emitError5 = (message, hint) => {
-    if (options.json) {
-      options.stderr(`${JSON.stringify({ error: message }, null, 2)}
-`);
-    } else {
-      options.stderr(`${cmd}: ${message}
-`);
-      if (hint) options.stderr(hint);
-    }
-  };
-  const registry = await loadRegistry2();
-  if (registry.length === 0) {
-    emitError5(
-      "not in a git repository and no repos registered yet.",
-      "Use any gji command inside a repository to register it.\n"
-    );
-    return null;
-  }
-  const registered = await listRegisteredWorktreeSources({
-    cwd: options.cwd,
-    repositoryPort: sourceDependencies
-  });
-  const skippedRegisteredRepos = registered.skipped.length;
-  const allItems = registered.sources.filter(
-    (item) => item.repoRoot !== options.excludeRepoRoot
-  );
-  if (allItems.length === 0) {
-    emitError5(
-      "no accessible worktrees found in any registered repo.",
-      skippedRegisteredRepos > 0 ? "Hint: Run 'gji doctor' to inspect stale repository entries.\n" : void 0
-    );
-    return null;
-  }
-  const promptSources = allItems.map((item) => ({
-    repoRoot: item.repoRoot,
-    repoName: item.repoName,
-    worktree: item.worktree
-  }));
-  if (options.branch) {
-    const match = resolveWorktreeQuery(promptSources, options.branch);
-    if (!match) {
-      emitError5(
-        `no worktree found matching: ${options.branch}`,
-        skippedRegisteredRepos > 0 ? "Hint: Run 'gji doctor' to inspect stale repository entries.\n" : void 0
-      );
-      return null;
-    }
-    return {
-      branch: match.worktree.branch,
-      path: match.worktree.path,
-      repository: createNavigationRepository(
-        match.repoName,
-        match.repoRoot ?? (await detectRepository2(match.worktree.path)).repoRoot
-      )
-    };
-  }
-  const promptEntries = await buildWorktreePromptEntries(promptSources, {
-    metadata: "fast",
-    catalog: withPullRequestQueries(runtime, options.queryPullRequests)
-  });
-  const path9 = await promptForWarpTarget(promptEntries);
-  if (!path9) {
-    options.stderr("Aborted\n");
-    return null;
-  }
-  const chosenSource = promptSources.find(
-    (item) => item.worktree.path === path9
-  );
-  if (chosenSource === void 0) {
-    emitError5("selected worktree is no longer registered");
-    return null;
-  }
-  return {
-    branch: chosenSource.worktree.branch,
-    path: path9,
-    repository: createNavigationRepository(
-      chosenSource.repoName,
-      chosenSource.repoRoot ?? (await detectRepository2(chosenSource.worktree.path)).repoRoot
-    )
-  };
-}
-async function promptForWarpTarget(items) {
-  return promptForSingleWorktree("Warp to a worktree", items);
-}
-
 // src/cli/program.ts
 function createProgram() {
   const program2 = new Command();
@@ -25080,25 +24799,9 @@ function registerCommands(program2) {
     "--json",
     "emit JSON on success or error instead of human-readable output"
   ).action(notImplemented("clean"));
-  program2.command("remove [branch]").alias("rm").description(
-    "deprecated: use gji done for one worktree or gji clean for bulk cleanup"
-  ).option(
-    "-f, --force",
-    "bypass prompts, force-remove a dirty worktree, and force-delete an unmerged branch"
-  ).option("--dry-run", "show what would be deleted without removing anything").option(
-    "--json",
-    "emit JSON on success or error instead of human-readable output"
-  ).action(notImplemented("remove"));
   program2.command("run-hook <hook>").alias("trigger-hook").description(
-    "run a named hook (after-create, after-enter, before-remove) in the current worktree"
+    "run a named hook (after-branch-create, after-create, after-enter, after-switch, before-remove) in the current worktree"
   ).action(notImplemented("run-hook"));
-  program2.command("warp [branch]").description("deprecated: use gji go (press Tab for all known repos)").option(
-    "--print",
-    "print the resolved worktree path without changing directory"
-  ).option(
-    "--json",
-    "emit JSON on success or error instead of human-readable output"
-  ).action(notImplemented("warp"));
   const configCommand = program2.command("config").description("manage global config defaults").action(notImplemented("config"));
   configCommand.command("get [key]").description("print the global config or a single key").action(notImplemented("config get"));
   configCommand.command("set <key> <value>").description("set a global config value").action(notImplemented("config set"));
@@ -25454,31 +25157,6 @@ function attachCommandActions(program2, options) {
       }
     }
   );
-  const runRemovalCommand = async (branch, commandOptions2 = {}) => {
-    const exitCode = await runRemoveCommand({
-      branch,
-      cwd: options.cwd,
-      dryRun: commandOptions2.dryRun,
-      force: commandOptions2.force,
-      json: commandOptions2.json,
-      runtime: options.dependencies,
-      stderr: options.stderr,
-      stdout: options.stdout
-    });
-    if (exitCode !== 0) {
-      throw commanderExit(exitCode);
-    }
-  };
-  requireCommand(program2, "remove").action(
-    async (branch, commandOptions2) => {
-      if (!commandOptions2.json) {
-        options.stderr(
-          "gji remove is deprecated; use 'gji done' for one worktree or 'gji clean' for bulk cleanup.\n"
-        );
-      }
-      return runRemovalCommand(branch, commandOptions2);
-    }
-  );
   requireCommand(program2, "run-hook").action(async (hook) => {
     const exitCode = await runHookCommand({
       cwd: options.cwd,
@@ -25490,26 +25168,6 @@ function attachCommandActions(program2, options) {
       throw commanderExit(exitCode);
     }
   });
-  requireCommand(program2, "warp").action(
-    async (branch, commandOptions2) => {
-      if (!commandOptions2.json) {
-        options.stderr(
-          "gji warp is deprecated; use 'gji go' (press Tab for all repositories).\n"
-        );
-      }
-      const exitCode = await runWarpCommand({
-        branch,
-        cwd: options.cwd,
-        json: commandOptions2.json,
-        runtime: options.dependencies,
-        stderr: options.stderr,
-        stdout: options.stdout
-      });
-      if (exitCode !== 0) {
-        throw commanderExit(exitCode);
-      }
-    }
-  );
   const configCommand = requireCommand(program2, "config");
   configCommand.action(async () => {
     const exitCode = await runConfigCommand({