@ogpoyraz/wtx 0.9.2 → 0.9.3

package/dist/cli.mjs

@@ -25068,7 +25068,7 @@ var init_owner = __esm(() => {
 });
 
 // src/lib/workspace.ts
-import fs23 from "fs";
+import fs24 from "fs";
 import path29 from "path";
 function getWorkspaceRoot(config2) {
   return path29.resolve(expandTilde(config2.workspace_root ?? path29.join(config2.root, "wtx-workspaces")));
@@ -25119,12 +25119,12 @@ function assertNoPathNesting(workspacePath, members) {
 async function writeManifest(workspacePath, manifest) {
   const manifestPath = path29.join(workspacePath, MANIFEST_FILE);
   const tmpPath = path29.join(workspacePath, `${MANIFEST_FILE}.${process.pid}.${Date.now()}.tmp`);
-  await fs23.promises.writeFile(tmpPath, `${JSON.stringify(manifest, null, 2)}
+  await fs24.promises.writeFile(tmpPath, `${JSON.stringify(manifest, null, 2)}
 `, "utf8");
-  await fs23.promises.rename(tmpPath, manifestPath);
+  await fs24.promises.rename(tmpPath, manifestPath);
 }
 async function readManifest(workspacePath) {
-  const raw = await fs23.promises.readFile(path29.join(workspacePath, MANIFEST_FILE), "utf8");
+  const raw = await fs24.promises.readFile(path29.join(workspacePath, MANIFEST_FILE), "utf8");
   const parsed = JSON.parse(raw);
   if (parsed.version !== 1) {
     throw new Error(`Unsupported workspace manifest version: ${parsed.version}`);
@@ -25139,7 +25139,7 @@ async function writeAgentsFile(workspacePath, linkNames) {
     ...linkNames.map((name) => `- ${name}`),
     ""
   ];
-  await fs23.promises.writeFile(path29.join(workspacePath, AGENTS_FILE), lines.join(`
+  await fs24.promises.writeFile(path29.join(workspacePath, AGENTS_FILE), lines.join(`
 `), "utf8");
 }
 async function createMemberSymlinks(workspacePath, members) {
@@ -25149,13 +25149,13 @@ async function createMemberSymlinks(workspacePath, members) {
     const linkName = memberLinkName(member, taken);
     const linkPath = path29.join(workspacePath, linkName);
     const target = path29.resolve(member.path);
-    await fs23.promises.symlink(target, linkPath, process.platform === "win32" ? "junction" : "dir");
+    await fs24.promises.symlink(target, linkPath, process.platform === "win32" ? "junction" : "dir");
     linkNames.push(linkName);
   }
   return linkNames;
 }
 async function workspaceLinkNames(workspacePath) {
-  const entries = await fs23.promises.readdir(workspacePath, { withFileTypes: true });
+  const entries = await fs24.promises.readdir(workspacePath, { withFileTypes: true });
   return entries.filter((entry) => entry.name !== MANIFEST_FILE && entry.name !== AGENTS_FILE && entry.isSymbolicLink()).map((entry) => entry.name).sort();
 }
 async function rebuildAgentsFile(workspacePath) {
@@ -25165,7 +25165,7 @@ async function createWorkspace(opts) {
   validateWorkspaceName(opts.name);
   const workspacePath = workspacePathFor(opts.name, opts.config);
   assertNoPathNesting(workspacePath, opts.members);
-  await fs23.promises.mkdir(workspacePath, { recursive: true });
+  await fs24.promises.mkdir(workspacePath, { recursive: true });
   const linkNames = await createMemberSymlinks(workspacePath, opts.members);
   await writeManifest(workspacePath, {
     version: 1,
@@ -25183,7 +25183,7 @@ async function addMember(opts) {
   const taken = new Set(await workspaceLinkNames(opts.workspacePath));
   const linkName = memberLinkName(opts.member, taken);
   const target = path29.resolve(opts.member.path);
-  await fs23.promises.symlink(target, path29.join(opts.workspacePath, linkName), process.platform === "win32" ? "junction" : "dir");
+  await fs24.promises.symlink(target, path29.join(opts.workspacePath, linkName), process.platform === "win32" ? "junction" : "dir");
   manifest.members.push({ repo: opts.member.repo, branch: opts.member.branch });
   await writeManifest(opts.workspacePath, manifest);
   await rebuildAgentsFile(opts.workspacePath);
@@ -25197,7 +25197,7 @@ async function removeMember(opts) {
   const linkNames = await workspaceLinkNames(opts.workspacePath);
   for (const linkName of linkNames) {
     if (linkName === opts.repo || linkName === `${opts.repo}-${opts.branch.replace(/[\\/]+/g, "-")}`) {
-      await fs23.promises.unlink(path29.join(opts.workspacePath, linkName));
+      await fs24.promises.unlink(path29.join(opts.workspacePath, linkName));
       break;
     }
   }
@@ -25206,7 +25206,7 @@ async function removeMember(opts) {
 }
 async function listWorkspaces(workspaceRoot) {
   try {
-    const entries = await fs23.promises.readdir(path29.resolve(expandTilde(workspaceRoot)), { withFileTypes: true });
+    const entries = await fs24.promises.readdir(path29.resolve(expandTilde(workspaceRoot)), { withFileTypes: true });
     const workspaces = [];
     for (const entry of entries) {
       if (!entry.isDirectory())
@@ -25235,7 +25235,7 @@ async function verifyLink(linkPath, visited) {
   visited.add(resolvedLink);
   let stats;
   try {
-    stats = await fs23.promises.lstat(linkPath);
+    stats = await fs24.promises.lstat(linkPath);
   } catch {
     return "broken";
   }
@@ -25243,13 +25243,13 @@ async function verifyLink(linkPath, visited) {
     return "ok";
   let rawTarget;
   try {
-    rawTarget = await fs23.promises.readlink(linkPath);
+    rawTarget = await fs24.promises.readlink(linkPath);
   } catch {
     return "broken";
   }
   const target = path29.isAbsolute(rawTarget) ? rawTarget : path29.resolve(path29.dirname(linkPath), rawTarget);
   try {
-    const targetStats = await fs23.promises.lstat(target);
+    const targetStats = await fs24.promises.lstat(target);
     if (!targetStats.isSymbolicLink())
       return "ok";
   } catch {
@@ -25260,7 +25260,7 @@ async function verifyLink(linkPath, visited) {
 async function verify(workspacePath) {
   const result = { ok: true, broken: [], cycles: [] };
   try {
-    const entries = await fs23.promises.readdir(workspacePath, { withFileTypes: true });
+    const entries = await fs24.promises.readdir(workspacePath, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.name === MANIFEST_FILE || entry.name === AGENTS_FILE || !entry.isSymbolicLink())
         continue;
@@ -27195,7 +27195,7 @@ var init_DetailsTab = __esm(() => {
 });
 
 // src/lib/changes.ts
-import fs33 from "node:fs";
+import fs34 from "node:fs";
 import path37 from "node:path";
 function cacheKey(opts, filePath) {
   return [opts.repoPath, opts.branch, opts.scope, filePath ?? ""].join("\x00");
@@ -27328,7 +27328,7 @@ async function getChangedFiles(opts) {
             continue;
           try {
             const full = path37.join(opts.repoPath, p);
-            const buf = fs33.readFileSync(full);
+            const buf = fs34.readFileSync(full);
             const binary = buf.includes(0);
             const str = binary ? "" : buf.toString("utf8");
             const added = binary ? 0 : str.split(`
@@ -27379,7 +27379,7 @@ async function getFileDiff(opts) {
     if (!rawDiff && opts.scope === "worktree" && changedFile.status === "A") {
       try {
         const full = path37.join(opts.repoPath, opts.filePath);
-        const buf = fs33.readFileSync(full);
+        const buf = fs34.readFileSync(full);
         if (!buf.includes(0)) {
           const content = buf.toString("utf8");
           const lines = content.split(`
@@ -28408,7 +28408,7 @@ var init_ActionLogModal = __esm(() => {
 });
 
 // src/lib/history.ts
-import fs34 from "fs";
+import fs35 from "fs";
 import path38 from "path";
 import os4 from "os";
 function getHistoryDir() {
@@ -28422,24 +28422,24 @@ function rotateHistory(maxBytes = HISTORY_MAX_BYTES, keepLines = HISTORY_ROTATE_
   const historyPath = getHistoryPath();
   let size = 0;
   try {
-    size = fs34.statSync(historyPath).size;
+    size = fs35.statSync(historyPath).size;
   } catch {
     return;
   }
   if (size <= maxBytes)
     return;
-  const lines = fs34.readFileSync(historyPath, "utf-8").split(`
+  const lines = fs35.readFileSync(historyPath, "utf-8").split(`
 `).filter(Boolean);
   const kept = lines.slice(-keepLines);
   const tmpPath = `${historyPath}.tmp.${process.pid}`;
   try {
-    fs34.writeFileSync(tmpPath, kept.length > 0 ? `${kept.join(`
+    fs35.writeFileSync(tmpPath, kept.length > 0 ? `${kept.join(`
 `)}
 ` : "", "utf-8");
-    fs34.renameSync(tmpPath, historyPath);
+    fs35.renameSync(tmpPath, historyPath);
   } catch (err) {
-    if (fs34.existsSync(tmpPath)) {
-      fs34.unlinkSync(tmpPath);
+    if (fs35.existsSync(tmpPath)) {
+      fs35.unlinkSync(tmpPath);
     }
     throw err;
   }
@@ -28447,18 +28447,18 @@ function rotateHistory(maxBytes = HISTORY_MAX_BYTES, keepLines = HISTORY_ROTATE_
 function appendHistory(entry) {
   try {
     const dir = getHistoryDir();
-    if (!fs34.existsSync(dir)) {
-      fs34.mkdirSync(dir, { recursive: true });
+    if (!fs35.existsSync(dir)) {
+      fs35.mkdirSync(dir, { recursive: true });
     }
     rotateHistory();
-    fs34.appendFileSync(getHistoryPath(), `${JSON.stringify(entry)}
+    fs35.appendFileSync(getHistoryPath(), `${JSON.stringify(entry)}
 `, "utf-8");
   } catch {}
 }
 function readRecentHistory(limit = 50) {
   let content;
   try {
-    content = fs34.readFileSync(getHistoryPath(), "utf-8");
+    content = fs35.readFileSync(getHistoryPath(), "utf-8");
   } catch {
     return [];
   }
@@ -34137,8 +34137,66 @@ init_config();
 init_log();
 init_git();
 init_resolver();
-import fs22 from "fs";
+import fs23 from "fs";
 import path28 from "path";
+
+// src/lib/worktree-remove.ts
+init_git();
+import fs22 from "fs";
+function isSubmoduleWorktreeError(message) {
+  return message.includes("submodule") || message.includes("containing submodules");
+}
+function isMissingWorktreePathError(message) {
+  return message.includes("ENOENT") || message.includes("No such file") || message.includes("does not exist") || message.includes("not a git repository") || message.includes("cannot change to");
+}
+function isRecoverableWorktreeRemoveError(message) {
+  return message.includes("not a working tree") || message.includes("already removed") || isSubmoduleWorktreeError(message) || isMissingWorktreePathError(message);
+}
+function removePathIfExists(wtPath, opts) {
+  if (!opts.dryRun && fs22.existsSync(wtPath)) {
+    fs22.rmSync(wtPath, { recursive: true, force: true });
+  }
+}
+async function pruneWorktreeAdmin(mainPath, opts) {
+  try {
+    await gitExec(["-C", mainPath, "worktree", "prune"], opts);
+  } catch {}
+}
+async function removeWorktreeSafely(params) {
+  const { mainPath, wtPath, force, opts } = params;
+  const args = ["-C", mainPath, "worktree", "remove", wtPath];
+  if (force) {
+    args.push("--force");
+  }
+  try {
+    await gitExec(args, opts);
+    return { usedForce: force, manualCleanup: false };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (isSubmoduleWorktreeError(msg) && !force) {
+      try {
+        await gitExec(["-C", mainPath, "worktree", "remove", "--force", wtPath], opts);
+        return { usedForce: true, manualCleanup: false };
+      } catch (forceErr) {
+        const forceMsg = forceErr instanceof Error ? forceErr.message : String(forceErr);
+        if (isRecoverableWorktreeRemoveError(forceMsg)) {
+          await pruneWorktreeAdmin(mainPath, opts);
+          removePathIfExists(wtPath, opts);
+          return { usedForce: true, manualCleanup: true };
+        }
+        throw forceErr;
+      }
+    }
+    if (isRecoverableWorktreeRemoveError(msg)) {
+      await pruneWorktreeAdmin(mainPath, opts);
+      removePathIfExists(wtPath, opts);
+      return { usedForce: force, manualCleanup: true };
+    }
+    throw err;
+  }
+}
+
+// src/commands/pull.ts
 init_forge();
 init_stack();
 function registerPullCommand(program2) {
@@ -34255,7 +34313,7 @@ function registerPullCommand(program2) {
       const worktrees = await getWorktreeList(target.mainPath);
       const existingWorktree = worktrees.find((w) => w.path === wtPath || w.branch === branch);
       const localBranchFound = await localBranchExists(target.mainPath, branch, globalOpts);
-      const dirExists = Boolean(existingWorktree) || fs22.existsSync(wtPath);
+      const dirExists = Boolean(existingWorktree) || fs23.existsSync(wtPath);
       if (localBranchFound || dirExists) {
         if (options.force) {
           stepWarning(`Branch '${branch}' already exists — --force: will override`, dirExists ? wtPath : "local branch exists");
@@ -34268,17 +34326,22 @@ function registerPullCommand(program2) {
       if (options.force && (localBranchFound || dirExists)) {
         if (existingWorktree) {
           try {
-            await gitExec(["-C", target.mainPath, "worktree", "remove", "--force", existingWorktree.path], { verbose: globalOpts.verbose, dryRun: globalOpts.dryRun });
+            await removeWorktreeSafely({
+              mainPath: target.mainPath,
+              wtPath: existingWorktree.path,
+              force: true,
+              opts: { verbose: globalOpts.verbose, dryRun: globalOpts.dryRun }
+            });
           } catch (err) {
             const message = err instanceof Error ? err.message : String(err);
-            if (!message.includes("not a working tree")) {
+            if (!isRecoverableWorktreeRemoveError(message)) {
               stepWarning("Worktree removal failed", message.split(`
 `)[0] ?? message);
             }
           }
         }
-        if (!globalOpts.dryRun && fs22.existsSync(wtPath)) {
-          fs22.rmSync(wtPath, { recursive: true, force: true });
+        if (!globalOpts.dryRun && fs23.existsSync(wtPath)) {
+          fs23.rmSync(wtPath, { recursive: true, force: true });
         }
         if (localBranchFound) {
           try {
@@ -34322,7 +34385,7 @@ function registerPullCommand(program2) {
       }
       stepSuccess("Fetched");
       if (!globalOpts.dryRun) {
-        fs22.mkdirSync(path28.dirname(wtPath), { recursive: true });
+        fs23.mkdirSync(path28.dirname(wtPath), { recursive: true });
       }
       try {
         const createBranchFlag = options.force ? "-B" : "-b";
@@ -34456,10 +34519,10 @@ function registerPullBranchCommand(program2) {
 init_config();
 init_log();
 init_git();
+import fs25 from "fs";
+import path30 from "path";
 init_resolver();
 init_path_safety();
-import fs24 from "fs";
-import path30 from "path";
 
 // src/lib/prompts.ts
 import * as readline2 from "readline";
@@ -34507,15 +34570,9 @@ init_workspace();
 function errorMessage2(err) {
   return err instanceof Error ? err.message : String(err);
 }
-function isMissingWorktreePathError(message) {
-  return message.includes("ENOENT") || message.includes("No such file") || message.includes("does not exist") || message.includes("not a git repository") || message.includes("cannot change to");
-}
-function isRecoverableWorktreeRemoveError(message) {
-  return message.includes("not a working tree") || message.includes("already removed") || message.includes("submodule") || message.includes("containing submodules") || isMissingWorktreePathError(message);
-}
 function removeExistingPath(wtPath, opts) {
-  if (!opts.dryRun && fs24.existsSync(wtPath)) {
-    fs24.rmSync(wtPath, { recursive: true, force: true });
+  if (!opts.dryRun && fs25.existsSync(wtPath)) {
+    fs25.rmSync(wtPath, { recursive: true, force: true });
   }
 }
 async function removeLocalBranchIfExists(repoPath, branch, opts) {
@@ -34604,7 +34661,7 @@ function registerRemoveCommand(program2) {
         const worktrees = await getWorktreeList(repo.mainPath);
         const target = findWorktreeForBranch(worktrees, branch, repo.mainPath, candidatePath);
         if (!target) {
-          if (options.force && (fs24.existsSync(candidatePath) || await localBranchExists(repo.mainPath, branch, globalOpts))) {
+          if (options.force && (fs25.existsSync(candidatePath) || await localBranchExists(repo.mainPath, branch, globalOpts))) {
             if (!await confirmDeletionIfNeeded(repo, candidatePath, options, globalOpts)) {
               skipCount++;
               continue;
@@ -34646,7 +34703,7 @@ function registerRemoveCommand(program2) {
             }
           } catch (err) {
             const msg = errorMessage2(err);
-            if (isMissingWorktreePathError(msg) || !fs24.existsSync(wtPath)) {
+            if (isMissingWorktreePathError(msg) || !fs25.existsSync(wtPath)) {
               stepWarning("Worktree path missing", "continuing with removal cleanup");
             } else {
               stepError("Failed to check for uncommitted changes", msg);
@@ -34655,7 +34712,7 @@ function registerRemoveCommand(program2) {
             }
           }
         }
-        if (options.force && !globalOpts.dryRun && !fs24.existsSync(wtPath)) {
+        if (options.force && !globalOpts.dryRun && !fs25.existsSync(wtPath)) {
           if (!await confirmDeletionIfNeeded(repo, wtPath, options, globalOpts)) {
             skipCount++;
             continue;
@@ -34679,52 +34736,16 @@ function registerRemoveCommand(program2) {
           skipCount++;
           continue;
         }
-        const args = ["-C", repo.mainPath, "worktree", "remove", wtPath];
-        if (options.force) {
-          args.push("--force");
-        }
-        try {
-          await gitExec(args, globalOpts);
-          stepSuccess("Worktree removed", wtPath);
-        } catch (err) {
-          const msg = errorMessage2(err);
-          const isSubmodule = msg.includes("submodule") || msg.includes("containing submodules");
-          if (isSubmodule && !options.force && !args.includes("--force")) {
-            stepWarning("Worktree contains submodules — retrying with --force", msg.split(`
-`)[0] ?? msg);
-            try {
-              await gitExec(["-C", repo.mainPath, "worktree", "remove", "--force", wtPath], globalOpts);
-              stepSuccess("Worktree removed", wtPath);
-            } catch (forceErr) {
-              const forceMsg = errorMessage2(forceErr);
-              if (isRecoverableWorktreeRemoveError(forceMsg)) {
-                stepWarning("Worktree already removed or invalid", forceMsg);
-                try {
-                  await gitExec(["-C", repo.mainPath, "worktree", "prune"], globalOpts);
-                } catch (pruneErr) {
-                  stepWarning("Worktree prune failed", errorMessage2(pruneErr));
-                }
-                removeExistingPath(wtPath, globalOpts);
-                await removeLocalBranchBestEffort(repo.mainPath, branch, globalOpts);
-                stepSuccess("Worktree removed", wtPath);
-              } else {
-                throw forceErr;
-              }
-            }
-          } else if (isRecoverableWorktreeRemoveError(msg)) {
-            stepWarning("Worktree already removed or invalid", msg);
-            try {
-              await gitExec(["-C", repo.mainPath, "worktree", "prune"], globalOpts);
-            } catch (pruneErr) {
-              stepWarning("Worktree prune failed", errorMessage2(pruneErr));
-            }
-            removeExistingPath(wtPath, globalOpts);
-            await removeLocalBranchBestEffort(repo.mainPath, branch, globalOpts);
-            stepSuccess("Worktree removed", wtPath);
-          } else {
-            throw err;
-          }
+        const result = await removeWorktreeSafely({
+          mainPath: repo.mainPath,
+          wtPath,
+          force: !!options.force,
+          opts: globalOpts
+        });
+        if (result.manualCleanup) {
+          await removeLocalBranchBestEffort(repo.mainPath, branch, globalOpts);
         }
+        stepSuccess("Worktree removed", wtPath);
         await finishCleanup(repo, wtPath, branch, globalOpts);
         await unlinkRemovedWorktreeFromWorkspaces({ workspaceRoot, repo: repo.name, branch });
         if (children.length > 0) {
@@ -34751,9 +34772,9 @@ init_source();
 init_config();
 init_log();
 init_git();
+import path31 from "path";
 init_resolver();
 init_forge();
-import path31 from "path";
 
 // src/lib/prune.ts
 function selectMergedCandidates(worktrees, mainPath, prMap) {
@@ -34890,16 +34911,17 @@ function registerPruneCommand(program2) {
         repoHeader(repo.name);
         currentRepo = repo.name;
       }
-      const args = ["-C", repo.mainPath, "worktree", "remove", candidate.path];
-      if (options.force) {
-        args.push("--force");
-      }
       try {
-        await gitExec(args, globalOpts);
+        await removeWorktreeSafely({
+          mainPath: repo.mainPath,
+          wtPath: candidate.path,
+          force: !!options.force,
+          opts: globalOpts
+        });
         stepSuccess("Worktree removed", label);
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
-        if (msg.includes("not a working tree") || msg.includes("already removed")) {
+        if (isRecoverableWorktreeRemoveError(msg)) {
           stepWarning("Worktree already removed or invalid", msg);
           skippedCount++;
           continue;
@@ -35002,7 +35024,7 @@ init_source();
 init_stack();
 init_stack();
 import path32 from "path";
-import fs25 from "fs";
+import fs26 from "fs";
 function buildLsJson(reposData) {
   const result = [];
   for (const repo of reposData) {
@@ -35112,7 +35134,7 @@ function registerLsCommand(program2) {
               statusStr = source_default.blue("[main checkout]");
             } else if (wt.isLocked) {
               statusStr = source_default.red("locked \uD83D\uDD12");
-            } else if (fs25.existsSync(wt.path)) {
+            } else if (fs26.existsSync(wt.path)) {
               try {
                 dirtyFiles = await getDirtyFiles(wt.path);
                 if (dirtyFiles.length > 0) {
@@ -35238,7 +35260,7 @@ end
 init_config();
 init_log();
 init_git();
-import fs26 from "fs";
+import fs27 from "fs";
 init_resolver();
 init_stack();
 function registerRebaseCommand(program2) {
@@ -35253,7 +35275,7 @@ function registerRebaseCommand(program2) {
       repoHeader(repo.name);
       const mainBranch = await resolveMainBranch(repo, config2);
       const wtPath = getWorktreePath(repo, branch);
-      if (!fs26.existsSync(wtPath)) {
+      if (!fs27.existsSync(wtPath)) {
         stepError("No worktree found", `${wtPath} (skipped)`);
         failCount++;
         continue;
@@ -35379,7 +35401,7 @@ init_execa();
 init_config();
 init_log();
 init_resolver();
-import fs27 from "fs";
+import fs28 from "fs";
 import path33 from "path";
 function registerSyncCommand(program2) {
   program2.command("sync <branch>").description("re-copy sync files + run post_sync").option("--repo <repos...>", "comma-separated list of repos to target").action(async (branch, _options, cmd) => {
@@ -35391,14 +35413,14 @@ function registerSyncCommand(program2) {
     for (const repo of repos) {
       repoHeader(repo.name);
       const wtPath = getWorktreePath(repo, branch);
-      if (!fs27.existsSync(wtPath)) {
+      if (!fs28.existsSync(wtPath)) {
         stepWarning("No worktree found", `${wtPath} (skipped)`);
         continue;
       }
       try {
         if (repo.config.sync_files) {
           for (const file2 of repo.config.sync_files) {
-            if (fs27.existsSync(path33.join(repo.mainPath, file2))) {
+            if (fs28.existsSync(path33.join(repo.mainPath, file2))) {
               if (!opts.dryRun) {
                 syncEntry(repo.mainPath, wtPath, file2);
               }
@@ -35451,14 +35473,14 @@ function registerSyncCommand(program2) {
           }
         }
         const wtNodeModules = path33.join(wtPath, "node_modules");
-        if (fs27.existsSync(wtNodeModules) && fs27.lstatSync(wtNodeModules).isSymbolicLink()) {
+        if (fs28.existsSync(wtNodeModules) && fs28.lstatSync(wtNodeModules).isSymbolicLink()) {
           const lockfiles = ["yarn.lock", "package-lock.json", "pnpm-lock.yaml", "bun.lockb", "bun.lock"];
           for (const lock of lockfiles) {
             const mainLock = path33.join(repo.mainPath, lock);
             const wtLock = path33.join(wtPath, lock);
-            if (fs27.existsSync(mainLock) && fs27.existsSync(wtLock)) {
-              const mainContent = fs27.readFileSync(mainLock);
-              const wtContent = fs27.readFileSync(wtLock);
+            if (fs28.existsSync(mainLock) && fs28.existsSync(wtLock)) {
+              const mainContent = fs28.readFileSync(mainLock);
+              const wtContent = fs28.readFileSync(wtLock);
               if (!mainContent.equals(wtContent)) {
                 stepWarning(`${lock} differs from main — node_modules is symlinked`);
                 indented(`Run: wtx deps ${branch} --repo ${repo.name} --install`);
@@ -35487,7 +35509,7 @@ init_config();
 init_log();
 init_resolver();
 init_deps();
-import fs28 from "fs";
+import fs29 from "fs";
 function registerDepsCommand(program2) {
   program2.command("deps [branch]").description("Manage node_modules strategy per worktree").option("-r, --repo <repos...>", "Target specific repo(s)").option("--install", "Switch to independent node_modules (run install)").option("--symlink", "Switch to legacy symlinked node_modules").option("--json", "Output machine-readable JSON state").action(async (branch, options) => {
     const globalOpts = program2.opts();
@@ -35524,7 +35546,7 @@ function registerDepsCommand(program2) {
         continue;
       }
       const wtPath = getWorktreePath(repo, branch);
-      if (!fs28.existsSync(wtPath)) {
+      if (!fs29.existsSync(wtPath)) {
         if (options.json) {
           jsonResults[repo.name] = { error: "No worktree found", branch };
         } else {
@@ -35582,7 +35604,7 @@ function registerDepsCommand(program2) {
 init_config();
 init_log();
 init_resolver();
-import fs29 from "fs";
+import fs30 from "fs";
 init_git();
 async function resolveMainCheckoutPath(repoCtx, branch) {
   try {
@@ -35607,7 +35629,7 @@ function registerOpenCommand(program2) {
     for (const repo of repos) {
       const wtPath = getWorktreePath(repo, branch);
       let targetPath = wtPath;
-      if (!fs29.existsSync(wtPath)) {
+      if (!fs30.existsSync(wtPath)) {
         const mainCheckoutPath = await resolveMainCheckoutPath(repo, branch);
         if (!mainCheckoutPath) {
           continue;
@@ -35643,7 +35665,7 @@ import path35 from "path";
 init_git();
 init_resolver();
 init_path_safety();
-import fs30 from "fs";
+import fs31 from "fs";
 import path34 from "path";
 init_workspace();
 async function getUpstream(wtPath) {
@@ -35686,7 +35708,7 @@ async function planRename(repo, oldBranch, newBranch, opts) {
     throw new Error(`Worktree '${oldBranch}' is locked — unlock it before renaming`);
   }
   const newPath = `${repo.wtRoot}/${newBranch}`;
-  if (fs30.existsSync(newPath)) {
+  if (fs31.existsSync(newPath)) {
     throw new Error(`Target path already exists: ${newPath}`);
   }
   if (!opts.dryRun && await localBranchExists(repo.mainPath, newBranch, opts)) {
@@ -35719,7 +35741,7 @@ async function renameWorktree(params) {
   }
   await gitExec(["-C", planned.worktreePath, "branch", "-m", oldBranch, newBranch], opts);
   try {
-    fs30.mkdirSync(path34.dirname(planned.newPath), { recursive: true });
+    fs31.mkdirSync(path34.dirname(planned.newPath), { recursive: true });
     await gitExec(["-C", repo.mainPath, "worktree", "move", planned.worktreePath, planned.newPath], opts);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
@@ -35738,10 +35760,10 @@ async function renameWorktree(params) {
   const resyncedFiles = [];
   const keptLocalSyncFiles = [];
   for (const entry of repo.config.sync_files ?? []) {
-    if (!fs30.existsSync(path34.join(repo.mainPath, entry)))
+    if (!fs31.existsSync(path34.join(repo.mainPath, entry)))
       continue;
     const destPath = path34.join(planned.newPath, entry);
-    if (!fs30.existsSync(destPath)) {
+    if (!fs31.existsSync(destPath)) {
       if (syncEntry(repo.mainPath, planned.newPath, entry)) {
         resyncedFiles.push(entry);
       }
@@ -35880,7 +35902,7 @@ init_resolver();
 init_deps();
 init_forge();
 init_types2();
-import fs31 from "fs";
+import fs32 from "fs";
 init_owner();
 init_stack();
 init_source();
@@ -35930,7 +35952,7 @@ function registerStatusCommand(program2) {
     const jsonOutputs = [];
     for (const repo of repos) {
       const wtPath = getWorktreePath(repo, branch);
-      if (!fs31.existsSync(wtPath)) {
+      if (!fs32.existsSync(wtPath)) {
         continue;
       }
       found++;
@@ -36230,7 +36252,7 @@ function registerPrsCommand(program2) {
 
 // src/commands/skill.ts
 init_log();
-import fs32 from "fs";
+import fs33 from "fs";
 import path36 from "path";
 import { URL as URL2 } from "url";
 var __dirname2 = new URL2(".", import.meta.url).pathname;
@@ -36387,7 +36409,7 @@ function registerSkillCommand(program2) {
     }
     let projectRoot = path36.resolve(__dirname2, "..", "..");
     let skillPath = path36.join(projectRoot, "skills", `${platform2}.md`);
-    if (fs32.existsSync(skillPath)) {
+    if (fs33.existsSync(skillPath)) {
       process.stdout.write(skillPath + `
 `);
     } else {
@@ -36400,7 +36422,7 @@ function registerSkillCommand(program2) {
 
 // src/commands/terminal.ts
 import { spawnSync as spawnSync3 } from "node:child_process";
-import fs35 from "node:fs";
+import fs36 from "node:fs";
 import path39 from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 function findEntry() {
@@ -36416,20 +36438,20 @@ function findEntry() {
   for (const p of candidates) {
     try {
       if (p.endsWith(".mjs") || p.endsWith(".js")) {
-        if (fs35.existsSync(p) && fs35.statSync(p).isFile())
+        if (fs36.existsSync(p) && fs36.statSync(p).isFile())
           return p;
-      } else if (fs35.existsSync(p)) {
-        const stat = fs35.statSync(p);
+      } else if (fs36.existsSync(p)) {
+        const stat = fs36.statSync(p);
         if (stat.isFile()) {
-          const head = fs35.readFileSync(p, "utf8").slice(0, 1024);
+          const head = fs36.readFileSync(p, "utf8").slice(0, 1024);
           if (head.includes("cli.mjs") || head.includes("#!/usr/bin/env node")) {
             if (p.endsWith("wtx") || p.endsWith("cli.mjs")) {
-              const dir = path39.dirname(fs35.realpathSync(p));
+              const dir = path39.dirname(fs36.realpathSync(p));
               const cli = path39.join(dir, "cli.mjs");
-              if (fs35.existsSync(cli))
+              if (fs36.existsSync(cli))
                 return cli;
               const cli2 = path39.resolve(dir, "../dist/cli.mjs");
-              if (fs35.existsSync(cli2))
+              if (fs36.existsSync(cli2))
                 return cli2;
               if (head.includes("import") || head.includes("commander"))
                 return p;
@@ -36443,7 +36465,7 @@ function findEntry() {
     const thisPath = fileURLToPath4(import.meta.url);
     const pkgRoot = path39.resolve(path39.dirname(thisPath), "../..");
     const cli = path39.join(pkgRoot, "dist", "cli.mjs");
-    if (fs35.existsSync(cli))
+    if (fs36.existsSync(cli))
       return cli;
   } catch {}
   return null;
@@ -36547,7 +36569,7 @@ init_deps();
 import readline3 from "readline";
 init_path_safety();
 init_stack();
-import fs36 from "fs";
+import fs37 from "fs";
 async function runMcpServer(opts = {}) {
   const input = opts.input ?? process.stdin;
   const output = opts.output ?? process.stdout;
@@ -36730,7 +36752,7 @@ async function handleToolCall(name, args, config2, _opts) {
         for (const wt of wts) {
           if (!wt.path.startsWith(repo.wtRoot))
             continue;
-          const dirtyCount = fs36.existsSync(wt.path) ? (await getDirtyFiles(wt.path)).length : 0;
+          const dirtyCount = fs37.existsSync(wt.path) ? (await getDirtyFiles(wt.path)).length : 0;
           items.push({
             repo: repo.name,
             branch: wt.branch || null,
@@ -36758,7 +36780,7 @@ async function handleToolCall(name, args, config2, _opts) {
       }
       const repo = resolveRepos(config2, [args.repo])[0];
       const wtPath = getWorktreePath(repo, args.branch);
-      if (!fs36.existsSync(wtPath)) {
+      if (!fs37.existsSync(wtPath)) {
         throw { isToolError: true, message: `Worktree not found for branch ${args.branch}` };
       }
       const mainBranch = await resolveMainBranch(repo, config2);
@@ -36877,13 +36899,18 @@ async function handleToolCall(name, args, config2, _opts) {
       if (children.length > 0 && args.force !== true) {
         throw { isToolError: true, message: `Branch has dependent worktrees: ${children.join(", ")}. Use force:true to override.` };
       }
-      if (!args.force && fs36.existsSync(wtPath)) {
+      if (!args.force && fs37.existsSync(wtPath)) {
         const dirty = await getDirtyFiles(wtPath);
         if (dirty.length > 0) {
           throw { isToolError: true, message: `Worktree is dirty. Use force:true to remove it.` };
         }
       }
-      await gitExec(["-C", repo.mainPath, "worktree", "remove", args.force ? "--force" : "", wtPath].filter(Boolean));
+      await removeWorktreeSafely({
+        mainPath: repo.mainPath,
+        wtPath,
+        force: args.force === true,
+        opts: { verbose: _opts.verbose === true, dryRun: false }
+      });
       cleanupEmptyParents(repo.wtRoot, repo.mainPath, wtPath);
       await removeStackEntry(repo.mainPath, args.branch, { verbose: _opts.verbose === true, dryRun: false });
       return {
@@ -36896,7 +36923,7 @@ async function handleToolCall(name, args, config2, _opts) {
       }
       const repo = resolveRepos(config2, [args.repo])[0];
       const wtPath = getWorktreePath(repo, args.branch);
-      if (!fs36.existsSync(wtPath)) {
+      if (!fs37.existsSync(wtPath)) {
         throw { isToolError: true, message: `Worktree not found for branch ${args.branch}` };
       }
       const mainBranch = await resolveMainBranch(repo, config2);
@@ -37118,7 +37145,7 @@ init_config();
 init_log();
 init_git();
 init_resolver();
-import fs37 from "fs";
+import fs38 from "fs";
 import path40 from "path";
 init_workspace();
 var DEPS_STRATEGIES2 = ["auto", "link", "symlink", "install", "off"];
@@ -37141,7 +37168,7 @@ async function resolveWorktreePathForMember(config2, repoName, branch) {
   if (match)
     return match.path;
   const candidate = getWorktreePath(repo, branch);
-  if (fs37.existsSync(candidate))
+  if (fs38.existsSync(candidate))
     return candidate;
   return null;
 }
@@ -37199,7 +37226,7 @@ function registerCreateSub(workspace) {
       process.exit(1);
     }
     const wsPath = workspacePathFor2(config2, name);
-    if (fs37.existsSync(wsPath)) {
+    if (fs38.existsSync(wsPath)) {
       stepError("Workspace already exists", wsPath);
       process.exit(1);
     }
@@ -37300,7 +37327,7 @@ function registerAddSub(workspace) {
     const globalOpts = workspace.parent.opts();
     const config2 = loadConfig();
     const wsPath = workspacePathFor2(config2, name);
-    if (!fs37.existsSync(wsPath)) {
+    if (!fs38.existsSync(wsPath)) {
       stepError("Workspace not found", wsPath);
       process.exit(1);
     }
@@ -37336,7 +37363,7 @@ function registerRmSub(workspace) {
     const globalOpts = workspace.parent.opts();
     const config2 = loadConfig();
     const wsPath = workspacePathFor2(config2, name);
-    if (!fs37.existsSync(wsPath)) {
+    if (!fs38.existsSync(wsPath)) {
       stepError("Workspace not found", wsPath);
       process.exit(1);
     }
@@ -37358,7 +37385,7 @@ function registerRemoveSub(workspace) {
     const globalOpts = workspace.parent.opts();
     const config2 = loadConfig();
     const wsPath = workspacePathFor2(config2, name);
-    if (!fs37.existsSync(wsPath)) {
+    if (!fs38.existsSync(wsPath)) {
       stepError("Workspace not found", wsPath);
       process.exit(1);
     }
@@ -37372,7 +37399,7 @@ function registerRemoveSub(workspace) {
       return;
     }
     try {
-      fs37.rmSync(wsPath, { recursive: true, force: true });
+      fs38.rmSync(wsPath, { recursive: true, force: true });
       stepSuccess("Workspace removed", wsPath);
       summary(`Done — workspace ${name} deleted (member worktrees preserved)`);
     } catch (err) {
@@ -37385,7 +37412,7 @@ function registerVerifySub(workspace) {
   workspace.command("verify <name>").description("Verify that every workspace member link resolves").action(async (name) => {
     const config2 = loadConfig();
     const wsPath = workspacePathFor2(config2, name);
-    if (!fs37.existsSync(wsPath)) {
+    if (!fs38.existsSync(wsPath)) {
       stepError("Workspace not found", wsPath);
       process.exit(1);
     }
@@ -37420,7 +37447,7 @@ init_config();
 init_resolver();
 init_log();
 init_history();
-import fs38 from "fs";
+import fs39 from "fs";
 var program2 = new Command;
 program2.name("wtx").description("Multi-repo git worktree manager").version(VERSION).option("-q, --quiet", "Suppress progress indicators", false).option("--verbose", "Show git commands as they run", false).option("--dry-run", "Show what would happen", false);
 var MUTATING_COMMANDS = new Set([
@@ -37530,7 +37557,7 @@ program2.command("_resolve-path <repo> <branch>", { hidden: true }).description(
     }
     const repo = repos[0];
     const wtPath = getWorktreePath(repo, branch);
-    if (!fs38.existsSync(wtPath)) {
+    if (!fs39.existsSync(wtPath)) {
       process.stderr.write(`✗ No worktree at ${wtPath}
 `);
       process.exit(1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ogpoyraz/wtx",
-  "version": "0.9.2",
+  "version": "0.9.3",
   "description": "Multi-repo git worktree manager",
   "type": "module",
   "bin": {