@ogpoyraz/wtx 0.9.1 → 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;
@@ -25503,20 +25503,22 @@ async function fetchWorktreeData(opts, scope) {
   }
   let repos;
   try {
-    repos = resolveRepos(config2);
+    if (scope && scope.length > 0) {
+      repos = resolveRepos(config2, scope);
+    } else {
+      repos = resolveRepos(config2, Object.keys(config2.repos));
+    }
   } catch (err) {
     throw new Error(`Failed to resolve repos: ${errorMessage3(err)}`);
   }
-  if (scope) {
-    const scopeSet = new Set(scope);
-    repos = repos.filter((r) => scopeSet.has(r.name));
-  }
   const semaphore = new Semaphore(4);
   const allRows = [];
   const processRepo = async (repo) => {
     await semaphore.acquire();
+    let mainBranch = config2.default_main_branch;
+    let hasMain = false;
     try {
-      const mainBranch = await resolveMainBranch(repo, config2);
+      mainBranch = await resolveMainBranch(repo, config2);
       const wts = await getWorktreeList(repo.mainPath);
       let stackMetadata = { version: 1, branches: {} };
       try {
@@ -25531,7 +25533,9 @@ async function fetchWorktreeData(opts, scope) {
         if (wt.isBare)
           continue;
         let branch = wt.branch;
-        const isMainCheckout = wt.path === repo.mainPath;
+        const isMainCheckout = safeResolve(wt.path) === safeResolve(repo.mainPath);
+        if (isMainCheckout)
+          hasMain = true;
         if (isMainCheckout && !branch) {
           branch = mainBranch;
         }
@@ -25562,6 +25566,7 @@ async function fetchWorktreeData(opts, scope) {
         };
         if (isMainCheckout) {
           allRows.push(row);
+          prRows.push(row);
           continue;
         }
         await Promise.allSettled([
@@ -25622,8 +25627,56 @@ async function fetchWorktreeData(opts, scope) {
       if (forge && branches.length > 0) {
         prFetchJobs.push({ repo, forge, mainBranch, rows: prRows, branches, stackMetadata });
       }
+      if (!hasMain) {
+        allRows.push({
+          repoName: repo.name,
+          branch: mainBranch,
+          path: repo.mainPath,
+          commitShort: "",
+          isMainCheckout: true,
+          isLocked: false,
+          isPrunable: false,
+          isBare: false,
+          dirtyFiles: [],
+          ahead: null,
+          behind: null,
+          prNumber: null,
+          prState: null,
+          prChecks: null,
+          prUrl: null,
+          owner: null,
+          rebaseStatus: null,
+          depsStrategy: "none",
+          base: undefined,
+          baseChanged: false
+        });
+      }
     } catch (err) {
       warnings.push({ repoName: repo.name, message: `Failed to process repo ${repo.name}: ${errorMessage3(err)}` });
+      if (!hasMain) {
+        allRows.push({
+          repoName: repo.name,
+          branch: mainBranch,
+          path: repo.mainPath,
+          commitShort: "",
+          isMainCheckout: true,
+          isLocked: false,
+          isPrunable: false,
+          isBare: false,
+          dirtyFiles: [],
+          ahead: null,
+          behind: null,
+          prNumber: null,
+          prState: null,
+          prChecks: null,
+          prUrl: null,
+          owner: null,
+          rebaseStatus: null,
+          depsStrategy: "none",
+          base: undefined,
+          baseChanged: false
+        });
+      }
     } finally {
       semaphore.release();
     }
@@ -25650,6 +25703,7 @@ var init_data = __esm(() => {
   init_owner();
   init_types2();
   init_stack();
+  init_path_safety();
   PR_CACHE_TTL_MS = 5 * 60 * 1000;
   prCache = new Map;
 });
@@ -25946,7 +26000,12 @@ var init_useWorktrees = __esm(() => {
 import { RGBA } from "@opentui/core";
 import { createContext, useContext } from "react";
 function useTheme() {
-  return useContext(ThemeContext);
+  try {
+    const ctx = useContext(ThemeContext);
+    return ctx ?? tokens;
+  } catch {
+    return tokens;
+  }
 }
 function truncateBranch(name, max = 42) {
   if (name.length <= max)
@@ -26101,18 +26160,18 @@ async function openInBrowser(url2) {
 // src/tui/components/WorktreeTable.tsx
 import { useEffect as useEffect2, useRef as useRef3 } from "react";
 import { jsx, jsxs } from "@opentui/react/jsx-runtime";
-function statusBadge(row) {
+function statusBadge(row, theme) {
   if (row.isMainCheckout)
-    return { text: "[main]", fg: tokens.accent };
+    return { text: "[main]", fg: theme.accent };
   if (row.isPrunable)
-    return { text: "missing", fg: tokens.error };
+    return { text: "missing", fg: theme.error };
   if (row.isLocked)
-    return { text: "locked", fg: tokens.error };
+    return { text: "locked", fg: theme.error };
   if (row.rebaseStatus)
-    return { text: "rebasing", fg: tokens.warning };
+    return { text: "rebasing", fg: theme.warning };
   if (row.dirtyFiles.length > 0)
-    return { text: `dirty (${row.dirtyFiles.length})`, fg: tokens.warning };
-  return { text: "clean", fg: tokens.dim };
+    return { text: `dirty (${row.dirtyFiles.length})`, fg: theme.warning };
+  return { text: "clean", fg: theme.dim };
 }
 function WorktreeItem({
   row,
@@ -26125,6 +26184,7 @@ function WorktreeItem({
   onRowClick,
   onToggleSelect
 }) {
+  const theme = useTheme();
   const prTap = useTapHandler(() => {
     if (row.prUrl)
       openInBrowser(row.prUrl);
@@ -26136,9 +26196,9 @@ function WorktreeItem({
     e.stopPropagation();
     onToggleSelect?.();
   });
-  const badge = indicator ? indicator.running ? { text: `${frame} ${indicator.verb}…`, fg: tokens.accent } : { text: `◌ ${indicator.verb}`, fg: tokens.dim } : row.isPendingCreate ? { text: `${frame} creating…`, fg: tokens.accent } : statusBadge(row);
+  const badge = indicator ? indicator.running ? { text: `${frame} ${indicator.verb}…`, fg: theme.accent } : { text: `◌ ${indicator.verb}`, fg: theme.dim } : row.isPendingCreate ? { text: `${frame} creating…`, fg: theme.accent } : statusBadge(row, theme);
   const disabled = indicator !== undefined || row.isPendingCreate === true;
-  const primary = isSelected ? tokens.bright : disabled ? tokens.dim : tokens.fg;
+  const primary = isSelected ? theme.bright : disabled ? theme.dim : theme.fg;
   const divergence = row.ahead !== null && row.behind !== null && (row.ahead > 0 || row.behind > 0) ? ` · ↑${row.ahead} ↓${row.behind}` : "";
   const ownerSegment = row.owner ? ` · by ${row.owner}` : "";
   const baseSegment = row.base ? ` · base ${row.base}` : "";
@@ -26156,7 +26216,7 @@ function WorktreeItem({
   return /* @__PURE__ */ jsxs("box", {
     id,
     flexDirection: "column",
-    backgroundColor: isSelected ? tokens.selectionBg : undefined,
+    backgroundColor: isSelected ? theme.selectionBg : undefined,
     style: { paddingRight: 1 },
     ...isClickable && onRowClick ? rowTap : {},
     children: [
@@ -26173,18 +26233,18 @@ function WorktreeItem({
             width: 2,
             ...onToggleSelect ? gutterTap : {},
             children: /* @__PURE__ */ jsx("text", {
-              fg: tokens.accent,
+              fg: theme.accent,
               children: isMultiSelected ? "✓ " : "  "
             })
           }),
           /* @__PURE__ */ jsxs("text", {
             children: [
               /* @__PURE__ */ jsx("span", {
-                fg: tokens.dim,
+                fg: theme.dim,
                 children: hierarchyPrefix
               }),
               isWorkspaceMember && /* @__PURE__ */ jsx("span", {
-                fg: tokens.accent,
+                fg: theme.accent,
                 children: "⬡ "
               }),
               /* @__PURE__ */ jsx("span", {
@@ -26205,11 +26265,11 @@ function WorktreeItem({
           /* @__PURE__ */ jsxs("text", {
             children: [
               /* @__PURE__ */ jsx("span", {
-                fg: tokens.dim,
+                fg: theme.dim,
                 children: secondary
               }),
               row.prNumber !== null && secondary ? /* @__PURE__ */ jsx("span", {
-                fg: tokens.dim,
+                fg: theme.dim,
                 children: " · "
               }) : null
             ]
@@ -26219,26 +26279,26 @@ function WorktreeItem({
             children: /* @__PURE__ */ jsxs("text", {
               children: [
                 /* @__PURE__ */ jsx("span", {
-                  fg: tokens.accent,
+                  fg: theme.accent,
                   children: `#${row.prNumber}`
                 }),
                 row.prState && /* @__PURE__ */ jsx("span", {
-                  fg: tokens.dim,
+                  fg: theme.dim,
                   children: ` ${row.prState}`
                 }),
                 row.prChecks && /* @__PURE__ */ jsx("span", {
-                  fg: tokens.dim,
+                  fg: theme.dim,
                   children: ` (${row.prChecks})`
                 }),
                 row.prUrl && /* @__PURE__ */ jsx("span", {
-                  fg: tokens.dim,
+                  fg: theme.dim,
                   children: " ↗"
                 })
               ]
             })
           }),
           row.prNumber === null && row.prState === "FETCHING" && /* @__PURE__ */ jsxs("text", {
-            fg: tokens.dim,
+            fg: theme.dim,
             children: [
               secondary ? " · " : "",
               "PR …"
@@ -26247,11 +26307,11 @@ function WorktreeItem({
           /* @__PURE__ */ jsxs("text", {
             children: [
               baseChangedSegment && /* @__PURE__ */ jsx("span", {
-                fg: tokens.warning,
+                fg: theme.warning,
                 children: baseChangedSegment
               }),
               rebaseSegment && /* @__PURE__ */ jsx("span", {
-                fg: tokens.error,
+                fg: theme.error,
                 children: rebaseSegment
               })
             ]
@@ -26262,6 +26322,7 @@ function WorktreeItem({
   });
 }
 function WorktreeTable({ blocks, selectedIndex, selection = new Set, frame, repoVerbs, rowVerbs, favorites = [], workspaceMemberSet = null, activeWorkspaceName = null, onRowClick, onToggleSelect }) {
+  const theme = useTheme();
   const favoriteSet = new Set(favorites);
   const scrollRef = useRef3(null);
   useEffect2(() => {
@@ -26285,8 +26346,8 @@ function WorktreeTable({ blocks, selectedIndex, selection = new Set, frame, repo
     width: "100%",
     height: "100%",
     border: true,
-    borderColor: tokens.border,
-    focusedBorderColor: tokens.border,
+    borderColor: theme.border,
+    focusedBorderColor: theme.border,
     focusable: false,
     title: activeWorkspaceName ? `Repositories · workspace: ${activeWorkspaceName}` : "Repositories",
     paddingX: 1,
@@ -26295,7 +26356,7 @@ function WorktreeTable({ blocks, selectedIndex, selection = new Set, frame, repo
       e.stopPropagation();
     },
     children: blocks.length === 0 ? /* @__PURE__ */ jsx("text", {
-      fg: tokens.dim,
+      fg: theme.dim,
       children: "No repositories configured."
     }) : blocks.map((block) => {
       const repoIndicator = repoVerbs.get(block.repoName);
@@ -26308,22 +26369,22 @@ function WorktreeTable({ blocks, selectedIndex, selection = new Set, frame, repo
             children: /* @__PURE__ */ jsxs("text", {
               children: [
                 favoriteSet.has(block.repoName) && /* @__PURE__ */ jsx("span", {
-                  fg: tokens.accent,
+                  fg: theme.accent,
                   children: "★ "
                 }),
                 /* @__PURE__ */ jsx("span", {
-                  fg: tokens.bright,
+                  fg: theme.bright,
                   children: block.repoName
                 }),
                 block.rows.length > 0 && /* @__PURE__ */ jsx("span", {
-                  fg: tokens.dim,
+                  fg: theme.dim,
                   children: ` · ${block.rows.filter((r) => !r.isPendingCreate).length}`
                 }),
                 repoIndicator ? /* @__PURE__ */ jsx("span", {
-                  fg: repoIndicator.running ? tokens.accent : tokens.dim,
+                  fg: repoIndicator.running ? theme.accent : theme.dim,
                   children: repoIndicator.running ? `  ${frame} ${repoIndicator.verb}…` : `  ◌ ${repoIndicator.verb}`
                 }) : block.rows.length === 0 ? /* @__PURE__ */ jsx("span", {
-                  fg: tokens.accent,
+                  fg: theme.accent,
                   children: `  ${frame} refreshing…`
                 }) : null
               ]
@@ -26357,6 +26418,7 @@ function WorktreeTable({ blocks, selectedIndex, selection = new Set, frame, repo
 }
 var SECONDARY_INDENT = "      ";
 var init_WorktreeTable = __esm(() => {
+  init_theme();
   init_theme();
   init_use_tap();
   init_utils();
@@ -26372,6 +26434,7 @@ function TabItem({
   onSelect,
   onClose
 }) {
+  const theme = useTheme();
   const tap = useTapHandler(() => onSelect(id));
   const closeTap = useTapHandler((e) => {
     e.stopPropagation();
@@ -26383,15 +26446,15 @@ function TabItem({
     ...tap,
     children: [
       /* @__PURE__ */ jsx2("text", {
-        fg: active ? tokens.accent : tokens.dim,
+        fg: active ? theme.accent : theme.dim,
         attributes: active ? 1 : 0,
         children: label
       }),
       closable ? /* @__PURE__ */ jsx2("box", {
         ...closeTap,
-        style: { marginLeft: 1 },
+        style: { marginLeft: 1, paddingLeft: 1, paddingRight: 1 },
         children: /* @__PURE__ */ jsx2("text", {
-          fg: active ? tokens.accent : tokens.dim,
+          fg: theme.accent,
           children: "✕"
         })
       }) : null,
@@ -26426,6 +26489,7 @@ var init_TabBar = __esm(() => {
 import { useState as useState2, useEffect as useEffect3, useRef as useRef4, useCallback as useCallback3 } from "react";
 import { jsx as jsx3, jsxs as jsxs3 } from "@opentui/react/jsx-runtime";
 function TerminalView({ session, focused, onFocus, onSend, onResize, registerListener, unregisterListener }) {
+  const theme = useTheme();
   const [draft, setDraft] = useState2("");
   const focusTap = useTapHandler(() => onFocus());
   const termRef = useRef4(null);
@@ -26568,7 +26632,7 @@ function TerminalView({ session, focused, onFocus, onSend, onResize, registerLis
           })
         }),
         session.exited !== null && /* @__PURE__ */ jsxs3("text", {
-          fg: tokens.warning,
+          fg: theme.warning,
           children: [
             "— exited with code ",
             session.exited,
@@ -26576,7 +26640,7 @@ function TerminalView({ session, focused, onFocus, onSend, onResize, registerLis
           ]
         }),
         !focused && /* @__PURE__ */ jsxs3("text", {
-          fg: tokens.dim,
+          fg: theme.dim,
           children: [
             "Click to focus · Ctrl+G or click table to unfocus · ",
             session.label,
@@ -26584,7 +26648,7 @@ function TerminalView({ session, focused, onFocus, onSend, onResize, registerLis
           ]
         }),
         focused && /* @__PURE__ */ jsx3("text", {
-          fg: tokens.accent,
+          fg: theme.accent,
           children: "Focused PTY — all keys go to shell · Ctrl+G to unfocus · scroll wheel to view history"
         })
       ]
@@ -26602,12 +26666,12 @@ function TerminalView({ session, focused, onFocus, onSend, onResize, registerLis
     children: [
       spawnError && /* @__PURE__ */ jsx3("box", {
         border: true,
-        borderColor: tokens.error,
+        borderColor: theme.error,
         paddingX: 1,
         paddingY: 0,
         marginBottom: 1,
         children: /* @__PURE__ */ jsx3("text", {
-          fg: tokens.error,
+          fg: theme.error,
           children: spawnError
         })
       }),
@@ -26622,14 +26686,14 @@ function TerminalView({ session, focused, onFocus, onSend, onResize, registerLis
         onMouseScroll: handlePipeScroll,
         children: [
           lines.length === 0 ? /* @__PURE__ */ jsx3("text", {
-            fg: tokens.dim,
+            fg: theme.dim,
             children: "No output yet — type a command below."
           }) : lines.slice(-500).map((line, idx) => /* @__PURE__ */ jsx3("text", {
-            fg: spawnError ? tokens.error : session.exited !== null ? tokens.dim : tokens.fg,
+            fg: spawnError ? theme.error : session.exited !== null ? theme.dim : theme.fg,
             children: line || " "
           }, idx)),
           session.exited !== null && /* @__PURE__ */ jsxs3("text", {
-            fg: tokens.warning,
+            fg: theme.warning,
             children: [
               "— exited with code ",
               session.exited,
@@ -26644,7 +26708,7 @@ function TerminalView({ session, focused, onFocus, onSend, onResize, registerLis
         width: "100%",
         children: [
           /* @__PURE__ */ jsx3("text", {
-            fg: tokens.dim,
+            fg: theme.dim,
             children: "$"
           }),
           /* @__PURE__ */ jsx3("box", {
@@ -26666,11 +26730,11 @@ function TerminalView({ session, focused, onFocus, onSend, onResize, registerLis
         ]
       }),
       !focused && /* @__PURE__ */ jsx3("text", {
-        fg: tokens.dim,
+        fg: theme.dim,
         children: "Click terminal or press 't' to focus · Ctrl+G or click table to unfocus"
       }),
       focused && /* @__PURE__ */ jsx3("text", {
-        fg: tokens.accent,
+        fg: theme.accent,
         children: "Focused — typing goes to shell · Ctrl+G to unfocus · max 5 per worktree persist across switches"
       })
     ]
@@ -26694,12 +26758,16 @@ function TabPane({
   onClose,
   allSessionsFlat,
   terminalFocused,
+  changesFocused,
+  onChangesFocus,
   activeTabId,
   recentSessionIds,
   terminalSessions
 }) {
-  const borderColor = focused ? tokens.accent : tokens.border;
+  const theme = useTheme();
+  const borderColor = focused ? theme.accent : theme.border;
   const mountedSessions = allSessionsFlat?.filter((s) => activeTabId === s.id || recentSessionIds?.has(s.id));
+  const nonSessionTabs = tabs.filter((t) => !t.closable);
   return /* @__PURE__ */ jsxs4("box", {
     flexDirection: "column",
     flexGrow: 1,
@@ -26724,13 +26792,28 @@ function TabPane({
         width: "100%",
         flexDirection: "column",
         children: [
-          tabs.map((t) => /* @__PURE__ */ jsx4("box", {
-            flexGrow: 1,
-            width: "100%",
-            flexDirection: "column",
-            visible: t.id === activeId,
-            children: t.render({ worktree: selectedRow, isActive: t.id === activeId, focused: focused && t.id === activeId })
-          }, t.id)),
+          nonSessionTabs.map((t) => {
+            const isChanges = t.id === "changes";
+            const tabFocused = isChanges ? !!changesFocused : !terminalFocused && !changesFocused && t.id === activeId;
+            const content = t.render({ worktree: selectedRow, isActive: t.id === activeId, focused: tabFocused });
+            if (isChanges) {
+              return /* @__PURE__ */ jsx4("box", {
+                flexGrow: 1,
+                width: "100%",
+                flexDirection: "column",
+                visible: t.id === activeId,
+                onMouseDown: () => onChangesFocus?.(),
+                children: content
+              }, t.id);
+            }
+            return /* @__PURE__ */ jsx4("box", {
+              flexGrow: 1,
+              width: "100%",
+              flexDirection: "column",
+              visible: t.id === activeId,
+              children: content
+            }, t.id);
+          }),
           mountedSessions?.map((s) => /* @__PURE__ */ jsx4("box", {
             flexGrow: 1,
             width: "100%",
@@ -26747,8 +26830,8 @@ function TabPane({
               unregisterListener: terminalSessions?.unregisterListener
             })
           }, s.id)),
-          tabs.length === 0 && (!mountedSessions || mountedSessions.length === 0) && /* @__PURE__ */ jsx4("text", {
-            fg: tokens.dim,
+          nonSessionTabs.length === 0 && (!mountedSessions || mountedSessions.length === 0) && /* @__PURE__ */ jsx4("text", {
+            fg: theme.dim,
             children: "No tab"
           })
         ]
@@ -26765,6 +26848,7 @@ var init_TabPane = __esm(() => {
 // src/tui/components/DetailsTab.tsx
 import { jsx as jsx5, jsxs as jsxs5, Fragment } from "@opentui/react/jsx-runtime";
 function DetailsContent({ selectedRow }) {
+  const theme = useTheme();
   const prTap = useTapHandler(() => {
     if (selectedRow?.prUrl)
       openInBrowser(selectedRow.prUrl);
@@ -26777,7 +26861,7 @@ function DetailsContent({ selectedRow }) {
       justifyContent: "center",
       alignItems: "center",
       children: /* @__PURE__ */ jsx5("text", {
-        fg: tokens.dim,
+        fg: theme.dim,
         children: "No worktree selected"
       })
     });
@@ -26814,11 +26898,11 @@ function DetailsContent({ selectedRow }) {
       /* @__PURE__ */ jsxs5("text", {
         children: [
           /* @__PURE__ */ jsx5("span", {
-            fg: tokens.dim,
+            fg: theme.dim,
             children: "Repo:"
           }),
           /* @__PURE__ */ jsxs5("span", {
-            fg: tokens.fg,
+            fg: theme.fg,
             children: [
               "   ",
               repoName
@@ -26829,11 +26913,11 @@ function DetailsContent({ selectedRow }) {
       /* @__PURE__ */ jsxs5("text", {
         children: [
           /* @__PURE__ */ jsx5("span", {
-            fg: tokens.dim,
+            fg: theme.dim,
             children: "Branch:"
           }),
           /* @__PURE__ */ jsxs5("span", {
-            fg: tokens.fg,
+            fg: theme.fg,
             children: [
               " ",
               branch,
@@ -26846,11 +26930,11 @@ function DetailsContent({ selectedRow }) {
       /* @__PURE__ */ jsxs5("text", {
         children: [
           /* @__PURE__ */ jsx5("span", {
-            fg: tokens.dim,
+            fg: theme.dim,
             children: "Path:"
           }),
           /* @__PURE__ */ jsxs5("span", {
-            fg: tokens.fg,
+            fg: theme.fg,
             children: [
               "   ",
               path37
@@ -26861,11 +26945,11 @@ function DetailsContent({ selectedRow }) {
       /* @__PURE__ */ jsxs5("text", {
         children: [
           /* @__PURE__ */ jsx5("span", {
-            fg: tokens.dim,
+            fg: theme.dim,
             children: "Commit:"
           }),
           /* @__PURE__ */ jsxs5("span", {
-            fg: tokens.fg,
+            fg: theme.fg,
             children: [
               " ",
               commitShort
@@ -26876,11 +26960,11 @@ function DetailsContent({ selectedRow }) {
       owner && /* @__PURE__ */ jsxs5("text", {
         children: [
           /* @__PURE__ */ jsx5("span", {
-            fg: tokens.dim,
+            fg: theme.dim,
             children: "Owner:"
           }),
           /* @__PURE__ */ jsxs5("span", {
-            fg: tokens.fg,
+            fg: theme.fg,
             children: [
               "  ",
               owner
@@ -26891,11 +26975,11 @@ function DetailsContent({ selectedRow }) {
       /* @__PURE__ */ jsxs5("text", {
         children: [
           /* @__PURE__ */ jsx5("span", {
-            fg: tokens.dim,
+            fg: theme.dim,
             children: "Status:"
           }),
           /* @__PURE__ */ jsxs5("span", {
-            fg: tokens.fg,
+            fg: theme.fg,
             children: [
               " ",
               isLocked ? "LOCKED" : isPrunable ? "PRUNABLE" : "Active"
@@ -26906,11 +26990,11 @@ function DetailsContent({ selectedRow }) {
       base2 && /* @__PURE__ */ jsxs5("text", {
         children: [
           /* @__PURE__ */ jsx5("span", {
-            fg: tokens.dim,
+            fg: theme.dim,
             children: "Base:"
           }),
           /* @__PURE__ */ jsxs5("span", {
-            fg: tokens.accent,
+            fg: theme.accent,
             children: [
               "   ",
               base2
@@ -26921,11 +27005,11 @@ function DetailsContent({ selectedRow }) {
       baseChanged && /* @__PURE__ */ jsxs5("text", {
         children: [
           /* @__PURE__ */ jsx5("span", {
-            fg: tokens.dim,
+            fg: theme.dim,
             children: "Base state:"
           }),
           /* @__PURE__ */ jsx5("span", {
-            fg: tokens.warning,
+            fg: theme.warning,
             children: " moved since recorded"
           })
         ]
@@ -26934,11 +27018,11 @@ function DetailsContent({ selectedRow }) {
         style: { marginTop: 1 },
         children: [
           /* @__PURE__ */ jsx5("span", {
-            fg: tokens.dim,
+            fg: theme.dim,
             children: base2 ? "vs base:" : "vs main:"
           }),
           /* @__PURE__ */ jsxs5("span", {
-            fg: tokens.fg,
+            fg: theme.fg,
             children: [
               " ",
               aheadBehindStr
@@ -26949,11 +27033,11 @@ function DetailsContent({ selectedRow }) {
       /* @__PURE__ */ jsxs5("text", {
         children: [
           /* @__PURE__ */ jsx5("span", {
-            fg: tokens.dim,
+            fg: theme.dim,
             children: "Deps:"
           }),
           /* @__PURE__ */ jsxs5("span", {
-            fg: tokens.fg,
+            fg: theme.fg,
             children: [
               "    ",
               depsStrategy
@@ -26964,11 +27048,11 @@ function DetailsContent({ selectedRow }) {
       rebaseStatus && /* @__PURE__ */ jsxs5("text", {
         children: [
           /* @__PURE__ */ jsx5("span", {
-            fg: tokens.dim,
+            fg: theme.dim,
             children: "Rebase:"
           }),
           /* @__PURE__ */ jsxs5("span", {
-            fg: tokens.error,
+            fg: theme.error,
             children: [
               "  ",
               rebaseStatus
@@ -26982,7 +27066,7 @@ function DetailsContent({ selectedRow }) {
             style: { marginTop: 1 },
             children: [
               /* @__PURE__ */ jsxs5("span", {
-                fg: tokens.accent,
+                fg: theme.accent,
                 children: [
                   "PR #",
                   prNumber,
@@ -26990,7 +27074,7 @@ function DetailsContent({ selectedRow }) {
                 ]
               }),
               /* @__PURE__ */ jsxs5("span", {
-                fg: tokens.dim,
+                fg: theme.dim,
                 children: [
                   " ",
                   prState
@@ -27001,11 +27085,11 @@ function DetailsContent({ selectedRow }) {
           prChecks && /* @__PURE__ */ jsxs5("text", {
             children: [
               /* @__PURE__ */ jsx5("span", {
-                fg: tokens.dim,
+                fg: theme.dim,
                 children: "Checks:"
               }),
               /* @__PURE__ */ jsxs5("span", {
-                fg: tokens.fg,
+                fg: theme.fg,
                 children: [
                   " ",
                   prChecks
@@ -27019,15 +27103,15 @@ function DetailsContent({ selectedRow }) {
               selectable: false,
               children: [
                 /* @__PURE__ */ jsx5("span", {
-                  fg: tokens.dim,
+                  fg: theme.dim,
                   children: "URL:"
                 }),
                 /* @__PURE__ */ jsx5("span", {
-                  fg: tokens.accent,
+                  fg: theme.accent,
                   children: ` ${prUrl}`
                 }),
                 /* @__PURE__ */ jsx5("span", {
-                  fg: tokens.dim,
+                  fg: theme.dim,
                   children: " ↗ click"
                 })
               ]
@@ -27040,7 +27124,7 @@ function DetailsContent({ selectedRow }) {
         style: { marginTop: 1 },
         children: [
           /* @__PURE__ */ jsxs5("text", {
-            fg: tokens.warning,
+            fg: theme.warning,
             children: [
               "Dirty Files (",
               dirtyFiles.length,
@@ -27048,14 +27132,14 @@ function DetailsContent({ selectedRow }) {
             ]
           }),
           dirtyFiles.slice(0, 20).map((file2, idx) => /* @__PURE__ */ jsxs5("text", {
-            fg: tokens.warning,
+            fg: theme.warning,
             children: [
               "  ",
               file2
             ]
           }, idx)),
           dirtyFiles.length > 20 && /* @__PURE__ */ jsxs5("text", {
-            fg: tokens.warning,
+            fg: theme.warning,
             children: [
               "  ...and ",
               dirtyFiles.length - 20,
@@ -27069,13 +27153,13 @@ function DetailsContent({ selectedRow }) {
         style: { marginTop: 1 },
         children: [
           /* @__PURE__ */ jsx5("text", {
-            fg: tokens.dim,
+            fg: theme.dim,
             children: "Actions:"
           }),
           !isMainCheckout && /* @__PURE__ */ jsxs5(Fragment, {
             children: [
               /* @__PURE__ */ jsxs5("text", {
-                fg: tokens.dim,
+                fg: theme.dim,
                 children: [
                   "  i install deps (",
                   depsStrategy,
@@ -27083,21 +27167,21 @@ function DetailsContent({ selectedRow }) {
                 ]
               }),
               /* @__PURE__ */ jsx5("text", {
-                fg: tokens.dim,
+                fg: theme.dim,
                 children: "  m rename worktree"
               })
             ]
           }),
           /* @__PURE__ */ jsx5("text", {
-            fg: tokens.dim,
+            fg: theme.dim,
             children: "  p pull branch"
           }),
           /* @__PURE__ */ jsx5("text", {
-            fg: tokens.dim,
+            fg: theme.dim,
             children: "  b rebase · s sync · o open in IDE · d remove"
           }),
           /* @__PURE__ */ jsx5("text", {
-            fg: tokens.dim,
+            fg: theme.dim,
             children: "  t new terminal session (max 5)"
           })
         ]
@@ -27111,6 +27195,8 @@ var init_DetailsTab = __esm(() => {
 });
 
 // src/lib/changes.ts
+import fs34 from "node:fs";
+import path37 from "node:path";
 function cacheKey(opts, filePath) {
   return [opts.repoPath, opts.branch, opts.scope, filePath ?? ""].join("\x00");
 }
@@ -27214,7 +27300,7 @@ async function getChangedFiles(opts) {
     return [];
   const key = cacheKey(opts);
   const cached2 = listCache.get(key);
-  if (!opts.invalidate && cached2?.head === head)
+  if (!opts.invalidate && cached2?.head === head && opts.scope !== "worktree")
     return cached2.value;
   try {
     const baseArgs = await diffArgs(opts);
@@ -27231,6 +27317,29 @@ async function getChangedFiles(opts) {
       if (!await isSubmodule(opts.repoPath, file2.path))
         filtered.push(file2);
     }
+    if (opts.scope === "worktree") {
+      try {
+        const untrackedRaw = await gitExec(["-C", opts.repoPath, "ls-files", "--others", "--exclude-standard", "-z"]);
+        const untrackedPaths = untrackedRaw.split("\x00").filter(Boolean);
+        for (const p of untrackedPaths) {
+          if (filtered.some((f) => f.path === p))
+            continue;
+          if (await isSubmodule(opts.repoPath, p))
+            continue;
+          try {
+            const full = path37.join(opts.repoPath, p);
+            const buf = fs34.readFileSync(full);
+            const binary = buf.includes(0);
+            const str = binary ? "" : buf.toString("utf8");
+            const added = binary ? 0 : str.split(`
+`).length;
+            filtered.push({ path: p, status: "A", added, removed: 0, binary });
+          } catch {
+            filtered.push({ path: p, status: "A", added: 1, removed: 0, binary: false });
+          }
+        }
+      } catch {}
+    }
     listCache.set(key, { head, value: filtered });
     return filtered;
   } catch {
@@ -27266,7 +27375,26 @@ async function getFileDiff(opts) {
     const args = await diffArgs(opts, opts.filePath);
     if (!args)
       return empty;
-    const rawDiff = await gitExec(args);
+    let rawDiff = await gitExec(args);
+    if (!rawDiff && opts.scope === "worktree" && changedFile.status === "A") {
+      try {
+        const full = path37.join(opts.repoPath, opts.filePath);
+        const buf = fs34.readFileSync(full);
+        if (!buf.includes(0)) {
+          const content = buf.toString("utf8");
+          const lines = content.split(`
+`);
+          const header = `diff --git a/${opts.filePath} b/${opts.filePath}
+new file mode 100644
+--- /dev/null
++++ b/${opts.filePath}
+@@ -0,0 +1,${lines.length} @@
+`;
+          rawDiff = header + lines.map((l) => `+${l}`).join(`
+`);
+        }
+      } catch {}
+    }
     const { diff, truncated } = truncateDiff(rawDiff);
     const value = { ...empty, diff, truncated };
     diffCache.set(key, { head, value });
@@ -27932,7 +28060,9 @@ var init_Divider = __esm(() => {
 
 // src/tui/components/Overlay.tsx
 import { jsx as jsx9 } from "@opentui/react/jsx-runtime";
-function Overlay({ title, borderColor = tokens.border, width = 64, children }) {
+function Overlay({ title, borderColor, width = 64, children }) {
+  const theme = useTheme();
+  const resolvedBorder = borderColor ?? theme.border;
   return /* @__PURE__ */ jsx9("box", {
     id: "overlay-scrim",
     position: "absolute",
@@ -27940,7 +28070,7 @@ function Overlay({ title, borderColor = tokens.border, width = 64, children }) {
     height: "100%",
     top: 0,
     left: 0,
-    backgroundColor: tokens.scrim,
+    backgroundColor: theme.scrim,
     zIndex: 100,
     flexDirection: "row",
     justifyContent: "center",
@@ -27949,13 +28079,13 @@ function Overlay({ title, borderColor = tokens.border, width = 64, children }) {
       id: "overlay-panel",
       width,
       border: true,
-      borderColor,
+      borderColor: resolvedBorder,
       title,
-      titleColor: borderColor,
+      titleColor: resolvedBorder,
       paddingX: 2,
       paddingY: 1,
       flexDirection: "column",
-      backgroundColor: tokens.panelBg,
+      backgroundColor: theme.panelBg,
       children
     })
   });
@@ -27967,85 +28097,132 @@ var init_Overlay = __esm(() => {
 // src/tui/components/HelpOverlay.tsx
 import { jsx as jsx10, jsxs as jsxs8 } from "@opentui/react/jsx-runtime";
 function HelpOverlay() {
+  const theme = useTheme();
   return /* @__PURE__ */ jsxs8(Overlay, {
     title: "Help",
-    borderColor: tokens.border,
-    width: 84,
+    borderColor: theme.border,
+    width: 100,
     children: [
       /* @__PURE__ */ jsx10("box", {
         flexDirection: "column",
-        style: { maxHeight: 36 },
+        style: { maxHeight: 38 },
         children: /* @__PURE__ */ jsx10("scrollbox", {
           flexGrow: 1,
-          children: HELP_ENTRIES.map(([key, desc]) => /* @__PURE__ */ jsxs8("box", {
-            flexDirection: "row",
-            gap: 1,
+          children: HELP_GROUPS.map((group) => /* @__PURE__ */ jsxs8("box", {
+            flexDirection: "column",
+            style: { marginBottom: 1 },
             children: [
               /* @__PURE__ */ jsx10("box", {
-                width: 18,
-                flexShrink: 0,
-                justifyContent: "flex-end",
+                style: { marginBottom: 1 },
                 children: /* @__PURE__ */ jsx10("text", {
-                  fg: tokens.accent,
-                  children: key
+                  fg: theme.accent,
+                  attributes: 1,
+                  children: group.title
                 })
               }),
-              /* @__PURE__ */ jsx10("text", {
-                fg: tokens.dim,
-                children: "-"
-              }),
-              /* @__PURE__ */ jsx10("box", {
-                flexGrow: 1,
-                children: /* @__PURE__ */ jsx10("text", {
-                  fg: tokens.fg,
-                  children: desc
-                })
-              })
+              group.entries.map(([key, desc]) => /* @__PURE__ */ jsxs8("box", {
+                flexDirection: "row",
+                gap: 1,
+                children: [
+                  /* @__PURE__ */ jsx10("box", {
+                    width: 22,
+                    flexShrink: 0,
+                    justifyContent: "flex-end",
+                    children: /* @__PURE__ */ jsx10("text", {
+                      fg: theme.accent,
+                      children: key
+                    })
+                  }),
+                  /* @__PURE__ */ jsx10("text", {
+                    fg: theme.dim,
+                    children: "-"
+                  }),
+                  /* @__PURE__ */ jsx10("box", {
+                    flexGrow: 1,
+                    children: /* @__PURE__ */ jsx10("text", {
+                      fg: theme.fg,
+                      children: desc
+                    })
+                  })
+                ]
+              }, key))
             ]
-          }, key))
+          }, group.title))
         })
       }),
       /* @__PURE__ */ jsx10("text", {
-        style: { marginTop: 1, fg: tokens.dim },
+        style: { marginTop: 1, fg: theme.dim },
         children: "Press any key to close"
       })
     ]
   });
 }
-var HELP_ENTRIES;
+var HELP_GROUPS;
 var init_HelpOverlay = __esm(() => {
   init_Overlay();
   init_theme();
-  HELP_ENTRIES = [
-    ["↑/↓, k/j", "Navigate list"],
-    ["/", "Filter list"],
-    ["Space", "Multi-select"],
-    ["c", "Open configuration"],
-    ["n", "Create new worktree (pick dependency strategy)"],
-    ["f", "Fetch main for selected repo(s)"],
-    ["F (shift+f)", "Pin/unpin selected repo (favorites float to top)"],
-    ["W (shift+w)", "Scope list to a workspace's members (press again to clear)"],
-    ["p", "Pull latest changes for selected branch(es)"],
-    ["P (shift+p)", "Pull PR by link (force-override if exists)"],
-    ["b", "Rebase selected onto base (or main)"],
-    ["s", "Sync selected (env files + hooks)"],
-    ["s / Tab (Changes)", "Cycle changes scope: worktree → staged → base"],
-    ["i", "Install dependencies in selection (worktrees and main)"],
-    ["m", "Rename selected worktree (branch + directory)"],
-    ["o", "Open selected in IDE"],
-    ["t", "New terminal session (max 5 per worktree, Details ↔ Session tabs)"],
-    ["T (shift+t)", "Cycle theme presets"],
-    ["click tab", "Switch Details ↔ Session (professional tabs with ▎ active)"],
-    ["Ctrl+G / click table", "Leave terminal focus — focused terminal gets all keys"],
-    ["d", "Remove selected worktree(s)"],
-    ["e", "View data warnings (when count > 0)"],
-    ["r", "Refresh data"],
-    ["H", "Action history"],
-    ["mouse drag", "Select text — copied to clipboard automatically"],
-    ["ctrl+shift+c", "Copy selection again (terminals reserve cmd+c)"],
-    ["click PR #/URL", "Open pull request in browser"],
-    ["?", "Toggle help"],
-    ["q/esc", "Quit"]
+  HELP_GROUPS = [
+    {
+      title: "Navigation & Filtering",
+      entries: [
+        ["↑/↓, k/j", "Navigate list"],
+        ["/", "Filter list"],
+        ["Space", "Multi-select"],
+        ["q/esc", "Quit"]
+      ]
+    },
+    {
+      title: "Worktree Lifecycle",
+      entries: [
+        ["n", "Create new worktree (pick dependency strategy)"],
+        ["d", "Remove selected worktree(s)"],
+        ["m", "Rename selected worktree (branch + directory)"],
+        ["o", "Open selected in IDE"],
+        ["f", "Fetch main for selected repo(s)"],
+        ["p", "Pull latest changes for selected branch(es)"],
+        ["P (shift+p)", "Pull PR by link (force-override if exists)"],
+        ["b", "Rebase selected onto base (or main)"],
+        ["s", "Sync selected (env files + hooks)"],
+        ["i", "Install dependencies in selection (worktrees and main)"]
+      ]
+    },
+    {
+      title: "Favorites & Workspaces",
+      entries: [
+        ["F (shift+f)", "Pin/unpin selected repo (favorites float to top)"],
+        ["W (shift+w)", "Scope list to a workspace's members (press again to clear)"]
+      ]
+    },
+    {
+      title: "Terminal & Tabs",
+      entries: [
+        ["t", "New terminal session (max 5 per worktree)"],
+        ["click tab", "Switch Details / Changes / Session tabs"],
+        ["Ctrl+G / click table", "Leave terminal focus — focused terminal gets all keys"]
+      ]
+    },
+    {
+      title: "Changes Explorer (only for dirty worktrees)",
+      entries: [
+        ["click Changes", "Focus pane — j/k navigates files, s/Tab cycles scope"],
+        ["s / Tab", "Cycle scope: worktree (dirty+untracked) → staged → base (vs base branch)"],
+        ["j / k, ↑/↓", "Navigate files (when Changes focused, Ctrl+G/Esc to unfocus)"]
+      ]
+    },
+    {
+      title: "View & System",
+      entries: [
+        ["T (shift+t)", "Cycle theme presets"],
+        ["c", "Open configuration"],
+        ["e", "View data warnings (when count > 0)"],
+        ["r", "Refresh data"],
+        ["H", "Action history"],
+        ["?", "Toggle help"],
+        ["mouse drag", "Select text — copied to clipboard automatically"],
+        ["ctrl+shift+c", "Copy selection again (terminals reserve cmd+c)"],
+        ["click PR #/URL", "Open pull request in browser"]
+      ]
+    }
   ];
 });
 
@@ -28231,38 +28408,38 @@ var init_ActionLogModal = __esm(() => {
 });
 
 // src/lib/history.ts
-import fs33 from "fs";
-import path37 from "path";
+import fs35 from "fs";
+import path38 from "path";
 import os4 from "os";
 function getHistoryDir() {
-  const stateHome = process.env.XDG_STATE_HOME ?? path37.join(os4.homedir(), ".local", "state");
-  return path37.join(stateHome, "wtx");
+  const stateHome = process.env.XDG_STATE_HOME ?? path38.join(os4.homedir(), ".local", "state");
+  return path38.join(stateHome, "wtx");
 }
 function getHistoryPath() {
-  return path37.join(getHistoryDir(), "history.jsonl");
+  return path38.join(getHistoryDir(), "history.jsonl");
 }
 function rotateHistory(maxBytes = HISTORY_MAX_BYTES, keepLines = HISTORY_ROTATE_KEEP_LINES) {
   const historyPath = getHistoryPath();
   let size = 0;
   try {
-    size = fs33.statSync(historyPath).size;
+    size = fs35.statSync(historyPath).size;
   } catch {
     return;
   }
   if (size <= maxBytes)
     return;
-  const lines = fs33.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 {
-    fs33.writeFileSync(tmpPath, kept.length > 0 ? `${kept.join(`
+    fs35.writeFileSync(tmpPath, kept.length > 0 ? `${kept.join(`
 `)}
 ` : "", "utf-8");
-    fs33.renameSync(tmpPath, historyPath);
+    fs35.renameSync(tmpPath, historyPath);
   } catch (err) {
-    if (fs33.existsSync(tmpPath)) {
-      fs33.unlinkSync(tmpPath);
+    if (fs35.existsSync(tmpPath)) {
+      fs35.unlinkSync(tmpPath);
     }
     throw err;
   }
@@ -28270,18 +28447,18 @@ function rotateHistory(maxBytes = HISTORY_MAX_BYTES, keepLines = HISTORY_ROTATE_
 function appendHistory(entry) {
   try {
     const dir = getHistoryDir();
-    if (!fs33.existsSync(dir)) {
-      fs33.mkdirSync(dir, { recursive: true });
+    if (!fs35.existsSync(dir)) {
+      fs35.mkdirSync(dir, { recursive: true });
     }
     rotateHistory();
-    fs33.appendFileSync(getHistoryPath(), `${JSON.stringify(entry)}
+    fs35.appendFileSync(getHistoryPath(), `${JSON.stringify(entry)}
 `, "utf-8");
   } catch {}
 }
 function readRecentHistory(limit = 50) {
   let content;
   try {
-    content = fs33.readFileSync(getHistoryPath(), "utf-8");
+    content = fs35.readFileSync(getHistoryPath(), "utf-8");
   } catch {
     return [];
   }
@@ -28419,13 +28596,19 @@ function InputModal({ title, placeholder, initialValue, errorMessage: errorMessa
     borderColor: tokens.accent,
     children: /* @__PURE__ */ jsxs12("box", {
       flexDirection: "column",
+      width: "100%",
       children: [
-        /* @__PURE__ */ jsx14("input", {
-          focused: true,
-          value,
-          placeholder,
-          onInput: (val) => setValue(val),
-          onSubmit: () => onSubmit(value)
+        /* @__PURE__ */ jsx14("box", {
+          flexGrow: 1,
+          width: "100%",
+          children: /* @__PURE__ */ jsx14("input", {
+            focused: true,
+            value,
+            placeholder,
+            onInput: (val) => setValue(val),
+            onSubmit: () => onSubmit(value),
+            width: "100%"
+          })
         }),
         errorMessage4 ? /* @__PURE__ */ jsx14("text", {
           fg: tokens.error,
@@ -28992,8 +29175,8 @@ function hasDirectStdinWrite(proc) {
 function hasWritableStreamStdin(proc) {
   return !!proc && proc.stdin instanceof WritableStream;
 }
-function worktreeKeyFor(repoName, branch, path38) {
-  return path38 || `${repoName}:${branch}`;
+function worktreeKeyFor(repoName, branch, path39) {
+  return path39 || `${repoName}:${branch}`;
 }
 function nextTerminalSessionLabel(existingCount) {
   return `Session ${existingCount + 1}`;
@@ -29011,13 +29194,13 @@ function useTerminalSessions() {
   const [sessionsByKey, setSessionsByKey] = useState10(() => new Map);
   const procsRef = useRef7(new Map);
   const listenersRef = useRef7(new Map);
-  const getSessions = useCallback6((repoName, branch, path38) => {
-    const key = worktreeKeyFor(repoName, branch, path38);
+  const getSessions = useCallback6((repoName, branch, path39) => {
+    const key = worktreeKeyFor(repoName, branch, path39);
     return sessionsByKey.get(key) ?? [];
   }, [sessionsByKey]);
-  const getKey = useCallback6((repoName, branch, path38) => worktreeKeyFor(repoName, branch, path38), []);
-  const createSession = useCallback6((repoName, branch, path38, opts) => {
-    const key = worktreeKeyFor(repoName, branch, path38);
+  const getKey = useCallback6((repoName, branch, path39) => worktreeKeyFor(repoName, branch, path39), []);
+  const createSession = useCallback6((repoName, branch, path39, opts) => {
+    const key = worktreeKeyFor(repoName, branch, path39);
     const existing = sessionsByKey.get(key) ?? [];
     if (existing.length >= MAX_TERMINAL_SESSIONS) {
       return { session: null, error: `Max ${MAX_TERMINAL_SESSIONS} sessions per worktree` };
@@ -29030,7 +29213,7 @@ function useTerminalSessions() {
       id,
       label,
       worktreeKey: key,
-      worktreePath: path38,
+      worktreePath: path39,
       repoName,
       branch,
       lines: [],
@@ -29115,7 +29298,7 @@ function useTerminalSessions() {
         throw new Error("pty not available");
       }
       const proc = Bun.spawn([shell], {
-        cwd: path38 || process.cwd(),
+        cwd: path39 || process.cwd(),
         env: { ...process.env, TERM: "xterm-256color", COLORTERM: "truecolor", WTX_SESSION: label },
         terminal: {
           cols,
@@ -29150,7 +29333,7 @@ function useTerminalSessions() {
       session.usePty = false;
       try {
         const proc = Bun.spawn([shell], {
-          cwd: path38 || process.cwd(),
+          cwd: path39 || process.cwd(),
           stdin: "pipe",
           stdout: "pipe",
           stderr: "pipe",
@@ -29198,9 +29381,9 @@ function useTerminalSessions() {
       } catch {}
     }
     if (session.usePty) {
-      session.lines = [`${label} — ${path38} (${shell}) [pty]`, ""];
+      session.lines = [`${label} — ${path39} (${shell}) [pty]`, ""];
     } else if (!session.spawnError && session.lines.length === 0) {
-      session.lines = [`${label} — ${path38} (${shell})`, ""];
+      session.lines = [`${label} — ${path39} (${shell})`, ""];
     }
     setSessionsByKey((prev) => {
       const next = new Map(prev);
@@ -29210,8 +29393,8 @@ function useTerminalSessions() {
     });
     return { session };
   }, [sessionsByKey]);
-  const removeSession = useCallback6((repoName, branch, path38, id) => {
-    const key = worktreeKeyFor(repoName, branch, path38);
+  const removeSession = useCallback6((repoName, branch, path39, id) => {
+    const key = worktreeKeyFor(repoName, branch, path39);
     setSessionsByKey((prev) => {
       const next = new Map(prev);
       const list = next.get(key);
@@ -29240,8 +29423,8 @@ function useTerminalSessions() {
       return next;
     });
   }, []);
-  const sendInput = useCallback6((repoName, branch, path38, id, data) => {
-    const key = worktreeKeyFor(repoName, branch, path38);
+  const sendInput = useCallback6((repoName, branch, path39, id, data) => {
+    const key = worktreeKeyFor(repoName, branch, path39);
     const list = sessionsByKey.get(key) ?? [];
     const sess = list.find((s) => s.id === id);
     if (!sess?.proc)
@@ -29289,8 +29472,8 @@ function useTerminalSessions() {
       }
     }
   }, [sessionsByKey]);
-  const resizeSession = useCallback6((repoName, branch, path38, id, cols, rows) => {
-    const key = worktreeKeyFor(repoName, branch, path38);
+  const resizeSession = useCallback6((repoName, branch, path39, id, cols, rows) => {
+    const key = worktreeKeyFor(repoName, branch, path39);
     setSessionsByKey((prev) => {
       const list = prev.get(key);
       if (!list)
@@ -29682,6 +29865,7 @@ function App({ opts }) {
   const [activeTabByWorktree, setActiveTabByWorktree] = useState11(() => new Map);
   const [recentTerminalSessionIds, setRecentTerminalSessionIds] = useState11([]);
   const [terminalFocused, setTerminalFocused] = useState11(false);
+  const [changesFocused, setChangesFocused] = useState11(false);
   const { width: termW, height: termH } = useTerminalDimensions();
   const totalWidth = termW || renderer.width || 80;
   const totalHeight = termH || renderer.terminalHeight || 24;
@@ -29799,7 +29983,17 @@ function App({ opts }) {
   const baseFiltered = useMemo3(() => blocks.map((b) => ({
     ...b,
     rows: b.rows.filter((r) => matchesFilter(r, filterText) && matchesWorkspace(r, workspaceMemberSet))
-  })).filter((b) => b.rows.length > 0 || workspaceMemberSet === null && pendingRepos.includes(b.repoName)), [blocks, filterText, pendingRepos, workspaceMemberSet]);
+  })).filter((b) => {
+    if (b.rows.length > 0)
+      return true;
+    if (workspaceMemberSet !== null)
+      return false;
+    if (pendingRepos.includes(b.repoName))
+      return true;
+    if (!filterText)
+      return true;
+    return matchesFilter({ repoName: b.repoName, branch: "" }, filterText);
+  }), [blocks, filterText, pendingRepos, workspaceMemberSet]);
   const missingMemberWarnings = useMemo3(() => {
     if (!activeWorkspace)
       return [];
@@ -29818,7 +30012,7 @@ function App({ opts }) {
   const displayBlocks = useMemo3(() => sortBlocks([
     ...withCreatePlaceholders(baseFiltered, ops.filter((o2) => o2.branch !== undefined).map((o2) => ({ repoName: o2.repoNames[0], branch: o2.branch }))),
     ...pendingBlocks
-  ]), [baseFiltered, ops, pendingBlocks]);
+  ], favorites), [baseFiltered, ops, pendingBlocks, favorites]);
   const flatRows = useMemo3(() => displayBlocks.flatMap((b) => b.rows.filter((r) => !r.isPendingCreate)), [displayBlocks]);
   const totalRows = blocks.flatMap((b) => b.rows).length;
   const maxIndex = Math.max(0, flatRows.length - 1);
@@ -29843,7 +30037,15 @@ function App({ opts }) {
     }
   }, [worktreeKey, activeTabByWorktree]);
   useEffect9(() => {
-    if (sessionsForSelected.length === 0 && activeTabId !== "details") {
+    if (activeTabId === "changes" && selectedRow && (selectedRow.isMainCheckout || selectedRow.dirtyFiles.length === 0)) {
+      setActiveTabByWorktree((prev) => {
+        const next = new Map(prev);
+        next.set(worktreeKey, "details");
+        return next;
+      });
+      return;
+    }
+    if (sessionsForSelected.length === 0 && activeTabId !== "details" && activeTabId !== "changes") {
       setActiveTabByWorktree((prev) => {
         const next = new Map(prev);
         next.set(worktreeKey, "details");
@@ -29851,7 +30053,7 @@ function App({ opts }) {
       });
       setTerminalFocused(false);
     } else if (sessionsForSelected.length > 0) {
-      const exists = sessionsForSelected.some((s) => s.id === activeTabId) || activeTabId === "details";
+      const exists = sessionsForSelected.some((s) => s.id === activeTabId) || activeTabId === "details" || selectedRow && !selectedRow.isMainCheckout && selectedRow.dirtyFiles.length > 0 && activeTabId === "changes";
       if (!exists) {
         setActiveTabByWorktree((prev) => {
           const next = new Map(prev);
@@ -29860,7 +30062,15 @@ function App({ opts }) {
         });
       }
     }
-  }, [sessionsForSelected, activeTabId, worktreeKey]);
+  }, [sessionsForSelected, activeTabId, worktreeKey, selectedRow]);
+  useEffect9(() => {
+    setChangesFocused(false);
+    setTerminalFocused(false);
+  }, [worktreeKey]);
+  useEffect9(() => {
+    if (activeTabId !== "changes")
+      setChangesFocused(false);
+  }, [activeTabId]);
   usePaste((event) => {
     if (!terminalFocused)
       return;
@@ -29884,7 +30094,8 @@ function App({ opts }) {
       return next;
     });
     setTerminalFocused(isSession);
-  }, [activeTabId, renderer, worktreeKey, sessionsForSelected]);
+    setChangesFocused(id === "changes" && selectedRow != null && !selectedRow.isMainCheckout && selectedRow.dirtyFiles.length > 0);
+  }, [activeTabId, renderer, worktreeKey, sessionsForSelected, selectedRow]);
   const handleAddSession = useCallback7(() => {
     if (!selectedRow) {
       flash("No worktree selected");
@@ -29908,13 +30119,31 @@ function App({ opts }) {
       return next;
     });
     setTerminalFocused(true);
+    setChangesFocused(false);
     flash(`Session ${session.label} created`, 2000);
   }, [selectedRow, terminalSessions, flash, totalWidth, splitRatio, totalHeight, activeTabId, sessionsForSelected]);
   const handleCloseSession = useCallback7((id) => {
-    if (!selectedRow)
-      return;
-    terminalSessions.removeSession(selectedRow.repoName, selectedRow.branch, selectedRow.path, id);
-    const key = terminalSessions.getKey(selectedRow.repoName, selectedRow.branch, selectedRow.path);
+    let targetRepo;
+    let targetBranch;
+    let targetPath;
+    for (const sessions of terminalSessions.sessionsByKey.values()) {
+      const found = sessions.find((s) => s.id === id);
+      if (found) {
+        targetRepo = found.repoName;
+        targetBranch = found.branch;
+        targetPath = found.worktreePath;
+        break;
+      }
+    }
+    if (!targetRepo || !targetBranch || !targetPath) {
+      if (!selectedRow)
+        return;
+      targetRepo = selectedRow.repoName;
+      targetBranch = selectedRow.branch;
+      targetPath = selectedRow.path;
+    }
+    terminalSessions.removeSession(targetRepo, targetBranch, targetPath, id);
+    const key = terminalSessions.getKey(targetRepo, targetBranch, targetPath);
     setActiveTabByWorktree((prev) => {
       const next = new Map(prev);
       const current = next.get(key);
@@ -29950,8 +30179,10 @@ function App({ opts }) {
         render: ({ worktree }) => /* @__PURE__ */ jsx18(DetailsContent, {
           selectedRow: worktree
         })
-      },
-      {
+      }
+    ];
+    if (selectedRow != null && !selectedRow.isMainCheckout && selectedRow.dirtyFiles.length > 0) {
+      base2.push({
         id: "changes",
         label: "Changes",
         render: ({ worktree, isActive, focused }) => /* @__PURE__ */ jsx18(ChangesContent, {
@@ -29960,8 +30191,8 @@ function App({ opts }) {
           focused,
           worktreeKey
         })
-      }
-    ];
+      });
+    }
     for (const s of sessionsForSelected) {
       base2.push({
         id: s.id,
@@ -29975,7 +30206,7 @@ function App({ opts }) {
       });
     }
     return base2;
-  }, [sessionsForSelected, worktreeKey]);
+  }, [selectedRow, sessionsForSelected, worktreeKey]);
   const { repoVerbs, rowVerbs } = useMemo3(() => {
     const rv = new Map;
     const nv = new Map;
@@ -30279,6 +30510,15 @@ function App({ opts }) {
     }
   }, [selectedRow, selection, combinedWarnings, busyRepos, busyRowPaths, doRefresh, flash, blocks, terminalSessions]);
   useKeyboard4((key) => {
+    if (changesFocused) {
+      if (key.ctrl && key.name === "g" || key.name === "escape") {
+        setChangesFocused(false);
+        return;
+      }
+      if (["j", "k", "down", "up", "s", "tab"].includes(key.name)) {
+        return;
+      }
+    }
     if (terminalFocused) {
       if (key.ctrl && key.name === "g") {
         setTerminalFocused(false);
@@ -30720,6 +30960,7 @@ function App({ opts }) {
   useEffect9(() => () => terminalResizeSchedulerRef.current?.flush(), []);
   useEffect9(() => {
     setTerminalFocused(false);
+    setChangesFocused(false);
   }, [selectedIndex]);
   return /* @__PURE__ */ jsx18(ThemeContext.Provider, {
     value: currentTheme,
@@ -30737,7 +30978,10 @@ function App({ opts }) {
               width: leftCols,
               height: "100%",
               flexDirection: "column",
-              onMouseDown: () => setTerminalFocused(false),
+              onMouseDown: () => {
+                setTerminalFocused(false);
+                setChangesFocused(false);
+              },
               children: /* @__PURE__ */ jsx18(WorktreeTable, {
                 blocks: displayBlocks,
                 selectedIndex,
@@ -30750,9 +30994,10 @@ function App({ opts }) {
                 activeWorkspaceName: activeWorkspace?.name ?? null,
                 onRowClick: (idx) => {
                   setTerminalFocused(false);
+                  setChangesFocused(false);
                   setSelectedIndex(idx);
                 },
-                onToggleSelect: (path38) => setSelection((prev) => toggleSelection(prev, path38))
+                onToggleSelect: (path39) => setSelection((prev) => toggleSelection(prev, path39))
               })
             }),
             /* @__PURE__ */ jsx18(Divider, {
@@ -30769,13 +31014,18 @@ function App({ opts }) {
                 selectedRow,
                 tabs: tabsForSelected,
                 activeId: activeTabId,
-                focused: terminalFocused && tabsForSelected.some((t) => t.id === activeTabId && t.id !== "details"),
+                focused: (terminalFocused || changesFocused) && activeTabId !== "details",
                 canAdd: sessionsForSelected.length < MAX_TERMINAL_SESSIONS,
                 onSelect: handleSelectTab,
                 onAdd: handleAddSession,
                 onClose: handleCloseSession,
                 allSessionsFlat,
                 terminalFocused,
+                changesFocused,
+                onChangesFocus: () => {
+                  setChangesFocused(true);
+                  setTerminalFocused(false);
+                },
                 activeTabId,
                 recentSessionIds: mountedRecentSessionIds,
                 terminalSessions
@@ -30788,15 +31038,20 @@ function App({ opts }) {
           paddingX: 1,
           border: true,
           borderColor: "magenta",
+          width: "100%",
           children: [
             /* @__PURE__ */ jsx18("text", {
               children: "filter: "
             }),
-            /* @__PURE__ */ jsx18("input", {
-              focused: true,
-              value: filterText,
-              placeholder: "Type to filter...",
-              onInput: (v) => setFilterText(v)
+            /* @__PURE__ */ jsx18("box", {
+              flexGrow: 1,
+              children: /* @__PURE__ */ jsx18("input", {
+                focused: true,
+                value: filterText,
+                placeholder: "Type to filter...",
+                onInput: (v) => setFilterText(v),
+                width: "100%"
+              })
             })
           ]
         }),
@@ -33882,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) {
@@ -34000,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");
@@ -34013,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 {
@@ -34067,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";
@@ -34201,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";
@@ -34252,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) {
@@ -34349,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;
@@ -34391,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);
@@ -34400,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;
@@ -34424,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) {
@@ -34496,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) {
@@ -34635,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;
@@ -34747,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) {
@@ -34857,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) {
@@ -34983,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) {
@@ -34998,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;
@@ -35124,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) => {
@@ -35136,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);
               }
@@ -35196,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`);
@@ -35232,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();
@@ -35269,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 {
@@ -35327,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 {
@@ -35352,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;
@@ -35388,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) {
@@ -35431,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)) {
@@ -35464,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);
@@ -35483,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);
       }
@@ -35625,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();
@@ -35675,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++;
@@ -35975,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;
@@ -36132,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 {
@@ -36145,8 +36422,8 @@ function registerSkillCommand(program2) {
 
 // src/commands/terminal.ts
 import { spawnSync as spawnSync3 } from "node:child_process";
-import fs34 from "node:fs";
-import path38 from "node:path";
+import fs36 from "node:fs";
+import path39 from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 function findEntry() {
   const candidates = [];
@@ -36155,26 +36432,26 @@ function findEntry() {
   try {
     const thisPath = fileURLToPath4(import.meta.url);
     candidates.push(thisPath);
-    candidates.push(path38.resolve(path38.dirname(thisPath), "../../dist/cli.mjs"));
-    candidates.push(path38.resolve(path38.dirname(thisPath), "../cli.mjs"));
+    candidates.push(path39.resolve(path39.dirname(thisPath), "../../dist/cli.mjs"));
+    candidates.push(path39.resolve(path39.dirname(thisPath), "../cli.mjs"));
   } catch {}
   for (const p of candidates) {
     try {
       if (p.endsWith(".mjs") || p.endsWith(".js")) {
-        if (fs34.existsSync(p) && fs34.statSync(p).isFile())
+        if (fs36.existsSync(p) && fs36.statSync(p).isFile())
           return p;
-      } else if (fs34.existsSync(p)) {
-        const stat = fs34.statSync(p);
+      } else if (fs36.existsSync(p)) {
+        const stat = fs36.statSync(p);
         if (stat.isFile()) {
-          const head = fs34.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 = path38.dirname(fs34.realpathSync(p));
-              const cli = path38.join(dir, "cli.mjs");
-              if (fs34.existsSync(cli))
+              const dir = path39.dirname(fs36.realpathSync(p));
+              const cli = path39.join(dir, "cli.mjs");
+              if (fs36.existsSync(cli))
                 return cli;
-              const cli2 = path38.resolve(dir, "../dist/cli.mjs");
-              if (fs34.existsSync(cli2))
+              const cli2 = path39.resolve(dir, "../dist/cli.mjs");
+              if (fs36.existsSync(cli2))
                 return cli2;
               if (head.includes("import") || head.includes("commander"))
                 return p;
@@ -36186,9 +36463,9 @@ function findEntry() {
   }
   try {
     const thisPath = fileURLToPath4(import.meta.url);
-    const pkgRoot = path38.resolve(path38.dirname(thisPath), "../..");
-    const cli = path38.join(pkgRoot, "dist", "cli.mjs");
-    if (fs34.existsSync(cli))
+    const pkgRoot = path39.resolve(path39.dirname(thisPath), "../..");
+    const cli = path39.join(pkgRoot, "dist", "cli.mjs");
+    if (fs36.existsSync(cli))
       return cli;
   } catch {}
   return null;
@@ -36292,7 +36569,7 @@ init_deps();
 import readline3 from "readline";
 init_path_safety();
 init_stack();
-import fs35 from "fs";
+import fs37 from "fs";
 async function runMcpServer(opts = {}) {
   const input = opts.input ?? process.stdin;
   const output = opts.output ?? process.stdout;
@@ -36475,7 +36752,7 @@ async function handleToolCall(name, args, config2, _opts) {
         for (const wt of wts) {
           if (!wt.path.startsWith(repo.wtRoot))
             continue;
-          const dirtyCount = fs35.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,
@@ -36503,7 +36780,7 @@ async function handleToolCall(name, args, config2, _opts) {
       }
       const repo = resolveRepos(config2, [args.repo])[0];
       const wtPath = getWorktreePath(repo, args.branch);
-      if (!fs35.existsSync(wtPath)) {
+      if (!fs37.existsSync(wtPath)) {
         throw { isToolError: true, message: `Worktree not found for branch ${args.branch}` };
       }
       const mainBranch = await resolveMainBranch(repo, config2);
@@ -36622,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 && fs35.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 {
@@ -36641,7 +36923,7 @@ async function handleToolCall(name, args, config2, _opts) {
       }
       const repo = resolveRepos(config2, [args.repo])[0];
       const wtPath = getWorktreePath(repo, args.branch);
-      if (!fs35.existsSync(wtPath)) {
+      if (!fs37.existsSync(wtPath)) {
         throw { isToolError: true, message: `Worktree not found for branch ${args.branch}` };
       }
       const mainBranch = await resolveMainBranch(repo, config2);
@@ -36863,8 +37145,8 @@ init_config();
 init_log();
 init_git();
 init_resolver();
-import fs36 from "fs";
-import path39 from "path";
+import fs38 from "fs";
+import path40 from "path";
 init_workspace();
 var DEPS_STRATEGIES2 = ["auto", "link", "symlink", "install", "off"];
 function errorMessage4(err) {
@@ -36874,7 +37156,7 @@ function workspaceRootFor(config2) {
   return getWorkspaceRoot(config2);
 }
 function workspacePathFor2(config2, name) {
-  return path39.join(workspaceRootFor(config2), name);
+  return path40.join(workspaceRootFor(config2), name);
 }
 async function resolveWorktreePathForMember(config2, repoName, branch) {
   const repos = resolveRepos(config2, [repoName]);
@@ -36886,7 +37168,7 @@ async function resolveWorktreePathForMember(config2, repoName, branch) {
   if (match)
     return match.path;
   const candidate = getWorktreePath(repo, branch);
-  if (fs36.existsSync(candidate))
+  if (fs38.existsSync(candidate))
     return candidate;
   return null;
 }
@@ -36944,7 +37226,7 @@ function registerCreateSub(workspace) {
       process.exit(1);
     }
     const wsPath = workspacePathFor2(config2, name);
-    if (fs36.existsSync(wsPath)) {
+    if (fs38.existsSync(wsPath)) {
       stepError("Workspace already exists", wsPath);
       process.exit(1);
     }
@@ -37045,7 +37327,7 @@ function registerAddSub(workspace) {
     const globalOpts = workspace.parent.opts();
     const config2 = loadConfig();
     const wsPath = workspacePathFor2(config2, name);
-    if (!fs36.existsSync(wsPath)) {
+    if (!fs38.existsSync(wsPath)) {
       stepError("Workspace not found", wsPath);
       process.exit(1);
     }
@@ -37081,7 +37363,7 @@ function registerRmSub(workspace) {
     const globalOpts = workspace.parent.opts();
     const config2 = loadConfig();
     const wsPath = workspacePathFor2(config2, name);
-    if (!fs36.existsSync(wsPath)) {
+    if (!fs38.existsSync(wsPath)) {
       stepError("Workspace not found", wsPath);
       process.exit(1);
     }
@@ -37103,7 +37385,7 @@ function registerRemoveSub(workspace) {
     const globalOpts = workspace.parent.opts();
     const config2 = loadConfig();
     const wsPath = workspacePathFor2(config2, name);
-    if (!fs36.existsSync(wsPath)) {
+    if (!fs38.existsSync(wsPath)) {
       stepError("Workspace not found", wsPath);
       process.exit(1);
     }
@@ -37117,7 +37399,7 @@ function registerRemoveSub(workspace) {
       return;
     }
     try {
-      fs36.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) {
@@ -37130,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 (!fs36.existsSync(wsPath)) {
+    if (!fs38.existsSync(wsPath)) {
       stepError("Workspace not found", wsPath);
       process.exit(1);
     }
@@ -37165,7 +37447,7 @@ init_config();
 init_resolver();
 init_log();
 init_history();
-import fs37 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([
@@ -37275,7 +37557,7 @@ program2.command("_resolve-path <repo> <branch>", { hidden: true }).description(
     }
     const repo = repos[0];
     const wtPath = getWorktreePath(repo, branch);
-    if (!fs37.existsSync(wtPath)) {
+    if (!fs39.existsSync(wtPath)) {
       process.stderr.write(`✗ No worktree at ${wtPath}
 `);
       process.exit(1);