dubstack 0.5.0 → 0.6.0

package/dist/index.js

@@ -100,6 +100,20 @@ async function deleteBranch(name, cwd) {
     throw new DubError(`Failed to delete branch '${name}'. It may not exist.`);
   }
 }
+async function deleteLocalBranch(name, cwd, force = false) {
+  try {
+    await execa("git", ["branch", force ? "-D" : "-d", name], { cwd });
+  } catch {
+    if (force) {
+      throw new DubError(
+        `Failed to delete branch '${name}'. It may not exist or be checked out.`
+      );
+    }
+    throw new DubError(
+      `Branch '${name}' is not fully merged. Re-run with --force to delete it.`
+    );
+  }
+}
 async function forceBranchTo(name, sha, cwd) {
   try {
     const current = await getCurrentBranch(cwd).catch(() => null);
@@ -139,6 +153,13 @@ async function rebaseContinue(cwd) {
     );
   }
 }
+async function rebaseAbort(cwd) {
+  try {
+    await execa("git", ["rebase", "--abort"], { cwd });
+  } catch {
+    throw new DubError("Failed to abort rebase.");
+  }
+}
 async function getMergeBase(a, b, cwd) {
   try {
     const { stdout } = await execa("git", ["merge-base", a, b], { cwd });
@@ -294,9 +315,9 @@ async function fetchBranches(branches, cwd, remote = "origin") {
     } catch (error) {
       const stderr = typeof error?.stderr === "string" ? error.stderr : "";
       const stdout = typeof error?.stdout === "string" ? error.stdout : "";
-      const output2 = `${stderr}
+      const output5 = `${stderr}
 ${stdout}`;
-      if (output2.includes("couldn't find remote ref")) {
+      if (output5.includes("couldn't find remote ref")) {
         continue;
       }
       throw new DubError(`Failed to fetch branches from '${remote}'.`);
@@ -461,25 +482,25 @@ function getParent(state, branchName) {
   const branch = stack.branches.find((b) => b.name === branchName);
   return branch?.parent ?? void 0;
 }
-function addBranchToStack(state, child, parent) {
+function addBranchToStack(state, child, parent2) {
   if (findStackForBranch(state, child)) {
     throw new DubError(`Branch '${child}' is already tracked in a stack.`);
   }
   const childBranch = {
     name: child,
-    parent,
+    parent: parent2,
     pr_number: null,
     pr_link: null,
     last_submitted_version: null,
     last_synced_at: null,
     sync_source: null
   };
-  const existingStack = findStackForBranch(state, parent);
+  const existingStack = findStackForBranch(state, parent2);
   if (existingStack) {
     existingStack.branches.push(childBranch);
   } else {
     const rootBranch = {
-      name: parent,
+      name: parent2,
       type: "root",
       parent: null,
       pr_number: null,
@@ -517,9 +538,9 @@ function topologicalOrder(stack) {
   const childMap = /* @__PURE__ */ new Map();
   for (const branch of stack.branches) {
     if (branch.parent) {
-      const children = childMap.get(branch.parent) ?? [];
-      children.push(branch);
-      childMap.set(branch.parent, children);
+      const children2 = childMap.get(branch.parent) ?? [];
+      children2.push(branch);
+      childMap.set(branch.parent, children2);
     }
   }
   const queue = [root];
@@ -527,8 +548,8 @@ function topologicalOrder(stack) {
     const current = queue.shift();
     if (!current) break;
     result.push(current);
-    const children = childMap.get(current.name) ?? [];
-    queue.push(...children);
+    const children2 = childMap.get(current.name) ?? [];
+    queue.push(...children2);
   }
   return result;
 }
@@ -541,29 +562,29 @@ var init_state = __esm({
 });
 
 // src/lib/undo-log.ts
-import * as fs2 from "fs";
-import * as path2 from "path";
+import * as fs3 from "fs";
+import * as path3 from "path";
 async function getUndoPath(cwd) {
   const dubDir = await getDubDir(cwd);
-  return path2.join(dubDir, "undo.json");
+  return path3.join(dubDir, "undo.json");
 }
 async function saveUndoEntry(entry, cwd) {
   const undoPath = await getUndoPath(cwd);
-  fs2.writeFileSync(undoPath, `${JSON.stringify(entry, null, 2)}
+  fs3.writeFileSync(undoPath, `${JSON.stringify(entry, null, 2)}
 `);
 }
 async function readUndoEntry(cwd) {
   const undoPath = await getUndoPath(cwd);
-  if (!fs2.existsSync(undoPath)) {
+  if (!fs3.existsSync(undoPath)) {
     throw new DubError("Nothing to undo.");
   }
-  const raw = fs2.readFileSync(undoPath, "utf-8");
+  const raw = fs3.readFileSync(undoPath, "utf-8");
   return JSON.parse(raw);
 }
 async function clearUndoEntry(cwd) {
   const undoPath = await getUndoPath(cwd);
-  if (fs2.existsSync(undoPath)) {
-    fs2.unlinkSync(undoPath);
+  if (fs3.existsSync(undoPath)) {
+    fs3.unlinkSync(undoPath);
   }
 }
 var init_undo_log = __esm({
@@ -818,14 +839,14 @@ async function modify(cwd, options) {
   const currentBranch = await getCurrentBranch(cwd);
   const state = await readState(cwd);
   if (options.interactiveRebase) {
-    const parent = getParent(state, currentBranch);
-    if (!parent) {
+    const parent2 = getParent(state, currentBranch);
+    if (!parent2) {
       throw new DubError(
         `Could not determine parent branch for '${currentBranch}'. Cannot start interactive rebase.`
       );
     }
-    const parentTip = await getBranchTip(parent, cwd);
-    console.log(`Starting interactive rebase on top of '${parent}'...`);
+    const parentTip = await getBranchTip(parent2, cwd);
+    console.log(`Starting interactive rebase on top of '${parent2}'...`);
     await interactiveRebase(parentTip, cwd);
     await restackChildren(cwd);
     return;
@@ -898,6 +919,55 @@ import { createRequire } from "module";
 import chalk2 from "chalk";
 import { Command } from "commander";
 
+// src/commands/abort.ts
+init_errors();
+init_git();
+
+// src/lib/operation-state.ts
+init_git();
+init_state();
+import * as fs2 from "fs";
+import * as path2 from "path";
+async function getRestackProgressPath(cwd) {
+  const dubDir = await getDubDir(cwd);
+  return path2.join(dubDir, "restack-progress.json");
+}
+async function hasRestackProgress(cwd) {
+  const progressPath = await getRestackProgressPath(cwd);
+  return fs2.existsSync(progressPath);
+}
+async function hasGitRebaseInProgress(cwd) {
+  const root = await getRepoRoot(cwd);
+  const rebaseMerge = path2.join(root, ".git", "rebase-merge");
+  const rebaseApply = path2.join(root, ".git", "rebase-apply");
+  return fs2.existsSync(rebaseMerge) || fs2.existsSync(rebaseApply);
+}
+async function detectActiveOperation(cwd) {
+  if (await hasRestackProgress(cwd)) return "restack";
+  if (await hasGitRebaseInProgress(cwd)) return "rebase";
+  return "none";
+}
+async function clearRestackProgress(cwd) {
+  const progressPath = await getRestackProgressPath(cwd);
+  if (!fs2.existsSync(progressPath)) return;
+  fs2.unlinkSync(progressPath);
+}
+
+// src/commands/abort.ts
+async function abortCommand(cwd) {
+  const active = await detectActiveOperation(cwd);
+  if (active === "none") {
+    throw new DubError("No operation in progress. Nothing to abort.");
+  }
+  if (await hasGitRebaseInProgress(cwd)) {
+    await rebaseAbort(cwd);
+  }
+  if (active === "restack") {
+    await clearRestackProgress(cwd);
+  }
+  return { aborted: active };
+}
+
 // src/commands/branch.ts
 init_git();
 init_state();
@@ -1045,6 +1115,42 @@ async function interactiveCheckout(cwd, options = {}) {
   }
 }
 
+// src/commands/children.ts
+init_errors();
+init_git();
+init_state();
+async function children(cwd, branchArg) {
+  const branch = branchArg ?? await getCurrentBranch(cwd);
+  const state = await readState(cwd);
+  const stack = findStackForBranch(state, branch);
+  if (!stack) {
+    throw new DubError(
+      `Branch '${branch}' is not tracked. Run 'dub track ${branch} --parent <branch>' first.`
+    );
+  }
+  const childBranches = stack.branches.filter((entry) => entry.parent === branch).map((entry) => entry.name).sort();
+  return { branch, children: childBranches };
+}
+
+// src/commands/continue.ts
+init_errors();
+init_git();
+init_restack();
+async function continueCommand(cwd) {
+  const active = await detectActiveOperation(cwd);
+  if (active === "none") {
+    throw new DubError(
+      "No operation in progress. Start a restack or resolve a rebase first."
+    );
+  }
+  if (active === "restack") {
+    const restackResult = await restackContinue(cwd);
+    return { continued: "restack", restackResult };
+  }
+  await rebaseContinue(cwd);
+  return { continued: "rebase" };
+}
+
 // src/commands/create.ts
 init_errors();
 init_git();
@@ -1057,7 +1163,7 @@ async function create(name, cwd, options) {
     );
   }
   const state = await ensureState(cwd);
-  const parent = await getCurrentBranch(cwd);
+  const parent2 = await getCurrentBranch(cwd);
   if (await branchExists(name, cwd)) {
     throw new DubError(`Branch '${name}' already exists.`);
   }
@@ -1078,7 +1184,7 @@ async function create(name, cwd, options) {
     {
       operation: "create",
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      previousBranch: parent,
+      previousBranch: parent2,
       previousState: structuredClone(state),
       branchTips: {},
       createdBranches: [name]
@@ -1086,7 +1192,7 @@ async function create(name, cwd, options) {
     cwd
   );
   await createBranch(name, cwd);
-  addBranchToStack(state, name, parent);
+  addBranchToStack(state, name, parent2);
   await writeState(state, cwd);
   if (options?.message) {
     try {
@@ -1097,17 +1203,267 @@ async function create(name, cwd, options) {
         `Branch '${name}' was created but commit failed: ${reason}. Run 'dub undo' to clean up.`
       );
     }
-    return { branch: name, parent, committed: options.message };
+    return { branch: name, parent: parent2, committed: options.message };
+  }
+  return { branch: name, parent: parent2 };
+}
+
+// src/commands/delete.ts
+import { stdin as input, stdout as output } from "process";
+import * as readline from "readline/promises";
+
+// src/lib/delete.ts
+init_errors();
+init_git();
+
+// src/lib/graph.ts
+init_errors();
+function buildChildMap(stack) {
+  const childMap = /* @__PURE__ */ new Map();
+  for (const branch of stack.branches) {
+    if (!branch.parent) continue;
+    const children2 = childMap.get(branch.parent) ?? [];
+    children2.push(branch);
+    childMap.set(branch.parent, children2);
+  }
+  return childMap;
+}
+function buildBranchMap(stack) {
+  return new Map(stack.branches.map((branch) => [branch.name, branch]));
+}
+function getDescendants(stack, branchName) {
+  const childMap = buildChildMap(stack);
+  const descendants = [];
+  const queue = [...childMap.get(branchName) ?? []];
+  while (queue.length > 0) {
+    const next = queue.shift();
+    if (!next) break;
+    descendants.push(next.name);
+    queue.push(...childMap.get(next.name) ?? []);
+  }
+  return descendants;
+}
+function getAncestors(stack, branchName) {
+  const branchMap = buildBranchMap(stack);
+  const ancestors = [];
+  const seen = /* @__PURE__ */ new Set();
+  let current = branchMap.get(branchName);
+  while (current?.parent) {
+    if (seen.has(current.parent)) break;
+    ancestors.push(current.parent);
+    seen.add(current.parent);
+    current = branchMap.get(current.parent);
+  }
+  return ancestors;
+}
+function assertAcyclic(stack) {
+  const branchMap = buildBranchMap(stack);
+  const visiting = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  function visit(name) {
+    if (visited.has(name)) return;
+    if (visiting.has(name)) {
+      throw new DubError(
+        `Invalid stack '${stack.id}': cycle detected at '${name}'.`
+      );
+    }
+    visiting.add(name);
+    const branch = branchMap.get(name);
+    if (branch?.parent && branchMap.has(branch.parent)) {
+      visit(branch.parent);
+    }
+    visiting.delete(name);
+    visited.add(name);
+  }
+  for (const branch of stack.branches) {
+    visit(branch.name);
+  }
+}
+
+// src/lib/invariants.ts
+init_errors();
+function assertStateInvariants(stacks) {
+  for (const stack of stacks) {
+    assertAcyclic(stack);
+    const branchMap = new Map(
+      stack.branches.map((branch) => [branch.name, branch])
+    );
+    for (const branch of stack.branches) {
+      if (branch.type === "root") {
+        if (branch.parent !== null) {
+          throw new DubError(
+            `Invalid stack '${stack.id}': root '${branch.name}' must have no parent.`
+          );
+        }
+        continue;
+      }
+      if (!branch.parent || !branchMap.has(branch.parent)) {
+        throw new DubError(
+          `Invalid stack '${stack.id}': branch '${branch.name}' has missing parent '${branch.parent ?? "null"}'.`
+        );
+      }
+    }
   }
-  return { branch: name, parent };
+}
+
+// src/lib/delete.ts
+init_state();
+async function getDeletePreview(cwd, options) {
+  const state = await readState(cwd);
+  const stack = findStackForBranch(state, options.branch);
+  if (!stack) {
+    throw new DubError(
+      `Branch '${options.branch}' is not tracked. Run 'dub track ${options.branch} --parent <branch>' first.`
+    );
+  }
+  const targets = collectTargets(stack, options);
+  return { branch: options.branch, targets };
+}
+async function deleteTrackedBranch(cwd, options) {
+  const state = await readState(cwd);
+  const stack = findStackForBranch(state, options.branch);
+  if (!stack) {
+    throw new DubError(
+      `Branch '${options.branch}' is not tracked by DubStack.`
+    );
+  }
+  const targets = collectTargets(stack, options);
+  const deleteSet = new Set(targets);
+  const currentBranch = await getCurrentBranch(cwd);
+  if (deleteSet.has(currentBranch)) {
+    const fallback = resolveFallbackBranch(stack, options.branch, deleteSet);
+    await checkoutBranch(fallback, cwd);
+  }
+  for (const branch of targets) {
+    await deleteLocalBranch(branch, cwd, options.force ?? false);
+  }
+  const deletedParent = /* @__PURE__ */ new Map();
+  for (const branch of stack.branches) {
+    if (deleteSet.has(branch.name)) {
+      deletedParent.set(branch.name, branch.parent);
+    }
+  }
+  stack.branches = stack.branches.filter(
+    (branch) => !deleteSet.has(branch.name)
+  );
+  const reparented = [];
+  for (const branch of stack.branches) {
+    let parent2 = branch.parent;
+    while (parent2 && deleteSet.has(parent2)) {
+      parent2 = deletedParent.get(parent2) ?? null;
+    }
+    if (parent2 !== branch.parent) {
+      branch.parent = parent2;
+      reparented.push({ branch: branch.name, parent: branch.parent });
+    }
+  }
+  state.stacks = state.stacks.filter(
+    (candidate) => candidate.branches.length > 0
+  );
+  assertStateInvariants(state.stacks);
+  await writeState(state, cwd);
+  return {
+    deleted: targets,
+    reparented
+  };
+}
+function collectTargets(stack, options) {
+  const target = stack.branches.find(
+    (branch) => branch.name === options.branch
+  );
+  if (!target) {
+    throw new DubError(
+      `Branch '${options.branch}' is missing from tracked stack.`
+    );
+  }
+  if (target.type === "root") {
+    throw new DubError(
+      `Cannot delete root branch '${options.branch}' via dub delete.`
+    );
+  }
+  const stackBranchMap = new Map(
+    stack.branches.map((branch) => [branch.name, branch])
+  );
+  const targets = /* @__PURE__ */ new Set([options.branch]);
+  if (options.upstack) {
+    for (const descendant of getDescendants(stack, options.branch)) {
+      targets.add(descendant);
+    }
+  }
+  if (options.downstack) {
+    for (const ancestor of getAncestors(stack, options.branch)) {
+      if (stackBranchMap.get(ancestor)?.type === "root") continue;
+      targets.add(ancestor);
+    }
+  }
+  return [...targets].sort(
+    (a, b) => getAncestors(stack, b).length - getAncestors(stack, a).length
+  );
+}
+function resolveFallbackBranch(stack, targetBranch, deleteSet) {
+  const ancestors = getAncestors(stack, targetBranch);
+  for (const ancestor of ancestors) {
+    if (!deleteSet.has(ancestor)) return ancestor;
+  }
+  const root = stack.branches.find((branch) => branch.type === "root")?.name;
+  if (root && !deleteSet.has(root)) return root;
+  throw new DubError(
+    "Unable to determine a safe checkout target before deleting current branch."
+  );
+}
+
+// src/commands/delete.ts
+init_errors();
+init_git();
+function isInteractiveShell() {
+  return Boolean(process.stdout.isTTY && process.stdin.isTTY);
+}
+async function confirmDelete(targets) {
+  const rl = readline.createInterface({ input, output });
+  try {
+    const answer = await rl.question(
+      `Delete ${targets.length} branch(es): ${targets.join(", ")}? [y/N] `
+    );
+    const normalized = answer.trim().toLowerCase();
+    return normalized === "y" || normalized === "yes";
+  } finally {
+    rl.close();
+  }
+}
+async function deleteCommand(cwd, branchArg, options = {}) {
+  const branch = branchArg ?? await getCurrentBranch(cwd);
+  const interactive = options.interactive ?? isInteractiveShell();
+  const preview = await getDeletePreview(cwd, {
+    branch,
+    upstack: options.upstack,
+    downstack: options.downstack
+  });
+  if (!options.force && !options.quiet) {
+    if (!interactive) {
+      throw new DubError(
+        "Delete requires confirmation. Re-run with --force or interactively."
+      );
+    }
+    const confirmed = await confirmDelete(preview.targets);
+    if (!confirmed) {
+      return { deleted: [], reparented: [], cancelled: true };
+    }
+  }
+  const result = await deleteTrackedBranch(cwd, {
+    branch,
+    upstack: options.upstack ?? false,
+    downstack: options.downstack ?? false,
+    force: options.force ?? false
+  });
+  return { ...result, cancelled: false };
 }
 
 // src/commands/init.ts
 init_errors();
 init_git();
 init_state();
-import * as fs3 from "fs";
-import * as path3 from "path";
+import * as fs5 from "fs";
+import * as path5 from "path";
 async function init(cwd) {
   if (!await isGitRepo(cwd)) {
     throw new DubError(
@@ -1116,20 +1472,20 @@ async function init(cwd) {
   }
   const status = await initState(cwd);
   const repoRoot = await getRepoRoot(cwd);
-  const gitignorePath = path3.join(repoRoot, ".gitignore");
+  const gitignorePath = path5.join(repoRoot, ".gitignore");
   const entry = ".git/dubstack";
   let gitignoreUpdated = false;
-  if (fs3.existsSync(gitignorePath)) {
-    const content = fs3.readFileSync(gitignorePath, "utf-8");
+  if (fs5.existsSync(gitignorePath)) {
+    const content = fs5.readFileSync(gitignorePath, "utf-8");
     const lines = content.split("\n");
     if (!lines.some((line) => line.trim() === entry)) {
       const separator = content.endsWith("\n") ? "" : "\n";
-      fs3.writeFileSync(gitignorePath, `${content}${separator}${entry}
+      fs5.writeFileSync(gitignorePath, `${content}${separator}${entry}
 `);
       gitignoreUpdated = true;
     }
   } else {
-    fs3.writeFileSync(gitignorePath, `${entry}
+    fs5.writeFileSync(gitignorePath, `${entry}
 `);
     gitignoreUpdated = true;
   }
@@ -1137,9 +1493,10 @@ async function init(cwd) {
 }
 
 // src/commands/log.ts
+init_errors();
 init_git();
 init_state();
-async function log(cwd) {
+async function log(cwd, options = {}) {
   const state = await readState(cwd);
   if (state.stacks.length === 0) {
     return "No stacks. Run 'dub create' to start.";
@@ -1149,29 +1506,57 @@ async function log(cwd) {
     currentBranch = await getCurrentBranch(cwd);
   } catch {
   }
+  let stacksToRender = state.stacks;
+  if (options.stack && !options.all) {
+    if (!currentBranch) {
+      throw new DubError(
+        "Cannot determine current branch for --stack mode. Checkout a branch first."
+      );
+    }
+    const currentStack = findStackForBranch(state, currentBranch);
+    if (!currentStack) {
+      throw new DubError(
+        `Current branch '${currentBranch}' is not tracked. Run 'dub track ${currentBranch} --parent <branch>' first.`
+      );
+    }
+    stacksToRender = [currentStack];
+  }
+  if (options.reverse) {
+    stacksToRender = [...stacksToRender].reverse();
+  }
   const sections = [];
-  for (const stack of state.stacks) {
-    const tree = await renderStack(stack, currentBranch, cwd);
+  for (const stack of stacksToRender) {
+    const tree = await renderStack(stack, currentBranch, cwd, options);
     sections.push(tree);
   }
   return sections.join("\n\n");
 }
-async function renderStack(stack, currentBranch, cwd) {
+async function renderStack(stack, currentBranch, cwd, options) {
   const root = stack.branches.find((b) => b.type === "root");
   if (!root) return "";
   const childMap = /* @__PURE__ */ new Map();
   for (const branch of stack.branches) {
     if (branch.parent) {
-      const children = childMap.get(branch.parent) ?? [];
-      children.push(branch);
-      childMap.set(branch.parent, children);
+      const children2 = childMap.get(branch.parent) ?? [];
+      children2.push(branch);
+      childMap.set(branch.parent, children2);
     }
   }
   const lines = [];
-  await renderNode(root, currentBranch, childMap, "", true, true, lines, cwd);
+  await renderNode(
+    root,
+    currentBranch,
+    childMap,
+    "",
+    true,
+    true,
+    lines,
+    cwd,
+    options
+  );
   return lines.join("\n");
 }
-async function renderNode(branch, currentBranch, childMap, prefix, isRoot, isLast, lines, cwd) {
+async function renderNode(branch, currentBranch, childMap, prefix, isRoot, isLast, lines, cwd, options) {
   let label;
   const exists = await branchExists(branch.name, cwd);
   if (isRoot) {
@@ -1189,19 +1574,20 @@ async function renderNode(branch, currentBranch, childMap, prefix, isRoot, isLas
     const connector = isLast ? "\u2514\u2500 " : "\u251C\u2500 ";
     lines.push(`${prefix}${connector}${label}`);
   }
-  const children = childMap.get(branch.name) ?? [];
+  const children2 = options.reverse ? [...childMap.get(branch.name) ?? []].reverse() : childMap.get(branch.name) ?? [];
   const childPrefix = isRoot ? "  " : `${prefix}${isLast ? "     " : "\u2502    "}`;
-  for (let i = 0; i < children.length; i++) {
-    const isChildLast = i === children.length - 1;
+  for (let i = 0; i < children2.length; i++) {
+    const isChildLast = i === children2.length - 1;
     await renderNode(
-      children[i],
+      children2[i],
       currentBranch,
       childMap,
       childPrefix,
       false,
       isChildLast,
       lines,
-      cwd
+      cwd,
+      options
     );
   }
 }
@@ -1213,8 +1599,8 @@ init_state();
 function getBranchByName(stack, name) {
   return stack.branches.find((branch) => branch.name === name);
 }
-function getChildren2(stack, parent) {
-  return stack.branches.filter((branch) => branch.parent === parent).map((branch) => branch.name);
+function getChildren2(stack, parent2) {
+  return stack.branches.filter((branch) => branch.parent === parent2).map((branch) => branch.name);
 }
 function getTrackedStackOrThrow(stateBranch, stack) {
   if (!stack) {
@@ -1236,16 +1622,16 @@ async function upBySteps(cwd, steps) {
   );
   let target = current;
   for (let i = 0; i < steps; i++) {
-    const children = getChildren2(stack, target);
-    if (children.length === 0) {
+    const children2 = getChildren2(stack, target);
+    if (children2.length === 0) {
       throw new DubError(`No branch above '${target}' in the current stack.`);
     }
-    if (children.length > 1) {
+    if (children2.length > 1) {
       throw new DubError(
         `Branch '${target}' has multiple children; 'dub up' requires a linear stack path.`
       );
     }
-    target = children[0];
+    target = children2[0];
   }
   await checkoutBranch(target, cwd);
   return { branch: target, changed: target !== current };
@@ -1287,14 +1673,14 @@ async function top(cwd) {
   );
   let target = current;
   while (true) {
-    const children = getChildren2(stack, target);
-    if (children.length === 0) break;
-    if (children.length > 1) {
+    const children2 = getChildren2(stack, target);
+    if (children2.length === 0) break;
+    if (children2.length > 1) {
       throw new DubError(
         `Branch '${target}' has multiple children; 'dub top' requires a linear stack path.`
       );
     }
-    target = children[0];
+    target = children2[0];
   }
   if (target !== current) {
     await checkoutBranch(target, cwd);
@@ -1316,30 +1702,30 @@ async function bottom(cwd) {
   }
   let target = current;
   if (!branch.parent) {
-    const children = getChildren2(stack, current);
-    if (children.length === 0) {
+    const children2 = getChildren2(stack, current);
+    if (children2.length === 0) {
       throw new DubError(
         `No branch above root '${current}' in the current stack.`
       );
     }
-    if (children.length > 1) {
+    if (children2.length > 1) {
       throw new DubError(
         `Root branch '${current}' has multiple children; 'dub bottom' requires a linear stack path.`
       );
     }
-    target = children[0];
+    target = children2[0];
   } else {
     let node = branch;
     while (node.parent) {
-      const parent = getBranchByName(stack, node.parent);
-      if (!parent) {
+      const parent2 = getBranchByName(stack, node.parent);
+      if (!parent2) {
         break;
       }
-      if (parent.parent === null) {
+      if (parent2.parent === null) {
         target = node.name;
         break;
       }
-      node = parent;
+      node = parent2;
     }
   }
   if (target !== current) {
@@ -1348,6 +1734,26 @@ async function bottom(cwd) {
   return { branch: target, changed: target !== current };
 }
 
+// src/commands/parent.ts
+init_errors();
+init_git();
+init_state();
+async function parent(cwd, branchArg) {
+  const branch = branchArg ?? await getCurrentBranch(cwd);
+  const state = await readState(cwd);
+  const stack = findStackForBranch(state, branch);
+  if (!stack) {
+    throw new DubError(
+      `Branch '${branch}' is not tracked. Run 'dub track ${branch} --parent <branch>' first.`
+    );
+  }
+  const entry = stack.branches.find((candidate) => candidate.name === branch);
+  if (!entry || !entry.parent) {
+    throw new DubError(`Branch '${branch}' is at the root and has no parent.`);
+  }
+  return { branch, parent: entry.parent };
+}
+
 // src/lib/github.ts
 init_errors();
 import { execa as execa2 } from "execa";
@@ -1530,9 +1936,9 @@ init_restack();
 // src/commands/submit.ts
 init_errors();
 init_git();
-import * as fs5 from "fs";
+import * as fs6 from "fs";
 import * as os from "os";
-import * as path5 from "path";
+import * as path6 from "path";
 
 // src/lib/pr-body.ts
 var DUBSTACK_START = "<!-- dubstack:start -->";
@@ -1608,10 +2014,17 @@ async function submit(cwd, dryRun) {
   const currentEntry = ordered.find((b) => b.name === currentBranch);
   if (currentEntry?.type === "root") {
     throw new DubError(
-      "Cannot submit from a root branch. Checkout a stack branch first."
+      "Cannot submit from a root branch. Run 'dub up' or 'dub checkout <branch>' first."
     );
   }
   const nonRootBranches = ordered.filter((b) => b.type !== "root");
+  const rootBranch = ordered.find((branch) => branch.type === "root")?.name ?? "(unknown)";
+  console.log(
+    `Submitting ${nonRootBranches.length} branch(es) from '${currentBranch}' onto trunk '${rootBranch}'.`
+  );
+  if (dryRun) {
+    console.log("[dry-run] no branches will be pushed or mutated.");
+  }
   validateLinearStack(ordered);
   const result = { pushed: [], created: [], updated: [] };
   const prMap = /* @__PURE__ */ new Map();
@@ -1679,10 +2092,10 @@ function validateLinearStack(ordered) {
       childCount.set(branch.parent, (childCount.get(branch.parent) ?? 0) + 1);
     }
   }
-  for (const [parent, count] of childCount) {
+  for (const [parent2, count] of childCount) {
     if (count > 1) {
       throw new DubError(
-        `Branch '${parent}' has ${count} children. Branching stacks are not supported by submit. Ensure each branch has at most one child.`
+        `Branch '${parent2}' has ${count} children. Branching stacks are not supported by submit. Ensure each branch has at most one child. Use 'dub track <child> --parent <branch>' to re-parent branches and linearize the stack before submitting.`
       );
     }
   }
@@ -1721,13 +2134,13 @@ async function updateAllPrBodies(branches, prMap, stackId, cwd) {
 }
 function writeTempBody(content) {
   const tmpDir = os.tmpdir();
-  const tmpFile = path5.join(tmpDir, `dubstack-body-${Date.now()}.md`);
-  fs5.writeFileSync(tmpFile, content);
+  const tmpFile = path6.join(tmpDir, `dubstack-body-${Date.now()}.md`);
+  fs6.writeFileSync(tmpFile, content);
   return tmpFile;
 }
 function cleanupTempFile(filePath) {
   try {
-    fs5.unlinkSync(filePath);
+    fs6.unlinkSync(filePath);
   } catch {
   }
 }
@@ -1735,36 +2148,36 @@ function cleanupTempFile(filePath) {
 // src/commands/sync.ts
 init_errors();
 init_git();
-import { stdin as input, stdout as output } from "process";
-import * as readline from "readline/promises";
+import { stdin as input2, stdout as output2 } from "process";
+import * as readline2 from "readline/promises";
 init_state();
 
 // src/lib/sync/branch-status.ts
-function classifyBranchSyncStatus(input2) {
-  if (!input2.hasRemote) return "missing-remote";
-  if (!input2.hasLocal) return "missing-local";
-  if (input2.localSha && input2.remoteSha && input2.localSha === input2.remoteSha) {
-    if (!input2.hasSubmittedBaseline) {
+function classifyBranchSyncStatus(input5) {
+  if (!input5.hasRemote) return "missing-remote";
+  if (!input5.hasLocal) return "missing-local";
+  if (input5.localSha && input5.remoteSha && input5.localSha === input5.remoteSha) {
+    if (!input5.hasSubmittedBaseline) {
       return "updated-outside-dubstack-but-up-to-date";
     }
     return "up-to-date";
   }
-  if (!input2.hasSubmittedBaseline) return "unsubmitted";
-  if (input2.localBehind) return "needs-remote-sync-safe";
-  if (input2.remoteBehind) return "local-ahead";
+  if (!input5.hasSubmittedBaseline) return "unsubmitted";
+  if (input5.localBehind) return "needs-remote-sync-safe";
+  if (input5.remoteBehind) return "local-ahead";
   return "reconcile-needed";
 }
 
 // src/lib/sync/cleanup.ts
-async function buildCleanupPlan(input2) {
+async function buildCleanupPlan(input5) {
   const toDelete = [];
   const skipped = [];
-  for (const branch of input2.branches) {
-    const prState = await input2.getPrStatus(branch);
+  for (const branch of input5.branches) {
+    const prState = await input5.getPrStatus(branch);
     if (prState !== "MERGED" && prState !== "CLOSED") {
       continue;
     }
-    const mergedIntoRoot = await input2.isMergedIntoAnyRoot(branch);
+    const mergedIntoRoot = await input5.isMergedIntoAnyRoot(branch);
     if (!mergedIntoRoot) {
       skipped.push({ branch, reason: "commits-not-in-trunk" });
       continue;
@@ -1775,10 +2188,10 @@ async function buildCleanupPlan(input2) {
 }
 
 // src/lib/sync/reconcile.ts
-async function resolveReconcileDecision(input2) {
-  if (input2.force) return "take-remote";
-  if (!input2.interactive) return "skip";
-  const raw = await input2.promptChoice();
+async function resolveReconcileDecision(input5) {
+  if (input5.force) return "take-remote";
+  if (!input5.interactive) return "skip";
+  const raw = await input5.promptChoice();
   if (raw === "take-remote" || raw === "keep-local" || raw === "reconcile" || raw === "skip") {
     return raw;
   }
@@ -1802,11 +2215,11 @@ function printSyncSummary(result) {
 
 // src/commands/sync.ts
 init_restack();
-function isInteractiveShell() {
+function isInteractiveShell2() {
   return Boolean(process.stdout.isTTY && process.stdin.isTTY);
 }
 async function confirm(question) {
-  const rl = readline.createInterface({ input, output });
+  const rl = readline2.createInterface({ input: input2, output: output2 });
   try {
     const answer = await rl.question(`${question} [Y/n] `);
     const normalized = answer.trim().toLowerCase();
@@ -1816,7 +2229,7 @@ async function confirm(question) {
   }
 }
 async function choose(question, choices) {
-  const rl = readline.createInterface({ input, output });
+  const rl = readline2.createInterface({ input: input2, output: output2 });
   try {
     console.log(question);
     for (let i = 0; i < choices.length; i++) {
@@ -1839,7 +2252,7 @@ async function sync(cwd, rawOptions = {}) {
     restack: rawOptions.restack ?? true,
     force: rawOptions.force ?? false,
     all: rawOptions.all ?? false,
-    interactive: rawOptions.interactive ?? isInteractiveShell()
+    interactive: rawOptions.interactive ?? isInteractiveShell2()
   };
   const state = await readState(cwd);
   const originalBranch = await getCurrentBranch(cwd);
@@ -1925,7 +2338,7 @@ async function sync(cwd, rawOptions = {}) {
   for (const skipped of cleanupPlan.skipped) {
     if (skipped.reason === "commits-not-in-trunk") {
       excludedFromSync.add(skipped.branch);
-      for (const child of getDescendants(scopeStacks, skipped.branch)) {
+      for (const child of getDescendants2(scopeStacks, skipped.branch)) {
         excludedFromSync.add(child);
       }
     }
@@ -2299,15 +2712,15 @@ async function markBranchSynced(branchMap, branchName, headSha, cwd, options) {
   entry.last_synced_at = (/* @__PURE__ */ new Date()).toISOString();
   entry.sync_source = options.source;
 }
-function getDescendants(stacks, branch) {
+function getDescendants2(stacks, branch) {
   const descendants = [];
   const childMap = /* @__PURE__ */ new Map();
   for (const stack of stacks) {
     for (const node of stack.branches) {
       if (!node.parent) continue;
-      const children = childMap.get(node.parent) ?? [];
-      children.push(node.name);
-      childMap.set(node.parent, children);
+      const children2 = childMap.get(node.parent) ?? [];
+      children2.push(node.name);
+      childMap.set(node.parent, children2);
     }
   }
   const queue = [...childMap.get(branch) ?? []];
@@ -2333,6 +2746,180 @@ function removeBranchFromState(stacks, branch) {
   }
 }
 
+// src/commands/track.ts
+init_errors();
+init_git();
+import { stdin as input3, stdout as output3 } from "process";
+import * as readline3 from "readline/promises";
+
+// src/lib/track.ts
+init_errors();
+init_git();
+import * as crypto2 from "crypto";
+init_state();
+async function validateTrackParent(cwd, branch, parent2) {
+  if (branch === parent2) {
+    throw new DubError("Branch cannot be its own parent.");
+  }
+  if (!await branchExists(parent2, cwd)) {
+    throw new DubError(`Parent branch '${parent2}' does not exist locally.`);
+  }
+}
+async function trackBranch(cwd, options) {
+  const { branch, parent: parent2 } = options;
+  if (!await branchExists(branch, cwd)) {
+    throw new DubError(`Branch '${branch}' does not exist locally.`);
+  }
+  await validateTrackParent(cwd, branch, parent2);
+  const state = await ensureState(cwd);
+  const sourceStack = findStackForBranch(state, branch);
+  const destinationStack = findStackForBranch(state, parent2);
+  if (!sourceStack) {
+    addBranchToStack(state, branch, parent2);
+    assertStateInvariants(state.stacks);
+    await writeState(state, cwd);
+    return { branch, parent: parent2, status: "tracked" };
+  }
+  const branchEntry = sourceStack.branches.find(
+    (entry) => entry.name === branch
+  );
+  if (!branchEntry) {
+    throw new DubError(`Branch '${branch}' is missing from tracked state.`);
+  }
+  if (branchEntry.type === "root") {
+    throw new DubError(
+      `Branch '${branch}' is a stack root and cannot be re-parented.`
+    );
+  }
+  if (branchEntry.parent === parent2) {
+    return { branch, parent: parent2, status: "unchanged" };
+  }
+  const descendants = new Set(getDescendants(sourceStack, branch));
+  if (descendants.has(parent2)) {
+    throw new DubError(
+      `Cannot track '${branch}' onto '${parent2}' because it would create a cycle.`
+    );
+  }
+  if (sourceStack.id === destinationStack?.id) {
+    branchEntry.parent = parent2;
+    assertStateInvariants(state.stacks);
+    await writeState(state, cwd);
+    return { branch, parent: parent2, status: "reparented" };
+  }
+  const movingNames = /* @__PURE__ */ new Set([branch, ...descendants]);
+  const movingBranches = sourceStack.branches.filter(
+    (entry) => movingNames.has(entry.name)
+  );
+  sourceStack.branches = sourceStack.branches.filter(
+    (entry) => !movingNames.has(entry.name)
+  );
+  const movingRoot = movingBranches.find((entry) => entry.name === branch);
+  if (!movingRoot) {
+    throw new DubError(`Failed to move subtree for '${branch}'.`);
+  }
+  movingRoot.parent = parent2;
+  movingRoot.type = void 0;
+  if (destinationStack) {
+    destinationStack.branches.push(...movingBranches);
+  } else {
+    state.stacks.push({
+      id: crypto2.randomUUID(),
+      branches: [
+        {
+          name: parent2,
+          type: "root",
+          parent: null,
+          pr_number: null,
+          pr_link: null,
+          last_submitted_version: null,
+          last_synced_at: null,
+          sync_source: null
+        },
+        ...movingBranches
+      ]
+    });
+  }
+  state.stacks = state.stacks.filter((stack) => stack.branches.length > 0);
+  assertStateInvariants(state.stacks);
+  await writeState(state, cwd);
+  return { branch, parent: parent2, status: "reparented" };
+}
+
+// src/commands/track.ts
+function isInteractiveShell3() {
+  return Boolean(process.stdout.isTTY && process.stdin.isTTY);
+}
+async function promptForParent(branch, suggestedParent) {
+  const rl = readline3.createInterface({ input: input3, output: output3 });
+  try {
+    const suffix = suggestedParent ? ` [${suggestedParent}]` : "";
+    const answer = await rl.question(
+      `Parent branch for '${branch}'${suffix}: `
+    );
+    const parent2 = answer.trim() || suggestedParent;
+    if (!parent2) {
+      throw new DubError(
+        `No parent selected for '${branch}'. Re-run with --parent <branch>.`
+      );
+    }
+    return parent2;
+  } finally {
+    rl.close();
+  }
+}
+async function resolveSuggestedParent(cwd, branch, currentBranch) {
+  if (currentBranch !== branch) return currentBranch;
+  if (await branchExists("main", cwd)) return "main";
+  if (await branchExists("master", cwd)) return "master";
+  return null;
+}
+async function track(cwd, branchArg, options = {}) {
+  const currentBranch = await getCurrentBranch(cwd);
+  const branch = branchArg ?? currentBranch;
+  const interactive = options.interactive ?? isInteractiveShell3();
+  let parent2 = options.parent;
+  if (!parent2) {
+    const suggestedParent = await resolveSuggestedParent(
+      cwd,
+      branch,
+      currentBranch
+    );
+    if (interactive) {
+      parent2 = await promptForParent(branch, suggestedParent);
+    } else if (suggestedParent) {
+      parent2 = suggestedParent;
+    }
+  }
+  if (!parent2) {
+    throw new DubError(
+      `Could not infer parent for '${branch}'. Re-run with --parent <branch>.`
+    );
+  }
+  return trackBranch(cwd, { branch, parent: parent2 });
+}
+
+// src/commands/trunk.ts
+init_errors();
+init_git();
+init_state();
+async function trunk(cwd, branchArg) {
+  const branch = branchArg ?? await getCurrentBranch(cwd);
+  const state = await readState(cwd);
+  const stack = findStackForBranch(state, branch);
+  if (!stack) {
+    throw new DubError(
+      `Branch '${branch}' is not tracked. Run 'dub track ${branch} --parent <branch>' first.`
+    );
+  }
+  const root = stack.branches.find((candidate) => candidate.type === "root");
+  if (!root) {
+    throw new DubError(
+      `Stack for '${branch}' is missing a root branch. Re-run 'dub track' to repair metadata.`
+    );
+  }
+  return { branch, trunk: root.name };
+}
+
 // src/commands/undo.ts
 init_errors();
 init_git();
@@ -2384,6 +2971,106 @@ async function undo(cwd) {
   };
 }
 
+// src/commands/untrack.ts
+init_errors();
+init_git();
+import { stdin as input4, stdout as output4 } from "process";
+import * as readline4 from "readline/promises";
+
+// src/lib/untrack.ts
+init_errors();
+init_state();
+async function getUntrackContext(cwd, branch) {
+  const state = await readState(cwd);
+  const stack = findStackForBranch(state, branch);
+  if (!stack) {
+    throw new DubError(
+      `Branch '${branch}' is not tracked. Run 'dub track ${branch} --parent <branch>' first.`
+    );
+  }
+  return {
+    stack,
+    branch,
+    descendants: getDescendants(stack, branch)
+  };
+}
+async function untrackBranch(cwd, options) {
+  const state = await readState(cwd);
+  const stack = findStackForBranch(state, options.branch);
+  if (!stack) {
+    throw new DubError(
+      `Branch '${options.branch}' is not tracked by DubStack.`
+    );
+  }
+  const entry = stack.branches.find((branch) => branch.name === options.branch);
+  if (!entry) {
+    throw new DubError(
+      `Branch '${options.branch}' is missing from tracked stack.`
+    );
+  }
+  const descendants = getDescendants(stack, options.branch);
+  const removedSet = new Set(
+    options.downstack ? [options.branch, ...descendants] : [options.branch]
+  );
+  if (entry.type === "root" && !options.downstack && descendants.length > 0) {
+    throw new DubError(
+      `Branch '${options.branch}' is a root with descendants. Use --downstack to untrack the whole subtree.`
+    );
+  }
+  const reparented = [];
+  if (!options.downstack) {
+    for (const branch of stack.branches) {
+      if (branch.parent !== options.branch) continue;
+      branch.parent = entry.parent;
+      reparented.push({ branch: branch.name, parent: branch.parent });
+    }
+  }
+  stack.branches = stack.branches.filter(
+    (branch) => !removedSet.has(branch.name)
+  );
+  state.stacks = state.stacks.filter(
+    (candidate) => candidate.branches.length > 0
+  );
+  assertStateInvariants(state.stacks);
+  await writeState(state, cwd);
+  return {
+    removed: [options.branch, ...options.downstack ? descendants : []],
+    reparented
+  };
+}
+
+// src/commands/untrack.ts
+function isInteractiveShell4() {
+  return Boolean(process.stdout.isTTY && process.stdin.isTTY);
+}
+async function confirmDownstack(branch, descendants) {
+  const rl = readline4.createInterface({ input: input4, output: output4 });
+  try {
+    const answer = await rl.question(
+      `Branch '${branch}' has descendants (${descendants.join(", ")}). Untrack them too? [y/N] `
+    );
+    const normalized = answer.trim().toLowerCase();
+    return normalized === "y" || normalized === "yes";
+  } finally {
+    rl.close();
+  }
+}
+async function untrack(cwd, branchArg, options = {}) {
+  const branch = branchArg ?? await getCurrentBranch(cwd);
+  const interactive = options.interactive ?? isInteractiveShell4();
+  let downstack = options.downstack ?? false;
+  const context = await getUntrackContext(cwd, branch);
+  if (context.descendants.length > 0 && !downstack) {
+    if (!interactive) {
+      throw new DubError(
+        `Branch '${branch}' has descendants (${context.descendants.join(", ")}). Re-run with --downstack or interactive mode.`
+      );
+    }
+    downstack = await confirmDownstack(branch, context.descendants);
+  }
+  return untrackBranch(cwd, { branch, downstack });
+}
+
 // src/index.ts
 init_errors();
 var require2 = createRequire(import.meta.url);
@@ -2436,17 +3123,21 @@ Examples:
     }
   }
 );
-program.command("log").alias("l").description("Display an ASCII tree of the current stack").addHelpText(
+program.command("log").alias("l").description("Display an ASCII tree of the current stack").option("-s, --stack", "Only show the current stack").option("-a, --all", "Show all stacks (default)").option("-r, --reverse", "Reverse stack/child ordering").addHelpText(
   "after",
   `
 Examples:
   $ dub log    Show the branch tree with current branch highlighted`
-).action(async () => {
-  await printLog(process.cwd());
-});
-program.command("ls").description("Display an ASCII tree of the current stack").action(async () => {
-  await printLog(process.cwd());
-});
+).action(
+  async (options) => {
+    await printLog(process.cwd(), options);
+  }
+);
+program.command("ls").description("Display an ASCII tree of the current stack").option("-s, --stack", "Only show the current stack").option("-a, --all", "Show all stacks (default)").option("-r, --reverse", "Reverse stack/child ordering").action(
+  async (options) => {
+    await printLog(process.cwd(), options);
+  }
+);
 program.command("up").argument("[steps]", "Number of levels to traverse upstack").option("-n, --steps <count>", "Number of levels to traverse upstack").description("Checkout the child branch directly above the current branch").action(async (stepsArg, options) => {
   const steps = parseSteps(stepsArg, options.steps);
   const result = await upBySteps(process.cwd(), steps);
@@ -2499,6 +3190,126 @@ program.command("info").argument("[branch]", "Branch to inspect (defaults to cur
   const info = await branchInfo(process.cwd(), branch);
   console.log(formatBranchInfo(info));
 });
+program.command("track").argument("[branch]", "Branch to track (defaults to current branch)").option("-p, --parent <branch>", "Parent branch for tracking").option(
+  "--no-interactive",
+  "Disable parent prompt and require deterministic behavior"
+).description("Track a branch or update its parent relationship").addHelpText(
+  "after",
+  `
+Examples:
+  $ dub track
+  $ dub track feat/a --parent main`
+).action(
+  async (branch, options) => {
+    const result = await track(process.cwd(), branch, {
+      parent: options.parent,
+      interactive: options.interactive
+    });
+    if (result.status === "tracked") {
+      console.log(
+        chalk2.green(`\u2714 Tracking '${result.branch}' on '${result.parent}'`)
+      );
+      return;
+    }
+    if (result.status === "reparented") {
+      console.log(
+        chalk2.green(
+          `\u2714 Re-parented '${result.branch}' onto '${result.parent}'`
+        )
+      );
+      console.log(
+        chalk2.dim(
+          "  Run 'dub restack' if descendant branches now need rebasing."
+        )
+      );
+      return;
+    }
+    console.log(
+      chalk2.yellow(
+        `\u26A0 '${result.branch}' is already tracked on '${result.parent}'.`
+      )
+    );
+  }
+);
+program.command("untrack").argument("[branch]", "Branch to untrack (defaults to current branch)").option("--downstack", "Also untrack descendants recursively").option("--no-interactive", "Disable prompts and require explicit flags").description(
+  "Remove branch metadata from DubStack without deleting git branches"
+).addHelpText(
+  "after",
+  `
+Examples:
+  $ dub untrack
+  $ dub untrack feat/a --downstack`
+).action(
+  async (branch, options) => {
+    const result = await untrack(process.cwd(), branch, {
+      downstack: options.downstack,
+      interactive: options.interactive
+    });
+    console.log(
+      chalk2.green(
+        `\u2714 Untracked ${result.removed.length} branch(es): ${result.removed.join(", ")}`
+      )
+    );
+    for (const entry of result.reparented) {
+      console.log(
+        chalk2.dim(
+          `  \u21B3 Re-parented '${entry.branch}' to '${entry.parent ?? "(none)"}'`
+        )
+      );
+    }
+  }
+);
+program.command("delete").argument("[branch]", "Branch to delete (defaults to current branch)").option("--upstack", "Also delete descendants of the target branch").option("--downstack", "Also delete ancestors toward trunk").option("-f, --force", "Delete branches even when not merged").option("-q, --quiet", "Skip confirmation prompts").option("--no-interactive", "Disable prompts and require explicit flags").description("Delete local branches and update DubStack metadata").addHelpText(
+  "after",
+  `
+Examples:
+  $ dub delete feat/a
+  $ dub delete feat/a --upstack -f -q`
+).action(
+  async (branch, options) => {
+    const result = await deleteCommand(process.cwd(), branch, {
+      upstack: options.upstack,
+      downstack: options.downstack,
+      force: options.force,
+      quiet: options.quiet,
+      interactive: options.interactive
+    });
+    if (result.cancelled) {
+      console.log(chalk2.yellow("\u26A0 Delete cancelled."));
+      return;
+    }
+    console.log(
+      chalk2.green(
+        `\u2714 Deleted ${result.deleted.length} branch(es): ${result.deleted.join(", ")}`
+      )
+    );
+    for (const entry of result.reparented) {
+      console.log(
+        chalk2.dim(
+          `  \u21B3 Re-parented '${entry.branch}' to '${entry.parent ?? "(none)"}'`
+        )
+      );
+    }
+  }
+);
+program.command("parent").argument("[branch]", "Branch to inspect (defaults to current branch)").description("Show the direct parent branch").action(async (branch) => {
+  const result = await parent(process.cwd(), branch);
+  console.log(result.parent);
+});
+program.command("children").argument("[branch]", "Branch to inspect (defaults to current branch)").description("Show direct child branches").action(async (branch) => {
+  const result = await children(process.cwd(), branch);
+  if (result.children.length === 0) {
+    console.log("(none)");
+    return;
+  }
+  for (const child of result.children) {
+    console.log(child);
+  }
+});
+program.command("trunk").argument("[branch]", "Branch to inspect (defaults to current branch)").description("Show trunk/root branch for the active stack").action(async (branch) => {
+  const result = await trunk(process.cwd(), branch);
+  console.log(result.trunk);
+});
 program.command("sync").description("Sync tracked branches with remote and reconcile divergence").option(
   "--restack",
   "Restack branches after sync (disable with --no-restack)",
@@ -2536,6 +3347,37 @@ Examples:
     }
   }
 });
+program.command("continue").description("Continue the active restack or git rebase operation").action(async () => {
+  const result = await continueCommand(process.cwd());
+  if (result.continued === "rebase") {
+    console.log(chalk2.green("\u2714 Continued git rebase."));
+    return;
+  }
+  if (result.restackResult?.status === "conflict") {
+    console.log(
+      chalk2.yellow(
+        `\u26A0 Conflict while restacking '${result.restackResult.conflictBranch}'`
+      )
+    );
+    console.log(
+      chalk2.dim("  Resolve conflicts, stage changes, then run: dub continue")
+    );
+    return;
+  }
+  if (result.restackResult?.status === "up-to-date") {
+    console.log(chalk2.green("\u2714 Stack is already up to date."));
+    return;
+  }
+  console.log(chalk2.green("\u2714 Continued restack."));
+});
+program.command("abort").description("Abort the active restack or git rebase operation").action(async () => {
+  const result = await abortCommand(process.cwd());
+  if (result.aborted === "restack") {
+    console.log(chalk2.green("\u2714 Aborted restack and cleared progress."));
+    return;
+  }
+  console.log(chalk2.green("\u2714 Aborted git rebase."));
+});
 program.command("undo").description("Undo the last dub create or dub restack operation").addHelpText(
   "after",
   `
@@ -2570,8 +3412,8 @@ program.command("checkout").alias("co").argument("[branch]", "Branch to checkout
       const result = await checkout(branch, process.cwd());
       console.log(chalk2.green(`\u2714 Switched to '${result.branch}'`));
     } else if (options.trunk) {
-      const trunk = await resolveCheckoutTrunk(process.cwd());
-      const result = await checkout(trunk, process.cwd());
+      const trunk2 = await resolveCheckoutTrunk(process.cwd());
+      const result = await checkout(trunk2, process.cwd());
       console.log(chalk2.green(`\u2714 Switched to '${result.branch}'`));
     } else {
       const result = await interactiveCheckout(process.cwd(), {
@@ -2635,9 +3477,9 @@ async function runSubmit(options) {
     }
   }
 }
-async function printLog(cwd) {
-  const output2 = await log(cwd);
-  const styled = output2.replace(/\*(.+?) \(Current\)\*/g, chalk2.bold.cyan("$1 (Current)")).replace(/⚠ \(missing\)/g, chalk2.yellow("\u26A0 (missing)"));
+async function printLog(cwd, options = {}) {
+  const output5 = await log(cwd, options);
+  const styled = output5.replace(/\*(.+?) \(Current\)\*/g, chalk2.bold.cyan("$1 (Current)")).replace(/⚠ \(missing\)/g, chalk2.yellow("\u26A0 (missing)"));
   console.log(styled);
 }
 function parseSteps(positional, option) {