@ogpoyraz/wtx 0.9.2 → 0.9.4

package/README.md

@@ -96,7 +96,7 @@ If origin already has a branch with that name owned by someone else, `wtx` warns
 | `stack` | `<branch>` | `--repo`, `--json` | Show recorded parent and descendant branches |
 | `prs` | | `--repo`, `--json`, `--all` | Pull request status across worktrees |
 | `exec` | `<branch> <command...>` | `--repo` | Run a command inside a worktree (`WTX_PORT` injected) |
-| `terminal` | | | Interactive worktree dashboard (requires Bun) |
+| `terminal` | | `--wo-details` | Interactive worktree dashboard (requires Bun) |
 | `mcp` | | | Run MCP server exposing worktree tools over stdio |
 | `cd` | `<repo> <branch>` | | cd into worktree (requires shell integration) |
 | `history` | | `--limit`, `--json`, `--source` | Show recent action history (`~/.local/state/wtx/history.jsonl`) |
@@ -304,6 +304,7 @@ Stack metadata is stored under the repository's common Git directory and is not
 
 Launch the TUI with `wtx terminal` (requires [Bun](https://bun.sh)). Navigation never locks, and actions run in the background.
 `wtx terminal` opens a full-screen dashboard across all configured repos (requires the [Bun](https://bun.sh) runtime).
+Pass `--wo-details` for a repositories-only view: the right pane (Details, Changes, terminal sessions) is hidden and the worktree list takes the full width.
 
 | Key | Action |
 |---|---|

package/completions/_wtx.zsh

@@ -73,6 +73,7 @@ _wtx() {
         'prs[Show pull request status across worktrees]' \
         'init[Output shell integration code]' \
         'skill[Manage AI agent skills]' \
+        'terminal[Interactive terminal dashboard]' \
         'mcp[Run MCP server exposing worktree tools]' \
         'exec[Execute commands across worktrees]'
       ;;
@@ -227,6 +228,13 @@ _wtx() {
             '--verbose[Show git commands]' \
             '--dry-run[Show what would happen]'
           ;;
+        terminal)
+          _arguments \
+            '--wo-details[Repositories panel only (hide details/right pane)]' \
+            {-q,--quiet}'[Suppress output]' \
+            '--verbose[Show git commands]' \
+            '--dry-run[Show what would happen]'
+          ;;
       esac
       ;;
   esac

package/completions/wtx.bash

@@ -102,6 +102,7 @@ _wtx_completions() {
       status)  flags="-r --repo --base --json -q --quiet --verbose --dry-run --help" ;;
       stack)   flags="-r --repo --json -q --quiet --verbose --dry-run --help" ;;
       prs)     flags="-r --repo --json --all -q --quiet --verbose --dry-run --help" ;;
+      terminal) flags="--wo-details -q --quiet --verbose --dry-run --help" ;;
       config)
         case "$subsubcommand" in
           add-repo) flags="--sync-files --post-create --post-sync --help" ;;

package/completions/wtx.fish

@@ -99,6 +99,9 @@ complete -c wtx -n "__fish_seen_subcommand_from ls" -l pr -d "Include pull reque
 # prs flags
 complete -c wtx -n "__fish_seen_subcommand_from prs" -l all -d "Include drafts and closed/merged PRs"
 
