@ogpoyraz/wtx 0.7.0 → 0.8.0

package/dist/cli.mjs

@@ -23014,6 +23014,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 +23145,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 +23363,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 +23430,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 +23451,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 +23485,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 +23501,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 +23514,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 +23526,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 +23558,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 +23569,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 +23578,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 +23606,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 +23615,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 +23643,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 +23652,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 +23674,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 +23683,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 +24040,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 +24088,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 +24098,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 +24106,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 +24159,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 +24177,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 +24191,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 +24201,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 +24224,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 +24245,7 @@ function detectCommonLinkageState(wtPath, mainPath) {
       return { state: "installed" };
     }
   } catch {
-    if (!fs17.existsSync(nodeModulesPath)) {
+    if (!fs18.existsSync(nodeModulesPath)) {
       return { state: "missing" };
     }
   }
@@ -24169,7 +24359,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 +24440,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 +24525,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 +24536,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 +24550,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 +24567,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 +24583,7 @@ function mapPrHead(raw) {
     state,
     isDraft,
     headRefName,
+    ...baseRefName ? { baseRefName } : {},
     isCrossRepository,
     headOwnerLogin,
     headRepoName
@@ -24485,7 +24679,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 +24724,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 +24750,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 +24783,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 +24823,7 @@ var init_github = __esm(() => {
     "statusCheckRollup",
     "reviewDecision",
     "headRefName",
+    "baseRefName",
     "updatedAt"
   ].join(",");
   REMOTE_URL_PATTERNS = [
@@ -24639,8 +24834,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 +24848,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 +24901,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 +24928,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 +25190,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 +25224,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 +25246,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 +25260,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 +25270,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 +25291,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 +25307,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 +25343,7 @@ var init_data = __esm(() => {
   init_forge();
   init_owner();
   init_types2();
+  init_stack();
   prCache = new Map;
 });
 
@@ -25147,14 +25364,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,6 +25400,13 @@ 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));
 }
@@ -25236,9 +25462,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 +25507,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 +25534,7 @@ function useWorktrees(opts) {
 var init_useWorktrees = __esm(() => {
   init_data();
   init_config();
+  init_utils();
 });
 
 // src/tui/theme.ts
@@ -25366,12 +25595,17 @@ function WorktreeItem({ row, isSelected, isMultiSelected, indicator, frame, id }
     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 +25623,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)
@@ -25405,6 +25643,10 @@ function WorktreeItem({ row, isSelected, isMultiSelected, indicator, frame, id }
             fg: tokens.dim,
             children: secondary
           }),
+          baseChangedSegment && /* @__PURE__ */ jsx("span", {
+            fg: tokens.warning,
+            children: baseChangedSegment
+          }),
           rebaseSegment && /* @__PURE__ */ jsx("span", {
             fg: tokens.error,
             children: rebaseSegment
@@ -25510,7 +25752,7 @@ function DetailPane({ selectedRow }) {
   const {
     repoName,
     branch,
-    path: path35,
+    path: path36,
     commitShort,
     isMainCheckout,
     isLocked,
@@ -25524,7 +25766,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 +25823,7 @@ function DetailPane({ selectedRow }) {
             fg: tokens.fg,
             children: [
               "   ",
-              path35
+              path36
             ]
           })
         ]
@@ -25629,12 +25873,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,
@@ -25960,9 +26231,9 @@ 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"],
@@ -26136,38 +26407,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 +26446,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 [];
   }
@@ -26787,6 +27058,7 @@ function ConfigOverlay({ onClose, onSaved, onError }) {
 }
 var init_ConfigOverlay = __esm(() => {
   init_Overlay();
+  init_utils();
   init_theme();
   init_config();
   init_InputModal();
@@ -26835,6 +27107,8 @@ function App({ opts }) {
   const nextOpId = useRef3(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();
@@ -26990,7 +27264,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 +27277,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 +27307,13 @@ function App({ opts }) {
       }
       return;
     }
+    if (createBaseModal) {
+      if (key.name === "escape") {
+        setCreateBaseModal(null);
+        setCreateBaseError(undefined);
+      }
+      return;
+    }
     if (createDepsChoice)
       return;
     if (renameModal) {
@@ -27154,16 +27437,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") {
@@ -27414,16 +27693,33 @@ function App({ opts }) {
           }
           setCreateModal(false);
           setCreateError(undefined);
-          setCreateDepsChoice({ branch, repoName });
+          setCreateBaseError(undefined);
+          setCreateBaseModal({ branch, repoName });
+        }
+      }),
+      createBaseModal && /* @__PURE__ */ jsx12(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, {
         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)
       }),
@@ -27493,6 +27789,7 @@ var init_App = __esm(() => {
   init_InputModal();
   init_ChoiceModal();
   init_ConfigOverlay();
+  init_utils();
   init_agents();
   init_config();
   init_history();
@@ -29661,8 +29958,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 +30024,7 @@ function resolveBranchTarget(input) {
 }
 
 // src/commands/create.ts
+init_stack();
 init_resolver();
 
 // src/lib/ide.ts
@@ -29742,14 +30040,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 +30082,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 +30113,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 +30246,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 +30256,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 +30329,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 +30411,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 +30436,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 +30534,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 +30563,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 +30577,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 +30698,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 +30741,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 +30766,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 +30806,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 +30836,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 +30871,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 +30889,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 +30913,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 +30938,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 +31027,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 +31102,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 +31137,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 +31177,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 +31192,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 +31215,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) {
@@ -30832,6 +31236,8 @@ function registerLsCommand(program2) {
               prSegment = `  #${prInfo.number} ${renderDisplayState(display)}  ${source_default.dim(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 +31257,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 +31341,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 +31356,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 +31482,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 +31494,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 +31556,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 +31593,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 +31608,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 +31688,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 +31713,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 +31743,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 +31770,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 +31794,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 +31818,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 +31856,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 +31885,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 +31904,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 +31919,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 +31935,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 +32000,9 @@ function registerStatusCommand(program2) {
           prInfo,
           ownership,
           deps: depsState,
-          rebase: rebaseStatus
+          rebase: rebaseStatus,
+          base: usingStackBase ? baseRef : undefined,
+          baseChanged
         }));
         continue;
       }
@@ -31533,10 +32016,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 +32072,7 @@ init_git();
 init_resolver();
 init_forge();
 init_owner();
+init_stack();
 init_types2();
 var ATTENTION_STATES = new Set([
   PR_DISPLAY_STATES.CONFLICTED,
@@ -31614,6 +32104,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 +32134,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 +32161,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(row.url)}`);
     }
   }
 }
@@ -31683,7 +32176,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 +32235,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 +32265,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 +32335,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 +32390,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 +32438,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 +32532,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 +32556,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 +32618,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 +32642,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 +32678,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 +32706,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 +32728,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 +32764,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 +32777,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 +32788,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 +32917,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 +33102,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 +33114,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);