@brainervirus/workit-claude-code 8.38.5 → 8.39.0

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "workit",
   "displayName": "Workit",
-  "version": "8.38.5",
+  "version": "8.39.0",
   "description": "Workflow rails for agentic coding: task context on every session, branch policy on shell commands, and the workit method skills",
   "author": {
     "name": "BrainerVirus"

package/dist/workit.js

@@ -9317,7 +9317,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@brainervirus/workit-cli",
-    version: "8.38.5",
+    version: "8.39.0",
     private: false,
     description: "Workit CLI — setup wizard, doctor, and task control for agentic coding workflows",
     keywords: [
@@ -9355,13 +9355,13 @@ var init_package = __esm(() => {
     },
     dependencies: {
       "@babel/parser": "7.29.9",
-      "@brainervirus/workit-cursor": "^8.38.5",
+      "@brainervirus/workit-cursor": "^8.39.0",
       "@inkjs/ui": "2.0.0",
       ink: "7.1.1",
       react: "19.2.8"
     },
     devDependencies: {
-      "@brainervirus/workit-core": "^8.38.5"
+      "@brainervirus/workit-core": "^8.39.0"
     },
     engines: {
       node: ">=24"
@@ -82478,6 +82478,74 @@ function syncStack(cwd, ctx, stack, options, actor) {
   }
   return { ok: true, data: outcome };
 }
+function pruneMergedBranches(cwd, ctx, stack, options) {
+  const outcome = { deleted: [], kept: [] };
+  const remote = remoteFor(cwd, ctx?.resolved ?? null, stack.trunk);
+  const trunkSha = trunkTip(cwd, remote, stack.trunk);
+  const keep = (branch, reason) => outcome.kept.push({ branch, reason });
+  for (const entry of stack.branches) {
+    if (!entry.merged || !safeRef3(entry.branch) || entry.branch === stack.trunk)
+      continue;
+    const tip = branchTip(cwd, entry.branch);
+    if (!tip)
+      continue;
+    if (isProtectedTarget(cwd, entry.branch)) {
+      keep(entry.branch, "a protected branch under the workspace branch policy; never deleted");
+      continue;
+    }
+    if (entry.lastHead === null || tip !== entry.lastHead) {
+      keep(entry.branch, `its tip ${tip.slice(0, 12)} is not recorded by the stack (last ${entry.lastHead?.slice(0, 12) ?? "none"}); commits made after it merged stay`);
+      continue;
+    }
+    const owner = worktreeOf(cwd, entry.branch);
+    if (owner) {
+      keep(entry.branch, `checked out in ${owner}; switch it away, then git branch -D ${entry.branch}`);
+      continue;
+    }
+    const safe = safeToDelete(cwd, ctx, remote, trunkSha, entry, tip);
+    if (safe === null) {
+      keep(entry.branch, `${tip.slice(0, 12)} is not on ${stack.trunk}, not the head its PR merged at and not on ${remote}/${entry.branch}: deleting it could lose commits (push them, or delete it yourself)`);
+      continue;
+    }
+    if (!options.dryRun) {
+      const removed = gitRun3(cwd, ["branch", "-D", "--", entry.branch]);
+      if (!removed.ok) {
+        keep(entry.branch, `git branch -D failed: ${removed.stderr.trim().split(`
+`)[0] ?? ""}`);
+        continue;
+      }
+      appendObserved(cwd, {
+        type: "stack.branch.deleted",
+        actor: options.actor,
+        stack: stack.name,
+        branch: entry.branch,
+        head: tip,
+        pr: entry.pr,
+        because: safe
+      });
+    }
+    outcome.deleted.push({ branch: entry.branch, sha: tip });
+  }
+  return outcome;
+}
+function safeToDelete(cwd, ctx, remote, trunkSha, entry, tip) {
+  if (trunkSha && isAncestor2(cwd, tip, trunkSha))
+    return "on_trunk";
+  if (ctx && entry.pr) {
+    const read = statusDoc(ctx, entry.pr);
+    if (read.ok && read.data.state === "merged" && read.data.head.sha === tip)
+      return "merged_head";
+  }
+  const own = pushRemoteName(cwd, entry.branch) ?? remote;
+  const remoteTip = remoteRefTip(cwd, own, `refs/heads/${entry.branch}`);
+  if (remoteTip.ok && remoteTip.sha) {
+    if (!hasCommit(cwd, remoteTip.sha))
+      fetchRefs(cwd, own, [remoteTip.sha]);
+    if (hasCommit(cwd, remoteTip.sha) && isAncestor2(cwd, tip, remoteTip.sha))
+      return "on_remote";
+  }
+  return null;
+}
 async function awaitChecks(ctx, pr, head, options) {
   let waited = 0;
   for (let poll = 0;; poll += 1) {
@@ -82718,6 +82786,7 @@ ${run.stdout}`.split(`
 }, commitCount = (cwd, base, head) => Number(gitRun3(cwd, ["rev-list", "--count", "--no-merges", `${base}..${head}`]).stdout.trim()) || 0, shortStat = (cwd, base, head) => gitRun3(cwd, ["diff", "--shortstat", `${base}...${head}`]).stdout.trim();
 var init_stack = __esm(() => {
   init_autonomy();
+  init_branch();
   init_store_lock();
   init_pr_ops();
   init_report2();
@@ -85168,8 +85237,213 @@ var init_pr_edit = __esm(() => {
   init_report2();
 });
 
-// packages/workit-core/src/core/live-session.ts
+// packages/workit-core/src/fanout-landed.ts
 import { spawnSync as spawnSync26 } from "node:child_process";
+function forgeBreaker(resolved) {
+  if (!resolved)
+    return { forge: null, down: () => null };
+  let tripped = null;
+  const guard = (call) => (...args) => {
+    if (tripped)
+      return { ok: false, code: "unavailable", error: tripped };
+    const result = call(...args);
+    if (!result.ok && result.code === "unavailable")
+      tripped = result.error;
+    return result;
+  };
+  const inner = resolved.forge;
+  const forge = Object.create(inner);
+  forge.findPr = guard(inner.findPr.bind(inner));
+  forge.prStatus = guard(inner.prStatus.bind(inner));
+  return { forge: { ...resolved, forge }, down: () => tripped };
+}
+function branchCreatedAt(cwd, branch) {
+  if (!branch || branch.startsWith("-"))
+    return null;
+  const log = gitRun4(cwd, ["log", "-g", "--format=%H", `refs/heads/${branch}`, "--"]);
+  if (!log.ok)
+    return null;
+  return log.stdout.trim().split(`
+`).findLast(Boolean) ?? null;
+}
+function hasOwnCommits2(cwd, branch, start, head) {
+  if (!branch || branch.startsWith("-"))
+    return false;
+  const log = gitRun4(cwd, ["log", "-g", "--format=%H%x00%gs", `refs/heads/${branch}`, "--"]);
+  if (!log.ok)
+    return false;
+  for (const line of log.stdout.split(`
+`)) {
+    const [sha, subject = ""] = line.split("\x00");
+    if (!sha)
+      continue;
+    const made = /^(?:commit(?: \((?:initial|amend)\))?|cherry-pick|rebase(?: -i)? \(pick\)):/u.test(subject);
+    const onto = /^rebase(?: -i)? \(finish\): \S+ onto ([0-9a-f]+)/u.exec(subject)?.[1];
+    if (!made && !(onto && !sha.startsWith(onto) && !onto.startsWith(sha)))
+      continue;
+    if (sha !== head && !isAncestor3(cwd, sha, head))
+      continue;
+    if (start && (sha === start || isAncestor3(cwd, sha, start)))
+      continue;
+    return true;
+  }
+  return false;
+}
+function reverted(cwd, trunk, landedHead, start) {
+  const fork = mergeBase(cwd, landedHead, trunk);
+  if (fork && fork !== landedHead)
+    return unchangedSince(cwd, fork, landedHead, trunk);
+  const before = start && start !== landedHead && isAncestor3(cwd, start, landedHead) ? start : gitRun4(cwd, ["rev-parse", "--verify", "-q", `${landedHead}^1`]).stdout.trim();
+  return before ? unchangedSince(cwd, before, landedHead, trunk) : false;
+}
+function unchangedSince(cwd, before, after, trunk) {
+  const paths = gitRun4(cwd, ["diff", "--name-only", "--no-renames", "-z", before, after]);
+  const files = paths.ok ? paths.stdout.split("\x00").filter(Boolean) : [];
+  if (files.length === 0)
+    return false;
+  return gitRun4(cwd, ["diff", "--quiet", before, trunk, "--", ...files]).ok;
+}
+function trunkPatchIds(ctx, fork) {
+  const cache = ctx.cache ??= new Map;
+  const known = cache.get(fork);
+  if (known)
+    return known;
+  const ids = new Set;
+  const log = gitRun4(ctx.cwd, [
+    "log",
+    "--no-merges",
+    `--max-count=${TRUNK_SCAN}`,
+    "-p",
+    "--format=commit %H",
+    "-U3",
+    "--diff-algorithm=myers",
+    "--indent-heuristic",
+    "--no-color",
+    "--no-ext-diff",
+    "--no-textconv",
+    "--no-renames",
+    "--full-index",
+    "--src-prefix=a/",
+    "--dst-prefix=b/",
+    `${fork}..${ctx.trunk}`,
+    "--"
+  ]);
+  if (log.ok && log.stdout.trim()) {
+    const run = spawnSync26("git", ["patch-id", "--stable"], {
+      cwd: ctx.cwd,
+      input: log.stdout,
+      encoding: "utf8",
+      timeout: GIT_TIMEOUTS.local,
+      windowsHide: true,
+      maxBuffer: 64 * 1024 * 1024
+    });
+    for (const line of (run.stdout ?? "").split(`
+`)) {
+      const id = line.trim().split(/\s+/u)[0];
+      if (id)
+        ids.add(id);
+    }
+  }
+  cache.set(fork, ids);
+  return ids;
+}
+function inSliceRun(row, slice) {
+  if (row.type === "fanout.worktree.created" && typeof row.sliceHash === "string" && slice.hash)
+    return row.sliceHash === slice.hash;
+  const since = Date.parse(slice.hashSince);
+  return Number.isNaN(since) || Date.parse(String(row.at)) >= since;
+}
+function linked(rows, input, slice, head) {
+  const since = input.since ? Date.parse(input.since) : Number.NaN;
+  const recent = (row) => Number.isNaN(since) || Date.parse(String(row.at)) >= since;
+  return rows.some((row) => {
+    if (row.type === "fanout.worktree.created" && row.fanout === input.fanout && row.slice === slice.id)
+      return typeof row.sliceHash === "string" && input.sliceHash ? row.sliceHash === input.sliceHash : recent(row);
+    return recent(row) && head !== null && row.branch === slice.branch && row.head === head;
+  });
+}
+function detectLanding(ctx, slice, input) {
+  const out = {
+    landed: false,
+    how: null,
+    pr: null,
+    landedHead: null,
+    forgeError: null,
+    note: null
+  };
+  const landed = (how, landedHead) => {
+    if (!hasCommit(ctx.cwd, landedHead) || !reverted(ctx.cwd, ctx.trunk, landedHead, input.createdFrom))
+      return { ...out, landed: true, how, landedHead };
+    return {
+      ...out,
+      note: `landed (${how}${out.pr ? ` #${out.pr.number}` : ""}), then reverted on the trunk: its paths read as before it`
+    };
+  };
+  const { head } = input;
+  if (ctx.forge) {
+    const found = ctx.forge.forge.findPr(slice.branch, {
+      owner: ctx.forge.headRepo.split("/")[0] ?? null,
+      projectId: ctx.forge.headProjectId,
+      sha: head
+    });
+    if (!found.ok)
+      out.forgeError = found.error;
+    else if (found.data) {
+      out.pr = found.data;
+      if (found.data.state === "merged") {
+        const merged = found.data.headSha;
+        const label = `#${found.data.number}`;
+        if (!head) {
+          if (!linked(input.rows, input, slice, merged)) {
+            out.pr = null;
+            out.note = `${slice.branch} is gone; merged ${label} is not linked to this slice in the ledger (an older branch of the same name?)`;
+            return out;
+          }
+          return merged ? landed("pr_merged", merged) : { ...out, landed: true, how: "pr_merged" };
+        }
+        if (!merged || head === merged || isAncestor3(ctx.cwd, head, merged))
+          return landed("pr_merged", merged ?? head);
+        out.note = isAncestor3(ctx.cwd, merged, head) ? `${label} merged at ${merged.slice(0, 12)}; ${slice.branch} is ahead of it with newer commits` : `${label} merged at ${merged.slice(0, 12)}; ${slice.branch} has diverged from it (rewritten after the merge)`;
+        return out;
+      }
+    }
+  }
+  if (!head)
+    return out;
+  const fork = mergeBase(ctx.cwd, head, ctx.trunk);
+  if (fork === head) {
+    return hasOwnCommits2(ctx.cwd, slice.branch, input.createdFrom, head) ? landed("on_trunk", head) : out;
+  }
+  if (!fork)
+    return out;
+  const trunkIds = trunkPatchIds(ctx, fork);
+  if (trunkIds.size === 0)
+    return out;
+  const froms = [fork];
+  if (input.parentHead && input.parentHead !== head && isAncestor3(ctx.cwd, input.parentHead, head))
+    froms.push(input.parentHead);
+  for (const from of froms) {
+    const id = patchId(ctx.cwd, from, head);
+    if (id && trunkIds.has(id))
+      return landed("squash_patch", head);
+  }
+  return out;
+}
+function sliceStart(cwd, rows, fanout, slice) {
+  const reflog = branchCreatedAt(cwd, slice.branch);
+  if (reflog)
+    return reflog;
+  const row = rows.findLast((candidate) => candidate.type === "fanout.worktree.created" && candidate.fanout === fanout && candidate.slice === slice.id && typeof candidate.baseSha === "string" && inSliceRun(candidate, slice));
+  return row?.baseSha ?? null;
+}
+var isAncestor3 = (cwd, a, b) => gitRun4(cwd, ["merge-base", "--is-ancestor", a, b]).ok, TRUNK_SCAN = 500;
+var init_fanout_landed = __esm(() => {
+  init_rev();
+  init_fanout();
+});
+
+// packages/workit-core/src/core/live-session.ts
+import { spawnSync as spawnSync27 } from "node:child_process";
 var LIVE_SESSION_TTL_MS, liveProbe, PIDS;
 var init_live_session = __esm(() => {
   init_paths();
@@ -85178,7 +85452,7 @@ var init_live_session = __esm(() => {
   LIVE_SESSION_TTL_MS = 15 * 60000;
   liveProbe = {
     platform: process.platform,
-    run: (args) => spawnSync26("ps", args, { encoding: "utf8", timeout: 2000 }).stdout ?? "",
+    run: (args) => spawnSync27("ps", args, { encoding: "utf8", timeout: 2000 }).stdout ?? "",
     start: (pid) => processStartOf(pid)
   };
   PIDS = new Map;
@@ -85471,8 +85745,65 @@ function worktreeDependencies(main, worktree) {
       ]
     };
   }
+  const stale = staleBunInstall(main);
+  if (stale && !fs32.existsSync(path64.join(worktree, "node_modules"))) {
+    const command = `bun install --frozen-lockfile --cwd ${worktree}`;
+    return {
+      linked: null,
+      install: command,
+      notes: [
+        `the main checkout's node_modules (${main}) do not match its bun.lock (${stale}), so they were not linked; install dependencies first: ${command}`
+      ]
+    };
+  }
   return { ...linkWorktreeDependencies(main, worktree), install: null };
 }
+function staleBunInstall(main) {
+  if (!fs32.existsSync(path64.join(main, "node_modules")))
+    return null;
+  const text = readBytes(path64.join(main, "bun.lock"))?.toString("utf8");
+  if (!text)
+    return null;
+  let packages;
+  try {
+    const parsed = JSON.parse(text.replace(/,(\s*[}\]])/gu, "$1"));
+    if (!parsed.packages || typeof parsed.packages !== "object")
+      return null;
+    packages = parsed.packages;
+  } catch {
+    return null;
+  }
+  const problems = [];
+  let scanned = 0;
+  for (const [key, entry] of Object.entries(packages)) {
+    if (scanned++ >= STALE_SCAN || problems.length >= 3)
+      break;
+    const spec = Array.isArray(entry) && typeof entry[0] === "string" ? entry[0] : null;
+    if (!spec)
+      continue;
+    const at = spec.lastIndexOf("@");
+    if (at <= 0)
+      continue;
+    const name = spec.slice(0, at);
+    const version = spec.slice(at + 1);
+    if (name !== key || version.includes(":"))
+      continue;
+    const manifest = readBytes(path64.join(main, "node_modules", key, "package.json"));
+    if (!manifest) {
+      problems.push(`${key} missing`);
+      continue;
+    }
+    let installed;
+    try {
+      installed = JSON.parse(manifest.toString("utf8")).version;
+    } catch {
+      installed = null;
+    }
+    if (installed !== version)
+      problems.push(`${key} ${String(installed ?? "?")} installed, bun.lock has ${version}`);
+  }
+  return problems.length ? problems.join("; ") : null;
+}
 function ensureScratch(worktree) {
   const scratch = path64.join(worktree, SCRATCH_DIR);
   fs32.mkdirSync(scratch, { recursive: true });
@@ -85549,14 +85880,19 @@ function createSliceWorktree(cwd, plan, input) {
       notes.push(`resumed ${slice.branch} from ${remote}/${slice.branch}`);
     } else {
       mode = "new";
-      const parent = plan.slices.find((other) => other.branch === slice.base);
-      const from = slice.base === plan.trunk ? trunkRef(cwd, plan.trunk) : parent ? branchRef(cwd, parent.branch) : branchRef(cwd, slice.base);
+      const landedOn = dependenciesLanded(cwd, plan, slice, input.forge);
+      if (landedOn) {
+        base.base = plan.trunk;
+        notes.push(landedOn);
+      }
+      const parent = landedOn ? undefined : plan.slices.find((other) => other.branch === slice.base);
+      const from = base.base === plan.trunk ? trunkRef(cwd, plan.trunk) : parent ? branchRef(cwd, parent.branch) : branchRef(cwd, slice.base);
       if (!from)
         return fanoutFail("not_found", `base ${slice.base} of slice ${slice.id} does not resolve here`, parent ? `start slice ${parent.id} first (its branch ${parent.branch} is the base)` : `git fetch origin ${slice.base}`);
       const added = gitRun4(cwd, ["worktree", "add", "--detach", target, from], SLOW);
       if (!added.ok)
         return worktreeFailed(added.stderr);
-      const branched = gitBranch(target, { name: slice.branch, base: slice.base });
+      const branched = gitBranch(target, { name: slice.branch, base: base.base });
       if (!branched.ok) {
         gitRun4(cwd, ["worktree", "remove", target], SLOW);
         return fanoutFail(branched.code, `workit git branch ${slice.branch} refused: ${branched.error}`, branched.unblock ?? `fix the branch name in the plan, then workit fanout worktree create ${slice.id}`);
@@ -85586,6 +85922,7 @@ function createSliceWorktree(cwd, plan, input) {
     sliceHash: slice.hash,
     ...admin ? { adminId: admin.id, adminIno: admin.ino, adminToken: admin.token } : {},
     ...baseSha ? { baseSha } : {},
+    ...base.base === slice.base ? {} : { startBase: base.base },
     ...deps.install ? { install: deps.install } : {}
   });
   return {
@@ -85602,6 +85939,35 @@ function createSliceWorktree(cwd, plan, input) {
     }
   };
 }
+function dependenciesLanded(cwd, plan, slice, forge) {
+  if (slice.base === plan.trunk || slice.dependsOn.length === 0)
+    return null;
+  const deps = slice.dependsOn.map((id) => plan.slices.find((other) => other.id === id));
+  if (deps.some((dep) => !dep))
+    return null;
+  const trunk = trunkRef(cwd, plan.trunk);
+  if (!trunk)
+    return null;
+  const ledger = readLedger(cwd);
+  const rows = ledger.ok ? ledger.value.rows : [];
+  const ctx = { cwd, trunk, forge: forgeBreaker(forge?.() ?? null).forge };
+  const landed = [];
+  for (const dep of deps) {
+    const landing = detectLanding(ctx, dep, {
+      head: branchRef(cwd, dep.branch),
+      createdFrom: sliceStart(cwd, rows, plan.name, dep),
+      parentHead: null,
+      fanout: plan.name,
+      since: dep.hashSince || plan.createdAt || null,
+      sliceHash: dep.hash || null,
+      rows
+    });
+    if (!landing.landed)
+      return null;
+    landed.push(`${dep.branch} landed (${landing.how ?? "pr_merged"}${landing.pr ? ` #${landing.pr.number}` : ""})`);
+  }
+  return `${landed.join(", ")}: started from ${plan.trunk}, not from ${slice.base}'s pre-merge tip`;
+}
 function releaseSliceWorktree(cwd, plan, input) {
   const found = findSlice(plan, input.slice);
   if (!found.ok)
@@ -85744,12 +86110,13 @@ var SLOW, SCRATCH_DIR = ".workit-scratch", EXCLUDE_LINE, DIRTY_ROW_BYTES = 2000,
   } catch {
     return null;
   }
-}, worktreeFailed = (stderr) => fanoutFail("failed", `git worktree add failed: ${stderr.trim().split(`
+}, STALE_SCAN = 5000, worktreeFailed = (stderr) => fanoutFail("failed", `git worktree add failed: ${stderr.trim().split(`
 `)[0] || "unknown error"}`);
 var init_fanout_worktree = __esm(() => {
   init_ops();
   init_rev();
   init_ledger();
+  init_fanout_landed();
   init_worktree_confine();
   init_worktree_deps();
   init_fanout();
@@ -87382,7 +87749,7 @@ var init_git2 = __esm(() => {
 });
 
 // packages/workit-core/src/forge/verify.ts
-import { spawnSync as spawnSync27 } from "node:child_process";
+import { spawnSync as spawnSync28 } from "node:child_process";
 function finish(cwd, report, actor) {
   const delivered = report.observations.length > 0 && report.observations.every((entry) => entry.ok);
   const out = { ...report, delivered };
@@ -87595,7 +87962,7 @@ var NPM_NAME, SEMVER2, SAFE_ARG, systemNpm = (args) => {
   };
   const found = process.platform === "win32" ? findExecutable("npm.cmd", process.env) : null;
   const npmCmd = found && !/["%!^]/u.test(found) ? `"${found}"` : "npm.cmd";
-  const result = process.platform === "win32" ? spawnSync27(`${npmCmd} ${args.join(" ")}`, { ...options, shell: true }) : spawnSync27("npm", [...args], options);
+  const result = process.platform === "win32" ? spawnSync28(`${npmCmd} ${args.join(" ")}`, { ...options, shell: true }) : spawnSync28("npm", [...args], options);
   return { status: result.status, stdout: result.stdout ?? "", stderr: result.stderr ?? "" };
 }, short3 = (sha) => sha ? sha.slice(0, 12) : "(absent)", npmView = (stdout) => {
   try {
@@ -87820,7 +88187,7 @@ function planReleaseFinish(cwd, input) {
       return failure3("not_found", `${name} exists neither locally nor on ${remote ?? "a remote"}`);
     if (!tracked || name === openRelease)
       continue;
-    if (!isAncestor3(cwd, tracked, local))
+    if (!isAncestor4(cwd, tracked, local))
       return failure3("blocked", `branch_behind: local ${name} is behind or diverged from ${remote}/${name}; git-flow finishes only onto up-to-date branches`, `git switch ${name} && git merge --ff-only ${remote}/${name}  # then: workit release finish ${version}`);
     const productionTracked = remote ? resolveRef(cwd, `refs/remotes/${remote}/${line.production}`) : null;
     const foreign = git5(cwd, [
@@ -87830,16 +88197,16 @@ function planReleaseFinish(cwd, input) {
       `^${releaseTip}`,
       ...productionTracked ? [`^${productionTracked}`] : []
     ]).stdout.split(`
-`).filter(Boolean).filter((sha) => !(git5(cwd, ["rev-parse", "-q", "--verify", `${sha}^2`]).ok && isAncestor3(cwd, releaseTip, sha)));
+`).filter(Boolean).filter((sha) => !(git5(cwd, ["rev-parse", "-q", "--verify", `${sha}^2`]).ok && isAncestor4(cwd, releaseTip, sha)));
     if (foreign.length)
       return failure3("blocked", `branch_ahead: local ${name} has ${foreign.length} commit(s) ${remote}/${name} lacks that are not part of ${branch}; the finish push would publish them`, `land them through review first, or: git switch ${name} && git reset --keep ${remote}/${name}  # then: workit release finish ${version}`);
   }
-  if (branchTip && remoteBranch && !isAncestor3(cwd, remoteBranch, branchTip))
+  if (branchTip && remoteBranch && !isAncestor4(cwd, remoteBranch, branchTip))
     return failure3("blocked", `release_behind: ${remote}/${branch} has commits local ${branch} lacks`, `git switch ${branch} && git merge --ff-only ${remote}/${branch}`);
   const production = resolveRef(cwd, `refs/heads/${line.production}`);
-  const merged = isAncestor3(cwd, releaseTip, production);
+  const merged = isAncestor4(cwd, releaseTip, production);
   const localTag = resolveRef(cwd, `refs/tags/${tag}`);
-  if (localTag && !(isAncestor3(cwd, localTag, production) && isAncestor3(cwd, releaseTip, localTag)))
+  if (localTag && !(isAncestor4(cwd, localTag, production) && isAncestor4(cwd, releaseTip, localTag)))
     return failure3("blocked", `tag_exists: ${tag} (${localTag.slice(0, 12)}) is not this release's merge on ${line.production}`, "a release tag never moves; finish under the next version");
   if (remote) {
     const remoteTag = remoteRefTip(cwd, remote, `refs/tags/${tag}`);
@@ -87853,7 +88220,7 @@ function planReleaseFinish(cwd, input) {
     tagged: localTag !== null,
     mergedBack: Object.fromEntries(mergeBack.map((name) => [
       name,
-      localTag !== null && isAncestor3(cwd, localTag, resolveRef(cwd, `refs/heads/${name}`))
+      localTag !== null && isAncestor4(cwd, localTag, resolveRef(cwd, `refs/heads/${name}`))
     ])),
     branchDeleted: branchTip === null
   };
@@ -88015,7 +88382,7 @@ var VERSION, PLACEHOLDER4, validVersion = (version) => VERSION.test(version) &&
   return ledger.value.rows.filter((row) => row.type.startsWith("release."));
 }, record2 = (cwd, actor, row) => {
   appendObserved(cwd, { ...row, actor });
-}, KINDS, isAncestor3 = (cwd, ancestor, descendant) => git5(cwd, ["merge-base", "--is-ancestor", ancestor, descendant]).ok, switchTo = (cwd, branch) => {
+}, KINDS, isAncestor4 = (cwd, ancestor, descendant) => git5(cwd, ["merge-base", "--is-ancestor", ancestor, descendant]).ok, switchTo = (cwd, branch) => {
   if (currentBranch(cwd) === branch)
     return success2(undefined);
   const switched = git5(cwd, ["switch", "-q", branch]);
@@ -88481,24 +88848,25 @@ async function status3(argv, io) {
     ...data.next ? [`next: ${data.next}`] : []
   ]);
 }
-async function sync(argv, io) {
+async function sync(argv, io, restack = false) {
+  const usageText = restack ? RESTACK_USAGE : SYNC_USAGE;
   const flags = parseFlags(argv, {
     name: "value",
-    local: "boolean",
+    ...restack ? {} : { local: "boolean" },
     "dry-run": "boolean",
     force: "list"
   });
   if (typeof flags === "string")
-    return usage4(io, flags, SYNC_USAGE);
+    return usage4(io, flags, usageText);
   if (flags.positionals.length)
-    return usage4(io, `unexpected argument ${flags.positionals[0]}`, SYNC_USAGE);
+    return usage4(io, `unexpected argument ${flags.positionals[0]}`, usageText);
   const selected = selectStack(io.cwd, flags.values.name ?? null);
   if (!selected.ok)
     return stackFailed(io, selected);
   const force = new Set(flags.lists.force ?? []);
   const unknown = [...force].filter((branch) => !selected.data.branches.some((entry) => entry.branch === branch));
   if (unknown.length)
-    return usage4(io, `--force ${unknown[0]}: not a branch of stack ${selected.data.name}`, SYNC_USAGE);
+    return usage4(io, `--force ${unknown[0]}: not a branch of stack ${selected.data.name}`, usageText);
   const local = flags.booleans.has("local");
   let ctx = null;
   if (!local) {
@@ -88517,14 +88885,23 @@ async function sync(argv, io) {
     const fresh = readStack(io.cwd, name);
     if (!fresh.ok)
       return fresh;
-    return syncStack(io.cwd, ctx, fresh.data ?? selected.data, {
-      publish: !local,
-      dryRun: flags.booleans.has("dry-run"),
-      force
-    }, actorFromEnv(io.env));
+    const stack = fresh.data ?? selected.data;
+    const dryRun = flags.booleans.has("dry-run");
+    const synced = syncStack(io.cwd, ctx, stack, { publish: !local, dryRun, force }, actorFromEnv(io.env));
+    if (!synced.ok || !restack)
+      return synced;
+    return {
+      ok: true,
+      data: {
+        ...synced.data,
+        pruned: pruneMergedBranches(io.cwd, ctx, stack, { dryRun, actor: actorFromEnv(io.env) })
+      }
+    };
   });
   if (!result.ok)
     return stackFailed(io, result);
+  if (restack)
+    return emit(io, ok2(result.data), renderRestack);
   return emit(io, ok2(result.data), renderSync);
 }
 async function land(argv, io) {
@@ -88611,11 +88988,13 @@ async function run20(argv, io) {
     return status3(rest, io);
   if (sub === "sync")
     return sync(rest, io);
+  if (sub === "restack")
+    return sync(rest, io, true);
   if (sub === "land")
     return land(rest, io);
   return usage4(io, sub && !sub.startsWith("-") ? `unknown stack subcommand "${sub}"` : "missing stack subcommand", USAGE13);
 }
-var PLAN_USAGE = "workit stack plan [--name <n>] [--trunk <b> | --track <t>] [<bottom> … <top>] [--json]", STATUS_USAGE2 = "workit stack status [--name <n>] [--json]", SYNC_USAGE = "workit stack sync [--name <n>] [--local] [--dry-run] [--force <branch>]… [--json]", LAND_USAGE = "workit stack land [--name <n>] [--dry-run] [--max <n>] [--method squash|merge|rebase] [--unverified --reason <why>] [--base-red-ok --reason <why>] [--timeout 20m] [--interval 30s] [--json]", USAGE13 = "workit stack plan|status|sync|land ... (workit help stack)", short5 = (sha) => sha ? sha.slice(0, 12) : "?", stackFailed = (io, result) => emit(io, fail2(result.code, result.error, {
+var PLAN_USAGE = "workit stack plan [--name <n>] [--trunk <b> | --track <t>] [<bottom> … <top>] [--json]", STATUS_USAGE2 = "workit stack status [--name <n>] [--json]", SYNC_USAGE = "workit stack sync [--name <n>] [--local] [--dry-run] [--force <branch>]… [--json]", RESTACK_USAGE = "workit stack restack [--name <n>] [--dry-run] [--force <branch>]… [--json]", LAND_USAGE = "workit stack land [--name <n>] [--dry-run] [--max <n>] [--method squash|merge|rebase] [--unverified --reason <why>] [--base-red-ok --reason <why>] [--timeout 20m] [--interval 30s] [--json]", USAGE13 = "workit stack plan|status|sync|restack|land ... (workit help stack)", short5 = (sha) => sha ? sha.slice(0, 12) : "?", stackFailed = (io, result) => emit(io, fail2(result.code, result.error, {
   unblock: result.unblock,
   data: result.data ?? {}
 })), label3 = (forge, pr) => pr === null ? "no PR" : `${forge === "gitlab" ? "MR !" : "PR #"}${pr}`, renderSync = (data) => [
@@ -88626,6 +89005,10 @@ var PLAN_USAGE = "workit stack plan [--name <n>] [--trunk <b> | --track <t>] [<b
     step.push ? step.push.pushed ? `pushed${step.push.forced ? " (lease)" : ""}` : "remote current" : "",
     step.retarget ? `retargeted ${step.retarget.from} -> ${step.retarget.to}` : ""
   ].filter(Boolean).join(" "))
+], renderRestack = (data) => [
+  ...renderSync(data),
+  ...data.pruned.deleted.map((item) => `${data.dryRun ? "would delete" : "deleted"} merged branch ${item.branch} at ${item.sha} (local; restore: git branch ${item.branch} ${item.sha})`),
+  ...data.pruned.kept.map((item) => `kept merged branch ${item.branch}: ${item.reason}`)
 ], METHODS3;
 var init_stack2 = __esm(() => {
   init_ledger();
@@ -88665,6 +89048,7 @@ function renderBrief(cwd, plan, input) {
   const planned = `${slicePath(cwd, slice)}${input.attempt === null ? "" : `+try${input.attempt}`}`;
   const made = ledger.value.rows.findLast((row) => row.type === "fanout.worktree.created" && row.fanout === plan.name && row.slice === slice.id && typeof row.path === "string" && samePath(row.path, planned));
   const fresh = Boolean(head) && made?.baseSha === head;
+  const sliceBase = typeof made?.startBase === "string" ? made.startBase : slice.base;
   const mode = input.mode ?? (head && !fresh ? "resume" : "new");
   if (mode === "resume" && !head)
     return fanoutFail("not_found", `MODE resume needs the branch ${branch}, which does not exist here`, `workit fanout brief ${slice.id} --mode new`);
@@ -88693,13 +89077,13 @@ function renderBrief(cwd, plan, input) {
     `GOAL: ${slice.goal}`,
     `SCOPE: ${slice.scope.join(", ")}`,
     ...slice.owns.length ? [`  owns: ${slice.owns.join(", ")}`] : [],
-    `  branch: ${branch}   base: ${slice.base}`,
+    `  branch: ${branch}   base: ${sliceBase}`,
     `CONTEXT: ${slice.context ?? "none given: read the files in SCOPE and the neighbours they import"}`,
     ...slice.issues.length ? [
       `ISSUE: ${slice.issues.join(", ")}  (\`workit pr create\` on ${branch} links ${slice.issues.length === 1 ? "it" : "them"} by itself; no --issue needed)`
     ] : [],
     ...mode === "resume" && head ? [
-      `  resume: continue ${branch} from ${head.slice(0, 12)}; read \`git log ${slice.base}..${branch}\` and \`workit ledger list --branch ${branch}\` (the last report, verdicts, rulings)`
+      `  resume: continue ${branch} from ${head.slice(0, 12)}; read \`git log ${sliceBase}..${branch}\` and \`workit ledger list --branch ${branch}\` (the last report, verdicts, rulings)`
     ] : [],
     "ACCEPTANCE:",
     ...slice.acceptance.map((line) => `  - ${line}`),
@@ -88722,7 +89106,7 @@ function renderBrief(cwd, plan, input) {
     exists ? `WORKTREE: ${planned}  (made by \`workit fanout worktree create ${slice.id}\`; yours alone)` : `WORKTREE: ${planned}  (not made yet: the lead runs \`workit fanout worktree create ${slice.id}\` before spawning, then renders this brief again)`,
     ...exists && typeof made?.install === "string" && !fs35.existsSync(path68.join(planned, "node_modules")) ? [`INSTALL: \`${made.install}\` first: the main checkout's node_modules was not linked here`] : [],
     ...identityLines(identity, minted),
-    ...rules(mode, branch, slice.base, exists ? planned : null)
+    ...rules(mode, branch, sliceBase, exists ? planned : null)
   ];
   return {
     ok: true,
@@ -88732,7 +89116,7 @@ function renderBrief(cwd, plan, input) {
       mode,
       attempt: input.attempt,
       branch,
-      base: slice.base,
+      base: sliceBase,
       tier: slice.tier,
       issues: slice.issues,
       model: model?.model ?? null,
@@ -88797,211 +89181,6 @@ var init_fanout_brief = __esm(() => {
   ];
 });
 
-// packages/workit-core/src/fanout-landed.ts
-import { spawnSync as spawnSync28 } from "node:child_process";
-function forgeBreaker(resolved) {
-  if (!resolved)
-    return { forge: null, down: () => null };
-  let tripped = null;
-  const guard = (call) => (...args) => {
-    if (tripped)
-      return { ok: false, code: "unavailable", error: tripped };
-    const result = call(...args);
-    if (!result.ok && result.code === "unavailable")
-      tripped = result.error;
-    return result;
-  };
-  const inner = resolved.forge;
-  const forge = Object.create(inner);
-  forge.findPr = guard(inner.findPr.bind(inner));
-  forge.prStatus = guard(inner.prStatus.bind(inner));
-  return { forge: { ...resolved, forge }, down: () => tripped };
-}
-function branchCreatedAt(cwd, branch) {
-  if (!branch || branch.startsWith("-"))
-    return null;
-  const log = gitRun4(cwd, ["log", "-g", "--format=%H", `refs/heads/${branch}`, "--"]);
-  if (!log.ok)
-    return null;
-  return log.stdout.trim().split(`
-`).findLast(Boolean) ?? null;
-}
-function hasOwnCommits2(cwd, branch, start, head) {
-  if (!branch || branch.startsWith("-"))
-    return false;
-  const log = gitRun4(cwd, ["log", "-g", "--format=%H%x00%gs", `refs/heads/${branch}`, "--"]);
-  if (!log.ok)
-    return false;
-  for (const line of log.stdout.split(`
-`)) {
-    const [sha, subject = ""] = line.split("\x00");
-    if (!sha)
-      continue;
-    const made = /^(?:commit(?: \((?:initial|amend)\))?|cherry-pick|rebase(?: -i)? \(pick\)):/u.test(subject);
-    const onto = /^rebase(?: -i)? \(finish\): \S+ onto ([0-9a-f]+)/u.exec(subject)?.[1];
-    if (!made && !(onto && !sha.startsWith(onto) && !onto.startsWith(sha)))
-      continue;
-    if (sha !== head && !isAncestor4(cwd, sha, head))
-      continue;
-    if (start && (sha === start || isAncestor4(cwd, sha, start)))
-      continue;
-    return true;
-  }
-  return false;
-}
-function reverted(cwd, trunk, landedHead, start) {
-  const fork = mergeBase(cwd, landedHead, trunk);
-  if (fork && fork !== landedHead)
-    return unchangedSince(cwd, fork, landedHead, trunk);
-  const before = start && start !== landedHead && isAncestor4(cwd, start, landedHead) ? start : gitRun4(cwd, ["rev-parse", "--verify", "-q", `${landedHead}^1`]).stdout.trim();
-  return before ? unchangedSince(cwd, before, landedHead, trunk) : false;
-}
-function unchangedSince(cwd, before, after, trunk) {
-  const paths = gitRun4(cwd, ["diff", "--name-only", "--no-renames", "-z", before, after]);
-  const files = paths.ok ? paths.stdout.split("\x00").filter(Boolean) : [];
-  if (files.length === 0)
-    return false;
-  return gitRun4(cwd, ["diff", "--quiet", before, trunk, "--", ...files]).ok;
-}
-function trunkPatchIds(ctx, fork) {
-  const cache = ctx.cache ??= new Map;
-  const known = cache.get(fork);
-  if (known)
-    return known;
-  const ids = new Set;
-  const log = gitRun4(ctx.cwd, [
-    "log",
-    "--no-merges",
-    `--max-count=${TRUNK_SCAN}`,
-    "-p",
-    "--format=commit %H",
-    "-U3",
-    "--diff-algorithm=myers",
-    "--indent-heuristic",
-    "--no-color",
-    "--no-ext-diff",
-    "--no-textconv",
-    "--no-renames",
-    "--full-index",
-    "--src-prefix=a/",
-    "--dst-prefix=b/",
-    `${fork}..${ctx.trunk}`,
-    "--"
-  ]);
-  if (log.ok && log.stdout.trim()) {
-    const run = spawnSync28("git", ["patch-id", "--stable"], {
-      cwd: ctx.cwd,
-      input: log.stdout,
-      encoding: "utf8",
-      timeout: GIT_TIMEOUTS.local,
-      windowsHide: true,
-      maxBuffer: 64 * 1024 * 1024
-    });
-    for (const line of (run.stdout ?? "").split(`
-`)) {
-      const id = line.trim().split(/\s+/u)[0];
-      if (id)
-        ids.add(id);
-    }
-  }
-  cache.set(fork, ids);
-  return ids;
-}
-function inSliceRun(row, slice) {
-  if (row.type === "fanout.worktree.created" && typeof row.sliceHash === "string" && slice.hash)
-    return row.sliceHash === slice.hash;
-  const since = Date.parse(slice.hashSince);
-  return Number.isNaN(since) || Date.parse(String(row.at)) >= since;
-}
-function linked(rows, input, slice, head) {
-  const since = input.since ? Date.parse(input.since) : Number.NaN;
-  const recent = (row) => Number.isNaN(since) || Date.parse(String(row.at)) >= since;
-  return rows.some((row) => {
-    if (row.type === "fanout.worktree.created" && row.fanout === input.fanout && row.slice === slice.id)
-      return typeof row.sliceHash === "string" && input.sliceHash ? row.sliceHash === input.sliceHash : recent(row);
-    return recent(row) && head !== null && row.branch === slice.branch && row.head === head;
-  });
-}
-function detectLanding(ctx, slice, input) {
-  const out = {
-    landed: false,
-    how: null,
-    pr: null,
-    landedHead: null,
-    forgeError: null,
-    note: null
-  };
-  const landed = (how, landedHead) => {
-    if (!hasCommit(ctx.cwd, landedHead) || !reverted(ctx.cwd, ctx.trunk, landedHead, input.createdFrom))
-      return { ...out, landed: true, how, landedHead };
-    return {
-      ...out,
-      note: `landed (${how}${out.pr ? ` #${out.pr.number}` : ""}), then reverted on the trunk: its paths read as before it`
-    };
-  };
-  const { head } = input;
-  if (ctx.forge) {
-    const found = ctx.forge.forge.findPr(slice.branch, {
-      owner: ctx.forge.headRepo.split("/")[0] ?? null,
-      projectId: ctx.forge.headProjectId,
-      sha: head
-    });
-    if (!found.ok)
-      out.forgeError = found.error;
-    else if (found.data) {
-      out.pr = found.data;
-      if (found.data.state === "merged") {
-        const merged = found.data.headSha;
-        const label = `#${found.data.number}`;
-        if (!head) {
-          if (!linked(input.rows, input, slice, merged)) {
-            out.pr = null;
-            out.note = `${slice.branch} is gone; merged ${label} is not linked to this slice in the ledger (an older branch of the same name?)`;
-            return out;
-          }
-          return merged ? landed("pr_merged", merged) : { ...out, landed: true, how: "pr_merged" };
-        }
-        if (!merged || head === merged || isAncestor4(ctx.cwd, head, merged))
-          return landed("pr_merged", merged ?? head);
-        out.note = isAncestor4(ctx.cwd, merged, head) ? `${label} merged at ${merged.slice(0, 12)}; ${slice.branch} is ahead of it with newer commits` : `${label} merged at ${merged.slice(0, 12)}; ${slice.branch} has diverged from it (rewritten after the merge)`;
-        return out;
-      }
-    }
-  }
-  if (!head)
-    return out;
-  const fork = mergeBase(ctx.cwd, head, ctx.trunk);
-  if (fork === head) {
-    return hasOwnCommits2(ctx.cwd, slice.branch, input.createdFrom, head) ? landed("on_trunk", head) : out;
-  }
-  if (!fork)
-    return out;
-  const trunkIds = trunkPatchIds(ctx, fork);
-  if (trunkIds.size === 0)
-    return out;
-  const froms = [fork];
-  if (input.parentHead && input.parentHead !== head && isAncestor4(ctx.cwd, input.parentHead, head))
-    froms.push(input.parentHead);
-  for (const from of froms) {
-    const id = patchId(ctx.cwd, from, head);
-    if (id && trunkIds.has(id))
-      return landed("squash_patch", head);
-  }
-  return out;
-}
-function sliceStart(cwd, rows, fanout, slice) {
-  const reflog = branchCreatedAt(cwd, slice.branch);
-  if (reflog)
-    return reflog;
-  const row = rows.findLast((candidate) => candidate.type === "fanout.worktree.created" && candidate.fanout === fanout && candidate.slice === slice.id && typeof candidate.baseSha === "string" && inSliceRun(candidate, slice));
-  return row?.baseSha ?? null;
-}
-var isAncestor4 = (cwd, a, b) => gitRun4(cwd, ["merge-base", "--is-ancestor", a, b]).ok, TRUNK_SCAN = 500;
-var init_fanout_landed = __esm(() => {
-  init_rev();
-  init_fanout();
-});
-
 // packages/workit-core/src/fanout-check.ts
 function mergeConflicts(cwd, a, b) {
   const run = gitRun4(cwd, [
@@ -89184,7 +89363,9 @@ function inspect(cwd, plan, slice, ctx, changedBy) {
     return check;
   }
   const parent = plan.slices.find((other) => other.branch === slice.base);
-  const baseRef = slice.base === plan.trunk ? trunk : parent ? tips.get(parent.id) ?? ctx.landings.get(parent.id)?.landedHead ?? null : branchRef(cwd, slice.base);
+  const parentLanded = parent ? ctx.landings.get(parent.id)?.landed === true : false;
+  const parentRef = parent ? tips.get(parent.id) ?? ctx.landings.get(parent.id)?.landedHead ?? null : null;
+  const baseRef = slice.base === plan.trunk ? trunk : parent ? parentLanded && !(parentRef && isAncestor5(cwd, parentRef, head)) ? trunk : parentRef : branchRef(cwd, slice.base);
   if (!SAFE(baseRef)) {
     check.reasons.push(`base ${slice.base} not found`);
     return check;
@@ -89652,7 +89833,8 @@ function worktree(argv, io) {
   if (action === "create") {
     const result = createSliceWorktree(io.cwd, selected.data, {
       slice: flags.positionals[0],
-      actor
+      actor,
+      forge: () => forgeFor(io, false).forge
     });
     if (!result.ok)
       return failed(io, result);
@@ -107587,6 +107769,11 @@ var VERBS = [
         usage: "workit stack sync [--name <n>] [--local] [--dry-run] [--force <branch>]…",
         summary: "Restack onto the moved bases, lease-push and retarget the PRs"
       },
+      {
+        name: "restack",
+        usage: "workit stack restack [--name <n>] [--dry-run] [--force <branch>]…",
+        summary: "After a parent merged (squash too): sync, then delete the merged stack branches locally"
+      },
       {
         name: "land",
         usage: "workit stack land [--name <n>] [--dry-run] [--max <n>] [--method squash|merge|rebase] [--unverified --reason <why>] [--base-red-ok --reason <why>] [--timeout 20m] [--interval 30s]",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brainervirus/workit-claude-code",
-  "version": "8.38.5",
+  "version": "8.39.0",
   "private": false,
   "description": "Workit Claude Code plugin — session and per-turn task context, branch policy on git shell commands, workit method skills, and verifier/reviewer/implementer agents",
   "keywords": [
@@ -39,8 +39,8 @@
     "build": "bun scripts/build.ts"
   },
   "devDependencies": {
-    "@brainervirus/workit-cli": "^8.38.5",
-    "@brainervirus/workit-core": "^8.38.5"
+    "@brainervirus/workit-cli": "^8.39.0",
+    "@brainervirus/workit-core": "^8.39.0"
   },
   "engines": {
     "node": ">=24"