+# terminal flags
+complete -c wtx -n "__fish_seen_subcommand_from terminal" -l wo-details -d "Repositories panel only (hide details/right pane)"
+
 # stack-aware flags
 complete -c wtx -n "__fish_seen_subcommand_from rebase" -l onto -xa "main master develop dev" -d "Override recorded base"
 complete -c wtx -n "__fish_seen_subcommand_from status" -l base -xa "main master develop dev" -d "Override recorded base"

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(`
@@ -28096,10 +28096,11 @@ var init_Overlay = __esm(() => {
 
 // src/tui/components/HelpOverlay.tsx
 import { jsx as jsx10, jsxs as jsxs8 } from "@opentui/react/jsx-runtime";
-function HelpOverlay() {
+function HelpOverlay({ withoutDetails = false }) {
   const theme = useTheme();
+  const groups = withoutDetails ? HELP_GROUPS.filter((g) => g.title !== "Terminal & Tabs" && !g.title.startsWith("Changes Explorer")) : HELP_GROUPS;
   return /* @__PURE__ */ jsxs8(Overlay, {
-    title: "Help",
+    title: withoutDetails ? "Help (repositories only)" : "Help",
     borderColor: theme.border,
     width: 100,
     children: [
@@ -28108,7 +28109,7 @@ function HelpOverlay() {
         style: { maxHeight: 38 },
         children: /* @__PURE__ */ jsx10("scrollbox", {
           flexGrow: 1,
-          children: HELP_GROUPS.map((group) => /* @__PURE__ */ jsxs8("box", {
+          children: groups.map((group) => /* @__PURE__ */ jsxs8("box", {
             flexDirection: "column",
             style: { marginBottom: 1 },
             children: [
@@ -28408,7 +28409,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 +28423,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 +28448,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 [];
   }
@@ -29811,7 +29812,7 @@ function createTerminalResizeScheduler(getSessionsByKey, resizeSession, onSettle
     flush
   };
 }
-function App({ opts }) {
+function App({ opts, withoutDetails = false }) {
   const renderer = useRenderer2();
   const { blocks, loading, refreshing, error: error52, warnings, lastRefreshed, pendingRepos, favorites, refresh, clearWarnings, applyFavorites } = useWorktrees(opts);
   const [selectedIndex, setSelectedIndex] = useState11(0);
@@ -30097,6 +30098,10 @@ function App({ opts }) {
     setChangesFocused(id === "changes" && selectedRow != null && !selectedRow.isMainCheckout && selectedRow.dirtyFiles.length > 0);
   }, [activeTabId, renderer, worktreeKey, sessionsForSelected, selectedRow]);
   const handleAddSession = useCallback7(() => {
+    if (withoutDetails) {
+      flash("Terminal sessions disabled (--wo-details)");
+      return;
+    }
     if (!selectedRow) {
       flash("No worktree selected");
       return;
@@ -30121,7 +30126,7 @@ function App({ opts }) {
     setTerminalFocused(true);
     setChangesFocused(false);
     flash(`Session ${session.label} created`, 2000);
-  }, [selectedRow, terminalSessions, flash, totalWidth, splitRatio, totalHeight, activeTabId, sessionsForSelected]);
+  }, [selectedRow, terminalSessions, flash, totalWidth, splitRatio, totalHeight, activeTabId, sessionsForSelected, withoutDetails]);
   const handleCloseSession = useCallback7((id) => {
     let targetRepo;
     let targetBranch;
@@ -30498,6 +30503,10 @@ function App({ opts }) {
       return;
     }
     if (key === "t") {
+      if (withoutDetails) {
+        flash("Terminal sessions disabled (--wo-details)");
+        return;
+      }
       if (!selectedRow)
         return;
       const sessions = terminalSessions.getSessions(selectedRow.repoName, selectedRow.branch, selectedRow.path);
@@ -30508,7 +30517,7 @@ function App({ opts }) {
       handleAddSession();
       return;
     }
-  }, [selectedRow, selection, combinedWarnings, busyRepos, busyRowPaths, doRefresh, flash, blocks, terminalSessions]);
+  }, [selectedRow, selection, combinedWarnings, busyRepos, busyRowPaths, doRefresh, flash, blocks, terminalSessions, withoutDetails]);
   useKeyboard4((key) => {
     if (changesFocused) {
       if (key.ctrl && key.name === "g" || key.name === "escape") {
@@ -30566,6 +30575,8 @@ function App({ opts }) {
       return;
     }
     if (key.ctrl && key.name === "g") {
+      if (withoutDetails)
+        return;
       if (sessionsForSelected.length > 0) {
         const targetId = activeTabId !== "details" ? activeTabId : sessionsForSelected[0].id;
         if (worktreeKey) {
@@ -30923,6 +30934,10 @@ function App({ opts }) {
       return;
     }
     if (key.name === "t") {
+      if (withoutDetails) {
+        flash("Terminal sessions disabled (--wo-details)");
+        return;
+      }
       if (!selectedRow) {
         flash("No worktree selected");
         return;
@@ -30937,7 +30952,7 @@ function App({ opts }) {
     }
   });
   const rawLeft = Math.floor(totalWidth * splitRatio);
-  const leftCols = Math.max(20, Math.min(totalWidth - 20 - DIVIDER_WIDTH, rawLeft));
+  const leftCols = withoutDetails ? totalWidth : Math.max(20, Math.min(totalWidth - 20 - DIVIDER_WIDTH, rawLeft));
   const rightCols = Math.max(20, totalWidth - leftCols - DIVIDER_WIDTH);
   const paneCols = Math.max(20, rightCols - 4);
   const paneRows = Math.max(10, totalHeight - 10);
@@ -31000,13 +31015,13 @@ function App({ opts }) {
                 onToggleSelect: (path39) => setSelection((prev) => toggleSelection(prev, path39))
               })
             }),
-            /* @__PURE__ */ jsx18(Divider, {
+            !withoutDetails && /* @__PURE__ */ jsx18(Divider, {
               splitRatio,
               totalWidth,
               onChange: setSplitRatio,
               onDraggingChange: setIsResizing
             }),
-            /* @__PURE__ */ jsx18("box", {
+            !withoutDetails && /* @__PURE__ */ jsx18("box", {
               width: rightCols,
               height: "100%",
               flexDirection: "column",
@@ -31083,7 +31098,9 @@ function App({ opts }) {
           },
           onCancel: () => setWorkspacePickerOpen(false)
         }),
-        modal.type === "help" && /* @__PURE__ */ jsx18(HelpOverlay, {}),
+        modal.type === "help" && /* @__PURE__ */ jsx18(HelpOverlay, {
+          withoutDetails
+        }),
         modal.type === "history" && /* @__PURE__ */ jsx18(HistoryOverlay, {}),
         modal.type === "warnings" && /* @__PURE__ */ jsx18(WarningsOverlay, {
           warnings: combinedWarnings,
@@ -31377,7 +31394,7 @@ __export(exports_tui, {
 import { createCliRenderer, TextTableRenderable, EmbeddedTerminalRenderable } from "@opentui/core";
 import { createRoot, extend as extend2 } from "@opentui/react";
 import { jsx as jsx19 } from "@opentui/react/jsx-runtime";
-async function runTerminal(opts) {
+async function runTerminal(opts, runOpts = {}) {
   setQuiet(true);
   const prevLog = console.log;
   const prevInfo = console.info;
@@ -31452,7 +31469,8 @@ async function runTerminal(opts) {
   const root = createRoot(renderer);
   try {
     root.render(/* @__PURE__ */ jsx19(App, {
-      opts
+      opts,
+      withoutDetails: runOpts.withoutDetails ?? false
     }));
   } catch (err) {
     restoreConsole();
@@ -34137,8 +34155,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 +34331,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 +34344,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 +34403,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 +34537,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 +34588,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 +34679,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 +34721,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 +34730,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 +34754,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 +34790,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 +34929,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 +35042,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 +35152,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 +35278,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 +35293,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 +35419,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 +35431,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 +35491,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 +35527,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 +35564,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 +35622,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 +35647,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 +35683,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 +35726,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 +35759,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 +35778,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 +35920,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 +35970,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 +36270,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 +36427,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 +36440,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 +36456,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 +36483,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;
@@ -36485,7 +36525,7 @@ function tryRelaunchViaBun(forwardedArgs) {
   return null;
 }
 function registerTerminalCommand(program2) {
-  program2.command("terminal").description("Interactive worktree dashboard (requires Bun)").action(async () => {
+  program2.command("terminal").description("Interactive worktree dashboard (requires Bun)").option("--wo-details", "Repositories panel only (hide details/right pane)").action(async (options) => {
     const opts = program2.optsWithGlobals();
     if (typeof Bun === "undefined") {
       const forwarded = process.argv.slice(2);
@@ -36534,7 +36574,7 @@ function registerTerminalCommand(program2) {
     process.env.PAGE_LIST_LOG ??= "off";
     process.env.OPENTUI_LOG ??= "off";
     const { runTerminal: runTerminal2 } = await Promise.resolve().then(() => (init_tui(), exports_tui));
-    await runTerminal2(opts);
+    await runTerminal2(opts, { withoutDetails: Boolean(options.woDetails) });
   });
 }
 
@@ -36547,7 +36587,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 +36770,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 +36798,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 +36917,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 +36941,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 +37163,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 +37186,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 +37244,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 +37345,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 +37381,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 +37403,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 +37417,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 +37430,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 +37465,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 +37575,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.4",
   "description": "Multi-repo git worktree manager",
   "type": "module",
   "bin": {