@ogpoyraz/wtx 0.7.0 → 0.8.1

package/dist/cli.mjs

@@ -15331,6 +15331,11 @@ function verbose(message, isVerbose) {
 function indented(message) {
   console.log(`    ${message}`);
 }
+function terminalLink(url2, text = url2, stream = process.stdout) {
+  if (!stream.isTTY)
+    return text;
+  return `\x1B]8;;${url2}\x1B\\${text}\x1B]8;;\x1B\\`;
+}
 var c, quietMode = false;
 var init_log = __esm(() => {
   init_source();
@@ -23014,6 +23019,20 @@ async function getLatestCommit(repoPath, ref) {
     subject: stdout.substring(splitIdx + 1)
   };
 }
+async function resolveCommitSha(repoPath, ref, opts = { verbose: false, dryRun: false }) {
+  try {
+    const stdout = await gitExec(["-C", repoPath, "rev-parse", "--verify", "--end-of-options", `${ref}^{commit}`], opts);
+    const sha = stdout.trim();
+    if (!sha) {
+      throw new Error("Git returned an empty commit id");
+    }
+    return sha;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(`Ref '${ref}' does not resolve to a commit: ${message.split(`
+`)[0]}`);
+  }
+}
 async function getDirtyFiles(worktreePath) {
   const stdout = await gitExec(["-C", worktreePath, "status", "--porcelain"]);
   return stdout.split(`
@@ -23131,19 +23150,195 @@ var init_git = __esm(() => {
   init_log();
 });
 
-// src/lib/resolver.ts
+// src/lib/stack.ts
 import fs7 from "fs";
 import path15 from "path";
+function emptyMetadata() {
+  return { version: 1, branches: {} };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseMetadata(value) {
+  if (!isRecord(value) || value.version !== 1 || !isRecord(value.branches)) {
+    throw new Error("invalid format or version");
+  }
+  const branches = {};
+  for (const [branch, rawEntry] of Object.entries(value.branches)) {
+    if (!isRecord(rawEntry))
+      continue;
+    if (typeof rawEntry.baseRef !== "string" || typeof rawEntry.baseSha !== "string")
+      continue;
+    branches[branch] = {
+      baseRef: rawEntry.baseRef,
+      baseSha: rawEntry.baseSha,
+      explicit: rawEntry.explicit === true,
+      createdAt: typeof rawEntry.createdAt === "string" ? rawEntry.createdAt : ""
+    };
+  }
+  return { version: 1, branches };
+}
+async function metadataPath(repoPath, opts) {
+  const commonDirOutput = await gitExec(["-C", repoPath, "rev-parse", "--git-common-dir"], { ...opts, dryRun: false });
+  const commonDir = commonDirOutput.trim();
+  if (!commonDir)
+    return null;
+  const resolvedCommonDir = path15.isAbsolute(commonDir) ? commonDir : path15.resolve(repoPath, commonDir);
+  return path15.join(resolvedCommonDir, "wtx", "stack.json");
+}
+async function readStackMetadata(repoPath, opts = { verbose: false, dryRun: false }) {
+  const filePath = await metadataPath(repoPath, opts);
+  if (!filePath || !fs7.existsSync(filePath))
+    return emptyMetadata();
+  try {
+    const raw = JSON.parse(fs7.readFileSync(filePath, "utf8"));
+    return parseMetadata(raw);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(`Failed to read stack metadata: ${message}`);
+  }
+}
+async function writeStackMetadata(repoPath, metadata, opts) {
+  if (opts.dryRun)
+    return;
+  const filePath = await metadataPath(repoPath, opts);
+  if (!filePath)
+    return;
+  const dir = path15.dirname(filePath);
+  fs7.mkdirSync(dir, { recursive: true });
+  const tempPath = `${filePath}.${process.pid}.tmp`;
+  fs7.writeFileSync(tempPath, `${JSON.stringify(metadata, null, 2)}
+`, "utf8");
+  fs7.renameSync(tempPath, filePath);
+}
+async function recordStackEntry(repoPath, branch, entry, opts) {
+  const metadata = await readStackMetadata(repoPath, opts);
+  metadata.branches[branch] = entry;
+  await writeStackMetadata(repoPath, metadata, opts);
+}
+async function removeStackEntry(repoPath, branch, opts) {
+  const metadata = await readStackMetadata(repoPath, opts);
+  if (!metadata.branches[branch])
+    return;
+  delete metadata.branches[branch];
+  await writeStackMetadata(repoPath, metadata, opts);
+}
+async function renameStackEntry(repoPath, oldBranch, newBranch, opts) {
+  const metadata = await readStackMetadata(repoPath, opts);
+  const entry = metadata.branches[oldBranch];
+  let changed = false;
+  if (entry) {
+    metadata.branches[newBranch] = entry;
+    delete metadata.branches[oldBranch];
+    changed = true;
+  }
+  for (const child of Object.values(metadata.branches)) {
+    if (child.baseRef !== oldBranch && child.baseRef !== `refs/heads/${oldBranch}`)
+      continue;
+    child.baseRef = newBranch;
+    changed = true;
+  }
+  if (changed)
+    await writeStackMetadata(repoPath, metadata, opts);
+}
+function getStackChildren(metadata, branch) {
+  return Object.entries(metadata.branches).filter(([, entry]) => entry.baseRef === branch || entry.baseRef === `refs/heads/${branch}`).map(([child]) => child).sort((a2, b) => a2.localeCompare(b));
+}
+function getStackAncestors(metadata, branch) {
+  const ancestors = [branch];
+  const seen = new Set([branch]);
+  let current = branch;
+  while (true) {
+    const entry = metadata.branches[current];
+    if (!entry || seen.has(entry.baseRef))
+      break;
+    ancestors.unshift(entry.baseRef);
+    seen.add(entry.baseRef);
+    current = entry.baseRef;
+  }
+  return ancestors;
+}
+function resolveParentBranch(baseRef, branches) {
+  if (!baseRef)
+    return null;
+  if (branches.has(baseRef))
+    return baseRef;
+  const headRef = baseRef.replace(/^refs\/heads\//, "");
+  if (branches.has(headRef))
+    return headRef;
+  const remoteRef = baseRef.replace(/^refs\/remotes\/[^/]+\//, "");
+  if (branches.has(remoteRef))
+    return remoteRef;
+  const slash = baseRef.indexOf("/");
+  if (slash > 0) {
+    const shortRef = baseRef.substring(slash + 1);
+    if (branches.has(shortRef))
+      return shortRef;
+  }
+  return null;
+}
+function buildStackHierarchy(items, getBranch, getBase, compare) {
+  const branchNames = new Set(items.map(getBranch).filter((branch) => branch !== undefined));
+  const byBranch = new Map;
+  const children = new Map;
+  const roots = [];
+  for (const item of items) {
+    const branch = getBranch(item);
+    if (branch)
+      byBranch.set(branch, item);
+  }
+  for (const item of items) {
+    const branch = getBranch(item);
+    const parent = resolveParentBranch(getBase(item), branchNames);
+    if (!parent || parent === branch || !byBranch.has(parent)) {
+      roots.push(item);
+      continue;
+    }
+    const siblings = children.get(parent) ?? [];
+    siblings.push(item);
+    children.set(parent, siblings);
+  }
+  const result = [];
+  const visited = new Set;
+  const visit = (item, depth, ancestorPrefix, isLast) => {
+    const branch = getBranch(item);
+    if (branch && visited.has(branch))
+      return;
+    if (branch)
+      visited.add(branch);
+    const prefix = depth === 0 ? "" : `${ancestorPrefix}${isLast ? "└─ " : "├─ "}`;
+    result.push({ item, depth, prefix });
+    const childRows = [...branch ? children.get(branch) ?? [] : []].sort(compare);
+    const childPrefix = depth === 0 ? "" : `${ancestorPrefix}${isLast ? "   " : "│  "}`;
+    childRows.forEach((child, index) => {
+      visit(child, depth + 1, childPrefix, index === childRows.length - 1);
+    });
+  };
+  roots.sort(compare).forEach((root) => visit(root, 0, "", true));
+  for (const item of items) {
+    const branch = getBranch(item);
+    if (!branch || !visited.has(branch))
+      visit(item, 0, "", true);
+  }
+  return result;
+}
+var init_stack = __esm(() => {
+  init_git();
+});
+
+// src/lib/resolver.ts
+import fs8 from "fs";
+import path16 from "path";
 function detectRepoFromCwd(config2) {
   const cwd = process.cwd();
   const root = expandTilde(config2.root);
   for (const name of Object.keys(config2.repos)) {
-    const mainPath = path15.join(root, name);
-    const wtRoot = path15.join(root, `${name}${config2.postfix}`);
-    if (cwd === mainPath || cwd.startsWith(mainPath + path15.sep)) {
+    const mainPath = path16.join(root, name);
+    const wtRoot = path16.join(root, `${name}${config2.postfix}`);
+    if (cwd === mainPath || cwd.startsWith(mainPath + path16.sep)) {
       return name;
     }
-    if (cwd === wtRoot || cwd.startsWith(wtRoot + path15.sep)) {
+    if (cwd === wtRoot || cwd.startsWith(wtRoot + path16.sep)) {
       return name;
     }
   }
@@ -23173,11 +23368,11 @@ function resolveRepos(config2, repoFilter) {
   return targetRepos.map((name) => {
     const mainPath = `${expandTilde(config2.root)}/${name}`;
     const wtRoot = `${expandTilde(config2.root)}/${name}${config2.postfix}`;
-    if (!fs7.existsSync(mainPath)) {
+    if (!fs8.existsSync(mainPath)) {
       throw new Error(`Repo directory not found at ${mainPath}`);
     }
-    const gitDir = path15.join(mainPath, ".git");
-    if (!fs7.existsSync(gitDir)) {
+    const gitDir = path16.join(mainPath, ".git");
+    if (!fs8.existsSync(gitDir)) {
       throw new Error(`Not a git repository: ${mainPath}`);
     }
     return {
@@ -23240,14 +23435,14 @@ function expandTemplate(template, vars) {
 }
 
 // src/lib/deps/workspaces.ts
-import fs10 from "fs";
-import path17 from "path";
+import fs11 from "fs";
+import path18 from "path";
 function getWorkspaceDirs(rootDir) {
   const dirs = new Set;
-  const pkgPath = path17.join(rootDir, "package.json");
-  if (fs10.existsSync(pkgPath)) {
+  const pkgPath = path18.join(rootDir, "package.json");
+  if (fs11.existsSync(pkgPath)) {
     try {
-      const pkg = JSON.parse(fs10.readFileSync(pkgPath, "utf-8"));
+      const pkg = JSON.parse(fs11.readFileSync(pkgPath, "utf-8"));
       if (pkg.workspaces) {
         let ws = [];
         if (Array.isArray(pkg.workspaces)) {
@@ -23261,10 +23456,10 @@ function getWorkspaceDirs(rootDir) {
       }
     } catch {}
   }
-  const pnpmPath = path17.join(rootDir, "pnpm-workspace.yaml");
-  if (fs10.existsSync(pnpmPath)) {
+  const pnpmPath = path18.join(rootDir, "pnpm-workspace.yaml");
+  if (fs11.existsSync(pnpmPath)) {
     try {
-      const content = fs10.readFileSync(pnpmPath, "utf-8");
+      const content = fs11.readFileSync(pnpmPath, "utf-8");
       const lines = content.split(/\r?\n/);
       let inPackages = false;
       for (let line of lines) {
@@ -23295,8 +23490,8 @@ function resolvePattern(rootDir, pattern, out) {
   const normalized = pattern.replace(/\/+$/, "");
   const hasGlob = normalized.includes("*");
   if (!hasGlob) {
-    const fullDir = path17.join(rootDir, normalized);
-    if (fs10.existsSync(fullDir) && fs10.statSync(fullDir).isDirectory()) {
+    const fullDir = path18.join(rootDir, normalized);
+    if (fs11.existsSync(fullDir) && fs11.statSync(fullDir).isDirectory()) {
       out.add(normalized);
     }
     return;
@@ -23311,12 +23506,12 @@ function globToRegex(pattern) {
 function collectMatchingDirs(base2, rel, regex, out, depth) {
   if (depth > 8)
     return;
-  if (rel && regex.test(rel) && fs10.existsSync(path17.join(base2, rel, "package.json"))) {
+  if (rel && regex.test(rel) && fs11.existsSync(path18.join(base2, rel, "package.json"))) {
     out.add(rel);
   }
   let entries;
   try {
-    entries = fs10.readdirSync(rel ? path17.join(base2, rel) : base2, { withFileTypes: true });
+    entries = fs11.readdirSync(rel ? path18.join(base2, rel) : base2, { withFileTypes: true });
   } catch {
     return;
   }
@@ -23324,7 +23519,7 @@ function collectMatchingDirs(base2, rel, regex, out, depth) {
     if (!entry.isDirectory() || entry.name === "node_modules" || entry.name.startsWith(".")) {
       continue;
     }
-    const nextRel = rel ? path17.posix.join(rel, entry.name) : entry.name;
+    const nextRel = rel ? path18.posix.join(rel, entry.name) : entry.name;
     if (!regex.test(nextRel) && !couldMatchDeeper(regex.source, nextRel))
       continue;
     collectMatchingDirs(base2, nextRel, regex, out, depth + 1);
@@ -23336,21 +23531,21 @@ function couldMatchDeeper(regexSource, rel) {
 var init_workspaces = () => {};
 
 // src/lib/deps/diff.ts
-import fs11 from "fs";
-import path18 from "path";
+import fs12 from "fs";
+import path19 from "path";
 function filesMatch(wtPath, mainPath, fileNames) {
   for (const name of fileNames) {
-    const wtFile = path18.join(wtPath, name);
-    const mainFile = path18.join(mainPath, name);
-    const wtExists = fs11.existsSync(wtFile);
-    const mainExists = fs11.existsSync(mainFile);
+    const wtFile = path19.join(wtPath, name);
+    const mainFile = path19.join(mainPath, name);
+    const wtExists = fs12.existsSync(wtFile);
+    const mainExists = fs12.existsSync(mainFile);
     if (wtExists !== mainExists)
       return false;
     if (!wtExists)
       continue;
     try {
-      const wtContent = fs11.readFileSync(wtFile);
-      const mainContent = fs11.readFileSync(mainFile);
+      const wtContent = fs12.readFileSync(wtFile);
+      const mainContent = fs12.readFileSync(mainFile);
       if (!wtContent.equals(mainContent))
         return false;
     } catch {
@@ -23368,7 +23563,7 @@ function getWorkspaceDelta(wtPath, mainPath, lockfileNames) {
   const changedWorkspaces = [];
   for (const ws of allWorkspaces) {
     const wsFiles = ["package.json"];
-    if (!filesMatch(path18.join(wtPath, ws), path18.join(mainPath, ws), wsFiles)) {
+    if (!filesMatch(path19.join(wtPath, ws), path19.join(mainPath, ws), wsFiles)) {
       changedWorkspaces.push(ws);
     }
   }
@@ -23379,8 +23574,8 @@ var init_diff = __esm(() => {
 });
 
 // src/lib/deps/adapters/bun.ts
-import fs12 from "fs";
-import path19 from "path";
+import fs13 from "fs";
+import path20 from "path";
 var bunAdapter;
 var init_bun = __esm(() => {
   init_diff();
@@ -23388,7 +23583,7 @@ var init_bun = __esm(() => {
   bunAdapter = {
     id: "bun",
     displayName: "bun",
-    detect: (dir) => fs12.existsSync(path19.join(dir, "bun.lockb")) || fs12.existsSync(path19.join(dir, "bun.lock")),
+    detect: (dir) => fs13.existsSync(path20.join(dir, "bun.lockb")) || fs13.existsSync(path20.join(dir, "bun.lock")),
     lockfileNames: ["bun.lockb", "bun.lock"],
     definitionsMatch: (wtPath, mainPath) => {
       const delta = getWorkspaceDelta(wtPath, mainPath, ["bun.lockb", "bun.lock"]);
@@ -23416,8 +23611,8 @@ var init_bun = __esm(() => {
 });
 
 // src/lib/deps/adapters/pnpm.ts
-import fs13 from "fs";
-import path20 from "path";
+import fs14 from "fs";
+import path21 from "path";
 var pnpmAdapter;
 var init_pnpm = __esm(() => {
   init_diff();
@@ -23425,7 +23620,7 @@ var init_pnpm = __esm(() => {
   pnpmAdapter = {
     id: "pnpm",
     displayName: "pnpm",
-    detect: (dir) => fs13.existsSync(path20.join(dir, "pnpm-lock.yaml")),
+    detect: (dir) => fs14.existsSync(path21.join(dir, "pnpm-lock.yaml")),
     lockfileNames: ["pnpm-lock.yaml"],
     definitionsMatch: (wtPath, mainPath) => {
       const delta = getWorkspaceDelta(wtPath, mainPath, ["pnpm-lock.yaml"]);
@@ -23453,8 +23648,8 @@ var init_pnpm = __esm(() => {
 });
 
 // src/lib/deps/adapters/yarn.ts
-import fs14 from "fs";
-import path21 from "path";
+import fs15 from "fs";
+import path22 from "path";
 var yarnAdapter;
 var init_yarn = __esm(() => {
   init_diff();
@@ -23462,7 +23657,7 @@ var init_yarn = __esm(() => {
   yarnAdapter = {
     id: "yarn",
     displayName: "yarn",
-    detect: (dir) => fs14.existsSync(path21.join(dir, "yarn.lock")),
+    detect: (dir) => fs15.existsSync(path22.join(dir, "yarn.lock")),
     lockfileNames: ["yarn.lock"],
     definitionsMatch: (wtPath, mainPath) => {
       const delta = getWorkspaceDelta(wtPath, mainPath, ["yarn.lock"]);
@@ -23484,8 +23679,8 @@ var init_yarn = __esm(() => {
 });
 
 // src/lib/deps/adapters/npm.ts
-import fs15 from "fs";
-import path22 from "path";
+import fs16 from "fs";
+import path23 from "path";
 var npmAdapter;
 var init_npm = __esm(() => {
   init_diff();
@@ -23493,7 +23688,7 @@ var init_npm = __esm(() => {
   npmAdapter = {
     id: "npm",
     displayName: "npm",
-    detect: (dir) => fs15.existsSync(path22.join(dir, "package-lock.json")),
+    detect: (dir) => fs16.existsSync(path23.join(dir, "package-lock.json")),
     lockfileNames: ["package-lock.json"],
     definitionsMatch: (wtPath, mainPath) => {
       const delta = getWorkspaceDelta(wtPath, mainPath, ["package-lock.json"]);
@@ -23850,47 +24045,47 @@ var init_registry = __esm(() => {
 });
 
 // src/lib/deps/linking.ts
-import fs16 from "fs";
-import path23 from "path";
+import fs17 from "fs";
+import path24 from "path";
 function performSafeLink(wtPath, mainPath, dryRun, quiet) {
-  const wtNm = path23.join(wtPath, "node_modules");
-  const mainNm = path23.join(mainPath, "node_modules");
-  if (!fs16.existsSync(mainNm)) {
+  const wtNm = path24.join(wtPath, "node_modules");
+  const mainNm = path24.join(mainPath, "node_modules");
+  if (!fs17.existsSync(mainNm)) {
     return;
   }
   let existingLink = false;
   try {
-    const stat = fs16.lstatSync(wtNm);
+    const stat = fs17.lstatSync(wtNm);
     existingLink = stat.isSymbolicLink();
   } catch {}
   if (existingLink) {
     if (!quiet)
       stepProgress("Removing whole-directory symlink to prepare for safe linking...");
     if (!dryRun) {
-      fs16.unlinkSync(wtNm);
+      fs17.unlinkSync(wtNm);
     }
   }
-  if (!dryRun && !fs16.existsSync(wtNm)) {
-    fs16.mkdirSync(wtNm, { recursive: true });
+  if (!dryRun && !fs17.existsSync(wtNm)) {
+    fs17.mkdirSync(wtNm, { recursive: true });
   }
   const entriesToLink = [];
   try {
-    const mainEntries = fs16.readdirSync(mainNm, { withFileTypes: true });
+    const mainEntries = fs17.readdirSync(mainNm, { withFileTypes: true });
     for (const entry of mainEntries) {
       if (entry.name === ".bin") {
         entriesToLink.push({
           name: ".bin",
-          target: path23.join(mainNm, ".bin"),
+          target: path24.join(mainNm, ".bin"),
           isBin: true
         });
       } else if (entry.name.startsWith("@") && entry.isDirectory()) {
-        const scopePath = path23.join(mainNm, entry.name);
+        const scopePath = path24.join(mainNm, entry.name);
         try {
-          const scopedEntries = fs16.readdirSync(scopePath, { withFileTypes: true });
+          const scopedEntries = fs17.readdirSync(scopePath, { withFileTypes: true });
           for (const scopedEntry of scopedEntries) {
             entriesToLink.push({
-              name: path23.join(entry.name, scopedEntry.name),
-              target: path23.join(scopePath, scopedEntry.name),
+              name: path24.join(entry.name, scopedEntry.name),
+              target: path24.join(scopePath, scopedEntry.name),
               isBin: false
             });
           }
@@ -23898,7 +24093,7 @@ function performSafeLink(wtPath, mainPath, dryRun, quiet) {
       } else {
         entriesToLink.push({
           name: entry.name,
-          target: path23.join(mainNm, entry.name),
+          target: path24.join(mainNm, entry.name),
           isBin: false
         });
       }
@@ -23908,7 +24103,7 @@ function performSafeLink(wtPath, mainPath, dryRun, quiet) {
   let failedCount = 0;
   const failedNames = [];
   for (const { name, target, isBin } of entriesToLink) {
-    const linkPath = path23.join(wtNm, name);
+    const linkPath = path24.join(wtNm, name);
     if (dryRun) {
       if (!quiet)
         info(`  [dry-run] Would link ${name}`);
@@ -23916,41 +24111,41 @@ function performSafeLink(wtPath, mainPath, dryRun, quiet) {
       continue;
     }
     try {
-      const parentDir = path23.dirname(linkPath);
-      if (!fs16.existsSync(parentDir)) {
-        fs16.mkdirSync(parentDir, { recursive: true });
+      const parentDir = path24.dirname(linkPath);
+      if (!fs17.existsSync(parentDir)) {
+        fs17.mkdirSync(parentDir, { recursive: true });
       }
       let shouldLink = true;
       let backupPath = null;
       try {
-        const stat = fs16.lstatSync(linkPath);
+        const stat = fs17.lstatSync(linkPath);
         if (stat.isSymbolicLink()) {
-          const existingTarget = fs16.readlinkSync(linkPath);
-          const resolvedExisting = path23.resolve(path23.dirname(linkPath), existingTarget);
+          const existingTarget = fs17.readlinkSync(linkPath);
+          const resolvedExisting = path24.resolve(path24.dirname(linkPath), existingTarget);
           if (resolvedExisting === target) {
             shouldLink = false;
           } else {
-            fs16.unlinkSync(linkPath);
+            fs17.unlinkSync(linkPath);
           }
         } else {
           backupPath = `${linkPath}.wtx-old`;
-          fs16.renameSync(linkPath, backupPath);
+          fs17.renameSync(linkPath, backupPath);
         }
       } catch {}
       if (shouldLink) {
         try {
-          const relTarget = path23.relative(path23.dirname(linkPath), target);
-          fs16.symlinkSync(relTarget, linkPath, isBin ? "dir" : fs16.statSync(target).isDirectory() ? "dir" : "file");
+          const relTarget = path24.relative(path24.dirname(linkPath), target);
+          fs17.symlinkSync(relTarget, linkPath, isBin ? "dir" : fs17.statSync(target).isDirectory() ? "dir" : "file");
           createdCount++;
         } catch (err) {
           if (backupPath) {
-            fs16.renameSync(backupPath, linkPath);
+            fs17.renameSync(backupPath, linkPath);
           }
           throw err;
         }
       }
-      if (backupPath && fs16.existsSync(backupPath)) {
-        fs16.rmSync(backupPath, { recursive: true, force: true });
+      if (backupPath && fs17.existsSync(backupPath)) {
+        fs17.rmSync(backupPath, { recursive: true, force: true });
       }
     } catch {
       failedCount++;
@@ -23969,15 +24164,15 @@ var init_linking = __esm(() => {
 });
 
 // src/lib/deps/engine.ts
-import fs17 from "fs";
-import path24 from "path";
+import fs18 from "fs";
+import path25 from "path";
 function resolveAdapter2(dir, managerOverride) {
   return resolveAdapter(dir, managerOverride);
 }
 function performLegacySymlink(wtPath, mainPath, dryRun, quiet) {
-  const nmPath = path24.join(wtPath, "node_modules");
-  const mainNm = path24.join(mainPath, "node_modules");
-  if (!fs17.existsSync(mainNm)) {
+  const nmPath = path25.join(wtPath, "node_modules");
+  const mainNm = path25.join(mainPath, "node_modules");
+  if (!fs18.existsSync(mainNm)) {
     if (!quiet)
       stepWarning("Main repo has no node_modules to symlink to");
     return;
@@ -23987,7 +24182,7 @@ function performLegacySymlink(wtPath, mainPath, dryRun, quiet) {
   let existingLink = false;
   let shouldRemove = false;
   try {
-    const stat = fs17.lstatSync(nmPath);
+    const stat = fs18.lstatSync(nmPath);
     existingLink = stat.isSymbolicLink();
     shouldRemove = true;
   } catch {}
@@ -24001,9 +24196,9 @@ function performLegacySymlink(wtPath, mainPath, dryRun, quiet) {
     }
     if (!dryRun) {
       if (existingLink) {
-        fs17.unlinkSync(nmPath);
+        fs18.unlinkSync(nmPath);
       } else {
-        fs17.rmSync(nmPath, { recursive: true, force: true });
+        fs18.rmSync(nmPath, { recursive: true, force: true });
       }
     }
   }
@@ -24011,22 +24206,22 @@ function performLegacySymlink(wtPath, mainPath, dryRun, quiet) {
     if (!quiet)
       info(`  [dry-run] Would symlink ${mainNm} to ${nmPath}`);
   } else {
-    fs17.symlinkSync(mainNm, nmPath);
+    fs18.symlinkSync(mainNm, nmPath);
   }
   if (!quiet)
     stepSuccess("Symlinked node_modules", mainNm);
 }
 function detectCommonLinkageState(wtPath, mainPath) {
-  const nodeModulesPath = path24.join(wtPath, "node_modules");
+  const nodeModulesPath = path25.join(wtPath, "node_modules");
   try {
-    const stat = fs17.lstatSync(nodeModulesPath);
+    const stat = fs18.lstatSync(nodeModulesPath);
     if (stat.isSymbolicLink()) {
-      const target = fs17.readlinkSync(nodeModulesPath);
-      const resolvedTarget = path24.resolve(wtPath, target);
+      const target = fs18.readlinkSync(nodeModulesPath);
+      const resolvedTarget = path25.resolve(wtPath, target);
       const resolvedMain = safeResolve(mainPath);
       let targetExists = false;
       try {
-        fs17.statSync(resolvedTarget);
+        fs18.statSync(resolvedTarget);
         targetExists = true;
       } catch {
         targetExists = false;
@@ -24034,14 +24229,14 @@ function detectCommonLinkageState(wtPath, mainPath) {
       if (!targetExists) {
         return { state: "broken", target };
       }
-      if (!isWithin(resolvedMain, resolvedTarget) && resolvedTarget !== path24.join(resolvedMain, "node_modules")) {
+      if (!isWithin(resolvedMain, resolvedTarget) && resolvedTarget !== path25.join(resolvedMain, "node_modules")) {
         return { state: "external", target };
       }
       return { state: "linked-whole", target };
     } else if (stat.isDirectory()) {
       let isLinkedPackages = false;
       try {
-        const entries = fs17.readdirSync(nodeModulesPath, { withFileTypes: true });
+        const entries = fs18.readdirSync(nodeModulesPath, { withFileTypes: true });
         for (const entry of entries) {
           if (entry.isSymbolicLink()) {
             isLinkedPackages = true;
@@ -24055,7 +24250,7 @@ function detectCommonLinkageState(wtPath, mainPath) {
       return { state: "installed" };
     }
   } catch {
-    if (!fs17.existsSync(nodeModulesPath)) {
+    if (!fs18.existsSync(nodeModulesPath)) {
       return { state: "missing" };
     }
   }
@@ -24169,7 +24364,7 @@ function findRepoDepsContext(wtPath) {
   try {
     const config2 = loadConfig();
     const repos = resolveRepos(config2, []);
-    const repo = repos.find((r) => wtPath === r.wtRoot || wtPath.startsWith(r.wtRoot + "/"));
+    const repo = repos.find((r) => wtPath === r.mainPath || wtPath === r.wtRoot || wtPath.startsWith(r.wtRoot + "/"));
     if (repo) {
       return {
         name: repo.name,
@@ -24250,18 +24445,18 @@ var init_deps = __esm(() => {
 });
 
 // src/lib/forge/map.ts
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function asCheckItem(value) {
-  if (!isRecord(value))
+  if (!isRecord2(value))
     return null;
   return {
     __typename: typeof value.__typename === "string" ? value.__typename : undefined,
     status: typeof value.status === "string" ? value.status : null,
     conclusion: typeof value.conclusion === "string" ? value.conclusion : null,
     state: typeof value.state === "string" ? value.state : null,
-    commit: isRecord(value.commit) ? value.commit : null
+    commit: isRecord2(value.commit) ? value.commit : null
   };
 }
 function collectCheckItems(raw) {
@@ -24335,7 +24530,7 @@ function mapReviewDecision(raw) {
   return null;
 }
 function mapGithubPr(raw) {
-  if (!isRecord(raw))
+  if (!isRecord2(raw))
     return null;
   const number4 = typeof raw.number === "number" ? raw.number : null;
   const headRefName = typeof raw.headRefName === "string" ? raw.headRefName : null;
@@ -24346,9 +24541,10 @@ function mapGithubPr(raw) {
   const url2 = typeof raw.url === "string" ? raw.url : "";
   const isDraft = raw.isDraft === true;
   const updatedAt = typeof raw.updatedAt === "string" ? raw.updatedAt : "";
+  const baseRefName = typeof raw.baseRefName === "string" ? raw.baseRefName : undefined;
   const checks3 = bucketChecks(collectCheckItems(raw.statusCheckRollup));
   const author = raw.author;
-  const authorLogin = isRecord(author) && typeof author.login === "string" ? author.login : null;
+  const authorLogin = isRecord2(author) && typeof author.login === "string" ? author.login : null;
   return {
     number: number4,
     authorLogin,
@@ -24359,12 +24555,13 @@ function mapGithubPr(raw) {
     mergeable: mapMergeable(raw.mergeable),
     checks: checks3,
     reviewDecision: mapReviewDecision(raw.reviewDecision),
+    ...baseRefName ? { baseRefName } : {},
     unresolvedThreads: 0,
     updatedAt
   };
 }
 function mapPrHead(raw) {
-  if (!isRecord(raw))
+  if (!isRecord2(raw))
     return null;
   const number4 = typeof raw.number === "number" ? raw.number : null;
   const headRefName = typeof raw.headRefName === "string" ? raw.headRefName : null;
@@ -24375,12 +24572,13 @@ function mapPrHead(raw) {
   const url2 = typeof raw.url === "string" ? raw.url : "";
   const isDraft = raw.isDraft === true;
   const isCrossRepository = raw.isCrossRepository === true;
+  const baseRefName = typeof raw.baseRefName === "string" ? raw.baseRefName : undefined;
   let headOwnerLogin = null;
-  if (isRecord(raw.headRepositoryOwner) && typeof raw.headRepositoryOwner.login === "string") {
+  if (isRecord2(raw.headRepositoryOwner) && typeof raw.headRepositoryOwner.login === "string") {
     headOwnerLogin = raw.headRepositoryOwner.login;
   }
   let headRepoName = null;
-  if (isRecord(raw.headRepository) && typeof raw.headRepository.name === "string") {
+  if (isRecord2(raw.headRepository) && typeof raw.headRepository.name === "string") {
     headRepoName = raw.headRepository.name;
   }
   return {
@@ -24390,6 +24588,7 @@ function mapPrHead(raw) {
     state,
     isDraft,
     headRefName,
+    ...baseRefName ? { baseRefName } : {},
     isCrossRepository,
     headOwnerLogin,
     headRepoName
@@ -24485,7 +24684,7 @@ async function ghExec(args, opts = {}) {
 }
 function mapWithBranch(raw) {
   const pr = mapGithubPr(raw);
-  if (!pr || !isRecord(raw) || typeof raw.headRefName !== "string")
+  if (!pr || !isRecord2(raw) || typeof raw.headRefName !== "string")
     return null;
   return { branch: raw.headRefName, pr };
 }
@@ -24530,12 +24729,12 @@ async function fetchBranchPrs(ctx) {
   return results.filter((entry) => entry !== null);
 }
 function countUnresolvedThreads(result) {
-  if (!isRecord(result))
+  if (!isRecord2(result))
     return 0;
   const threads = result.reviewThreads;
-  if (!isRecord(threads) || !Array.isArray(threads.nodes))
+  if (!isRecord2(threads) || !Array.isArray(threads.nodes))
     return 0;
-  return threads.nodes.filter((node) => isRecord(node) && node.isResolved === false).length;
+  return threads.nodes.filter((node) => isRecord2(node) && node.isResolved === false).length;
 }
 function buildThreadQuery(numbers) {
   const aliases = numbers.map((n2, i2) => `pr${i2}: pullRequest(number: ${n2}) { reviewThreads(first: ${THREADS_PER_PR}) { nodes { isResolved } } }`).join(" ");
@@ -24556,10 +24755,10 @@ async function enrichUnresolvedThreads(slug, prs, verboseFlag) {
     `name=${slug.name}`
   ], { verbose: verboseFlag });
   const payload = parseJson(stdout);
-  if (!isRecord(payload) || !isRecord(payload.data))
+  if (!isRecord2(payload) || !isRecord2(payload.data))
     return;
   const repoData = payload.data.repository;
-  if (!isRecord(repoData))
+  if (!isRecord2(repoData))
     return;
   prs.forEach((pr, i2) => {
     pr.unresolvedThreads = countUnresolvedThreads(repoData[`pr${i2}`]);
@@ -24589,7 +24788,7 @@ function createGithubAdapter(slug) {
         "-R",
         `${slug.owner}/${slug.name}`,
         "--json",
-        "number,title,url,state,isDraft,headRefName,isCrossRepository,headRepositoryOwner,headRepository"
+        "number,title,url,state,isDraft,headRefName,baseRefName,isCrossRepository,headRepositoryOwner,headRepository"
       ];
       const stdout = await ghExec(args, opts);
       const parsed = parseJson(stdout);
@@ -24629,6 +24828,7 @@ var init_github = __esm(() => {
     "statusCheckRollup",
     "reviewDecision",
     "headRefName",
+    "baseRefName",
     "updatedAt"
   ].join(",");
   REMOTE_URL_PATTERNS = [
@@ -24639,8 +24839,8 @@ var init_github = __esm(() => {
 });
 
 // src/lib/forge/index.ts
-import fs18 from "fs";
-import path25 from "path";
+import fs19 from "fs";
+import path26 from "path";
 function parsePrLink(link) {
   for (const forge of FORGES) {
     const ref = forge.parsePrLink(link);
@@ -24653,10 +24853,10 @@ function descriptorFor(id) {
   return FORGES.find((f) => f.id === id) ?? null;
 }
 function readOriginUrl(mainPath) {
-  const gitConfigPath = path25.join(mainPath, ".git", "config");
-  if (!fs18.existsSync(gitConfigPath))
+  const gitConfigPath = path26.join(mainPath, ".git", "config");
+  if (!fs19.existsSync(gitConfigPath))
     return null;
-  const content = fs18.readFileSync(gitConfigPath, "utf-8");
+  const content = fs19.readFileSync(gitConfigPath, "utf-8");
   const originSection = content.match(/\[remote "origin"\]([^[]*)/);
   if (!originSection)
     return null;
@@ -24706,7 +24906,7 @@ var init_forge = __esm(() => {
 });
 
 // src/lib/owner.ts
-import fs19 from "fs";
+import fs20 from "fs";
 function deriveOwnership(input) {
   if (input.hasLocalChanges) {
     return { mine: true, author: null };
@@ -24733,7 +24933,7 @@ async function resolveOwnership(input) {
   }
   const { mainPath, branch, verbose: verbose2 } = input;
   let hasLocalChanges = false;
-  if (input.wtPath && fs19.existsSync(input.wtPath)) {
+  if (input.wtPath && fs20.existsSync(input.wtPath)) {
     try {
       const dirtyFiles = await getDirtyFiles(input.wtPath);
       hasLocalChanges = dirtyFiles.length > 0;
@@ -24995,6 +25195,13 @@ async function fetchWorktreeData(opts, scope) {
     try {
       const mainBranch = await resolveMainBranch(repo, config2);
       const wts = await getWorktreeList(repo.mainPath);
+      let stackMetadata = { version: 1, branches: {} };
+      try {
+        stackMetadata = await readStackMetadata(repo.mainPath, opts);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        warnings.push({ repoName: repo.name, message });
+      }
       const forge = resolveForge(repo);
       const branches = wts.map((w) => w.branch).filter(Boolean);
       let prMap = new Map;
@@ -25022,6 +25229,10 @@ async function fetchWorktreeData(opts, scope) {
         if (isMainCheckout && !branch) {
           branch = mainBranch;
         }
+        const stackEntry = branch ? stackMetadata.branches[branch] : undefined;
+        const pr = branch ? prMap.get(branch) : undefined;
+        const base2 = stackEntry?.baseRef ?? pr?.baseRefName;
+        const comparisonBase = stackEntry?.explicit ? stackEntry.baseRef : pr?.baseRefName && pr.baseRefName !== mainBranch ? pr.baseRefName : `origin/${mainBranch}`;
         const row = {
           repoName: repo.name,
           branch: branch || "(detached)",
@@ -25040,7 +25251,9 @@ async function fetchWorktreeData(opts, scope) {
           prUrl: null,
           owner: null,
           rebaseStatus: null,
-          depsStrategy: "none"
+          depsStrategy: "none",
+          base: base2,
+          baseChanged: false
         };
         if (isMainCheckout) {
           allRows.push(row);
@@ -25052,7 +25265,7 @@ async function fetchWorktreeData(opts, scope) {
           })(),
           (async () => {
             try {
-              const stdout = await gitExec(["-C", wt.path, "rev-list", "--left-right", "--count", `origin/${mainBranch}...HEAD`], { dryRun: opts.dryRun });
+              const stdout = await gitExec(["-C", wt.path, "rev-list", "--left-right", "--count", `${comparisonBase}...HEAD`], { dryRun: opts.dryRun });
               if (stdout) {
                 const parts = stdout.trim().split(/\s+/);
                 if (parts.length === 2) {
@@ -25062,6 +25275,16 @@ async function fetchWorktreeData(opts, scope) {
               }
             } catch {}
           })(),
+          (async () => {
+            if (!stackEntry?.explicit || opts.dryRun)
+              return;
+            try {
+              const currentBaseSha = await resolveCommitSha(repo.mainPath, stackEntry.baseRef, opts);
+              row.baseChanged = currentBaseSha !== stackEntry.baseSha;
+            } catch {
+              row.baseChanged = true;
+            }
+          })(),
           (async () => {
             row.rebaseStatus = detectInProgressRebase(wt.path);
           })(),
@@ -25073,7 +25296,6 @@ async function fetchWorktreeData(opts, scope) {
           })(),
           (async () => {
             if (branch && config2.user) {
-              const pr = prMap.get(branch);
               try {
                 const owner = await resolveOwnership({
                   configUser: config2.user,
@@ -25090,7 +25312,6 @@ async function fetchWorktreeData(opts, scope) {
           })()
         ]);
         if (branch) {
-          const pr = prMap.get(branch);
           if (pr) {
             row.prNumber = pr.number;
             row.prUrl = pr.url;
@@ -25127,6 +25348,7 @@ var init_data = __esm(() => {
   init_forge();
   init_owner();
   init_types2();
+  init_stack();
   prCache = new Map;
 });
 
@@ -25147,14 +25369,16 @@ function matchesFilter(entry, term) {
     return true;
   if (entry.prUrl?.toLowerCase().includes(lower))
     return true;
+  if (entry.base?.toLowerCase().includes(lower))
+    return true;
   return false;
 }
-function toggleSelection(current, path35) {
+function toggleSelection(current, path36) {
   const next = new Set(current);
-  if (next.has(path35)) {
-    next.delete(path35);
+  if (next.has(path36)) {
+    next.delete(path36);
   } else {
-    next.add(path35);
+    next.add(path36);
   }
   return next;
 }
@@ -25181,9 +25405,38 @@ function rowSort(a2, b) {
     return 1;
   return a2.branch.localeCompare(b.branch);
 }
+function sortRowsHierarchically(rows) {
+  return buildStackHierarchy(rows, (row) => row.branch, (row) => row.base, rowSort).map(({ item, depth, prefix }) => ({
+    ...item,
+    hierarchyDepth: depth,
+    hierarchyPrefix: prefix
+  }));
+}
 function sortBlocks(blocks) {
   return [...blocks].sort((a2, b) => a2.repoName.localeCompare(b.repoName));
 }
+function wrapText(text, width) {
+  const lines = [];
+  for (const paragraph of text.split(`
+`)) {
+    let current = "";
+    for (const word of paragraph.split(/\s+/).filter(Boolean)) {
+      if (!current) {
+        current = word;
+      } else if (current.length + 1 + word.length <= width) {
+        current += ` ${word}`;
+      } else {
+        lines.push(current);
+        current = word;
+      }
+    }
+    lines.push(current);
+  }
+  return lines;
+}
+function isTapWithoutDrag(down, up) {
+  return Math.abs(up.x - down.x) <= 1 && Math.abs(up.y - down.y) <= 1;
+}
 function mergeBlocks(prev, next, scope) {
   if (!scope)
     return sortBlocks(next);
@@ -25236,9 +25489,12 @@ function withCreatePlaceholders(blocks, creating) {
     if (!branches)
       return block;
     const placeholders = branches.map((br) => makePlaceholderRow(block.repoName, br));
-    return { ...block, rows: [...block.rows, ...placeholders].sort(rowSort) };
+    return { ...block, rows: sortRowsHierarchically([...block.rows, ...placeholders]) };
   });
 }
+var init_utils = __esm(() => {
+  init_stack();
+});
 
 // src/tui/hooks/useWorktrees.ts
 import { useState, useEffect, useCallback, useRef } from "react";
@@ -25278,8 +25534,7 @@ function useWorktrees(opts) {
       }
       const newBlocks = [];
       for (const [repoName, rows] of byRepo.entries()) {
-        rows.sort(rowSort);
-        newBlocks.push({ repoName, rows });
+        newBlocks.push({ repoName, rows: sortRowsHierarchically(rows) });
       }
       newBlocks.sort((a2, b) => a2.repoName.localeCompare(b.repoName));
       const scopeSet = scope ? new Set(scope) : undefined;
@@ -25306,6 +25561,7 @@ function useWorktrees(opts) {
 var init_useWorktrees = __esm(() => {
   init_data();
   init_config();
+  init_utils();
 });
 
 // src/tui/theme.ts
@@ -25339,9 +25595,91 @@ var init_theme = __esm(() => {
   };
 });
 
+// src/tui/hooks/use-tap.ts
+import { useRef as useRef2, useCallback as useCallback2 } from "react";
+function useTapHandler(onTap) {
+  const down = useRef2(null);
+  const onMouseDown = useCallback2((e) => {
+    down.current = { x: e.x, y: e.y };
+  }, []);
+  const onMouseUp = useCallback2((e) => {
+    const start = down.current;
+    down.current = null;
+    if (!start || !isTapWithoutDrag(start, e))
+      return;
+    onTap();
+  }, [onTap]);
+  return { onMouseDown, onMouseUp };
+}
+var init_use_tap = __esm(() => {
+  init_utils();
+});
+
+// src/tui/platform.ts
+function clipboardCandidatesFor(platform2, env2 = process.env) {
+  if (platform2 === "darwin")
+    return [{ cmd: "pbcopy", args: [] }];
+  if (platform2 === "win32")
+    return [{ cmd: "clip", args: [] }];
+  const candidates = [];
+  if (env2.WAYLAND_DISPLAY)
+    candidates.push({ cmd: "wl-copy", args: [] });
+  if (env2.DISPLAY) {
+    candidates.push({ cmd: "xclip", args: ["-selection", "clipboard"] });
+    candidates.push({ cmd: "xsel", args: ["--clipboard", "--input"] });
+  }
+  return candidates;
+}
+async function copyTextToClipboard(renderer, text) {
+  if (!text)
+    return false;
+  const viaTerminal = renderer.copyToClipboardOSC52(text);
+  let viaSystem = false;
+  for (const candidate of clipboardCandidatesFor(process.platform)) {
+    try {
+      const proc = Bun.spawn([candidate.cmd, ...candidate.args], {
+        stdin: "pipe",
+        stdout: "ignore",
+        stderr: "ignore"
+      });
+      proc.stdin.write(text);
+      proc.stdin.end();
+      if (await proc.exited === 0) {
+        viaSystem = true;
+        break;
+      }
+    } catch {}
+  }
+  return viaSystem || viaTerminal;
+}
+function browserCommandFor(platform2, url2) {
+  if (!/^https?:\/\//.test(url2))
+    return null;
+  if (platform2 === "darwin")
+    return { cmd: "open", args: [url2] };
+  if (platform2 === "win32")
+    return { cmd: "cmd", args: ["/c", "start", "", url2] };
+  return { cmd: "xdg-open", args: [url2] };
+}
+async function openInBrowser(url2) {
+  const command = browserCommandFor(process.platform, url2);
+  if (!command)
+    return false;
+  try {
+    const proc = Bun.spawn([command.cmd, ...command.args], {
+      stdin: "ignore",
+      stdout: "ignore",
+      stderr: "ignore"
+    });
+    return await proc.exited === 0;
+  } catch {
+    return false;
+  }
+}
+
 // src/tui/components/WorktreeTable.tsx
-import { useEffect as useEffect2, useRef as useRef2 } from "react";
-import { jsx, jsxs } from "@opentui/react/jsx-runtime";
+import { useEffect as useEffect2, useRef as useRef3 } from "react";
+import { jsx, jsxs, Fragment } from "@opentui/react/jsx-runtime";
 function statusBadge(row) {
   if (row.isMainCheckout)
     return { text: "[main]", fg: tokens.accent };
@@ -25356,22 +25694,25 @@ function statusBadge(row) {
   return { text: "clean", fg: tokens.dim };
 }
 function WorktreeItem({ row, isSelected, isMultiSelected, indicator, frame, id }) {
+  const prTap = useTapHandler(() => {
+    if (row.prUrl)
+      openInBrowser(row.prUrl);
+  });
   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 disabled = indicator !== undefined || row.isPendingCreate === true;
   const primary = isSelected ? tokens.bright : disabled ? tokens.dim : tokens.fg;
   const divergence = row.ahead !== null && row.behind !== null && (row.ahead > 0 || row.behind > 0) ? ` · ↑${row.ahead} ↓${row.behind}` : "";
-  const prSegment = row.prNumber ? [
-    `· #${row.prNumber}`,
-    row.prState ?? "",
-    row.prChecks ? `(${row.prChecks})` : ""
-  ].filter(Boolean).join(" ") : "";
   const ownerSegment = row.owner ? ` · by ${row.owner}` : "";
+  const baseSegment = row.base ? ` · base ${row.base}` : "";
   const rebaseSegment = !row.isMainCheckout && row.rebaseStatus && !row.isPrunable ? ` · ${row.rebaseStatus}` : "";
+  const baseChangedSegment = row.baseChanged ? " · base moved" : "";
+  const hierarchyPrefix = row.hierarchyPrefix ?? "";
+  const secondaryIndent = " ".repeat(SECONDARY_INDENT.length + hierarchyPrefix.length);
   const secondary = [
-    `${SECONDARY_INDENT}${row.commitShort}`,
+    `${secondaryIndent}${row.commitShort}`,
     divergence,
-    prSegment,
-    ownerSegment
+    ownerSegment,
+    baseSegment
   ].filter(Boolean).join(" ").trimEnd();
   return /* @__PURE__ */ jsxs("box", {
     id,
@@ -25389,6 +25730,10 @@ function WorktreeItem({ row, isSelected, isMultiSelected, indicator, frame, id }
             fg: tokens.accent,
             children: isMultiSelected ? "✓ " : "  "
           }),
+          /* @__PURE__ */ jsx("span", {
+            fg: tokens.dim,
+            children: hierarchyPrefix
+          }),
           /* @__PURE__ */ jsx("span", {
             fg: primary,
             children: truncateBranch(row.branch)
@@ -25400,11 +25745,40 @@ function WorktreeItem({ row, isSelected, isMultiSelected, indicator, frame, id }
         ]
       }),
       /* @__PURE__ */ jsxs("text", {
+        ...row.prUrl ? prTap : {},
         children: [
           /* @__PURE__ */ jsx("span", {
             fg: tokens.dim,
             children: secondary
           }),
+          row.prNumber !== null && /* @__PURE__ */ jsxs(Fragment, {
+            children: [
+              /* @__PURE__ */ jsx("span", {
+                fg: tokens.dim,
+                children: secondary ? " · " : ""
+              }),
+              /* @__PURE__ */ jsx("span", {
+                fg: tokens.accent,
+                children: `#${row.prNumber}`
+              }),
+              row.prState && /* @__PURE__ */ jsx("span", {
+                fg: tokens.dim,
+                children: ` ${row.prState}`
+              }),
+              row.prChecks && /* @__PURE__ */ jsx("span", {
+                fg: tokens.dim,
+                children: ` (${row.prChecks})`
+              }),
+              row.prUrl && /* @__PURE__ */ jsx("span", {
+                fg: tokens.dim,
+                children: " ↗"
+              })
+            ]
+          }),
+          baseChangedSegment && /* @__PURE__ */ jsx("span", {
+            fg: tokens.warning,
+            children: baseChangedSegment
+          }),
           rebaseSegment && /* @__PURE__ */ jsx("span", {
             fg: tokens.error,
             children: rebaseSegment
@@ -25415,7 +25789,7 @@ function WorktreeItem({ row, isSelected, isMultiSelected, indicator, frame, id }
   });
 }
 function WorktreeTable({ blocks, selectedIndex, selection = new Set, frame, repoVerbs, rowVerbs }) {
-  const scrollRef = useRef2(null);
+  const scrollRef = useRef3(null);
   useEffect2(() => {
     if (scrollRef.current?.scrollChildIntoView) {
       scrollRef.current.scrollChildIntoView("selected-row");
@@ -25485,11 +25859,16 @@ function WorktreeTable({ blocks, selectedIndex, selection = new Set, frame, repo
 var SECONDARY_INDENT = "      ";
 var init_WorktreeTable = __esm(() => {
   init_theme();
+  init_use_tap();
 });
 
 // src/tui/components/DetailPane.tsx
-import { jsx as jsx2, jsxs as jsxs2, Fragment } from "@opentui/react/jsx-runtime";
+import { jsx as jsx2, jsxs as jsxs2, Fragment as Fragment2 } from "@opentui/react/jsx-runtime";
 function DetailPane({ selectedRow }) {
+  const prTap = useTapHandler(() => {
+    if (selectedRow?.prUrl)
+      openInBrowser(selectedRow.prUrl);
+  });
   if (!selectedRow) {
     return /* @__PURE__ */ jsx2("box", {
       id: "detail-pane",
@@ -25510,7 +25889,7 @@ function DetailPane({ selectedRow }) {
   const {
     repoName,
     branch,
-    path: path35,
+    path: path36,
     commitShort,
     isMainCheckout,
     isLocked,
@@ -25524,7 +25903,9 @@ function DetailPane({ selectedRow }) {
     prUrl,
     owner,
     rebaseStatus,
-    depsStrategy
+    depsStrategy,
+    base: base2,
+    baseChanged
   } = selectedRow;
   const aheadBehindStr = ahead !== null && behind !== null ? `${ahead} ahead, ${behind} behind` : "unknown";
   return /* @__PURE__ */ jsxs2("scrollbox", {
@@ -25579,7 +25960,7 @@ function DetailPane({ selectedRow }) {
             fg: tokens.fg,
             children: [
               "   ",
-              path35
+              path36
             ]
           })
         ]
@@ -25629,12 +26010,39 @@ function DetailPane({ selectedRow }) {
           })
         ]
       }),
+      base2 && /* @__PURE__ */ jsxs2("text", {
+        children: [
+          /* @__PURE__ */ jsx2("span", {
+            fg: tokens.dim,
+            children: "Base:"
+          }),
+          /* @__PURE__ */ jsxs2("span", {
+            fg: tokens.accent,
+            children: [
+              "   ",
+              base2
+            ]
+          })
+        ]
+      }),
+      baseChanged && /* @__PURE__ */ jsxs2("text", {
+        children: [
+          /* @__PURE__ */ jsx2("span", {
+            fg: tokens.dim,
+            children: "Base state:"
+          }),
+          /* @__PURE__ */ jsx2("span", {
+            fg: tokens.warning,
+            children: " moved since recorded"
+          })
+        ]
+      }),
       /* @__PURE__ */ jsxs2("text", {
         style: { marginTop: 1 },
         children: [
           /* @__PURE__ */ jsx2("span", {
             fg: tokens.dim,
-            children: "vs main:"
+            children: base2 ? "vs base:" : "vs main:"
           }),
           /* @__PURE__ */ jsxs2("span", {
             fg: tokens.fg,
@@ -25675,7 +26083,7 @@ function DetailPane({ selectedRow }) {
           })
         ]
       }),
-      prNumber !== null && /* @__PURE__ */ jsxs2(Fragment, {
+      prNumber !== null && /* @__PURE__ */ jsxs2(Fragment2, {
         children: [
           /* @__PURE__ */ jsxs2("text", {
             style: { marginTop: 1 },
@@ -25712,20 +26120,25 @@ function DetailPane({ selectedRow }) {
               })
             ]
           }),
-          prUrl && /* @__PURE__ */ jsxs2("text", {
-            children: [
-              /* @__PURE__ */ jsx2("span", {
-                fg: tokens.dim,
-                children: "URL:"
-              }),
-              /* @__PURE__ */ jsxs2("span", {
-                fg: tokens.fg,
-                children: [
-                  "    ",
-                  prUrl
-                ]
-              })
-            ]
+          prUrl && /* @__PURE__ */ jsx2("box", {
+            ...prTap,
+            children: /* @__PURE__ */ jsxs2("text", {
+              selectable: false,
+              children: [
+                /* @__PURE__ */ jsx2("span", {
+                  fg: tokens.dim,
+                  children: "URL:"
+                }),
+                /* @__PURE__ */ jsx2("span", {
+                  fg: tokens.accent,
+                  children: ` ${prUrl}`
+                }),
+                /* @__PURE__ */ jsx2("span", {
+                  fg: tokens.dim,
+                  children: " ↗ click"
+                })
+              ]
+            })
           })
         ]
       }),
@@ -25766,7 +26179,7 @@ function DetailPane({ selectedRow }) {
             fg: tokens.dim,
             children: "Actions:"
           }),
-          !isMainCheckout && /* @__PURE__ */ jsxs2(Fragment, {
+          !isMainCheckout && /* @__PURE__ */ jsxs2(Fragment2, {
             children: [
               /* @__PURE__ */ jsxs2("text", {
                 fg: tokens.dim,
@@ -25797,6 +26210,7 @@ function DetailPane({ selectedRow }) {
 }
 var init_DetailPane = __esm(() => {
   init_theme();
+  init_use_tap();
 });
 
 // src/tui/components/Footer.tsx
@@ -25843,11 +26257,15 @@ function Footer({ loading, lastRefreshed, errorCount, message, busyText, spinner
             ]
           }) : null,
           errorCount > 0 ? /* @__PURE__ */ jsxs3("text", {
-            fg: tokens.error,
             children: [
-              errorCount,
-              " error",
-              errorCount !== 1 ? "s" : ""
+              /* @__PURE__ */ jsx3("span", {
+                fg: tokens.error,
+                children: `${errorCount} error${errorCount !== 1 ? "s" : ""}`
+              }),
+              /* @__PURE__ */ jsx3("span", {
+                fg: tokens.dim,
+                children: " · e view"
+              })
             ]
           }) : null,
           /* @__PURE__ */ jsx3("text", {
@@ -25960,15 +26378,18 @@ var init_HelpOverlay = __esm(() => {
     ["n", "Create new worktree (pick dependency strategy)"],
     ["f", "Fetch main for selected repo(s)"],
     ["p", "Pull latest changes for selected branch(es)"],
-    ["b", "Rebase selected onto main"],
+    ["b", "Rebase selected onto base (or main)"],
     ["s", "Sync selected (env files + hooks)"],
-    ["i", "Install dependencies in selected worktree(s)"],
+    ["i", "Install dependencies in selection (worktrees and main)"],
     ["m", "Rename selected worktree (branch + directory)"],
     ["o", "Open selected in IDE"],
     ["a", "Spawn agent in selected"],
     ["d", "Remove selected worktree(s)"],
+    ["e", "View data warnings (when count > 0)"],
     ["r", "Refresh data"],
     ["H", "Action history"],
+    ["cmd+c / ctrl+shift+c", "Copy selected text to clipboard"],
+    ["click PR #/URL", "Open pull request in browser"],
     ["?", "Toggle help"],
     ["q/esc", "Quit"]
   ];
@@ -26136,38 +26557,38 @@ var init_ActionLogModal = __esm(() => {
 });
 
 // src/lib/history.ts
-import fs30 from "fs";
-import path35 from "path";
+import fs31 from "fs";
+import path36 from "path";
 import os4 from "os";
 function getHistoryDir() {
-  const stateHome = process.env.XDG_STATE_HOME ?? path35.join(os4.homedir(), ".local", "state");
-  return path35.join(stateHome, "wtx");
+  const stateHome = process.env.XDG_STATE_HOME ?? path36.join(os4.homedir(), ".local", "state");
+  return path36.join(stateHome, "wtx");
 }
 function getHistoryPath() {
-  return path35.join(getHistoryDir(), "history.jsonl");
+  return path36.join(getHistoryDir(), "history.jsonl");
 }
 function rotateHistory(maxBytes = HISTORY_MAX_BYTES, keepLines = HISTORY_ROTATE_KEEP_LINES) {
   const historyPath = getHistoryPath();
   let size = 0;
   try {
-    size = fs30.statSync(historyPath).size;
+    size = fs31.statSync(historyPath).size;
   } catch {
     return;
   }
   if (size <= maxBytes)
     return;
-  const lines = fs30.readFileSync(historyPath, "utf-8").split(`
+  const lines = fs31.readFileSync(historyPath, "utf-8").split(`
 `).filter(Boolean);
   const kept = lines.slice(-keepLines);
   const tmpPath = `${historyPath}.tmp.${process.pid}`;
   try {
-    fs30.writeFileSync(tmpPath, kept.length > 0 ? `${kept.join(`
+    fs31.writeFileSync(tmpPath, kept.length > 0 ? `${kept.join(`
 `)}
 ` : "", "utf-8");
-    fs30.renameSync(tmpPath, historyPath);
+    fs31.renameSync(tmpPath, historyPath);
   } catch (err) {
-    if (fs30.existsSync(tmpPath)) {
-      fs30.unlinkSync(tmpPath);
+    if (fs31.existsSync(tmpPath)) {
+      fs31.unlinkSync(tmpPath);
     }
     throw err;
   }
@@ -26175,18 +26596,18 @@ function rotateHistory(maxBytes = HISTORY_MAX_BYTES, keepLines = HISTORY_ROTATE_
 function appendHistory(entry) {
   try {
     const dir = getHistoryDir();
-    if (!fs30.existsSync(dir)) {
-      fs30.mkdirSync(dir, { recursive: true });
+    if (!fs31.existsSync(dir)) {
+      fs31.mkdirSync(dir, { recursive: true });
     }
     rotateHistory();
-    fs30.appendFileSync(getHistoryPath(), `${JSON.stringify(entry)}
+    fs31.appendFileSync(getHistoryPath(), `${JSON.stringify(entry)}
 `, "utf-8");
   } catch {}
 }
 function readRecentHistory(limit = 50) {
   let content;
   try {
-    content = fs30.readFileSync(getHistoryPath(), "utf-8");
+    content = fs31.readFileSync(getHistoryPath(), "utf-8");
   } catch {
     return [];
   }
@@ -26424,7 +26845,7 @@ var init_ChoiceModal = __esm(() => {
 // src/tui/components/ConfigOverlay.tsx
 import { useState as useState5, useEffect as useEffect4 } from "react";
 import { useKeyboard as useKeyboard2 } from "@opentui/react";
-import { jsx as jsx11, jsxs as jsxs10, Fragment as Fragment2 } from "@opentui/react/jsx-runtime";
+import { jsx as jsx11, jsxs as jsxs10, Fragment as Fragment3 } from "@opentui/react/jsx-runtime";
 function ConfigOverlay({ onClose, onSaved, onError }) {
   const [config2, setConfig] = useState5(null);
   const [viewState, setViewState] = useState5({ type: "main" });
@@ -26687,7 +27108,7 @@ function ConfigOverlay({ onClose, onSaved, onError }) {
       hint = "Remove this repository from config";
     }
   }
-  return /* @__PURE__ */ jsxs10(Fragment2, {
+  return /* @__PURE__ */ jsxs10(Fragment3, {
     children: [
       /* @__PURE__ */ jsx11(Overlay, {
         title: "Configuration",
@@ -26787,12 +27208,54 @@ function ConfigOverlay({ onClose, onSaved, onError }) {
 }
 var init_ConfigOverlay = __esm(() => {
   init_Overlay();
+  init_utils();
   init_theme();
   init_config();
   init_InputModal();
   init_ConfirmModal();
 });
 
+// src/tui/components/WarningsOverlay.tsx
+import { jsx as jsx12, jsxs as jsxs11 } from "@opentui/react/jsx-runtime";
+function WarningsOverlay({ warnings }) {
+  return /* @__PURE__ */ jsxs11(Overlay, {
+    title: `Warnings (${warnings.length})`,
+    borderColor: tokens.warning,
+    children: [
+      /* @__PURE__ */ jsx12("box", {
+        flexDirection: "column",
+        style: { maxHeight: 30 },
+        children: /* @__PURE__ */ jsx12("scrollbox", {
+          flexGrow: 1,
+          children: warnings.map((warning, i2) => /* @__PURE__ */ jsxs11("box", {
+            flexDirection: "column",
+            style: { marginBottom: 1 },
+            children: [
+              /* @__PURE__ */ jsx12("text", {
+                fg: tokens.warning,
+                children: `⚠ ${warning.repoName}`
+              }),
+              wrapText(warning.message, 56).map((line, j) => /* @__PURE__ */ jsx12("text", {
+                fg: tokens.fg,
+                children: `  ${line}`
+              }, j))
+            ]
+          }, i2))
+        })
+      }),
+      /* @__PURE__ */ jsx12("text", {
+        style: { marginTop: 1, fg: tokens.dim },
+        children: "Press any key to close"
+      })
+    ]
+  });
+}
+var init_WarningsOverlay = __esm(() => {
+  init_Overlay();
+  init_theme();
+  init_utils();
+});
+
 // src/tui/hooks/useSpinnerFrame.ts
 import { useEffect as useEffect5, useState as useState6 } from "react";
 function useSpinnerFrame(active) {
@@ -26811,9 +27274,9 @@ var init_useSpinnerFrame = __esm(() => {
 });
 
 // src/tui/components/App.tsx
-import { useState as useState7, useEffect as useEffect6, useMemo, useRef as useRef3, useCallback as useCallback2 } from "react";
+import { useState as useState7, useEffect as useEffect6, useMemo, useRef as useRef4, useCallback as useCallback3 } from "react";
 import { useKeyboard as useKeyboard3, useRenderer } from "@opentui/react";
-import { jsx as jsx12, jsxs as jsxs11 } from "@opentui/react/jsx-runtime";
+import { jsx as jsx13, jsxs as jsxs12 } from "@opentui/react/jsx-runtime";
 function getWorktreePathFor(repoName, branch) {
   try {
     const config2 = loadConfig();
@@ -26829,12 +27292,14 @@ function App({ opts }) {
   const [selectedIndex, setSelectedIndex] = useState7(0);
   const [modal, setModal] = useState7({ type: "none" });
   const [actionMessage, setActionMessage] = useState7();
-  const messageTimer = useRef3(null);
+  const messageTimer = useRef4(null);
   const [ops, setOps] = useState7([]);
   const [failedLogs, setFailedLogs] = useState7([]);
-  const nextOpId = useRef3(1);
+  const nextOpId = useRef4(1);
   const [createModal, setCreateModal] = useState7(false);
   const [createError, setCreateError] = useState7();
+  const [createBaseModal, setCreateBaseModal] = useState7(null);
+  const [createBaseError, setCreateBaseError] = useState7();
   const [createDepsChoice, setCreateDepsChoice] = useState7(null);
   const [renameModal, setRenameModal] = useState7(false);
   const [renameError, setRenameError] = useState7();
@@ -26843,7 +27308,7 @@ function App({ opts }) {
   const [filterText, setFilterText] = useState7("");
   const [isFiltering, setIsFiltering] = useState7(false);
   const [selection, setSelection] = useState7(new Set);
-  const doRefresh = useCallback2(async (scope) => {
+  const doRefresh = useCallback3(async (scope) => {
     const targets = scope ?? [
       ...new Set([...blocks.map((b) => b.repoName), ...pendingRepos])
     ];
@@ -26859,7 +27324,7 @@ function App({ opts }) {
       setModal({ type: "error", message: error52 });
     }
   }, [error52]);
-  const flash = useCallback2((message, ms = 3000) => {
+  const flash = useCallback3((message, ms = 3000) => {
     if (messageTimer.current)
       clearTimeout(messageTimer.current);
     setActionMessage(message);
@@ -26990,7 +27455,7 @@ function App({ opts }) {
     setOps((prev) => [...prev, op]);
     executeOp(op, ["fetch", "--repo", repoNames.join(",")], repoNames).then(() => setSelection(new Set));
   };
-  const startCreate = (branch, repoName, deps) => {
+  const startCreate = (branch, repoName, deps, base2) => {
     const op = {
       id: nextOpId.current++,
       kind: "create",
@@ -27003,6 +27468,8 @@ function App({ opts }) {
     };
     setOps((prev) => [...prev, op]);
     const args = ["create", branch, "--repo", repoName];
+    if (base2)
+      args.push("--base", base2);
     if (deps && deps !== "auto")
       args.push("--deps", deps);
     executeOp(op, args, [repoName]);
@@ -27031,6 +27498,13 @@ function App({ opts }) {
       }
       return;
     }
+    if (createBaseModal) {
+      if (key.name === "escape") {
+        setCreateBaseModal(null);
+        setCreateBaseError(undefined);
+      }
+      return;
+    }
     if (createDepsChoice)
       return;
     if (renameModal) {
@@ -27041,7 +27515,7 @@ function App({ opts }) {
       return;
     }
     if (modal.type !== "none") {
-      if (modal.type === "error" || modal.type === "help" || modal.type === "history") {
+      if (modal.type === "error" || modal.type === "help" || modal.type === "history" || modal.type === "warnings") {
         setModal({ type: "none" });
         if (modal.type === "error" && error52) {
           renderer.destroy();
@@ -27089,6 +27563,15 @@ function App({ opts }) {
         return;
       }
     }
+    if ((key.super || key.meta || key.ctrl && key.shift) && key.name === "c") {
+      const text = renderer.getSelection()?.getSelectedText() ?? "";
+      if (!text) {
+        flash("Nothing selected to copy");
+        return;
+      }
+      copyTextToClipboard(renderer, text).then((ok) => flash(ok ? `Copied ${text.length} character${text.length !== 1 ? "s" : ""}` : "Copy failed"));
+      return;
+    }
     if (key.name === "q" || key.name === "escape" || key.name === "c" && key.ctrl) {
       if (key.name === "escape" && selection.size > 0) {
         setSelection(new Set);
@@ -27131,6 +27614,10 @@ function App({ opts }) {
       }
       return;
     }
+    if (key.name === "e" && warnings.length > 0) {
+      setModal({ type: "warnings" });
+      return;
+    }
     if (key.name === "n") {
       if (!selectedRow)
         return;
@@ -27154,16 +27641,12 @@ function App({ opts }) {
       const targets = getSelectedRows();
       if (targets.length === 0)
         return;
-      if (targets.some((r) => r.isMainCheckout)) {
-        flash("Cannot install deps on main checkout");
-        return;
-      }
       const conflict = findConflict(targets);
       if (conflict) {
         flash(conflict);
         return;
       }
-      startBatchActions("install", targets, (r) => ["deps", r.branch, "--repo", r.repoName, "--install"]);
+      startBatchActions("install", targets, (r) => r.isMainCheckout ? ["deps", "--repo", r.repoName, "--install"] : ["deps", r.branch, "--repo", r.repoName, "--install"]);
       return;
     }
     if (key.name === "m") {
@@ -27312,17 +27795,17 @@ function App({ opts }) {
       })();
     }
   });
-  return /* @__PURE__ */ jsxs11("box", {
+  return /* @__PURE__ */ jsxs12("box", {
     flexDirection: "column",
     width: "100%",
     height: "100%",
     children: [
-      /* @__PURE__ */ jsxs11("box", {
+      /* @__PURE__ */ jsxs12("box", {
         flexDirection: "row",
         width: "100%",
         flexGrow: 1,
         children: [
-          /* @__PURE__ */ jsx12(WorktreeTable, {
+          /* @__PURE__ */ jsx13(WorktreeTable, {
             blocks: displayBlocks,
             selectedIndex,
             selection,
@@ -27330,28 +27813,28 @@ function App({ opts }) {
             repoVerbs,
             rowVerbs
           }),
-          /* @__PURE__ */ jsx12(DetailPane, {
+          /* @__PURE__ */ jsx13(DetailPane, {
             selectedRow
           })
         ]
       }),
-      isFiltering && /* @__PURE__ */ jsxs11("box", {
+      isFiltering && /* @__PURE__ */ jsxs12("box", {
         flexDirection: "row",
         paddingX: 1,
         border: true,
         borderColor: "magenta",
         children: [
-          /* @__PURE__ */ jsx12("text", {
+          /* @__PURE__ */ jsx13("text", {
             children: "filter: "
           }),
-          /* @__PURE__ */ jsx12("input", {
+          /* @__PURE__ */ jsx13("input", {
             focused: true,
             placeholder: "Type to filter...",
             onInput: (v) => setFilterText(v)
           })
         ]
       }),
-      /* @__PURE__ */ jsx12(Footer, {
+      /* @__PURE__ */ jsx13(Footer, {
         loading: loading || refreshing,
         lastRefreshed,
         errorCount: warnings.length,
@@ -27360,13 +27843,16 @@ function App({ opts }) {
         spinnerFrame,
         filter: filterText ? { term: filterText, matches: flatRows.length, total: totalRows } : undefined
       }),
-      modal.type === "help" && /* @__PURE__ */ jsx12(HelpOverlay, {}),
-      modal.type === "history" && /* @__PURE__ */ jsx12(HistoryOverlay, {}),
-      modal.type === "error" && /* @__PURE__ */ jsx12(ConfirmModal, {
+      modal.type === "help" && /* @__PURE__ */ jsx13(HelpOverlay, {}),
+      modal.type === "history" && /* @__PURE__ */ jsx13(HistoryOverlay, {}),
+      modal.type === "warnings" && /* @__PURE__ */ jsx13(WarningsOverlay, {
+        warnings
+      }),
+      modal.type === "error" && /* @__PURE__ */ jsx13(ConfirmModal, {
         title: "Error",
         message: modal.message
       }),
-      modal.type === "confirm_remove" && /* @__PURE__ */ jsx12(ConfirmModal, {
+      modal.type === "confirm_remove" && /* @__PURE__ */ jsx13(ConfirmModal, {
         title: `Remove ${modal.rows.length} Worktree(s)`,
         message: (() => {
           const count2 = modal.rows.length;
@@ -27383,15 +27869,15 @@ function App({ opts }) {
 `);
         })()
       }),
-      modal.type === "confirm_rebase" && /* @__PURE__ */ jsx12(ConfirmModal, {
+      modal.type === "confirm_rebase" && /* @__PURE__ */ jsx13(ConfirmModal, {
         title: `Rebase ${modal.rows.length} Worktree(s)`,
         message: `Are you sure you want to fetch and rebase ${modal.rows.length === 1 ? modal.rows[0]?.branch : modal.rows.length + " worktrees"}?`
       }),
-      modal.type === "confirm_sync" && /* @__PURE__ */ jsx12(ConfirmModal, {
+      modal.type === "confirm_sync" && /* @__PURE__ */ jsx13(ConfirmModal, {
         title: `Sync ${modal.rows.length} Worktree(s)`,
         message: `Are you sure you want to sync ${modal.rows.length === 1 ? modal.rows[0]?.branch : modal.rows.length + " worktrees"}?`
       }),
-      createModal && /* @__PURE__ */ jsx12(InputModal, {
+      createModal && /* @__PURE__ */ jsx13(InputModal, {
         title: `New worktree branch in ${selectedRow?.repoName ?? ""}`,
         placeholder: "Branch name (empty to cancel)",
         errorMessage: createError,
@@ -27414,20 +27900,37 @@ function App({ opts }) {
           }
           setCreateModal(false);
           setCreateError(undefined);
-          setCreateDepsChoice({ branch, repoName });
+          setCreateBaseError(undefined);
+          setCreateBaseModal({ branch, repoName });
+        }
+      }),
+      createBaseModal && /* @__PURE__ */ jsx13(InputModal, {
+        title: `Base ref for ${createBaseModal.branch}`,
+        placeholder: "origin/main (empty for default main)",
+        errorMessage: createBaseError,
+        onSubmit: (value) => {
+          const base2 = value.trim();
+          if (base2 && !validateSafeBranchName(base2)) {
+            setCreateBaseError("Invalid base ref");
+            return;
+          }
+          const { branch, repoName } = createBaseModal;
+          setCreateBaseModal(null);
+          setCreateBaseError(undefined);
+          setCreateDepsChoice({ branch, repoName, base: base2 || undefined });
         }
       }),
-      createDepsChoice && /* @__PURE__ */ jsx12(ChoiceModal, {
+      createDepsChoice && /* @__PURE__ */ jsx13(ChoiceModal, {
         title: `Dependencies for ${createDepsChoice.branch}`,
         options: DEPS_CHOICES,
         onSubmit: (choice) => {
-          const { branch, repoName } = createDepsChoice;
+          const { branch, repoName, base: base2 } = createDepsChoice;
           setCreateDepsChoice(null);
-          startCreate(branch, repoName, choice);
+          startCreate(branch, repoName, choice, base2);
         },
         onCancel: () => setCreateDepsChoice(null)
       }),
-      renameModal && selectedRow && /* @__PURE__ */ jsx12(InputModal, {
+      renameModal && selectedRow && /* @__PURE__ */ jsx13(InputModal, {
         title: `Rename branch ${selectedRow.branch}`,
         placeholder: `New branch name (${selectedRow.branch})`,
         errorMessage: renameError,
@@ -27451,7 +27954,7 @@ function App({ opts }) {
           setModal({ type: "confirm_rename", row: target, to });
         }
       }),
-      modal.type === "confirm_rename" && /* @__PURE__ */ jsx12(ConfirmModal, {
+      modal.type === "confirm_rename" && /* @__PURE__ */ jsx13(ConfirmModal, {
         title: "Rename Worktree",
         message: [
           `${modal.row.branch} → ${modal.to}`,
@@ -27464,12 +27967,12 @@ function App({ opts }) {
         ].join(`
 `)
       }),
-      configOpen && /* @__PURE__ */ jsx12(ConfigOverlay, {
+      configOpen && /* @__PURE__ */ jsx13(ConfigOverlay, {
         onClose: () => setConfigOpen(false),
         onSaved: () => void doRefresh(),
         onError: (msg) => setModal({ type: "error", message: msg })
       }),
-      failedLogs.length > 0 && /* @__PURE__ */ jsx12(ActionLogModal, {
+      failedLogs.length > 0 && /* @__PURE__ */ jsx13(ActionLogModal, {
         title: failedLogs[0].title,
         lines: failedLogs[0].lines,
         done: true,
@@ -27493,6 +27996,8 @@ var init_App = __esm(() => {
   init_InputModal();
   init_ChoiceModal();
   init_ConfigOverlay();
+  init_WarningsOverlay();
+  init_utils();
   init_agents();
   init_config();
   init_history();
@@ -27522,14 +28027,14 @@ __export(exports_tui, {
 });
 import { createCliRenderer, TextTableRenderable } from "@opentui/core";
 import { createRoot, extend as extend2 } from "@opentui/react";
-import { jsx as jsx13 } from "@opentui/react/jsx-runtime";
+import { jsx as jsx14 } from "@opentui/react/jsx-runtime";
 async function runTerminal(opts) {
   const renderer = await createCliRenderer({
     exitOnCtrlC: false
   });
   const root = createRoot(renderer);
   try {
-    root.render(/* @__PURE__ */ jsx13(App, {
+    root.render(/* @__PURE__ */ jsx14(App, {
       opts
     }));
   } catch (err) {
@@ -29661,8 +30166,8 @@ Run 'wtx config show' to see available repos.`);
 init_config();
 init_log();
 init_git();
-import fs20 from "fs";
-import path26 from "path";
+import fs21 from "fs";
+import path27 from "path";
 
 // src/lib/remotes.ts
 init_execa();
@@ -29727,6 +30232,7 @@ function resolveBranchTarget(input) {
 }
 
 // src/commands/create.ts
+init_stack();
 init_resolver();
 
 // src/lib/ide.ts
@@ -29742,14 +30248,14 @@ function spawnIde(ide, wtPath) {
 // src/lib/worktree-setup.ts
 init_execa();
 init_log();
-import fs9 from "fs";
-import path16 from "path";
+import fs10 from "fs";
+import path17 from "path";
 
 // src/lib/ports.ts
 init_git();
 init_path_safety();
 init_config();
-import fs8 from "fs";
+import fs9 from "fs";
 function hashPort(key, min, max) {
   let h2 = 2166136261;
   for (let i2 = 0;i2 < key.length; i2++) {
@@ -29784,7 +30290,7 @@ async function getWorktreePort(repoName, branch, config2, currentWtPath) {
   const taken = new Set;
   for (const name of allRepos) {
     const mainPath = `${root}/${name}`;
-    if (!fs8.existsSync(mainPath)) {
+    if (!fs9.existsSync(mainPath)) {
       continue;
     }
     let wts = [];
@@ -29815,12 +30321,12 @@ async function runPostCreateSetup(params) {
   let hooks = [];
   if (repo.config.sync_files && repo.config.sync_files.length > 0) {
     for (const file2 of repo.config.sync_files) {
-      const src = path16.join(repo.mainPath, file2);
-      const dest = path16.join(wtPath, file2);
-      if (fs9.existsSync(src)) {
+      const src = path17.join(repo.mainPath, file2);
+      const dest = path17.join(wtPath, file2);
+      if (fs10.existsSync(src)) {
         if (!globalOpts.dryRun) {
-          fs9.mkdirSync(path16.dirname(dest), { recursive: true });
-          fs9.copyFileSync(src, dest);
+          fs10.mkdirSync(path17.dirname(dest), { recursive: true });
+          fs10.copyFileSync(src, dest);
           copiedFiles.push(file2);
         }
         stepSuccess(`Synced ${file2}`);
@@ -29948,9 +30454,6 @@ function registerCreateCommand(program2) {
           openWorktree(wtPath);
           continue;
         }
-        if (!globalOpts.dryRun) {
-          fs20.mkdirSync(path26.dirname(wtPath), { recursive: true });
-        }
         const mainBranch = await resolveMainBranch(repo, config2);
         const resolvedRemote = await resolveBaseRemote(repo.mainPath, mainBranch);
         if (repo.config.fetch_main_on_create) {
@@ -29961,6 +30464,19 @@ function registerCreateCommand(program2) {
         }
         stepProgress("Checking branch status...");
         const baseRef = options.base || `${resolvedRemote}/${mainBranch}`;
+        if (baseRef === branch || baseRef === `refs/heads/${branch}`) {
+          throw new Error(`Base ref '${baseRef}' cannot be the new branch '${branch}'`);
+        }
+        let baseSha = null;
+        if (!globalOpts.dryRun) {
+          baseSha = await resolveCommitSha(repo.mainPath, baseRef, globalOpts);
+          stepSuccess("Base resolved", `${baseRef} at ${baseSha.substring(0, 7)}`);
+        } else {
+          stepProgress("Using base", baseRef);
+        }
+        if (!globalOpts.dryRun) {
+          fs21.mkdirSync(path27.dirname(wtPath), { recursive: true });
+        }
         const localSha = await getLocalBranchSha(repo.mainPath, branch, globalOpts);
         const remoteSha = await getRemoteBranchSha(repo.mainPath, resolvedRemote, branch, globalOpts);
         const localExists = localSha !== null;
@@ -30021,6 +30537,21 @@ function registerCreateCommand(program2) {
           throw err;
         }
         stepSuccess("Worktree created", wtPath);
+        if (!globalOpts.dryRun && baseSha && resolvedAction.kind === "create-new") {
+          try {
+            const metadataBaseRef = options.base ? baseRef : mainBranch;
+            await recordStackEntry(repo.mainPath, branch, {
+              baseRef: metadataBaseRef,
+              baseSha,
+              explicit: options.base !== undefined,
+              createdAt: new Date().toISOString()
+            }, globalOpts);
+            stepSuccess("Base recorded", metadataBaseRef);
+          } catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            stepWarning("Base metadata not recorded", message);
+          }
+        }
         const setupResult = await runPostCreateSetup({ config: config2, repo, wtPath, branch, globalOpts });
         if (options.deps && options.deps !== "auto" && options.deps !== "link" && options.deps !== "off") {
           const ok = await applyDepsStrategy(options.deps, wtPath, repo.mainPath, globalOpts);
@@ -30088,9 +30619,10 @@ init_config();
 init_log();
 init_git();
 init_resolver();
-import fs21 from "fs";
-import path27 from "path";
+import fs22 from "fs";
+import path28 from "path";
 init_forge();
+init_stack();
 function registerPullCommand(program2) {
   program2.command("pull <link>").description("Fetch a forge PR and create its worktree").option("-r, --repo <repos...>", "Target specific repo").action(async (link, options) => {
     const globalOpts = program2.opts();
@@ -30112,7 +30644,7 @@ function registerPullCommand(program2) {
       for (const name of Object.keys(config2.repos).sort()) {
         if (config2.repos[name].check_prs === false)
           continue;
-        const mainPath = path27.join(expandTilde(config2.root), name);
+        const mainPath = path28.join(expandTilde(config2.root), name);
         const detected = detectRepoForge(mainPath);
         if (!detected)
           continue;
@@ -30210,10 +30742,22 @@ function registerPullCommand(program2) {
         summaryWarning(`Nothing pulled — branch '${branch}' already exists`);
         return;
       }
-      const baseRemote = await resolveBaseRemote(target.mainPath, target.config.main_branch === "auto" ? config2.default_main_branch : target.config.main_branch);
+      const mainBranch = await resolveMainBranch(target, config2);
+      const baseRemote = await resolveBaseRemote(target.mainPath, mainBranch);
+      const baseBranch = head.baseRefName || mainBranch;
+      const baseRef = `${baseRemote}/${baseBranch}`;
       const fetch = adapter.buildHeadFetch(head);
       stepProgress(fetch.url ? `Fetching ${fetch.refspec} from fork...` : `Fetching pull/${head.number}/head from ${baseRemote}...`);
       try {
+        if (baseBranch !== mainBranch) {
+          try {
+            await gitExec(["-C", target.mainPath, "fetch", baseRemote, "--", baseBranch], { verbose: globalOpts.verbose, dryRun: globalOpts.dryRun });
+          } catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            stepWarning("PR base was not fetched", message.split(`
+`)[0] ?? message);
+          }
+        }
         await gitExec([
           "-C",
           target.mainPath,
@@ -30227,7 +30771,7 @@ function registerPullCommand(program2) {
       }
       stepSuccess("Fetched");
       if (!globalOpts.dryRun) {
-        fs21.mkdirSync(path27.dirname(wtPath), { recursive: true });
+        fs22.mkdirSync(path28.dirname(wtPath), { recursive: true });
       }
       try {
         await gitExec(["-C", target.mainPath, "worktree", "add", "-b", branch, wtPath, "FETCH_HEAD"], { verbose: globalOpts.verbose, dryRun: globalOpts.dryRun });
@@ -30241,6 +30785,22 @@ function registerPullCommand(program2) {
         throw err;
       }
       stepSuccess("Worktree created", wtPath);
+      if (!globalOpts.dryRun) {
+        try {
+          const baseSha = await resolveCommitSha(target.mainPath, baseRef, globalOpts);
+          const metadataBaseRef = baseBranch === mainBranch ? mainBranch : baseRef;
+          await recordStackEntry(target.mainPath, branch, {
+            baseRef: metadataBaseRef,
+            baseSha,
+            explicit: baseBranch !== mainBranch,
+            createdAt: new Date().toISOString()
+          }, globalOpts);
+          stepSuccess("Base recorded", metadataBaseRef);
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          stepWarning("Base metadata not recorded", message);
+        }
+      }
       const setupResult = await runPostCreateSetup({ config: config2, repo: target, wtPath, branch, globalOpts });
       const failedHooks = setupResult.hooks.filter((h2) => !h2.ok);
       if (failedHooks.length > 0) {
@@ -30346,7 +30906,7 @@ init_log();
 init_git();
 init_resolver();
 init_path_safety();
-import path28 from "path";
+import path29 from "path";
 
 // src/lib/prompts.ts
 import * as readline2 from "readline";
@@ -30389,6 +30949,7 @@ async function confirm(message, io) {
 }
 
 // src/commands/remove.ts
+init_stack();
 function registerRemoveCommand(program2) {
   program2.command("remove <branch>").description("Remove worktree(s)").option("-r, --repo <repos...>", "Target specific repo(s)").option("-f, --force", "Force removal even if there are uncommitted changes").option("-y, --yes", "Skip confirmation prompt").action(async (branch, options) => {
     const globalOpts = program2.opts();
@@ -30413,6 +30974,16 @@ function registerRemoveCommand(program2) {
           continue;
         }
         const wtPath = target.path;
+        const stackMetadata = await readStackMetadata(repo.mainPath, globalOpts);
+        const children = getStackChildren(stackMetadata, branch);
+        if (children.length > 0 && !options.force) {
+          stepError("Worktree has dependent branches", `${children.join(", ")} — retarget or remove them first (use --force to override)`);
+          skipCount++;
+          continue;
+        }
+        if (children.length > 0) {
+          stepWarning("Removing a parent with dependent branches", children.join(", "));
+        }
         if (!options.force && !globalOpts.dryRun) {
           try {
             const dirtyFiles = await getDirtyFiles(wtPath);
@@ -30443,7 +31014,7 @@ function registerRemoveCommand(program2) {
             const toClean = planEmptyParentRemoval(repo.wtRoot, repo.mainPath, wtPath);
             indented(`Will remove worktree: ${wtPath}`);
             for (const dir of toClean) {
-              indented(`Will clean up empty dir: ${path28.relative(repo.wtRoot, dir)}/`);
+              indented(`Will clean up empty dir: ${path29.relative(repo.wtRoot, dir)}/`);
             }
             const proceed = await confirm("Are you sure you want to delete these?");
             if (!proceed) {
@@ -30473,9 +31044,18 @@ function registerRemoveCommand(program2) {
         if (!globalOpts.dryRun) {
           const removedDirs = cleanupEmptyParents(repo.wtRoot, repo.mainPath, wtPath);
           for (const dir of removedDirs) {
-            stepSuccess("Cleaned up empty directory", path28.relative(repo.wtRoot, dir) + "/");
+            stepSuccess("Cleaned up empty directory", path29.relative(repo.wtRoot, dir) + "/");
           }
         }
+        try {
+          await removeStackEntry(repo.mainPath, branch, globalOpts);
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          stepWarning("Stack metadata not removed", message);
+        }
+        if (children.length > 0) {
+          stepWarning("Dependent base metadata retained", children.join(", "));
+        }
         successCount++;
       } catch (err) {
         stepError("Failed to remove worktree", err.message);
@@ -30499,7 +31079,7 @@ init_log();
 init_git();
 init_resolver();
 init_forge();
-import path29 from "path";
+import path30 from "path";
 
 // src/lib/prune.ts
 function selectMergedCandidates(worktrees, mainPath, prMap) {
@@ -30517,6 +31097,7 @@ function selectMergedCandidates(worktrees, mainPath, prMap) {
 
 // src/commands/prune.ts
 init_path_safety();
+init_stack();
 function registerPruneCommand(program2) {
   program2.command("prune").description("Remove worktrees whose branch has a merged PR").option("-r, --repo <repos...>", "Target specific repo(s)").option("-f, --force", "Remove even if there are uncommitted changes").option("-y, --yes", "Skip confirmation prompt").action(async (options) => {
     const globalOpts = program2.opts();
@@ -30540,6 +31121,7 @@ function registerPruneCommand(program2) {
       }
       try {
         const worktrees = await getWorktreeList(repo.mainPath);
+        const stackMetadata = await readStackMetadata(repo.mainPath, globalOpts);
         const branches = worktrees.filter((wt) => wt.path !== repo.mainPath && wt.branch).map((wt) => wt.branch);
         if (branches.length === 0) {
           continue;
@@ -30564,6 +31146,15 @@ function registerPruneCommand(program2) {
             continue;
           }
           const wtInfo = worktrees.find((wt) => wt.path === candidate.path);
+          const children = getStackChildren(stackMetadata, candidate.branch);
+          if (children.length > 0 && !options.force) {
+            stepWarning("Skipped — branch has dependent worktrees", `${label}: ${children.join(", ")}`);
+            skippedCount++;
+            continue;
+          }
+          if (children.length > 0) {
+            stepWarning("Pruning parent with dependent worktrees", `${label}: ${children.join(", ")}`);
+          }
           if (wtInfo?.isLocked && !options.force) {
             stepWarning("Skipped — worktree is locked \uD83D\uDD12", label);
             skippedCount++;
@@ -30644,9 +31235,15 @@ function registerPruneCommand(program2) {
       if (!globalOpts.dryRun) {
         const removedDirs = cleanupEmptyParents(repo.wtRoot, repo.mainPath, candidate.path);
         for (const dir of removedDirs) {
-          stepSuccess("Cleaned up empty directory", path29.relative(repo.wtRoot, dir) + "/");
+          stepSuccess("Cleaned up empty directory", path30.relative(repo.wtRoot, dir) + "/");
         }
       }
+      try {
+        await removeStackEntry(repo.mainPath, candidate.branch, globalOpts);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        stepWarning("Stack metadata not removed", message);
+      }
       removedCount++;
     }
     if (removedCount === 0 && skippedCount === 0) {
@@ -30713,13 +31310,15 @@ function formatRelativeTime(isoTimestamp) {
 // src/commands/ls.ts
 init_owner();
 init_source();
-import path30 from "path";
-import fs22 from "fs";
+init_stack();
+init_stack();
+import path31 from "path";
+import fs23 from "fs";
 function buildLsJson(reposData) {
   const result = [];
   for (const repo of reposData) {
     for (const wt of repo.worktrees) {
-      const branch = wt.branch || path30.basename(wt.path);
+      const branch = wt.branch || path31.basename(wt.path);
       const sha = (wt.commit || "0000000").substring(0, 7);
       let status = "clean";
       if (wt.path === repo.mainPath) {
@@ -30746,6 +31345,8 @@ function buildLsJson(reposData) {
         }
       }
       const entry = { repo: repo.name, branch, sha, status };
+      if (wt.base)
+        entry.base = wt.base;
       if (pr)
         entry.pr = pr;
       if (ownerStr)
@@ -30784,7 +31385,7 @@ function registerLsCommand(program2) {
         };
         try {
           const worktrees = await getWorktreeList(repo.mainPath);
-          const maxBranchLen = Math.max(...worktrees.map((wt) => (wt.branch || "main").length));
+          const stackMetadata = await readStackMetadata(repo.mainPath, globalOpts);
           let prMap = null;
           if (options.pr) {
             const branches = worktrees.filter((wt) => wt.path !== repo.mainPath && wt.branch).map((wt) => wt.branch);
@@ -30799,9 +31400,20 @@ function registerLsCommand(program2) {
               }
             }
           }
-          for (const wt of worktrees) {
-            const branch = wt.branch || path30.basename(wt.path);
-            const paddedBranch = branch.padEnd(maxBranchLen + 2);
+          const displayItems = buildStackHierarchy(worktrees, (wt) => wt.branch || path31.basename(wt.path), (wt) => {
+            const branch = wt.branch || path31.basename(wt.path);
+            return stackMetadata.branches[branch]?.baseRef ?? prMap?.get(branch)?.baseRefName;
+          }, (a2, b) => {
+            if (a2.path === repo.mainPath && b.path !== repo.mainPath)
+              return -1;
+            if (a2.path !== repo.mainPath && b.path === repo.mainPath)
+              return 1;
+            return (a2.branch || path31.basename(a2.path)).localeCompare(b.branch || path31.basename(b.path));
+          });
+          const maxBranchLen = Math.max(0, ...displayItems.map(({ item, prefix }) => `${prefix}${item.branch || path31.basename(item.path)}`.length));
+          for (const { item: wt, prefix } of displayItems) {
+            const branch = wt.branch || path31.basename(wt.path);
+            const paddedBranch = `${prefix}${branch}`.padEnd(maxBranchLen + 2);
             const hash2 = (wt.commit || "0000000").substring(0, 7);
             let statusStr = source_default.dim("clean");
             let isMissing = false;
@@ -30811,7 +31423,7 @@ function registerLsCommand(program2) {
               statusStr = source_default.blue("[main checkout]");
             } else if (wt.isLocked) {
               statusStr = source_default.red("locked \uD83D\uDD12");
-            } else if (fs22.existsSync(wt.path)) {
+            } else if (fs23.existsSync(wt.path)) {
               try {
                 dirtyFiles = await getDirtyFiles(wt.path);
                 if (dirtyFiles.length > 0) {
@@ -30829,9 +31441,11 @@ function registerLsCommand(program2) {
             const prInfo = prMap?.get(branch);
             if (prInfo) {
               const display = derivePrDisplay(prInfo);
-              prSegment = `  #${prInfo.number} ${renderDisplayState(display)}  ${source_default.dim(prInfo.url)}`;
+              prSegment = `  #${prInfo.number} ${renderDisplayState(display)}  ${source_default.dim(terminalLink(prInfo.url))}`;
             }
             let ownerSuffix = "";
+            const baseRef = wt.branch ? stackMetadata.branches[wt.branch]?.baseRef ?? prInfo?.baseRefName : prInfo?.baseRefName;
+            const baseSuffix = baseRef ? `  base ${baseRef}` : "";
             let ownership = null;
             if (wt.path !== repo.mainPath) {
               ownership = await resolveOwnership({
@@ -30851,13 +31465,14 @@ function registerLsCommand(program2) {
               path: wt.path,
               branch: wt.branch,
               commit: wt.commit,
+              base: baseRef,
               isLocked: wt.isLocked,
               dirtyFiles,
               isMissing,
               isError
             });
             if (!options.json) {
-              info(`  ${paddedBranch} ${hash2}  ${statusStr}${prSegment}${ownerSuffix}`);
+              info(`  ${paddedBranch} ${hash2}  ${statusStr}${baseSuffix}${prSegment}${ownerSuffix}`);
             }
           }
         } catch (err) {
@@ -30934,10 +31549,11 @@ end
 init_config();
 init_log();
 init_git();
-import fs23 from "fs";
+import fs24 from "fs";
 init_resolver();
+init_stack();
 function registerRebaseCommand(program2) {
-  program2.command("rebase <branch>").description("fetch + rebase vs main branch").option("--repo <repos...>", "comma-separated list of repos to target").action(async (branch, _options, cmd) => {
+  program2.command("rebase <branch>").description("fetch + rebase worktree onto its base").option("--repo <repos...>", "comma-separated list of repos to target").option("--onto <ref>", "Override the recorded base ref for this rebase").action(async (branch, options, cmd) => {
     const opts = cmd.optsWithGlobals();
     const config2 = loadConfig();
     const targetRepos = parseRepoFlag(opts.repo);
@@ -30948,30 +31564,58 @@ function registerRebaseCommand(program2) {
       repoHeader(repo.name);
       const mainBranch = await resolveMainBranch(repo, config2);
       const wtPath = getWorktreePath(repo, branch);
-      if (!fs23.existsSync(wtPath)) {
+      if (!fs24.existsSync(wtPath)) {
         stepError("No worktree found", `${wtPath} (skipped)`);
         failCount++;
         continue;
       }
       let rebaseStarted = false;
       try {
-        const resolvedRemote = await resolveBaseRemote(repo.mainPath, mainBranch);
-        await gitExec(["-C", repo.mainPath, "fetch", resolvedRemote, "--", mainBranch], opts);
-        const commit = await getLatestCommit(repo.mainPath, `${resolvedRemote}/${mainBranch}`);
-        stepProgress(`Fetching ${resolvedRemote}/${mainBranch}...`, `${commit.hash} "${commit.subject}"`);
-        stepProgress(`Rebasing ${branch} onto main...`);
+        const metadata = await readStackMetadata(repo.mainPath, opts);
+        const recorded = metadata.branches[branch];
+        const resolvedRemote = !options.onto && !recorded?.explicit ? await resolveBaseRemote(repo.mainPath, mainBranch) : undefined;
+        const defaultBase = resolvedRemote ? `${resolvedRemote}/${mainBranch}` : mainBranch;
+        const baseRef = options.onto || (recorded?.explicit ? recorded.baseRef : defaultBase);
+        const shouldFetchMain = !options.onto && (!recorded || !recorded.explicit);
+        if (shouldFetchMain) {
+          if (!resolvedRemote) {
+            throw new Error(`Could not determine the remote for base branch '${mainBranch}'`);
+          }
+          await gitExec(["-C", repo.mainPath, "fetch", resolvedRemote, "--", mainBranch], opts);
+          const commit = await getLatestCommit(repo.mainPath, defaultBase);
+          stepProgress(`Fetching ${resolvedRemote}/${mainBranch}...`, `${commit.hash} "${commit.subject}"`);
+        } else {
+          stepProgress("Using recorded base", baseRef);
+        }
+        const baseSha = await resolveCommitSha(repo.mainPath, baseRef, opts);
+        stepProgress(`Rebasing ${branch} onto ${baseRef}...`);
         rebaseStarted = true;
-        const rebaseOut = await gitExec(["-C", wtPath, "rebase", "--", `${resolvedRemote}/${mainBranch}`], opts);
+        const rebaseOut = await gitExec(["-C", wtPath, "rebase", "--", baseRef], opts);
         if (rebaseOut.includes("is up to date") || rebaseOut.includes("up-to-date")) {
           stepSuccess("Up to date", "0 commits replayed");
         } else {
-          const count2 = await gitExec(["-C", wtPath, "rev-list", "--count", `${resolvedRemote}/${mainBranch}..HEAD`], opts).then((s) => s.trim());
+          const count2 = await gitExec(["-C", wtPath, "rev-list", "--count", `${baseRef}..HEAD`], opts).then((s) => s.trim());
           stepSuccess("Rebased", `${count2} commits replayed`);
         }
+        if (recorded || options.onto) {
+          const metadataBaseRef = options.onto || (recorded?.explicit ? baseRef : mainBranch);
+          try {
+            await recordStackEntry(repo.mainPath, branch, {
+              baseRef: metadataBaseRef,
+              baseSha,
+              explicit: options.onto ? true : recorded?.explicit ?? true,
+              createdAt: recorded?.createdAt || new Date().toISOString()
+            }, opts);
+            stepSuccess("Base recorded", metadataBaseRef);
+          } catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            stepWarning("Base metadata not updated", message);
+          }
+        }
         successCount++;
       } catch (err) {
         if (!rebaseStarted) {
-          stepError("Rebase skipped — could not fetch base branch:", err.message.split(`
+          stepError("Rebase skipped — could not resolve base:", err.message.split(`
 `)[0] ?? err.message);
           failCount++;
           continue;
@@ -31046,8 +31690,8 @@ init_execa();
 init_config();
 init_log();
 init_resolver();
-import fs24 from "fs";
-import path31 from "path";
+import fs25 from "fs";
+import path32 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) => {
     const opts = cmd.optsWithGlobals();
@@ -31058,19 +31702,19 @@ function registerSyncCommand(program2) {
     for (const repo of repos) {
       repoHeader(repo.name);
       const wtPath = getWorktreePath(repo, branch);
-      if (!fs24.existsSync(wtPath)) {
+      if (!fs25.existsSync(wtPath)) {
         stepWarning("No worktree found", `${wtPath} (skipped)`);
         continue;
       }
       try {
         if (repo.config.sync_files) {
           for (const file2 of repo.config.sync_files) {
-            const src = path31.join(repo.mainPath, file2);
-            const dest = path31.join(wtPath, file2);
-            if (fs24.existsSync(src)) {
+            const src = path32.join(repo.mainPath, file2);
+            const dest = path32.join(wtPath, file2);
+            if (fs25.existsSync(src)) {
               if (!opts.dryRun) {
-                fs24.mkdirSync(path31.dirname(dest), { recursive: true });
-                fs24.copyFileSync(src, dest);
+                fs25.mkdirSync(path32.dirname(dest), { recursive: true });
+                fs25.copyFileSync(src, dest);
               }
               stepSuccess(`Synced ${file2}`);
             }
@@ -31120,15 +31764,15 @@ function registerSyncCommand(program2) {
             process.exit(1);
           }
         }
-        const wtNodeModules = path31.join(wtPath, "node_modules");
-        if (fs24.existsSync(wtNodeModules) && fs24.lstatSync(wtNodeModules).isSymbolicLink()) {
+        const wtNodeModules = path32.join(wtPath, "node_modules");
+        if (fs25.existsSync(wtNodeModules) && fs25.lstatSync(wtNodeModules).isSymbolicLink()) {
           const lockfiles = ["yarn.lock", "package-lock.json", "pnpm-lock.yaml", "bun.lockb", "bun.lock"];
           for (const lock of lockfiles) {
-            const mainLock = path31.join(repo.mainPath, lock);
-            const wtLock = path31.join(wtPath, lock);
-            if (fs24.existsSync(mainLock) && fs24.existsSync(wtLock)) {
-              const mainContent = fs24.readFileSync(mainLock);
-              const wtContent = fs24.readFileSync(wtLock);
+            const mainLock = path32.join(repo.mainPath, lock);
+            const wtLock = path32.join(wtPath, lock);
+            if (fs25.existsSync(mainLock) && fs25.existsSync(wtLock)) {
+              const mainContent = fs25.readFileSync(mainLock);
+              const wtContent = fs25.readFileSync(wtLock);
               if (!mainContent.equals(wtContent)) {
                 stepWarning(`${lock} differs from main — node_modules is symlinked`);
                 indented(`Run: wtx deps ${branch} --repo ${repo.name} --install`);
@@ -31157,7 +31801,7 @@ init_config();
 init_log();
 init_resolver();
 init_deps();
-import fs25 from "fs";
+import fs26 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();
@@ -31172,16 +31816,29 @@ function registerDepsCommand(program2) {
       if (!options.json)
         repoHeader(repo.name);
       if (!branch) {
-        const state = detectDepsState(repo.mainPath, repo.mainPath);
-        if (options.json) {
-          jsonResults[repo.name] = { main: state };
+        if (options.install) {
+          const ok = await switchToInstall(repo.mainPath, globalOpts);
+          if (!ok)
+            process.exitCode = 1;
+          if (options.json) {
+            jsonResults[repo.name] = detectDepsState(repo.mainPath, repo.mainPath);
+          }
+        } else if (options.symlink) {
+          if (!options.json) {
+            stepWarning("Symlink strategy requires a worktree", "usage: wtx deps <branch> --symlink");
+          }
         } else {
-          info(`  Main repo package manager: ${state.packageManager ?? "none detected"}`);
+          const state = detectDepsState(repo.mainPath, repo.mainPath);
+          if (options.json) {
+            jsonResults[repo.name] = { main: state };
+          } else {
+            info(`  Main repo package manager: ${state.packageManager ?? "none detected"}`);
+          }
         }
         continue;
       }
       const wtPath = getWorktreePath(repo, branch);
-      if (!fs25.existsSync(wtPath)) {
+      if (!fs26.existsSync(wtPath)) {
         if (options.json) {
           jsonResults[repo.name] = { error: "No worktree found", branch };
         } else {
@@ -31239,7 +31896,7 @@ function registerDepsCommand(program2) {
 init_config();
 init_log();
 init_resolver();
-import fs26 from "fs";
+import fs27 from "fs";
 init_git();
 async function resolveMainCheckoutPath(repoCtx, branch) {
   try {
@@ -31264,7 +31921,7 @@ function registerOpenCommand(program2) {
     for (const repo of repos) {
       const wtPath = getWorktreePath(repo, branch);
       let targetPath = wtPath;
-      if (!fs26.existsSync(wtPath)) {
+      if (!fs27.existsSync(wtPath)) {
         const mainCheckoutPath = await resolveMainCheckoutPath(repo, branch);
         if (!mainCheckoutPath) {
           continue;
@@ -31294,14 +31951,14 @@ init_config();
 init_log();
 init_git();
 init_resolver();
-import path33 from "path";
+import path34 from "path";
 
 // src/lib/rename-worktree.ts
 init_git();
 init_resolver();
 init_path_safety();
-import fs27 from "fs";
-import path32 from "path";
+import fs28 from "fs";
+import path33 from "path";
 async function getUpstream(wtPath) {
   try {
     const out = await gitExec(["-C", wtPath, "rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"], {});
@@ -31321,7 +31978,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 (fs27.existsSync(newPath)) {
+  if (fs28.existsSync(newPath)) {
     throw new Error(`Target path already exists: ${newPath}`);
   }
   if (!opts.dryRun && await localBranchExists(repo.mainPath, newBranch, opts)) {
@@ -31345,7 +32002,7 @@ async function renameWorktree(params) {
   }
   await gitExec(["-C", planned.worktreePath, "branch", "-m", oldBranch, newBranch], opts);
   try {
-    fs27.mkdirSync(path32.dirname(planned.newPath), { recursive: true });
+    fs28.mkdirSync(path33.dirname(planned.newPath), { recursive: true });
     await gitExec(["-C", repo.mainPath, "worktree", "move", planned.worktreePath, planned.newPath], opts);
   } catch (err) {
     try {
@@ -31369,6 +32026,7 @@ async function renameWorktree(params) {
 }
 
 // src/commands/rename.ts
+init_stack();
 function registerRenameCommand(program2) {
   program2.command("rename <old-branch> <new-branch>").description("Rename a worktree's branch and move its checkout to the new location").option("-r, --repo <repos...>", "Target specific repo(s)").action(async (oldBranch, newBranch, options) => {
     const globalOpts = program2.opts();
@@ -31406,12 +32064,19 @@ function registerRenameCommand(program2) {
       stepProgress(`Renaming ${oldBranch} → ${newBranch}...`);
       const outcome = await renameWorktree({ repo, oldBranch, newBranch, opts: globalOpts });
       for (const dir of outcome.cleanedDirs) {
-        stepSuccess("Cleaned up empty directory", path33.relative(repo.wtRoot, dir) + "/");
+        stepSuccess("Cleaned up empty directory", path34.relative(repo.wtRoot, dir) + "/");
       }
       stepSuccess("Renamed", `${outcome.oldPath} → ${outcome.newPath}`);
       if (outcome.upstream) {
         indented(`Upstream still tracks '${outcome.upstream}' — after pushing run: git push -u origin ${newBranch}`);
       }
+      try {
+        await renameStackEntry(repo.mainPath, oldBranch, newBranch, globalOpts);
+        stepSuccess("Updated stack metadata", newBranch);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        stepWarning("Stack metadata not updated", message);
+      }
       summary(`Done — renamed ${oldBranch} to ${newBranch}`);
     } catch (err) {
       stepError("Rename failed", err.message);
@@ -31428,8 +32093,9 @@ init_resolver();
 init_deps();
 init_forge();
 init_types2();
-import fs28 from "fs";
+import fs29 from "fs";
 init_owner();
+init_stack();
 init_source();
 function buildStatusJson(item) {
   const entry = {
@@ -31446,11 +32112,14 @@ function buildStatusJson(item) {
     entry.behind = item.behind;
   entry.deps = item.deps;
   if (item.prInfo) {
-    entry.pr = {
+    const prEntry = {
       number: item.prInfo.number,
       state: item.prInfo.state,
       url: item.prInfo.url
     };
+    if (item.prInfo.baseRefName)
+      prEntry.base = item.prInfo.baseRefName;
+    entry.pr = prEntry;
   }
   if (item.ownership && !item.ownership.mine && item.ownership.author) {
     entry.owner = item.ownership.author;
@@ -31458,10 +32127,14 @@ function buildStatusJson(item) {
   if (item.rebase) {
     entry.rebase = item.rebase;
   }
+  if (item.base)
+    entry.base = item.base;
+  if (item.baseChanged)
+    entry.baseChanged = true;
   return entry;
 }
 function registerStatusCommand(program2) {
-  program2.command("status <branch>").description("Show worktree status across repos").option("-r, --repo <repos...>", "Target specific repo(s)").option("--json", "Output machine-readable JSON").action(async (branch, options) => {
+  program2.command("status <branch>").description("Show worktree status across repos").option("-r, --repo <repos...>", "Target specific repo(s)").option("--json", "Output machine-readable JSON").option("--base <ref>", "Override the recorded base ref for this status check").action(async (branch, options) => {
     const globalOpts = program2.opts();
     const config2 = loadConfig();
     const repoFilter = parseRepoFlag(options.repo);
@@ -31470,17 +32143,33 @@ function registerStatusCommand(program2) {
     const jsonOutputs = [];
     for (const repo of repos) {
       const wtPath = getWorktreePath(repo, branch);
-      if (!fs28.existsSync(wtPath)) {
+      if (!fs29.existsSync(wtPath)) {
         continue;
       }
       found++;
       const dirtyFiles = await getDirtyFiles(wtPath);
       let ahead = null;
       let behind = null;
+      let baseRef;
+      let baseChanged = false;
+      let usingStackBase = false;
       try {
         const mainBranch = await resolveMainBranch(repo, config2);
-        const resolvedRemote = await resolveBaseRemote(repo.mainPath, mainBranch);
-        const countOutput = await gitExec(["-C", wtPath, "rev-list", "--left-right", "--count", `${resolvedRemote}/${mainBranch}...HEAD`], { verbose: globalOpts.verbose });
+        const metadata = await readStackMetadata(repo.mainPath, globalOpts);
+        const recorded = metadata.branches[branch];
+        const resolvedRemote = !options.base && !recorded?.explicit ? await resolveBaseRemote(repo.mainPath, mainBranch) : undefined;
+        const defaultBase = resolvedRemote ? `${resolvedRemote}/${mainBranch}` : mainBranch;
+        baseRef = options.base || (recorded?.explicit ? recorded.baseRef : defaultBase);
+        usingStackBase = Boolean(options.base || recorded?.explicit);
+        if (recorded?.explicit && !options.base && !globalOpts.dryRun) {
+          try {
+            const currentBaseSha = await resolveCommitSha(repo.mainPath, recorded.baseRef, globalOpts);
+            baseChanged = currentBaseSha !== recorded.baseSha;
+          } catch {
+            baseChanged = true;
+          }
+        }
+        const countOutput = await gitExec(["-C", wtPath, "rev-list", "--left-right", "--count", `${baseRef}...HEAD`], { verbose: globalOpts.verbose });
         const parts = countOutput.trim().split(/\s+/);
         behind = parts[0] ? parseInt(parts[0], 10) : null;
         ahead = parts[1] ? parseInt(parts[1], 10) : null;
@@ -31519,7 +32208,9 @@ function registerStatusCommand(program2) {
           prInfo,
           ownership,
           deps: depsState,
-          rebase: rebaseStatus
+          rebase: rebaseStatus,
+          base: usingStackBase ? baseRef : undefined,
+          baseChanged
         }));
         continue;
       }
@@ -31533,10 +32224,16 @@ function registerStatusCommand(program2) {
           indented(`         ${f}`);
         }
       }
+      if (usingStackBase && baseRef) {
+        info(`  Base:      ${baseRef}`);
+        if (baseChanged) {
+          info(`  Base state: moved since stack entry`);
+        }
+      }
       if (ahead !== null && behind !== null) {
-        info(`  vs main:   ${ahead} ahead, ${behind} behind`);
+        info(`  ${usingStackBase ? "vs base" : "vs main"}:   ${ahead} ahead, ${behind} behind`);
       } else {
-        info(`  vs main:   unknown`);
+        info(`  ${usingStackBase ? "vs base" : "vs main"}:   unknown`);
       }
       if (prInfo) {
         const display = derivePrDisplay(prInfo);
@@ -31583,6 +32280,7 @@ init_git();
 init_resolver();
 init_forge();
 init_owner();
+init_stack();
 init_types2();
 var ATTENTION_STATES = new Set([
   PR_DISPLAY_STATES.CONFLICTED,
@@ -31614,6 +32312,7 @@ async function collectPrRows(repos, config2, verboseFlag) {
       continue;
     try {
       const worktrees = await getWorktreeList(repo.mainPath);
+      const stackMetadata = await readStackMetadata(repo.mainPath, { verbose: verboseFlag, dryRun: false });
       const branches = worktrees.filter((wt) => wt.path !== repo.mainPath && wt.branch).map((wt) => wt.branch);
       if (branches.length === 0)
         continue;
@@ -31643,7 +32342,8 @@ async function collectPrRows(repos, config2, verboseFlag) {
           unresolvedThreads: pr.unresolvedThreads,
           updatedAt: pr.updatedAt,
           authorLogin: pr.authorLogin ?? null,
-          ownership
+          ownership,
+          baseRef: pr.baseRefName ?? stackMetadata.branches[branch]?.baseRef ?? null
         });
       }
     } catch (err) {
@@ -31669,8 +32369,9 @@ function renderTable(rows) {
       const threads = row.unresolvedThreads > 0 ? `${row.unresolvedThreads} thread${row.unresolvedThreads > 1 ? "s" : ""}` : null;
       const details = [row.checksSummary, threads].filter(Boolean).join(" · ");
       const detailSuffix = details ? `  ${details}` : "";
+      const baseSuffix = row.baseRef ? `  → ${row.baseRef}` : "";
       const authorTag = row.ownership && !row.ownership.mine && row.ownership.author ? `  ${source_default.dim(row.ownership.author)}` : "";
-      info(`  #${row.prNumber}  ${paddedBranch} ${renderDisplayState(row.prDisplay)}${detailSuffix}${authorTag}  ${formatRelativeTime(row.updatedAt)}  ${source_default.dim(row.url)}`);
+      info(`  #${row.prNumber}  ${paddedBranch} ${renderDisplayState(row.prDisplay)}${baseSuffix}${detailSuffix}${authorTag}  ${formatRelativeTime(row.updatedAt)}  ${source_default.dim(terminalLink(row.url))}`);
     }
   }
 }
@@ -31683,7 +32384,8 @@ function toJsonOutput(rows) {
     awaitingReview: row.prDisplay.awaitingReview,
     approved: row.prDisplay.approved,
     prNumber: row.prNumber,
-    author: row.authorLogin
+    author: row.authorLogin,
+    base: row.baseRef
   }));
 }
 function registerPrsCommand(program2) {
@@ -31741,8 +32443,8 @@ function registerPrsCommand(program2) {
 
 // src/commands/skill.ts
 init_log();
-import fs29 from "fs";
-import path34 from "path";
+import fs30 from "fs";
+import path35 from "path";
 import { URL as URL2 } from "url";
 var __dirname2 = new URL2(".", import.meta.url).pathname;
 var COMMON_MARKDOWN = `# wtx — Worktree Manager
@@ -31771,8 +32473,12 @@ Lists all worktrees across repositories.
 Shows git statuses for all worktrees.
 
 ### \`wtx rebase <branch>\`
-Fetches the main branch from origin and rebases the given worktree's branch onto it.
-- **Flags**: \`-r, --repo <repos...>\`
+Fetches the configured main branch for an independent worktree, or rebases onto its recorded base for a stacked worktree.
+- **Flags**: \`-r, --repo <repos...>\`, \`--onto <ref>\` to override the base.
+
+### \`wtx stack <branch>\`
+Shows the recorded parent and descendant branches for a worktree.
+- **Flags**: \`-r, --repo <repos...>\`, \`--json\`
 
 ### \`wtx sync <branch>\`
 Re-copies \`sync_files\` from the main checkout to the worktree and runs \`post_sync\` hooks. Also checks for package lockfile differences if \`node_modules\` is symlinked.
@@ -31837,15 +32543,23 @@ Hooks (\`post_create\` and \`post_sync\`) support the following template variabl
    \`\`\`bash
    wtx rebase feature-xyz
    \`\`\`
-   *Fetches the latest main branch from origin and rebases the \`feature-xyz\` worktrees.*
+   *Fetches the latest main branch for independent work, or uses the recorded parent for a stacked branch.*
+
+3. **Creating a stacked branch**:
+   \`\`\`bash
+   wtx create feature-api
+   wtx create feature-ui --base feature-api
+   wtx stack feature-ui
+   \`\`\`
+   *Open the child PR against \`feature-api\`; after the parent merges, retarget the child to main before rebasing it onto main.*
 
-3. **Syncing environment variables**:
+4. **Syncing environment variables**:
    If the \`.env\` file in the main checkout was updated, run:
    \`\`\`bash
    wtx sync feature-xyz
    \`\`\`
 
-4. **Managing node_modules dependencies**:
+5. **Managing node_modules dependencies**:
    If a worktree requires different dependencies than the main branch (e.g. you're testing an upgrade):
    \`\`\`bash
    wtx deps feature-xyz --install
@@ -31884,9 +32598,9 @@ function registerSkillCommand(program2) {
       error51(`Unknown platform: ${platform2}`);
       process.exit(1);
     }
-    let projectRoot = path34.resolve(__dirname2, "..", "..");
-    let skillPath = path34.join(projectRoot, "skills", `${platform2}.md`);
-    if (fs29.existsSync(skillPath)) {
+    let projectRoot = path35.resolve(__dirname2, "..", "..");
+    let skillPath = path35.join(projectRoot, "skills", `${platform2}.md`);
+    if (fs30.existsSync(skillPath)) {
       process.stdout.write(skillPath + `
 `);
     } else {
@@ -31932,7 +32646,8 @@ init_git();
 init_deps();
 import readline3 from "readline";
 init_path_safety();
-import fs31 from "fs";
+init_stack();
+import fs32 from "fs";
 async function runMcpServer(opts = {}) {
   const input = opts.input ?? process.stdin;
   const output = opts.output ?? process.stdout;
@@ -32025,7 +32740,7 @@ async function handleRequest(req, send, config2, opts) {
             description: "Get status of a specific worktree",
             inputSchema: {
               type: "object",
-              properties: { repo: { type: "string" }, branch: { type: "string" } },
+              properties: { repo: { type: "string" }, branch: { type: "string" }, base: { type: "string" } },
               required: ["repo", "branch"]
             }
           },
@@ -32049,10 +32764,10 @@ async function handleRequest(req, send, config2, opts) {
           },
           {
             name: "rebase_worktree",
-            description: "Rebase a worktree against main branch",
+            description: "Rebase a worktree against its recorded base or an explicit ref",
             inputSchema: {
               type: "object",
-              properties: { repo: { type: "string" }, branch: { type: "string" } },
+              properties: { repo: { type: "string" }, branch: { type: "string" }, onto: { type: "string" } },
               required: ["repo", "branch"]
             }
           }
@@ -32111,16 +32826,18 @@ async function handleToolCall(name, args, config2, _opts) {
       const items = [];
       for (const repo of repos) {
         const wts = await getWorktreeList(repo.mainPath);
+        const stackMetadata = await readStackMetadata(repo.mainPath, { verbose: _opts.verbose === true, dryRun: false });
         for (const wt of wts) {
           if (!wt.path.startsWith(repo.wtRoot))
             continue;
-          const dirtyCount = fs31.existsSync(wt.path) ? (await getDirtyFiles(wt.path)).length : 0;
+          const dirtyCount = fs32.existsSync(wt.path) ? (await getDirtyFiles(wt.path)).length : 0;
           items.push({
             repo: repo.name,
             branch: wt.branch || null,
             path: wt.path,
             sha: wt.commit ? wt.commit.substring(0, 7) : null,
-            dirtyFiles: dirtyCount
+            dirtyFiles: dirtyCount,
+            base: wt.branch && stackMetadata.branches[wt.branch]?.explicit ? stackMetadata.branches[wt.branch]?.baseRef : null
           });
         }
       }
@@ -32133,18 +32850,27 @@ async function handleToolCall(name, args, config2, _opts) {
       if (!validateSafeBranchName(args.branch)) {
         throw { isToolError: true, message: "unsafe branch name" };
       }
+      if (args.base !== undefined && typeof args.base !== "string") {
+        throw { isSchemaError: true, message: "base must be a string" };
+      }
+      if (typeof args.base === "string" && !validateSafeBranchName(args.base)) {
+        throw { isToolError: true, message: "unsafe base ref" };
+      }
       const repo = resolveRepos(config2, [args.repo])[0];
       const wtPath = getWorktreePath(repo, args.branch);
-      if (!fs31.existsSync(wtPath)) {
+      if (!fs32.existsSync(wtPath)) {
         throw { isToolError: true, message: `Worktree not found for branch ${args.branch}` };
       }
       const mainBranch = await resolveMainBranch(repo, config2);
       const resolvedRemote = await resolveBaseRemote(repo.mainPath, mainBranch);
+      const stackMetadata = await readStackMetadata(repo.mainPath, { verbose: _opts.verbose === true, dryRun: false });
+      const recorded = stackMetadata.branches[args.branch];
+      const baseRef = typeof args.base === "string" ? args.base : recorded?.explicit ? recorded.baseRef : `${resolvedRemote}/${mainBranch}`;
       const dirtyFiles = await getDirtyFiles(wtPath);
       let ahead = null;
       let behind = null;
       try {
-        const countOutput = await gitExec(["-C", wtPath, "rev-list", "--left-right", "--count", `${resolvedRemote}/${mainBranch}...HEAD`]);
+        const countOutput = await gitExec(["-C", wtPath, "rev-list", "--left-right", "--count", `${baseRef}...HEAD`]);
         const parts = countOutput.trim().split(/\s+/);
         behind = parts[0] ? parseInt(parts[0], 10) : null;
         ahead = parts[1] ? parseInt(parts[1], 10) : null;
@@ -32160,6 +32886,7 @@ async function handleToolCall(name, args, config2, _opts) {
             dirtyCount: dirtyFiles.length,
             ahead,
             behind,
+            base: recorded?.explicit || typeof args.base === "string" ? baseRef : null,
             depsStrategy: depsState.strategy
           })
         }]
@@ -32187,9 +32914,11 @@ async function handleToolCall(name, args, config2, _opts) {
       }
       const mainBranch = await resolveMainBranch(repo, config2);
       const resolvedRemote = await resolveBaseRemote(repo.mainPath, mainBranch);
+      const baseRef = args.base || `${resolvedRemote}/${mainBranch}`;
       if (repo.config.fetch_main_on_create !== false) {
         await gitExec(["-C", repo.mainPath, "fetch", resolvedRemote, "--", mainBranch]);
       }
+      const baseSha = await resolveCommitSha(repo.mainPath, baseRef, { verbose: _opts.verbose === true, dryRun: false });
       const localExists = await localBranchExists(repo.mainPath, args.branch, { verbose: false, dryRun: false });
       const remoteExists = await branchExistsOnRemote(repo.mainPath, args.branch, { verbose: false, dryRun: false }, resolvedRemote);
       const localSha = localExists ? await getLocalBranchSha(repo.mainPath, args.branch, { verbose: false, dryRun: false }) : null;
@@ -32207,6 +32936,14 @@ async function handleToolCall(name, args, config2, _opts) {
         gitArgs.push(wtPath, args.branch);
       }
       await gitExec(gitArgs);
+      if (resolution.kind === "create-new") {
+        await recordStackEntry(repo.mainPath, args.branch, {
+          baseRef: args.base || mainBranch,
+          baseSha,
+          explicit: args.base !== undefined,
+          createdAt: new Date().toISOString()
+        }, { verbose: _opts.verbose === true, dryRun: false });
+      }
       return {
         content: [{ type: "text", text: JSON.stringify({ path: wtPath }) }]
       };
@@ -32235,7 +32972,12 @@ async function handleToolCall(name, args, config2, _opts) {
         throw { isToolError: true, message: `Worktree for ${args.branch} is not registered` };
       }
       const wtPath = target.path;
-      if (!args.force && fs31.existsSync(wtPath)) {
+      const stackMetadata = await readStackMetadata(repo.mainPath, { verbose: _opts.verbose === true, dryRun: false });
+      const children = getStackChildren(stackMetadata, args.branch);
+      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 && fs32.existsSync(wtPath)) {
         const dirty = await getDirtyFiles(wtPath);
         if (dirty.length > 0) {
           throw { isToolError: true, message: `Worktree is dirty. Use force:true to remove it.` };
@@ -32243,6 +32985,7 @@ async function handleToolCall(name, args, config2, _opts) {
       }
       await gitExec(["-C", repo.mainPath, "worktree", "remove", args.force ? "--force" : "", wtPath].filter(Boolean));
       cleanupEmptyParents(repo.wtRoot, repo.mainPath, wtPath);
+      await removeStackEntry(repo.mainPath, args.branch, { verbose: _opts.verbose === true, dryRun: false });
       return {
         content: [{ type: "text", text: JSON.stringify({ removed: true }) }]
       };
@@ -32253,18 +32996,46 @@ async function handleToolCall(name, args, config2, _opts) {
       }
       const repo = resolveRepos(config2, [args.repo])[0];
       const wtPath = getWorktreePath(repo, args.branch);
-      if (!fs31.existsSync(wtPath)) {
+      if (!fs32.existsSync(wtPath)) {
         throw { isToolError: true, message: `Worktree not found for branch ${args.branch}` };
       }
       const mainBranch = await resolveMainBranch(repo, config2);
       const resolvedRemote = await resolveBaseRemote(repo.mainPath, mainBranch);
-      await gitExec(["-C", repo.mainPath, "fetch", resolvedRemote, "--", mainBranch]);
+      if (args.onto !== undefined && typeof args.onto !== "string") {
+        throw { isSchemaError: true, message: "onto must be a string" };
+      }
+      if (typeof args.onto === "string" && !validateSafeBranchName(args.onto)) {
+        throw { isToolError: true, message: "unsafe base ref" };
+      }
+      const stackMetadata = await readStackMetadata(repo.mainPath, { verbose: _opts.verbose === true, dryRun: false });
+      const recorded = stackMetadata.branches[args.branch];
+      const baseRef = args.onto || (recorded?.explicit ? recorded.baseRef : `${resolvedRemote}/${mainBranch}`);
+      if (!args.onto && (!recorded || !recorded.explicit)) {
+        await gitExec(["-C", repo.mainPath, "fetch", resolvedRemote, "--", mainBranch]);
+      }
+      const baseSha = await resolveCommitSha(repo.mainPath, baseRef, { verbose: _opts.verbose === true, dryRun: false });
       try {
-        const rebaseOut = await gitExec(["-C", wtPath, "rebase", "--", `${resolvedRemote}/${mainBranch}`]);
+        const rebaseOut = await gitExec(["-C", wtPath, "rebase", "--", baseRef]);
         if (rebaseOut.includes("is up to date") || rebaseOut.includes("up-to-date")) {
+          if (recorded || args.onto) {
+            await recordStackEntry(repo.mainPath, args.branch, {
+              baseRef: args.onto || (recorded?.explicit ? baseRef : mainBranch),
+              baseSha,
+              explicit: args.onto ? true : recorded?.explicit ?? true,
+              createdAt: recorded?.createdAt || new Date().toISOString()
+            }, { verbose: _opts.verbose === true, dryRun: false });
+          }
           return { content: [{ type: "text", text: JSON.stringify({ status: "up-to-date" }) }] };
         } else {
-          const count2 = await gitExec(["-C", wtPath, "rev-list", "--count", `${resolvedRemote}/${mainBranch}..HEAD`]).then((s) => s.trim());
+          const count2 = await gitExec(["-C", wtPath, "rev-list", "--count", `${baseRef}..HEAD`]).then((s) => s.trim());
+          if (recorded || args.onto) {
+            await recordStackEntry(repo.mainPath, args.branch, {
+              baseRef: args.onto || (recorded?.explicit ? baseRef : mainBranch),
+              baseSha,
+              explicit: args.onto ? true : recorded?.explicit ?? true,
+              createdAt: recorded?.createdAt || new Date().toISOString()
+            }, { verbose: _opts.verbose === true, dryRun: false });
+          }
           return { content: [{ type: "text", text: JSON.stringify({ status: "rebased", commits: count2 }) }] };
         }
       } catch (err) {
@@ -32354,12 +33125,100 @@ function registerHistoryCommand(program2) {
   });
 }
 
+// src/commands/stack.ts
+init_config();
+init_git();
+init_resolver();
+init_stack();
+init_log();
+function nodeFor(branch, metadata, worktrees) {
+  const entry = metadata.branches[branch];
+  const worktree = worktrees.find((wt) => wt.branch === branch)?.path ?? null;
+  return {
+    branch,
+    base: entry?.baseRef ?? null,
+    explicit: entry?.explicit ?? false,
+    baseSha: entry?.baseSha ?? null,
+    worktree
+  };
+}
+function collectDescendants(metadata, branch, worktrees, seen) {
+  const nodes = [];
+  for (const child of getStackChildren(metadata, branch)) {
+    if (seen.has(child))
+      continue;
+    seen.add(child);
+    nodes.push(nodeFor(child, metadata, worktrees));
+    nodes.push(...collectDescendants(metadata, child, worktrees, seen));
+  }
+  return nodes;
+}
+function renderNode(node, prefix) {
+  const base2 = node.base ? `  base ${node.base}` : "  base not recorded";
+  const location = node.worktree ? `  ${node.worktree}` : "  no local worktree";
+  info(`    ${prefix}${node.branch}`);
+  indented(`${" ".repeat(prefix.length)}${base2} · ${location}`);
+}
+function registerStackCommand(program2) {
+  program2.command("stack <branch>").description("Show the recorded branch stack").option("-r, --repo <repos...>", "Target specific repo(s)").option("--json", "Output machine-readable JSON").action(async (branch, options) => {
+    const globalOpts = program2.opts();
+    if (!validateSafeBranchName(branch)) {
+      stepError(`Invalid branch name: '${branch}'`);
+      process.exit(1);
+    }
+    const config2 = loadConfig();
+    const repoFilter = parseRepoFlag(options.repo);
+    const repos = resolveRepos(config2, repoFilter);
+    const jsonResults = [];
+    let successCount = 0;
+    for (const repo of repos) {
+      try {
+        const metadata = await readStackMetadata(repo.mainPath, globalOpts);
+        const worktrees = await getWorktreeList(repo.mainPath);
+        const ancestors = getStackAncestors(metadata, branch);
+        const nodes = ancestors.map((item) => nodeFor(item, metadata, worktrees));
+        const descendants = collectDescendants(metadata, branch, worktrees, new Set(ancestors));
+        const allNodes = [...nodes, ...descendants];
+        const displayNodes = buildStackHierarchy(allNodes, (node) => node.branch, (node) => node.base ?? undefined, (a2, b) => a2.branch.localeCompare(b.branch));
+        if (options.json) {
+          jsonResults.push({ repo: repo.name, branch, nodes: allNodes });
+        } else {
+          repoHeader(repo.name);
+          info(`  Stack for ${branch}`);
+          if (allNodes.length === 1 && !metadata.branches[branch]) {
+            const mainBranch = await resolveMainBranch(repo, config2);
+            const defaultRemote = await resolveBaseRemote(repo.mainPath, mainBranch);
+            const defaultBase = `${defaultRemote}/${mainBranch}`;
+            indented(`No recorded parent; default base is ${defaultBase}`);
+          }
+          displayNodes.forEach(({ item, prefix }) => renderNode(item, prefix));
+        }
+        successCount++;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        if (options.json) {
+          console.error(JSON.stringify({ repo: repo.name, error: message }));
+        } else {
+          stepError("Failed to read stack", `${repo.name}: ${message}`);
+        }
+      }
+    }
+    if (options.json) {
+      console.log(JSON.stringify(jsonResults.length === 1 ? jsonResults[0] : jsonResults, null, 2));
+    } else if (successCount === 0) {
+      summaryWarning("No stacks found");
+    } else {
+      summary(`Done — ${successCount} repo${successCount > 1 ? "s" : ""} checked`);
+    }
+  });
+}
+
 // src/index.ts
 init_config();
 init_resolver();
 init_log();
 init_history();
-import fs32 from "fs";
+import fs33 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([
@@ -32451,6 +33310,7 @@ registerSkillCommand(program2);
 registerTerminalCommand(program2);
 registerMcpCommand(program2);
 registerHistoryCommand(program2);
+registerStackCommand(program2);
 program2.command("_resolve-path <repo> <branch>", { hidden: true }).description("Internal command to resolve worktree path for shell wrapper cd").action((repoName, branch) => {
   try {
     const config2 = loadConfig();
@@ -32462,7 +33322,7 @@ program2.command("_resolve-path <repo> <branch>", { hidden: true }).description(
     }
     const repo = repos[0];
     const wtPath = getWorktreePath(repo, branch);
-    if (!fs32.existsSync(wtPath)) {
+    if (!fs33.existsSync(wtPath)) {
       process.stderr.write(`✗ No worktree at ${wtPath}
 `);
       process.exit(1);