dubstack 0.3.0 → 0.5.0

package/dist/index.js

@@ -1,20 +1,27 @@
 #!/usr/bin/env node
-
-// src/index.ts
-import { createRequire } from "module";
-import chalk from "chalk";
-import { Command } from "commander";
-
-// src/commands/checkout.ts
-import search from "@inquirer/search";
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 
 // src/lib/errors.ts
-var DubError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "DubError";
+var DubError;
+var init_errors = __esm({
+  "src/lib/errors.ts"() {
+    "use strict";
+    DubError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "DubError";
+      }
+    };
   }
-};
+});
 
 // src/lib/git.ts
 import { execa } from "execa";
@@ -204,6 +211,69 @@ async function commitStaged(message, cwd) {
     );
   }
 }
+async function commit(cwd, options) {
+  const args = ["commit"];
+  if (options?.message) {
+    args.push("-m", options.message);
+  }
+  if (options?.noEdit) {
+    args.push("--no-edit");
+  }
+  try {
+    await execa("git", args, { cwd, stdio: "inherit" });
+  } catch {
+    throw new DubError(
+      "Commit failed. Ensure there are staged changes and git hooks pass."
+    );
+  }
+}
+async function amendCommit(cwd, options) {
+  const args = ["commit", "--amend"];
+  if (options?.message) {
+    args.push("-m", options.message);
+  }
+  if (options?.noEdit) {
+    args.push("--no-edit");
+  }
+  try {
+    await execa("git", args, { cwd, stdio: "inherit" });
+  } catch (e) {
+    throw new DubError(
+      `Amend failed: ${e instanceof Error ? e.message : String(e)}`
+    );
+  }
+}
+async function interactiveRebase(base, cwd) {
+  try {
+    await execa("git", ["rebase", "-i", base], { cwd, stdio: "inherit" });
+  } catch {
+    throw new DubError("Interactive rebase failed or was cancelled.");
+  }
+}
+async function interactiveStage(cwd) {
+  try {
+    await execa("git", ["add", "-p"], { cwd, stdio: "inherit" });
+  } catch {
+    throw new DubError("Interactive staging failed.");
+  }
+}
+async function stageUpdate(cwd) {
+  try {
+    await execa("git", ["add", "-u"], { cwd });
+  } catch {
+    throw new DubError("Failed to stage updates.");
+  }
+}
+async function getDiff(cwd, staged) {
+  try {
+    const args = ["diff"];
+    if (staged) args.push("--cached");
+    const { stdout } = await execa("git", args, { cwd });
+    return stdout;
+  } catch {
+    return "";
+  }
+}
 async function listBranches(cwd) {
   try {
     const { stdout } = await execa(
@@ -216,6 +286,111 @@ async function listBranches(cwd) {
     throw new DubError("Failed to list branches.");
   }
 }
+async function fetchBranches(branches, cwd, remote = "origin") {
+  if (branches.length === 0) return;
+  for (const branch of branches) {
+    try {
+      await execa("git", ["fetch", remote, branch], { cwd });
+    } catch (error) {
+      const stderr = typeof error?.stderr === "string" ? error.stderr : "";
+      const stdout = typeof error?.stdout === "string" ? error.stdout : "";
+      const output2 = `${stderr}
+${stdout}`;
+      if (output2.includes("couldn't find remote ref")) {
+        continue;
+      }
+      throw new DubError(`Failed to fetch branches from '${remote}'.`);
+    }
+  }
+}
+async function remoteBranchExists(branch, cwd, remote = "origin") {
+  try {
+    await execa("git", ["rev-parse", "--verify", `${remote}/${branch}`], {
+      cwd
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function getRefSha(ref, cwd) {
+  try {
+    const { stdout } = await execa("git", ["rev-parse", ref], { cwd });
+    return stdout.trim();
+  } catch {
+    throw new DubError(`Failed to read ref '${ref}'.`);
+  }
+}
+async function isAncestor(ancestor, descendant, cwd) {
+  try {
+    await execa("git", ["merge-base", "--is-ancestor", ancestor, descendant], {
+      cwd
+    });
+    return true;
+  } catch (error) {
+    const exitCode = error.exitCode;
+    if (exitCode === 1) return false;
+    throw new DubError(
+      `Failed to compare ancestry between '${ancestor}' and '${descendant}'.`
+    );
+  }
+}
+async function checkoutRemoteBranch(branch, cwd, remote = "origin") {
+  try {
+    await execa("git", ["checkout", "-B", branch, `${remote}/${branch}`], {
+      cwd
+    });
+  } catch {
+    throw new DubError(
+      `Failed to create local branch '${branch}' from '${remote}/${branch}'.`
+    );
+  }
+}
+async function hardResetBranchToRef(branch, ref, cwd) {
+  try {
+    const current = await getCurrentBranch(cwd).catch(() => null);
+    if (current !== branch) {
+      await checkoutBranch(branch, cwd);
+    }
+    await execa("git", ["reset", "--hard", ref], { cwd });
+  } catch {
+    throw new DubError(`Failed to hard reset '${branch}' to '${ref}'.`);
+  }
+}
+async function fastForwardBranchToRef(branch, ref, cwd) {
+  try {
+    const current = await getCurrentBranch(cwd).catch(() => null);
+    if (current !== branch) {
+      await checkoutBranch(branch, cwd);
+    }
+    await execa("git", ["merge", "--ff-only", ref], { cwd });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function rebaseBranchOntoRef(branch, ref, cwd) {
+  try {
+    const current = await getCurrentBranch(cwd).catch(() => null);
+    if (current !== branch) {
+      await checkoutBranch(branch, cwd);
+    }
+    await execa("git", ["rebase", ref], { cwd });
+    return true;
+  } catch {
+    try {
+      await execa("git", ["rebase", "--abort"], { cwd });
+    } catch {
+    }
+    return false;
+  }
+}
+var init_git = __esm({
+  "src/lib/git.ts"() {
+    "use strict";
+    init_errors();
+  }
+});
 
 // src/lib/state.ts
 import * as crypto from "crypto";
@@ -236,7 +411,7 @@ async function readState(cwd) {
   }
   try {
     const raw = fs.readFileSync(statePath, "utf-8");
-    return JSON.parse(raw);
+    return normalizeState(JSON.parse(raw));
   } catch {
     throw new DubError(
       "State file is corrupted. Delete .git/dubstack and run 'dub init' to re-initialize."
@@ -280,6 +455,12 @@ function findStackForBranch(state, name) {
     (stack) => stack.branches.some((b) => b.name === name)
   );
 }
+function getParent(state, branchName) {
+  const stack = findStackForBranch(state, branchName);
+  if (!stack) return void 0;
+  const branch = stack.branches.find((b) => b.name === branchName);
+  return branch?.parent ?? void 0;
+}
 function addBranchToStack(state, child, parent) {
   if (findStackForBranch(state, child)) {
     throw new DubError(`Branch '${child}' is already tracked in a stack.`);
@@ -288,7 +469,10 @@ function addBranchToStack(state, child, parent) {
     name: child,
     parent,
     pr_number: null,
-    pr_link: null
+    pr_link: null,
+    last_submitted_version: null,
+    last_synced_at: null,
+    sync_source: null
   };
   const existingStack = findStackForBranch(state, parent);
   if (existingStack) {
@@ -299,7 +483,10 @@ function addBranchToStack(state, child, parent) {
       type: "root",
       parent: null,
       pr_number: null,
-      pr_link: null
+      pr_link: null,
+      last_submitted_version: null,
+      last_synced_at: null,
+      sync_source: null
     };
     state.stacks.push({
       id: crypto.randomUUID(),
@@ -307,6 +494,22 @@ function addBranchToStack(state, child, parent) {
     });
   }
 }
+function normalizeState(state) {
+  return {
+    stacks: state.stacks.map((stack) => ({
+      ...stack,
+      branches: stack.branches.map((branch) => normalizeBranch(branch))
+    }))
+  };
+}
+function normalizeBranch(branch) {
+  return {
+    ...branch,
+    last_submitted_version: branch.last_submitted_version ?? null,
+    last_synced_at: branch.last_synced_at ?? null,
+    sync_source: branch.sync_source ?? null
+  };
+}
 function topologicalOrder(stack) {
   const result = [];
   const root = stack.branches.find((b) => b.type === "root");
@@ -329,76 +532,13 @@ function topologicalOrder(stack) {
   }
   return result;
 }
-
-// src/commands/checkout.ts
-function getTrackedBranches(state) {
-  const names = /* @__PURE__ */ new Set();
-  for (const stack of state.stacks) {
-    for (const branch of stack.branches) {
-      names.add(branch.name);
-    }
-  }
-  return [...names].sort();
-}
-function getValidBranches(tracked, local) {
-  const localSet = new Set(local);
-  return tracked.filter((b) => localSet.has(b));
-}
-async function checkout(name, cwd) {
-  await checkoutBranch(name, cwd);
-  return { branch: name };
-}
-async function interactiveCheckout(cwd) {
-  const state = await readState(cwd);
-  const trackedBranches = getTrackedBranches(state);
-  const localBranches = await listBranches(cwd);
-  const validBranches = getValidBranches(trackedBranches, localBranches);
-  if (validBranches.length === 0) {
-    throw new DubError(
-      "No valid tracked branches found. Run 'dub create' first."
-    );
-  }
-  let currentBranch = null;
-  try {
-    currentBranch = await getCurrentBranch(cwd);
-  } catch {
-  }
-  const controller = new AbortController();
-  const onKeypress = (_str, key) => {
-    if (key && key.name === "escape") {
-      controller.abort();
-    }
-  };
-  process.stdin.on("keypress", onKeypress);
-  try {
-    const selected = await search(
-      {
-        message: "Checkout a branch (autocomplete or arrow keys)",
-        source(term) {
-          const filtered = term ? validBranches.filter(
-            (b) => b.toLowerCase().includes(term.toLowerCase())
-          ) : validBranches;
-          return filtered.map((name) => ({
-            name,
-            value: name,
-            disabled: name === currentBranch ? "(current)" : false
-          }));
-        }
-      },
-      { signal: controller.signal }
-    );
-    return checkout(selected, cwd);
-  } catch (error) {
-    if (error instanceof Error) {
-      if (error.name === "ExitPromptError" || error.name === "AbortError" || error.name === "AbortPromptError") {
-        return null;
-      }
-    }
-    throw error;
-  } finally {
-    process.stdin.off("keypress", onKeypress);
+var init_state = __esm({
+  "src/lib/state.ts"() {
+    "use strict";
+    init_errors();
+    init_git();
   }
-}
+});
 
 // src/lib/undo-log.ts
 import * as fs2 from "fs";
@@ -426,55 +566,546 @@ async function clearUndoEntry(cwd) {
     fs2.unlinkSync(undoPath);
   }
 }
+var init_undo_log = __esm({
+  "src/lib/undo-log.ts"() {
+    "use strict";
+    init_errors();
+    init_state();
+  }
+});
 
-// src/commands/create.ts
-async function create(name, cwd, options) {
-  if (options?.all && !options.message) {
-    throw new DubError("'-a' requires '-m'. Pass a commit message.");
+// src/commands/restack.ts
+import * as fs4 from "fs";
+import * as path4 from "path";
+async function restack(cwd) {
+  const state = await readState(cwd);
+  if (!await isWorkingTreeClean(cwd)) {
+    throw new DubError(
+      "Working tree has uncommitted changes. Commit or stash them before restacking."
+    );
   }
-  const state = await ensureState(cwd);
-  const parent = await getCurrentBranch(cwd);
-  if (await branchExists(name, cwd)) {
-    throw new DubError(`Branch '${name}' already exists.`);
+  const originalBranch = await getCurrentBranch(cwd);
+  const targetStacks = getTargetStacks(state.stacks, originalBranch);
+  if (targetStacks.length === 0) {
+    throw new DubError(
+      `Branch '${originalBranch}' is not part of any stack. Run 'dub create' first.`
+    );
   }
-  if (options?.message) {
-    if (options.all) {
-      await stageAll(cwd);
-    }
-    if (!await hasStagedChanges(cwd)) {
-      const hint = options.all ? "No changes to commit." : "No staged changes. Stage files with 'git add' or use '-a' to stage all.";
-      throw new DubError(hint);
+  const allBranches = targetStacks.flatMap((s) => s.branches);
+  for (const branch of allBranches) {
+    if (!await branchExists(branch.name, cwd)) {
+      throw new DubError(
+        `Branch '${branch.name}' is tracked in state but no longer exists in git.
+  Remove it from the stack or recreate it before restacking.`
+      );
     }
   }
+  const branchTips = {};
+  for (const branch of allBranches) {
+    branchTips[branch.name] = await getBranchTip(branch.name, cwd);
+  }
+  const steps = await buildRestackSteps(targetStacks, cwd);
+  if (steps.length === 0) {
+    return { status: "up-to-date", rebased: [] };
+  }
   await saveUndoEntry(
     {
-      operation: "create",
+      operation: "restack",
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      previousBranch: parent,
+      previousBranch: originalBranch,
       previousState: structuredClone(state),
-      branchTips: {},
-      createdBranches: [name]
+      branchTips,
+      createdBranches: []
     },
     cwd
   );
-  await createBranch(name, cwd);
-  addBranchToStack(state, name, parent);
-  await writeState(state, cwd);
-  if (options?.message) {
-    try {
-      await commitStaged(options.message, cwd);
-    } catch (error) {
-      const reason = error instanceof DubError ? error.message : String(error);
-      throw new DubError(
-        `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 };
+  const progress = { originalBranch, steps };
+  await writeProgress(progress, cwd);
+  return executeRestackSteps(progress, cwd);
+}
+async function restackContinue(cwd) {
+  const progress = await readProgress(cwd);
+  if (!progress) {
+    throw new DubError("No restack in progress. Run 'dub restack' to start.");
+  }
+  await rebaseContinue(cwd);
+  const conflictedStep = progress.steps.find((s) => s.status === "conflicted");
+  if (conflictedStep) {
+    conflictedStep.status = "done";
+  }
+  return executeRestackSteps(progress, cwd);
+}
+async function executeRestackSteps(progress, cwd) {
+  const rebased = [];
+  for (const step of progress.steps) {
+    if (step.status !== "pending") {
+      if (step.status === "done") rebased.push(step.branch);
+      continue;
+    }
+    const parentNewTip = await getBranchTip(step.parent, cwd);
+    if (parentNewTip === step.parentOldTip) {
+      step.status = "skipped";
+      await writeProgress(progress, cwd);
+      continue;
+    }
+    try {
+      await rebaseOnto(parentNewTip, step.parentOldTip, step.branch, cwd);
+      step.status = "done";
+      rebased.push(step.branch);
+      await writeProgress(progress, cwd);
+    } catch (error) {
+      if (error instanceof DubError && error.message.includes("Conflict")) {
+        step.status = "conflicted";
+        await writeProgress(progress, cwd);
+        return { status: "conflict", rebased, conflictBranch: step.branch };
+      }
+      throw error;
+    }
+  }
+  await clearProgress(cwd);
+  await checkoutBranch(progress.originalBranch, cwd);
+  const allSkipped = progress.steps.every(
+    (s) => s.status === "skipped" || s.status === "done"
+  );
+  return {
+    status: rebased.length === 0 && allSkipped ? "up-to-date" : "success",
+    rebased
+  };
+}
+function getTargetStacks(stacks, currentBranch) {
+  const rootStacks = stacks.filter(
+    (s) => s.branches.some((b) => b.name === currentBranch && b.type === "root")
+  );
+  if (rootStacks.length > 0) return rootStacks;
+  const stack = stacks.find(
+    (s) => s.branches.some((b) => b.name === currentBranch)
+  );
+  return stack ? [stack] : [];
+}
+async function buildRestackSteps(stacks, cwd) {
+  const steps = [];
+  for (const stack of stacks) {
+    const ordered = topologicalOrder(stack);
+    for (const branch of ordered) {
+      if (branch.type === "root" || !branch.parent) continue;
+      const mergeBase = await getMergeBase(branch.parent, branch.name, cwd);
+      steps.push({
+        branch: branch.name,
+        parent: branch.parent,
+        parentOldTip: mergeBase,
+        status: "pending"
+      });
+    }
+  }
+  return steps;
+}
+async function getProgressPath(cwd) {
+  const dubDir = await getDubDir(cwd);
+  return path4.join(dubDir, "restack-progress.json");
+}
+async function writeProgress(progress, cwd) {
+  const progressPath = await getProgressPath(cwd);
+  fs4.writeFileSync(progressPath, `${JSON.stringify(progress, null, 2)}
+`);
+}
+async function readProgress(cwd) {
+  const progressPath = await getProgressPath(cwd);
+  if (!fs4.existsSync(progressPath)) return null;
+  const raw = fs4.readFileSync(progressPath, "utf-8");
+  return JSON.parse(raw);
+}
+async function clearProgress(cwd) {
+  const progressPath = await getProgressPath(cwd);
+  if (fs4.existsSync(progressPath)) {
+    fs4.unlinkSync(progressPath);
+  }
+}
+var init_restack = __esm({
+  "src/commands/restack.ts"() {
+    "use strict";
+    init_errors();
+    init_git();
+    init_state();
+    init_undo_log();
+  }
+});
+
+// src/lib/skills.ts
+function getSkillRemote(name) {
+  return AVAILABLE_SKILLS[name];
+}
+var AVAILABLE_SKILLS;
+var init_skills = __esm({
+  "src/lib/skills.ts"() {
+    "use strict";
+    AVAILABLE_SKILLS = {
+      dubstack: "wiseiodev/dubstack/skills/dubstack",
+      "dub-flow": "wiseiodev/dubstack/skills/dub-flow"
+    };
+  }
+});
+
+// src/commands/skills.ts
+var skills_exports = {};
+__export(skills_exports, {
+  addSkills: () => addSkills,
+  removeSkills: () => removeSkills
+});
+import chalk from "chalk";
+import { execa as execa3 } from "execa";
+function validateSkills(skills) {
+  const invalidSkills = skills.filter((s) => !(s in AVAILABLE_SKILLS));
+  if (invalidSkills.length > 0) {
+    throw new DubError(
+      `Unknown skill(s): ${invalidSkills.join(", ")}. Available skills: ${Object.keys(AVAILABLE_SKILLS).join(", ")}`
+    );
+  }
+  return skills;
+}
+async function addSkills(skills, options = {}) {
+  const targets = skills.length > 0 ? validateSkills(skills) : Object.keys(AVAILABLE_SKILLS);
+  console.log(chalk.blue(`Adding ${targets.length} skill(s)...`));
+  for (const skill of targets) {
+    const remote = getSkillRemote(skill);
+    const args = ["skills", "add", remote];
+    if (options.global) args.push("--global");
+    const command = `npx ${args.join(" ")}`;
+    console.log(chalk.dim(`Running: ${command}`));
+    if (!options.dryRun) {
+      try {
+        await execa3("npx", args, { stdio: "inherit" });
+        console.log(chalk.green(`\u2714 Added skill: ${skill}`));
+      } catch (error) {
+        console.error(chalk.red(`\u2716 Failed to add skill: ${skill}`));
+        throw error;
+      }
+    }
+  }
+}
+async function removeSkills(skills, options = {}) {
+  const targets = skills.length > 0 ? validateSkills(skills) : Object.keys(AVAILABLE_SKILLS);
+  console.log(chalk.blue(`Removing ${targets.length} skill(s)...`));
+  for (const skill of targets) {
+    const args = ["skills", "remove", skill];
+    if (options.global) args.push("--global");
+    const command = `npx ${args.join(" ")}`;
+    console.log(chalk.dim(`Running: ${command}`));
+    if (!options.dryRun) {
+      try {
+        await execa3("npx", args, { stdio: "inherit" });
+        console.log(chalk.green(`\u2714 Removed skill: ${skill}`));
+      } catch (error) {
+        console.error(chalk.red(`\u2716 Failed to remove skill: ${skill}`));
+        throw error;
+      }
+    }
+  }
+}
+var init_skills2 = __esm({
+  "src/commands/skills.ts"() {
+    "use strict";
+    init_errors();
+    init_skills();
+  }
+});
+
+// src/commands/modify.ts
+var modify_exports = {};
+__export(modify_exports, {
+  modify: () => modify
+});
+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) {
+      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}'...`);
+    await interactiveRebase(parentTip, cwd);
+    await restackChildren(cwd);
+    return;
+  }
+  if (options.patch) {
+    await interactiveStage(cwd);
+  } else if (options.all) {
+    await stageAll(cwd);
+  } else if (options.update) {
+    await stageUpdate(cwd);
+  }
+  await printVerboseDiff(cwd, options.verbose ?? 0);
+  const hasStaged = await hasStagedChanges(cwd);
+  const shouldCreateNew = options.commit;
+  const message = normalizeMessage(options.message);
+  const noEdit = !options.edit && !!message;
+  if (shouldCreateNew) {
+    if (!hasStaged) {
+      throw new DubError("No staged changes to commit.");
+    }
+    await commit(cwd, { message, noEdit: !options.edit });
+  } else {
+    await amendCommit(cwd, { message, noEdit });
+  }
+  await restackChildren(cwd);
+}
+function normalizeMessage(message) {
+  if (Array.isArray(message)) {
+    const chunks = message.map((part) => part.trim()).filter(Boolean);
+    return chunks.length > 0 ? chunks.join("\n\n") : void 0;
+  }
+  return message;
+}
+async function printVerboseDiff(cwd, level) {
+  if (level < 1) return;
+  const staged = await getDiff(cwd, true);
+  console.log(staged || "(no staged diff)");
+  if (level > 1) {
+    const unstaged = await getDiff(cwd, false);
+    console.log(unstaged || "(no unstaged diff)");
+  }
+}
+async function restackChildren(cwd) {
+  try {
+    await restack(cwd);
+  } catch (e) {
+    if (e instanceof DubError && e.message.includes("Conflict")) {
+      console.log(
+        "\u26A0 Modify successful, but auto-restacking encountered conflicts."
+      );
+      console.log("  Run 'dub restack --continue' to resolve.");
+    } else {
+      console.log("\u26A0 Modify successful, but auto-restacking failed.");
+      console.log(`  ${e instanceof Error ? e.message : String(e)}`);
+    }
+  }
+}
+var init_modify = __esm({
+  "src/commands/modify.ts"() {
+    "use strict";
+    init_errors();
+    init_git();
+    init_state();
+    init_restack();
+  }
+});
+
+// src/index.ts
+import { createRequire } from "module";
+import chalk2 from "chalk";
+import { Command } from "commander";
+
+// src/commands/branch.ts
+init_git();
+init_state();
+function findRootName(stack) {
+  return stack.branches.find((branch) => branch.type === "root")?.name ?? null;
+}
+function getChildren(stack, branchName) {
+  return stack.branches.filter((branch) => branch.parent === branchName).map((branch) => branch.name).sort();
+}
+async function branchInfo(cwd, branchName) {
+  const state = await readState(cwd);
+  const resolvedBranch = branchName ?? await getCurrentBranch(cwd);
+  const stack = findStackForBranch(state, resolvedBranch);
+  if (!stack) {
+    return {
+      currentBranch: resolvedBranch,
+      tracked: false,
+      stackId: null,
+      root: null,
+      parent: null,
+      children: []
+    };
+  }
+  const current = stack.branches.find(
+    (branch) => branch.name === resolvedBranch
+  );
+  return {
+    currentBranch: resolvedBranch,
+    tracked: true,
+    stackId: stack.id,
+    root: findRootName(stack),
+    parent: current?.parent ?? null,
+    children: getChildren(stack, resolvedBranch)
+  };
+}
+function formatBranchInfo(info) {
+  if (!info.tracked) {
+    return [
+      `Branch: ${info.currentBranch}`,
+      "Tracked: no",
+      "Status: not tracked by DubStack"
+    ].join("\n");
+  }
+  const childrenLabel = info.children.length > 0 ? info.children.join(", ") : "(none)";
+  return [
+    `Branch: ${info.currentBranch}`,
+    "Tracked: yes",
+    `Stack ID: ${info.stackId ?? "(unknown)"}`,
+    `Root: ${info.root ?? "(unknown)"}`,
+    `Parent: ${info.parent ?? "(root)"}`,
+    `Children: ${childrenLabel}`
+  ].join("\n");
+}
+
+// src/commands/checkout.ts
+init_errors();
+init_git();
+init_state();
+import search from "@inquirer/search";
+function getTrackedBranches(state) {
+  const names = /* @__PURE__ */ new Set();
+  for (const stack of state.stacks) {
+    for (const branch of stack.branches) {
+      names.add(branch.name);
+    }
+  }
+  return [...names].sort();
+}
+function getValidBranches(tracked, local) {
+  const localSet = new Set(local);
+  return tracked.filter((b) => localSet.has(b));
+}
+function getStackRelativeBranches(state, branchName) {
+  const stack = findStackForBranch(state, branchName);
+  if (!stack) return [];
+  return [...new Set(stack.branches.map((branch) => branch.name))].sort();
+}
+async function resolveCheckoutTrunk(cwd) {
+  const state = await readState(cwd);
+  const currentBranch = await getCurrentBranch(cwd);
+  const stack = findStackForBranch(state, currentBranch);
+  const trackedRoot = stack?.branches.find((branch) => branch.type === "root")?.name ?? null;
+  if (trackedRoot) return trackedRoot;
+  if (await branchExists("main", cwd)) return "main";
+  if (await branchExists("master", cwd)) return "master";
+  throw new DubError(
+    `Could not determine trunk branch for '${currentBranch}'.`
+  );
+}
+async function checkout(name, cwd) {
+  await checkoutBranch(name, cwd);
+  return { branch: name };
+}
+async function interactiveCheckout(cwd, options = {}) {
+  const state = await readState(cwd);
+  const localBranches = await listBranches(cwd);
+  const currentBranch = await getCurrentBranch(cwd).catch(() => null);
+  const trackedBranches = getTrackedBranches(state);
+  const stackBranches = currentBranch ? getStackRelativeBranches(state, currentBranch) : [];
+  let branchCandidates = options.showUntracked ? [...new Set(localBranches)].sort() : getValidBranches(trackedBranches, localBranches);
+  if (options.stack && stackBranches.length > 0) {
+    const stackSet = new Set(stackBranches);
+    branchCandidates = branchCandidates.filter((name) => stackSet.has(name));
+  }
+  const validBranches = branchCandidates;
+  if (validBranches.length === 0) {
+    throw new DubError(
+      "No valid tracked branches found. Run 'dub create' first."
+    );
+  }
+  const controller = new AbortController();
+  const onKeypress = (_str, key) => {
+    if (key && key.name === "escape") {
+      controller.abort();
+    }
+  };
+  process.stdin.on("keypress", onKeypress);
+  try {
+    const selected = await search(
+      {
+        message: "Checkout a branch (autocomplete or arrow keys)",
+        source(term) {
+          const filtered = term ? validBranches.filter(
+            (b) => b.toLowerCase().includes(term.toLowerCase())
+          ) : validBranches;
+          return filtered.map((name) => ({
+            name,
+            value: name,
+            disabled: name === currentBranch ? "(current)" : false
+          }));
+        }
+      },
+      { signal: controller.signal }
+    );
+    return checkout(selected, cwd);
+  } catch (error) {
+    if (error instanceof Error) {
+      if (error.name === "ExitPromptError" || error.name === "AbortError" || error.name === "AbortPromptError") {
+        return null;
+      }
+    }
+    throw error;
+  } finally {
+    process.stdin.off("keypress", onKeypress);
+  }
+}
+
+// src/commands/create.ts
+init_errors();
+init_git();
+init_state();
+init_undo_log();
+async function create(name, cwd, options) {
+  if ((options?.all || options?.update || options?.patch) && !options.message) {
+    throw new DubError(
+      "'--all', '--update', and '--patch' require '-m'. Pass a commit message."
+    );
+  }
+  const state = await ensureState(cwd);
+  const parent = await getCurrentBranch(cwd);
+  if (await branchExists(name, cwd)) {
+    throw new DubError(`Branch '${name}' already exists.`);
+  }
+  if (options?.message) {
+    if (options.patch) {
+      await interactiveStage(cwd);
+    } else if (options.all) {
+      await stageAll(cwd);
+    } else if (options.update) {
+      await stageUpdate(cwd);
+    }
+    if (!await hasStagedChanges(cwd)) {
+      const hint = options.all ? "No changes to commit." : "No staged changes. Stage files with 'git add' or use '-a' to stage all.";
+      throw new DubError(hint);
+    }
+  }
+  await saveUndoEntry(
+    {
+      operation: "create",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      previousBranch: parent,
+      previousState: structuredClone(state),
+      branchTips: {},
+      createdBranches: [name]
+    },
+    cwd
+  );
+  await createBranch(name, cwd);
+  addBranchToStack(state, name, parent);
+  await writeState(state, cwd);
+  if (options?.message) {
+    try {
+      await commitStaged(options.message, cwd);
+    } catch (error) {
+      const reason = error instanceof DubError ? error.message : String(error);
+      throw new DubError(
+        `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 };
 }
 
 // src/commands/init.ts
+init_errors();
+init_git();
+init_state();
 import * as fs3 from "fs";
 import * as path3 from "path";
 async function init(cwd) {
@@ -506,6 +1137,8 @@ async function init(cwd) {
 }
 
 // src/commands/log.ts
+init_git();
+init_state();
 async function log(cwd) {
   const state = await readState(cwd);
   if (state.stacks.length === 0) {
@@ -573,159 +1206,150 @@ async function renderNode(branch, currentBranch, childMap, prefix, isRoot, isLas
   }
 }
 
-// src/commands/restack.ts
-import * as fs4 from "fs";
-import * as path4 from "path";
-async function restack(cwd) {
-  const state = await readState(cwd);
-  if (!await isWorkingTreeClean(cwd)) {
+// src/commands/navigate.ts
+init_errors();
+init_git();
+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 getTrackedStackOrThrow(stateBranch, stack) {
+  if (!stack) {
     throw new DubError(
-      "Working tree has uncommitted changes. Commit or stash them before restacking."
+      `Current branch '${stateBranch}' is not tracked by DubStack.`
     );
   }
-  const originalBranch = await getCurrentBranch(cwd);
-  const targetStacks = getTargetStacks(state.stacks, originalBranch);
-  if (targetStacks.length === 0) {
-    throw new DubError(
-      `Branch '${originalBranch}' is not part of any stack. Run 'dub create' first.`
-    );
+  return stack;
+}
+async function upBySteps(cwd, steps) {
+  if (!Number.isInteger(steps) || steps < 1) {
+    throw new DubError("'steps' must be a positive integer.");
   }
-  const allBranches = targetStacks.flatMap((s) => s.branches);
-  for (const branch of allBranches) {
-    if (!await branchExists(branch.name, cwd)) {
+  const state = await readState(cwd);
+  const current = await getCurrentBranch(cwd);
+  const stack = getTrackedStackOrThrow(
+    current,
+    findStackForBranch(state, current)
+  );
+  let target = current;
+  for (let i = 0; i < steps; i++) {
+    const children = getChildren2(stack, target);
+    if (children.length === 0) {
+      throw new DubError(`No branch above '${target}' in the current stack.`);
+    }
+    if (children.length > 1) {
       throw new DubError(
-        `Branch '${branch.name}' is tracked in state but no longer exists in git.
-  Remove it from the stack or recreate it before restacking.`
+        `Branch '${target}' has multiple children; 'dub up' requires a linear stack path.`
       );
     }
+    target = children[0];
   }
-  const branchTips = {};
-  for (const branch of allBranches) {
-    branchTips[branch.name] = await getBranchTip(branch.name, cwd);
-  }
-  const steps = await buildRestackSteps(targetStacks, cwd);
-  if (steps.length === 0) {
-    return { status: "up-to-date", rebased: [] };
-  }
-  await saveUndoEntry(
-    {
-      operation: "restack",
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      previousBranch: originalBranch,
-      previousState: structuredClone(state),
-      branchTips,
-      createdBranches: []
-    },
-    cwd
-  );
-  const progress = { originalBranch, steps };
-  await writeProgress(progress, cwd);
-  return executeRestackSteps(progress, cwd);
+  await checkoutBranch(target, cwd);
+  return { branch: target, changed: target !== current };
 }
-async function restackContinue(cwd) {
-  const progress = await readProgress(cwd);
-  if (!progress) {
-    throw new DubError("No restack in progress. Run 'dub restack' to start.");
-  }
-  await rebaseContinue(cwd);
-  const conflictedStep = progress.steps.find((s) => s.status === "conflicted");
-  if (conflictedStep) {
-    conflictedStep.status = "done";
+async function downBySteps(cwd, steps) {
+  if (!Number.isInteger(steps) || steps < 1) {
+    throw new DubError("'steps' must be a positive integer.");
   }
-  return executeRestackSteps(progress, cwd);
-}
-async function executeRestackSteps(progress, cwd) {
-  const rebased = [];
-  for (const step of progress.steps) {
-    if (step.status !== "pending") {
-      if (step.status === "done") rebased.push(step.branch);
-      continue;
-    }
-    const parentNewTip = await getBranchTip(step.parent, cwd);
-    if (parentNewTip === step.parentOldTip) {
-      step.status = "skipped";
-      await writeProgress(progress, cwd);
-      continue;
+  const state = await readState(cwd);
+  const current = await getCurrentBranch(cwd);
+  const stack = getTrackedStackOrThrow(
+    current,
+    findStackForBranch(state, current)
+  );
+  let target = current;
+  for (let i = 0; i < steps; i++) {
+    const branch = getBranchByName(stack, target);
+    if (!branch) {
+      throw new DubError(
+        `Current branch '${target}' is not tracked by DubStack.`
+      );
     }
-    try {
-      await rebaseOnto(parentNewTip, step.parentOldTip, step.branch, cwd);
-      step.status = "done";
-      rebased.push(step.branch);
-      await writeProgress(progress, cwd);
-    } catch (error) {
-      if (error instanceof DubError && error.message.includes("Conflict")) {
-        step.status = "conflicted";
-        await writeProgress(progress, cwd);
-        return { status: "conflict", rebased, conflictBranch: step.branch };
-      }
-      throw error;
+    if (!branch.parent) {
+      throw new DubError(
+        `Already at the bottom of the stack (root branch '${target}').`
+      );
     }
+    target = branch.parent;
   }
-  await clearProgress(cwd);
-  await checkoutBranch(progress.originalBranch, cwd);
-  const allSkipped = progress.steps.every(
-    (s) => s.status === "skipped" || s.status === "done"
-  );
-  return {
-    status: rebased.length === 0 && allSkipped ? "up-to-date" : "success",
-    rebased
-  };
+  await checkoutBranch(target, cwd);
+  return { branch: target, changed: target !== current };
 }
-function getTargetStacks(stacks, currentBranch) {
-  const rootStacks = stacks.filter(
-    (s) => s.branches.some((b) => b.name === currentBranch && b.type === "root")
-  );
-  if (rootStacks.length > 0) return rootStacks;
-  const stack = stacks.find(
-    (s) => s.branches.some((b) => b.name === currentBranch)
+async function top(cwd) {
+  const state = await readState(cwd);
+  const current = await getCurrentBranch(cwd);
+  const stack = getTrackedStackOrThrow(
+    current,
+    findStackForBranch(state, current)
   );
-  return stack ? [stack] : [];
+  let target = current;
+  while (true) {
+    const children = getChildren2(stack, target);
+    if (children.length === 0) break;
+    if (children.length > 1) {
+      throw new DubError(
+        `Branch '${target}' has multiple children; 'dub top' requires a linear stack path.`
+      );
+    }
+    target = children[0];
+  }
+  if (target !== current) {
+    await checkoutBranch(target, cwd);
+  }
+  return { branch: target, changed: target !== current };
 }
-async function buildRestackSteps(stacks, cwd) {
-  const steps = [];
-  for (const stack of stacks) {
-    const ordered = topologicalOrder(stack);
-    for (const branch of ordered) {
-      if (branch.type === "root" || !branch.parent) continue;
-      const mergeBase = await getMergeBase(branch.parent, branch.name, cwd);
-      steps.push({
-        branch: branch.name,
-        parent: branch.parent,
-        parentOldTip: mergeBase,
-        status: "pending"
-      });
+async function bottom(cwd) {
+  const state = await readState(cwd);
+  const current = await getCurrentBranch(cwd);
+  const stack = getTrackedStackOrThrow(
+    current,
+    findStackForBranch(state, current)
+  );
+  const branch = getBranchByName(stack, current);
+  if (!branch) {
+    throw new DubError(
+      `Current branch '${current}' is not tracked by DubStack.`
+    );
+  }
+  let target = current;
+  if (!branch.parent) {
+    const children = getChildren2(stack, current);
+    if (children.length === 0) {
+      throw new DubError(
+        `No branch above root '${current}' in the current stack.`
+      );
+    }
+    if (children.length > 1) {
+      throw new DubError(
+        `Root branch '${current}' has multiple children; 'dub bottom' requires a linear stack path.`
+      );
+    }
+    target = children[0];
+  } else {
+    let node = branch;
+    while (node.parent) {
+      const parent = getBranchByName(stack, node.parent);
+      if (!parent) {
+        break;
+      }
+      if (parent.parent === null) {
+        target = node.name;
+        break;
+      }
+      node = parent;
     }
   }
-  return steps;
-}
-async function getProgressPath(cwd) {
-  const dubDir = await getDubDir(cwd);
-  return path4.join(dubDir, "restack-progress.json");
-}
-async function writeProgress(progress, cwd) {
-  const progressPath = await getProgressPath(cwd);
-  fs4.writeFileSync(progressPath, `${JSON.stringify(progress, null, 2)}
-`);
-}
-async function readProgress(cwd) {
-  const progressPath = await getProgressPath(cwd);
-  if (!fs4.existsSync(progressPath)) return null;
-  const raw = fs4.readFileSync(progressPath, "utf-8");
-  return JSON.parse(raw);
-}
-async function clearProgress(cwd) {
-  const progressPath = await getProgressPath(cwd);
-  if (fs4.existsSync(progressPath)) {
-    fs4.unlinkSync(progressPath);
+  if (target !== current) {
+    await checkoutBranch(target, cwd);
   }
+  return { branch: target, changed: target !== current };
 }
 
-// src/commands/submit.ts
-import * as fs5 from "fs";
-import * as os from "os";
-import * as path5 from "path";
-
 // src/lib/github.ts
+init_errors();
 import { execa as execa2 } from "execa";
 async function ensureGhInstalled() {
   try {
@@ -766,6 +1390,58 @@ async function getPr(branch, cwd) {
     throw new DubError(`Failed to parse PR info for branch '${branch}'.`);
   }
 }
+async function getBranchPrLifecycleState(branch, cwd) {
+  const info = await getBranchPrSyncInfo(branch, cwd);
+  return info.state;
+}
+async function getBranchPrSyncInfo(branch, cwd) {
+  const { stdout } = await execa2(
+    "gh",
+    [
+      "pr",
+      "list",
+      "--head",
+      branch,
+      "--state",
+      "all",
+      "--json",
+      "state,mergedAt,baseRefName",
+      "--jq",
+      ".[0]"
+    ],
+    { cwd }
+  );
+  const trimmed = stdout.trim();
+  if (!trimmed || trimmed === "null") {
+    return { state: "NONE", baseRefName: null };
+  }
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (parsed.mergedAt) {
+      return {
+        state: "MERGED",
+        baseRefName: parsed.baseRefName ?? null
+      };
+    }
+    if (parsed.state === "CLOSED") {
+      return {
+        state: "CLOSED",
+        baseRefName: parsed.baseRefName ?? null
+      };
+    }
+    if (parsed.state === "OPEN") {
+      return {
+        state: "OPEN",
+        baseRefName: parsed.baseRefName ?? null
+      };
+    }
+    return { state: "NONE", baseRefName: parsed.baseRefName ?? null };
+  } catch {
+    throw new DubError(
+      `Failed to parse PR lifecycle state for branch '${branch}'.`
+    );
+  }
+}
 async function createPr(branch, base, title, bodyFile, cwd) {
   let stdout;
   try {
@@ -824,6 +1500,39 @@ async function updatePrBody(prNumber, bodyFile, cwd) {
     throw new DubError(`Failed to update PR #${prNumber}: ${message}`);
   }
 }
+async function openPrInBrowser(cwd, target) {
+  const args = target ? ["pr", "view", target, "--web"] : ["pr", "view", "--web"];
+  try {
+    await execa2("gh", args, { cwd, stdio: "inherit" });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (message.toLowerCase().includes("no pull requests")) {
+      throw new DubError(
+        target ? `No PR found for '${target}'.` : "No PR found for the current branch."
+      );
+    }
+    throw new DubError(
+      target ? `Failed to open PR for '${target}': ${message}` : `Failed to open PR: ${message}`
+    );
+  }
+}
+
+// src/commands/pr.ts
+async function pr(cwd, branch) {
+  await ensureGhInstalled();
+  await checkGhAuth();
+  await openPrInBrowser(cwd, branch);
+}
+
+// src/index.ts
+init_restack();
+
+// src/commands/submit.ts
+init_errors();
+init_git();
+import * as fs5 from "fs";
+import * as os from "os";
+import * as path5 from "path";
 
 // src/lib/pr-body.ts
 var DUBSTACK_START = "<!-- dubstack:start -->";
@@ -883,6 +1592,7 @@ function composePrBody(existingBody, stackTable, metadataBlock) {
 }
 
 // src/commands/submit.ts
+init_state();
 async function submit(cwd, dryRun) {
   await ensureGhInstalled();
   await checkGhAuth();
@@ -938,12 +1648,23 @@ async function submit(cwd, dryRun) {
   if (!dryRun) {
     await updateAllPrBodies(nonRootBranches, prMap, stack.id, cwd);
     for (const branch of nonRootBranches) {
-      const pr = prMap.get(branch.name);
-      if (pr) {
+      const pr2 = prMap.get(branch.name);
+      if (pr2) {
         const stateBranch = stack.branches.find((b) => b.name === branch.name);
         if (stateBranch) {
-          stateBranch.pr_number = pr.number;
-          stateBranch.pr_link = pr.url;
+          stateBranch.pr_number = pr2.number;
+          stateBranch.pr_link = pr2.url;
+          const headSha = await getBranchTip(branch.name, cwd);
+          const baseSha = await getBranchTip(branch.parent, cwd);
+          stateBranch.last_submitted_version = {
+            head_sha: headSha,
+            base_sha: baseSha,
+            base_branch: branch.parent,
+            version_number: null,
+            source: "submit"
+          };
+          stateBranch.last_synced_at = (/* @__PURE__ */ new Date()).toISOString();
+          stateBranch.sync_source = "submit";
         }
       }
     }
@@ -969,30 +1690,30 @@ function validateLinearStack(ordered) {
 async function updateAllPrBodies(branches, prMap, stackId, cwd) {
   const tableEntries = /* @__PURE__ */ new Map();
   for (const branch of branches) {
-    const pr = prMap.get(branch.name);
-    if (pr) {
-      tableEntries.set(branch.name, { number: pr.number, title: pr.title });
+    const pr2 = prMap.get(branch.name);
+    if (pr2) {
+      tableEntries.set(branch.name, { number: pr2.number, title: pr2.title });
     }
   }
   for (let i = 0; i < branches.length; i++) {
     const branch = branches[i];
-    const pr = prMap.get(branch.name);
-    if (!pr) continue;
+    const pr2 = prMap.get(branch.name);
+    if (!pr2) continue;
     const prevPr = i > 0 ? prMap.get(branches[i - 1].name)?.number ?? null : null;
     const nextPr = i < branches.length - 1 ? prMap.get(branches[i + 1].name)?.number ?? null : null;
     const stackTable = buildStackTable(branches, tableEntries, branch.name);
     const metadataBlock = buildMetadataBlock(
       stackId,
-      pr.number,
+      pr2.number,
       prevPr,
       nextPr,
       branch.name
     );
-    const existingBody = pr.body;
+    const existingBody = pr2.body;
     const finalBody = composePrBody(existingBody, stackTable, metadataBlock);
     const tmpFile = writeTempBody(finalBody);
     try {
-      await updatePrBody(pr.number, tmpFile, cwd);
+      await updatePrBody(pr2.number, tmpFile, cwd);
     } finally {
       cleanupTempFile(tmpFile);
     }
@@ -1011,7 +1732,612 @@ 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";
+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) {
+      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";
+  return "reconcile-needed";
+}
+
+// src/lib/sync/cleanup.ts
+async function buildCleanupPlan(input2) {
+  const toDelete = [];
+  const skipped = [];
+  for (const branch of input2.branches) {
+    const prState = await input2.getPrStatus(branch);
+    if (prState !== "MERGED" && prState !== "CLOSED") {
+      continue;
+    }
+    const mergedIntoRoot = await input2.isMergedIntoAnyRoot(branch);
+    if (!mergedIntoRoot) {
+      skipped.push({ branch, reason: "commits-not-in-trunk" });
+      continue;
+    }
+    toDelete.push(branch);
+  }
+  return { toDelete, skipped };
+}
+
+// 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();
+  if (raw === "take-remote" || raw === "keep-local" || raw === "reconcile" || raw === "skip") {
+    return raw;
+  }
+  return "skip";
+}
+
+// src/lib/sync/report.ts
+function printBranchOutcome(outcome) {
+  console.log(outcome.message);
+}
+function printSyncSummary(result) {
+  const synced = result.branches.filter((b) => b.action === "synced").length;
+  const skipped = result.branches.filter((b) => b.action === "skipped").length;
+  const keptLocal = result.branches.filter(
+    (b) => b.action === "kept-local"
+  ).length;
+  console.log(
+    `\u2714 Sync complete: ${synced} synced, ${keptLocal} kept-local, ${skipped} skipped, ${result.cleaned.length} cleaned`
+  );
+}
+
+// src/commands/sync.ts
+init_restack();
+function isInteractiveShell() {
+  return Boolean(process.stdout.isTTY && process.stdin.isTTY);
+}
+async function confirm(question) {
+  const rl = readline.createInterface({ input, output });
+  try {
+    const answer = await rl.question(`${question} [Y/n] `);
+    const normalized = answer.trim().toLowerCase();
+    return normalized === "" || normalized === "y" || normalized === "yes";
+  } finally {
+    rl.close();
+  }
+}
+async function choose(question, choices) {
+  const rl = readline.createInterface({ input, output });
+  try {
+    console.log(question);
+    for (let i = 0; i < choices.length; i++) {
+      console.log(`  ${i + 1}. ${choices[i].label}`);
+    }
+    const answer = await rl.question("Select option: ");
+    const idx = Number.parseInt(answer.trim(), 10) - 1;
+    if (Number.isNaN(idx) || idx < 0 || idx >= choices.length) {
+      return choices[choices.length - 1].value;
+    }
+    return choices[idx].value;
+  } finally {
+    rl.close();
+  }
+}
+async function sync(cwd, rawOptions = {}) {
+  await ensureGhInstalled();
+  await checkGhAuth();
+  const options = {
+    restack: rawOptions.restack ?? true,
+    force: rawOptions.force ?? false,
+    all: rawOptions.all ?? false,
+    interactive: rawOptions.interactive ?? isInteractiveShell()
+  };
+  const state = await readState(cwd);
+  const originalBranch = await getCurrentBranch(cwd);
+  const scopeStacks = options.all ? state.stacks : (() => {
+    const stack = findStackForBranch(state, originalBranch);
+    if (!stack) {
+      throw new DubError(
+        `Branch '${originalBranch}' is not part of any stack. Run 'dub create' first.`
+      );
+    }
+    return [stack];
+  })();
+  const stateBranchMap = new Map(
+    scopeStacks.flatMap((stack) => stack.branches.map((b) => [b.name, b]))
+  );
+  const roots = Array.from(
+    new Set(
+      scopeStacks.flatMap((s) => s.branches).filter((b) => b.type === "root").map((b) => b.name)
+    )
+  );
+  const stackBranches = Array.from(
+    new Set(
+      scopeStacks.flatMap((s) => s.branches).filter((b) => b.type !== "root").map((b) => b.name)
+    )
+  );
+  const result = {
+    fetched: [],
+    trunksSynced: [],
+    cleaned: [],
+    branches: [],
+    restacked: false
+  };
+  const rootHasRemote = /* @__PURE__ */ new Map();
+  console.log("\u{1F332} Fetching branches from remote...");
+  const toFetch = [.../* @__PURE__ */ new Set([...roots, ...stackBranches])];
+  if (toFetch.length > 0) {
+    await fetchBranches(toFetch, cwd);
+    result.fetched = toFetch;
+  }
+  for (const root of roots) {
+    const remoteRef = `origin/${root}`;
+    const hasRemoteRoot = await remoteBranchExists(root, cwd);
+    rootHasRemote.set(root, hasRemoteRoot);
+    if (!hasRemoteRoot) continue;
+    const ff = await fastForwardBranchToRef(root, remoteRef, cwd);
+    if (ff) {
+      result.trunksSynced.push(root);
+      continue;
+    }
+    if (options.force) {
+      await hardResetBranchToRef(root, remoteRef, cwd);
+      result.trunksSynced.push(root);
+      continue;
+    }
+    if (options.interactive) {
+      const takeRemote = await confirm(
+        `Trunk '${root}' cannot be fast-forwarded. Overwrite local trunk with '${remoteRef}'?`
+      );
+      if (takeRemote) {
+        await hardResetBranchToRef(root, remoteRef, cwd);
+        result.trunksSynced.push(root);
+      }
+    }
+  }
+  console.log("\u{1F9F9} Cleaning up branches with merged/closed PRs...");
+  const localTrackedBranches = [];
+  for (const branch of stackBranches) {
+    const hasLocal = await branchExists(branch, cwd);
+    if (hasLocal) localTrackedBranches.push(branch);
+  }
+  const cleanupPlan = await buildCleanupPlan({
+    branches: localTrackedBranches,
+    getPrStatus: (branch) => getBranchPrLifecycleState(branch, cwd),
+    isMergedIntoAnyRoot: async (branch) => {
+      for (const root of roots) {
+        const compareRef = rootHasRemote.get(root) ? `origin/${root}` : root;
+        if (await isAncestor(branch, compareRef, cwd)) return true;
+      }
+      return false;
+    }
+  });
+  const excludedFromSync = /* @__PURE__ */ new Set();
+  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)) {
+        excludedFromSync.add(child);
+      }
+    }
+  }
+  for (const branch of cleanupPlan.toDelete) {
+    if (excludedFromSync.has(branch)) continue;
+    let shouldDelete = options.force;
+    if (!shouldDelete && options.interactive) {
+      shouldDelete = await confirm(
+        `Branch '${branch}' has merged/closed PR and is in trunk. Delete local branch?`
+      );
+    }
+    if (shouldDelete) {
+      await checkoutBranch(roots[0] ?? originalBranch, cwd);
+      await deleteBranch(branch, cwd);
+      removeBranchFromState(scopeStacks, branch);
+      result.cleaned.push(branch);
+    }
+  }
+  for (const skipped of cleanupPlan.skipped) {
+    console.log(
+      `\u2022 Skipped cleanup for '${skipped.branch}' (${skipped.reason}).`
+    );
+  }
+  for (const excluded of excludedFromSync) {
+    console.log(
+      `\u2022 Excluding '${excluded}' from sync because its stack is not cleanable yet.`
+    );
+  }
+  console.log("\u{1F504} Syncing branches...");
+  for (const branch of stackBranches) {
+    if (result.cleaned.includes(branch) || excludedFromSync.has(branch))
+      continue;
+    const hasRemote = await remoteBranchExists(branch, cwd);
+    const hasLocal = await branchExists(branch, cwd);
+    let outcome;
+    const remoteRef = `origin/${branch}`;
+    const localSha = hasLocal ? await getRefSha(branch, cwd) : null;
+    const remoteSha = hasRemote ? await getRefSha(remoteRef, cwd) : null;
+    const localBehind = hasLocal && hasRemote ? await isAncestor(branch, remoteRef, cwd) : false;
+    const remoteBehind = hasLocal && hasRemote ? await isAncestor(remoteRef, branch, cwd) : false;
+    let status = classifyBranchSyncStatus({
+      hasRemote,
+      hasLocal,
+      localSha,
+      remoteSha,
+      localBehind,
+      remoteBehind,
+      hasSubmittedBaseline: stateBranchMap.get(branch)?.last_submitted_version != null
+    });
+    const prSyncInfo = hasRemote ? await getBranchPrSyncInfo(branch, cwd) : { state: "NONE", baseRefName: null };
+    const localParent = stateBranchMap.get(branch)?.parent ?? null;
+    if (hasRemote && hasLocal && localSha !== remoteSha && prSyncInfo.baseRefName && localParent && prSyncInfo.baseRefName !== localParent) {
+      status = "needs-remote-sync";
+    }
+    if (status === "missing-remote") {
+      outcome = {
+        branch,
+        status,
+        action: "skipped",
+        message: `\u26A0 Skipped '${branch}' (missing on remote).`
+      };
+      result.branches.push(outcome);
+      printBranchOutcome(outcome);
+      continue;
+    }
+    if (status === "missing-local") {
+      await checkoutRemoteBranch(branch, cwd);
+      outcome = {
+        branch,
+        status,
+        action: "synced",
+        message: `\u2714 Restored '${branch}' from remote.`
+      };
+      result.branches.push(outcome);
+      printBranchOutcome(outcome);
+      const restoredSha = await getRefSha(branch, cwd);
+      await markBranchSynced(stateBranchMap, branch, restoredSha, cwd, {
+        source: "sync",
+        baseBranch: stateBranchMap.get(branch)?.parent ?? null
+      });
+      continue;
+    }
+    if (status === "up-to-date") {
+      outcome = {
+        branch,
+        status,
+        action: "none",
+        message: `\u2022 '${branch}' is up to date.`
+      };
+      result.branches.push(outcome);
+      printBranchOutcome(outcome);
+      await markBranchSynced(
+        stateBranchMap,
+        branch,
+        localSha ?? remoteSha ?? null,
+        cwd,
+        {
+          source: "sync",
+          baseBranch: stateBranchMap.get(branch)?.parent ?? null
+        }
+      );
+      continue;
+    }
+    if (status === "updated-outside-dubstack-but-up-to-date") {
+      outcome = {
+        branch,
+        status,
+        action: "none",
+        message: `\u2022 '${branch}' is up to date but was previously unmanaged by DubStack sync metadata.`
+      };
+      result.branches.push(outcome);
+      printBranchOutcome(outcome);
+      await markBranchSynced(
+        stateBranchMap,
+        branch,
+        localSha ?? remoteSha ?? null,
+        cwd,
+        {
+          source: "imported",
+          baseBranch: stateBranchMap.get(branch)?.parent ?? null
+        }
+      );
+      continue;
+    }
+    if (status === "needs-remote-sync-safe") {
+      await hardResetBranchToRef(branch, remoteRef, cwd);
+      outcome = {
+        branch,
+        status,
+        action: "synced",
+        message: `\u2714 Synced '${branch}' to remote head.`
+      };
+      result.branches.push(outcome);
+      printBranchOutcome(outcome);
+      await markBranchSynced(stateBranchMap, branch, remoteSha, cwd, {
+        source: "sync",
+        baseBranch: stateBranchMap.get(branch)?.parent ?? null
+      });
+      continue;
+    }
+    if (status === "local-ahead") {
+      outcome = {
+        branch,
+        status,
+        action: "kept-local",
+        message: `\u2022 Kept local '${branch}' (local commits ahead of remote).`
+      };
+      result.branches.push(outcome);
+      printBranchOutcome(outcome);
+      continue;
+    }
+    if (status === "unsubmitted") {
+      if (options.force) {
+        await hardResetBranchToRef(branch, remoteRef, cwd);
+        outcome = {
+          branch,
+          status,
+          action: "synced",
+          message: `\u2714 Synced unsubmitted branch '${branch}' to remote with --force.`
+        };
+        await markBranchSynced(stateBranchMap, branch, remoteSha, cwd, {
+          source: "sync",
+          baseBranch: localParent
+        });
+      } else if (!options.interactive) {
+        outcome = {
+          branch,
+          status,
+          action: "skipped",
+          message: `\u26A0 Skipped unsubmitted branch '${branch}' (use --force or interactive mode).`
+        };
+      } else {
+        const takeRemote = await confirm(
+          `Branch '${branch}' has no DubStack submit baseline. Overwrite local with remote version?`
+        );
+        if (takeRemote) {
+          await hardResetBranchToRef(branch, remoteRef, cwd);
+          outcome = {
+            branch,
+            status,
+            action: "synced",
+            message: `\u2714 Synced unsubmitted branch '${branch}' to remote.`
+          };
+          await markBranchSynced(stateBranchMap, branch, remoteSha, cwd, {
+            source: "sync",
+            baseBranch: localParent
+          });
+        } else {
+          outcome = {
+            branch,
+            status,
+            action: "kept-local",
+            message: `\u2022 Kept local unsubmitted branch '${branch}'.`
+          };
+        }
+      }
+      result.branches.push(outcome);
+      printBranchOutcome(outcome);
+      continue;
+    }
+    if (status === "needs-remote-sync") {
+      if (options.force) {
+        await hardResetBranchToRef(branch, remoteRef, cwd);
+        if (prSyncInfo.baseRefName && localParent !== prSyncInfo.baseRefName) {
+          const stateBranch = stateBranchMap.get(branch);
+          if (stateBranch) stateBranch.parent = prSyncInfo.baseRefName;
+        }
+        outcome = {
+          branch,
+          status,
+          action: "synced",
+          message: `\u2714 Synced '${branch}' to remote and adopted remote parent '${prSyncInfo.baseRefName ?? "unknown"}'.`
+        };
+        await markBranchSynced(stateBranchMap, branch, remoteSha, cwd, {
+          source: "sync",
+          baseBranch: prSyncInfo.baseRefName ?? localParent
+        });
+      } else if (!options.interactive) {
+        outcome = {
+          branch,
+          status,
+          action: "skipped",
+          message: `\u26A0 Skipped '${branch}' parent-mismatch sync (run interactively or with --force).`
+        };
+      } else {
+        const parentDecision = await choose(
+          `Branch '${branch}' parent differs locally ('${localParent}') vs remote ('${prSyncInfo.baseRefName}').`,
+          [
+            { label: "Take remote version and remote parent", value: "remote" },
+            { label: "Keep local branch and parent", value: "local" },
+            { label: "Skip for now", value: "skip" }
+          ]
+        );
+        if (parentDecision === "remote") {
+          await hardResetBranchToRef(branch, remoteRef, cwd);
+          const stateBranch = stateBranchMap.get(branch);
+          if (stateBranch && prSyncInfo.baseRefName) {
+            stateBranch.parent = prSyncInfo.baseRefName;
+          }
+          outcome = {
+            branch,
+            status,
+            action: "synced",
+            message: `\u2714 Synced '${branch}' to remote and adopted remote parent.`
+          };
+          await markBranchSynced(stateBranchMap, branch, remoteSha, cwd, {
+            source: "sync",
+            baseBranch: prSyncInfo.baseRefName ?? localParent
+          });
+        } else if (parentDecision === "local") {
+          outcome = {
+            branch,
+            status,
+            action: "kept-local",
+            message: `\u2022 Kept local parent and local state for '${branch}'.`
+          };
+        } else {
+          outcome = {
+            branch,
+            status,
+            action: "skipped",
+            message: `\u26A0 Skipped '${branch}' parent-mismatch sync by user choice.`
+          };
+        }
+      }
+      result.branches.push(outcome);
+      printBranchOutcome(outcome);
+      continue;
+    }
+    const decision = await resolveReconcileDecision({
+      branch,
+      force: options.force,
+      interactive: options.interactive,
+      promptChoice: () => choose(
+        `Branch '${branch}' diverged from remote. How should sync proceed?`,
+        [
+          {
+            label: "Take remote version (discard local divergence)",
+            value: "take-remote"
+          },
+          { label: "Keep local version", value: "keep-local" },
+          {
+            label: "Attempt reconciliation and keep local commits",
+            value: "reconcile"
+          },
+          { label: "Skip this branch", value: "skip" }
+        ]
+      )
+    });
+    if (decision === "take-remote") {
+      await hardResetBranchToRef(branch, remoteRef, cwd);
+      outcome = {
+        branch,
+        status: "reconcile-needed",
+        action: "synced",
+        message: `\u2714 Synced '${branch}' to remote version.`
+      };
+      await markBranchSynced(stateBranchMap, branch, remoteSha, cwd, {
+        source: "sync",
+        baseBranch: stateBranchMap.get(branch)?.parent ?? null
+      });
+    } else if (decision === "keep-local") {
+      outcome = {
+        branch,
+        status: "reconcile-needed",
+        action: "kept-local",
+        message: `\u2022 Kept local '${branch}' (remote divergence ignored).`
+      };
+    } else if (decision === "reconcile") {
+      const reconciled = await rebaseBranchOntoRef(branch, remoteRef, cwd);
+      outcome = {
+        branch,
+        status: "reconcile-needed",
+        action: reconciled ? "synced" : "kept-local",
+        message: reconciled ? `\u2714 Reconciled '${branch}' by rebasing local commits onto remote.` : `\u26A0 Could not auto-reconcile '${branch}'. Kept local state; reconcile manually.`
+      };
+      if (reconciled) {
+        const newSha = await getRefSha(branch, cwd);
+        await markBranchSynced(stateBranchMap, branch, newSha, cwd, {
+          source: "sync",
+          baseBranch: stateBranchMap.get(branch)?.parent ?? null
+        });
+      }
+    } else {
+      outcome = {
+        branch,
+        status: "reconcile-needed",
+        action: "skipped",
+        message: options.interactive ? `\u26A0 Skipped '${branch}' by user choice.` : `\u26A0 Skipped '${branch}' (diverged from remote; rerun with --force or interactive).`
+      };
+    }
+    result.branches.push(outcome);
+    printBranchOutcome(outcome);
+  }
+  if (options.restack) {
+    console.log("\u{1F95E} Restacking branches...");
+    const rootsToRestack = options.all ? roots : [roots[0]].filter(Boolean);
+    for (const root of rootsToRestack) {
+      await checkoutBranch(root, cwd);
+      await restack(cwd);
+    }
+    result.restacked = true;
+  }
+  await writeState(state, cwd);
+  await checkoutBranch(originalBranch, cwd);
+  printSyncSummary(result);
+  return result;
+}
+async function markBranchSynced(branchMap, branchName, headSha, cwd, options) {
+  if (!headSha) return;
+  const entry = branchMap.get(branchName);
+  if (!entry) return;
+  const priorBaseline = entry.last_submitted_version;
+  const resolvedBaseBranch = options.baseBranch ?? priorBaseline?.base_branch ?? null;
+  let resolvedBaseSha = priorBaseline?.base_sha ?? null;
+  if (resolvedBaseBranch) {
+    try {
+      resolvedBaseSha = await getRefSha(resolvedBaseBranch, cwd);
+    } catch {
+    }
+  }
+  if (!resolvedBaseBranch || !resolvedBaseSha) return;
+  entry.last_submitted_version = {
+    head_sha: headSha,
+    base_sha: resolvedBaseSha,
+    base_branch: resolvedBaseBranch,
+    version_number: priorBaseline?.version_number ?? null,
+    source: options.source
+  };
+  entry.last_synced_at = (/* @__PURE__ */ new Date()).toISOString();
+  entry.sync_source = options.source;
+}
+function getDescendants(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 queue = [...childMap.get(branch) ?? []];
+  while (queue.length > 0) {
+    const next = queue.shift();
+    if (!next) break;
+    descendants.push(next);
+    queue.push(...childMap.get(next) ?? []);
+  }
+  return descendants;
+}
+function removeBranchFromState(stacks, branch) {
+  for (const stack of stacks) {
+    const deleted = stack.branches.find((b) => b.name === branch);
+    if (!deleted) continue;
+    const newParent = deleted.parent;
+    for (const child of stack.branches) {
+      if (child.parent === branch) {
+        child.parent = newParent;
+      }
+    }
+    stack.branches = stack.branches.filter((b) => b.name !== branch);
+  }
+}
+
 // src/commands/undo.ts
+init_errors();
+init_git();
+init_state();
+init_undo_log();
 async function undo(cwd) {
   const entry = await readUndoEntry(cwd);
   if (!await isWorkingTreeClean(cwd)) {
@@ -1059,6 +2385,7 @@ async function undo(cwd) {
 }
 
 // src/index.ts
+init_errors();
 var require2 = createRequire(import.meta.url);
 var { version } = require2("../package.json");
 var program = new Command();
@@ -1071,12 +2398,15 @@ Examples:
 ).action(async () => {
   const result = await init(process.cwd());
   if (result.status === "created") {
-    console.log(chalk.green("\u2714 DubStack initialized"));
+    console.log(chalk2.green("\u2714 DubStack initialized"));
   } else {
-    console.log(chalk.yellow("\u26A0 DubStack already initialized"));
+    console.log(chalk2.yellow("\u26A0 DubStack already initialized"));
   }
 });
-program.command("create").argument("<branch-name>", "Name of the new branch to create").description("Create a new branch stacked on top of the current branch").option("-m, --message <message>", "Commit staged changes with this message").option("-a, --all", "Stage all changes before committing (requires -m)").addHelpText(
+program.command("create").argument("<branch-name>", "Name of the new branch to create").description("Create a new branch stacked on top of the current branch").option("-m, --message <message>", "Commit staged changes with this message").option("-a, --all", "Stage all changes before committing (requires -m)").option(
+  "-u, --update",
+  "Stage tracked file updates before committing (requires -m)"
+).option("-p, --patch", "Pick hunks to stage before committing (requires -m)").addHelpText(
   "after",
   `
 Examples:
@@ -1087,33 +2417,97 @@ Examples:
   async (branchName, options) => {
     const result = await create(branchName, process.cwd(), {
       message: options.message,
-      all: options.all
+      all: options.all,
+      update: options.update,
+      patch: options.patch
     });
     if (result.committed) {
       console.log(
-        chalk.green(
+        chalk2.green(
           `\u2714 Created '${result.branch}' on '${result.parent}' \u2022 ${result.committed}`
         )
       );
     } else {
       console.log(
-        chalk.green(
+        chalk2.green(
           `\u2714 Created branch '${result.branch}' on top of '${result.parent}'`
         )
       );
     }
   }
 );
-program.command("log").description("Display an ASCII tree of the current stack").addHelpText(
+program.command("log").alias("l").description("Display an ASCII tree of the current stack").addHelpText(
   "after",
   `
 Examples:
   $ dub log    Show the branch tree with current branch highlighted`
 ).action(async () => {
-  const output = await log(process.cwd());
-  const styled = output.replace(/\*(.+?) \(Current\)\*/g, chalk.bold.cyan("$1 (Current)")).replace(/⚠ \(missing\)/g, chalk.yellow("\u26A0 (missing)"));
-  console.log(styled);
+  await printLog(process.cwd());
+});
+program.command("ls").description("Display an ASCII tree of the current stack").action(async () => {
+  await printLog(process.cwd());
+});
+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);
+  if (result.changed) {
+    console.log(chalk2.green(`\u2714 Switched up to '${result.branch}'`));
+  } else {
+    console.log(chalk2.yellow(`\u26A0 Already at top branch '${result.branch}'`));
+  }
+});
+program.command("down").argument("[steps]", "Number of levels to traverse downstack").option("-n, --steps <count>", "Number of levels to traverse downstack").description("Checkout the parent branch directly below the current branch").action(async (stepsArg, options) => {
+  const steps = parseSteps(stepsArg, options.steps);
+  const result = await downBySteps(process.cwd(), steps);
+  if (result.changed) {
+    console.log(chalk2.green(`\u2714 Switched down to '${result.branch}'`));
+  } else {
+    console.log(
+      chalk2.yellow(`\u26A0 Already at bottom branch '${result.branch}'`)
+    );
+  }
+});
+program.command("top").description("Checkout the topmost branch in the current stack path").action(async () => {
+  const result = await top(process.cwd());
+  if (result.changed) {
+    console.log(chalk2.green(`\u2714 Switched to top branch '${result.branch}'`));
+  } else {
+    console.log(chalk2.yellow(`\u26A0 Already at top branch '${result.branch}'`));
+  }
+});
+program.command("bottom").description(
+  "Checkout the first branch above the root in the current stack path"
+).action(async () => {
+  const result = await bottom(process.cwd());
+  if (result.changed) {
+    console.log(
+      chalk2.green(`\u2714 Switched to bottom stack branch '${result.branch}'`)
+    );
+  } else {
+    console.log(
+      chalk2.yellow(`\u26A0 Already at bottom stack branch '${result.branch}'`)
+    );
+  }
+});
+program.command("branch").description("Show DubStack branch metadata").addCommand(
+  new Command("info").description("Show tracked stack info for the current branch").argument("[branch]", "Branch to inspect (defaults to current branch)").action(async (branch) => {
+    const info = await branchInfo(process.cwd(), branch);
+    console.log(formatBranchInfo(info));
+  })
+);
+program.command("info").argument("[branch]", "Branch to inspect (defaults to current branch)").description("Show tracked stack info for a branch").action(async (branch) => {
+  const info = await branchInfo(process.cwd(), branch);
+  console.log(formatBranchInfo(info));
 });
+program.command("sync").description("Sync tracked branches with remote and reconcile divergence").option(
+  "--restack",
+  "Restack branches after sync (disable with --no-restack)",
+  true
+).option("-f, --force", "Skip prompts for destructive sync decisions").option("-a, --all", "Sync all tracked stacks across trunks").option("--no-interactive", "Disable prompts and use deterministic behavior").action(
+  async (options) => {
+    await sync(process.cwd(), options);
+  }
+);
 program.command("restack").description("Rebase all branches in the stack onto their updated parents").option("--continue", "Continue restacking after resolving conflicts").addHelpText(
   "after",
   `
@@ -1123,22 +2517,22 @@ Examples:
 ).action(async (options) => {
   const result = options.continue ? await restackContinue(process.cwd()) : await restack(process.cwd());
   if (result.status === "up-to-date") {
-    console.log(chalk.green("\u2714 Stack is already up to date"));
+    console.log(chalk2.green("\u2714 Stack is already up to date"));
   } else if (result.status === "conflict") {
     console.log(
-      chalk.yellow(`\u26A0 Conflict while restacking '${result.conflictBranch}'`)
+      chalk2.yellow(`\u26A0 Conflict while restacking '${result.conflictBranch}'`)
     );
     console.log(
-      chalk.dim(
+      chalk2.dim(
         "  Resolve conflicts, stage changes, then run: dub restack --continue"
       )
     );
   } else {
     console.log(
-      chalk.green(`\u2714 Restacked ${result.rebased.length} branch(es)`)
+      chalk2.green(`\u2714 Restacked ${result.rebased.length} branch(es)`)
     );
     for (const branch of result.rebased) {
-      console.log(chalk.dim(`  \u21B3 ${branch}`));
+      console.log(chalk2.dim(`  \u21B3 ${branch}`));
     }
   }
 });
@@ -1149,7 +2543,7 @@ Examples:
   $ dub undo    Roll back the last dub operation`
 ).action(async () => {
   const result = await undo(process.cwd());
-  console.log(chalk.green(`\u2714 Undid '${result.undone}': ${result.details}`));
+  console.log(chalk2.green(`\u2714 Undid '${result.undone}': ${result.details}`));
 });
 program.command("submit").description(
   "Push branches and create/update GitHub PRs for the current stack"
@@ -1161,36 +2555,106 @@ Examples:
   $ dub submit --dry-run Preview what would happen`
 ).action(runSubmit);
 program.command("ss").description("Submit the current stack (alias for submit)").option("--dry-run", "Print what would happen without executing").action(runSubmit);
-program.command("co").argument("[branch]", "Branch to checkout (interactive if omitted)").description("Checkout a branch (interactive picker if no name given)").action(async (branch) => {
-  if (branch) {
-    const result = await checkout(branch, process.cwd());
-    console.log(chalk.green(`\u2714 Switched to '${result.branch}'`));
-  } else {
-    const result = await interactiveCheckout(process.cwd());
-    if (result) {
-      console.log(chalk.green(`\u2714 Switched to '${result.branch}'`));
+program.command("checkout").alias("co").argument("[branch]", "Branch to checkout (interactive if omitted)").option("-t, --trunk", "Checkout the current trunk").option(
+  "-u, --show-untracked",
+  "Include untracked branches in interactive selection"
+).option(
+  "-s, --stack",
+  "Only show ancestors and descendants of current branch in interactive selection"
+).option(
+  "-a, --all",
+  "Show branches across all tracked stacks in interactive selection"
+).description("Checkout a branch (interactive picker if no name given)").action(
+  async (branch, options) => {
+    if (branch) {
+      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());
+      console.log(chalk2.green(`\u2714 Switched to '${result.branch}'`));
+    } else {
+      const result = await interactiveCheckout(process.cwd(), {
+        showUntracked: options.showUntracked,
+        stack: options.stack,
+        all: options.all
+      });
+      if (result) {
+        console.log(chalk2.green(`\u2714 Switched to '${result.branch}'`));
+      }
     }
   }
+);
+program.command("skills").description("Manage DubStack agent skills").addCommand(
+  new Command("add").description("Install agent skills (e.g. dubstack, dub-flow)").argument("[skills...]", "Names of skills to install (default: all)").option("-g, --global", "Install skills globally").option("--dry-run", "Preview actions without installing").action(async (skills, options) => {
+    const { addSkills: addSkills2 } = await Promise.resolve().then(() => (init_skills2(), skills_exports));
+    await addSkills2(skills, options);
+  })
+).addCommand(
+  new Command("remove").description("Remove agent skills").argument("[skills...]", "Names of skills to remove (default: all)").option("-g, --global", "Remove skills globally").option("--dry-run", "Preview actions without removing").action(async (skills, options) => {
+    const { removeSkills: removeSkills2 } = await Promise.resolve().then(() => (init_skills2(), skills_exports));
+    await removeSkills2(skills, options);
+  })
+);
+program.command("modify").alias("m").description(
+  "Modify the current branch by amending commits or creating new ones"
+).option("-a, --all", "Stage all changes before committing").option("-c, --commit", "Create a new commit instead of amending").option("-e, --edit", "Open editor to edit the commit message").option(
+  "-m, --message <message>",
+  "Message for the new or amended commit",
+  (value, previous = []) => [...previous, value],
+  []
+).option("-p, --patch", "Pick hunks to stage before committing").option("-u, --update", "Stage all updates to tracked files").option(
+  "-v, --verbose",
+  "Show staged diff before modify (repeat for unstaged diff too)",
+  (_value, previous = 0) => previous + 1,
+  0
+).option(
+  "--interactive-rebase",
+  "Start an interactive rebase on the branch commits"
+).action(async (options) => {
+  const { modify: modify2 } = await Promise.resolve().then(() => (init_modify(), modify_exports));
+  const normalizedOptions = {
+    ...options,
+    message: Array.isArray(options.message) && options.message.length === 1 ? options.message[0] : options.message
+  };
+  await modify2(process.cwd(), normalizedOptions);
+});
+program.command("pr").argument("[branch]", "Branch name or PR number to open").description("Open a branch PR in your browser").action(async (branch) => {
+  await pr(process.cwd(), branch);
 });
 async function runSubmit(options) {
   const result = await submit(process.cwd(), options.dryRun ?? false);
   if (result.pushed.length > 0) {
     console.log(
-      chalk.green(
+      chalk2.green(
         `\u2714 Pushed ${result.pushed.length} branch(es), created ${result.created.length} PR(s), updated ${result.updated.length} PR(s)`
       )
     );
     for (const branch of [...result.created, ...result.updated]) {
-      console.log(chalk.dim(`  \u21B3 ${branch}`));
+      console.log(chalk2.dim(`  \u21B3 ${branch}`));
     }
   }
 }
+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)"));
+  console.log(styled);
+}
+function parseSteps(positional, option) {
+  const raw = option ?? positional;
+  if (!raw) return 1;
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isInteger(parsed) || parsed < 1) {
+    throw new DubError("Steps must be a positive integer.");
+  }
+  return parsed;
+}
 async function main() {
   try {
     await program.parseAsync(process.argv);
   } catch (error) {
     if (error instanceof DubError) {
-      console.error(chalk.red(`\u2716 ${error.message}`));
+      console.error(chalk2.red(`\u2716 ${error.message}`));
       process.exit(1);
     }
     throw error;