@brainervirus/workit-claude-code 7.4.0 → 7.5.0

package/dist/workit.js

@@ -65,7 +65,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@brainervirus/workit-cli",
-    version: "7.4.0",
+    version: "7.5.0",
     private: false,
     description: "Workit CLI — setup wizard, doctor, and task control for agentic coding workflows",
     keywords: [
@@ -103,9 +103,9 @@ var init_package = __esm(() => {
     },
     dependencies: {
       "@babel/parser": "7.29.9",
-      "@brainervirus/workit-core": "^7.4.0",
-      "@brainervirus/workit-cursor": "^7.4.0",
-      "@brainervirus/workit-opencode": "^7.4.0",
+      "@brainervirus/workit-core": "^7.5.0",
+      "@brainervirus/workit-cursor": "^7.5.0",
+      "@brainervirus/workit-opencode": "^7.5.0",
       "@inkjs/ui": "2.0.0",
       ink: "7.1.1",
       react: "19.2.8"
@@ -73255,6 +73255,33 @@ var init_resolve = __esm(() => {
   init_gitlab();
 });
 
+// packages/workit-core/src/duration.ts
+function parseDuration2(value) {
+  const text = value.trim().toLowerCase();
+  if (/^\d+(?:\.\d+)?$/u.test(text))
+    return Math.round(Number(text) * 1000);
+  const parts = [...text.matchAll(/(\d+(?:\.\d+)?)\s*([a-z]+)\s*/gu)];
+  if (parts.length === 0 || parts.map((part) => part[0]).join("") !== text)
+    return null;
+  let total = 0;
+  for (const [, amount, unit] of parts) {
+    const factor = UNITS.find(([pattern]) => pattern.test(unit))?.[1];
+    if (factor === undefined)
+      return null;
+    total += Number(amount) * factor;
+  }
+  return Math.round(total);
+}
+var UNITS;
+var init_duration = __esm(() => {
+  UNITS = [
+    [/^(?:ms|milliseconds?)$/u, 1],
+    [/^(?:s|secs?|seconds?)$/u, 1000],
+    [/^(?:m|mins?|minutes?)$/u, 60000],
+    [/^(?:h|hrs?|hours?)$/u, 3600000]
+  ];
+});
+
 // packages/workit-cli/src/verbs/forge-common.ts
 function parseFlags(argv, spec) {
   const parsed = { values: {}, booleans: new Set, lists: {}, positionals: [] };
@@ -73292,14 +73319,6 @@ function positiveInt(value, flag) {
     return null;
   return /^[1-9]\d{0,8}$/u.test(value) ? Number(value) : `${flag} must be a positive integer`;
 }
-function parseDuration2(value) {
-  const match = /^(\d+(?:\.\d+)?)(ms|s|m|h)?$/u.exec(value.trim());
-  if (!match)
-    return null;
-  const unit = match[2] ?? "s";
-  const factor = unit === "ms" ? 1 : unit === "s" ? 1000 : unit === "m" ? 60000 : 3600000;
-  return Math.round(Number(match[1]) * factor);
-}
 function releaseTrunk(io, track, branch) {
   const resolved = vcsConfig("resolve", io.cwd, {
     track,
@@ -73382,6 +73401,7 @@ var forgeDeps, usage3 = (io, message, line) => emit(io, fail("invalid_input", me
 var init_forge_common = __esm(() => {
   init_resolve();
   init_vcs_config();
+  init_duration();
   init_output();
   forgeDeps = {
     runner: undefined,
@@ -75694,9 +75714,34 @@ var init_stack2 = __esm(() => {
 import { spawnSync as spawnSync21 } from "node:child_process";
 import fs23 from "node:fs";
 import path43 from "node:path";
+function expandBraces(pattern, limit = 64) {
+  for (let index = 0;index < pattern.length; index += 1) {
+    if (pattern[index] === "\\") {
+      index += 1;
+      continue;
+    }
+    const close = pattern.indexOf("}", index);
+    if (pattern[index] !== "{" || close < index)
+      continue;
+    const head = pattern.slice(0, index);
+    const tail = pattern.slice(close + 1);
+    const out = [];
+    for (const alternative of pattern.slice(index + 1, close).split(","))
+      for (const rest of expandBraces(tail, limit)) {
+        if (out.length >= limit)
+          return out;
+        out.push(`${head}${alternative}${rest}`);
+      }
+    return out;
+  }
+  return [pattern];
+}
 function scopeSamples(pattern) {
   if (!hasWildcard(pattern))
     return [unescape2(pattern)];
+  return [...new Set(expandBraces(pattern).map(sampleOne))];
+}
+function sampleOne(pattern) {
   let out = "";
   for (let index = 0;index < pattern.length; index += 1) {
     const char = pattern[index];
@@ -75715,14 +75760,10 @@ function scopeSamples(pattern) {
       out += "<any>";
     else if (char === "?")
       out += "x";
-    else if (char === "{" && pattern.indexOf("}", index) > index) {
-      const close = pattern.indexOf("}", index);
-      out += pattern.slice(index + 1, close).split(",")[0];
-      index = close;
-    } else
+    else
       out += char;
   }
-  return [out];
+  return out;
 }
 function globSource(pattern) {
   let out = "";
@@ -75763,7 +75804,20 @@ function matchesScope(pattern, file) {
   return regex.test(file) || !hasWildcard(pattern) && file.startsWith(`${unescape2(pattern)}/`);
 }
 function normalizePattern(raw) {
-  let pattern = raw.trim().replace(/\\(?![[\]{}*?])/gu, "/");
+  let pattern = raw.trim();
+  if (pattern.includes("\\")) {
+    if (/\\[*?{}]/u.test(pattern))
+      return {
+        error: "has \\*, \\?, \\{ or \\}: only \\[ and \\] are escapes; use / as the separator (src/**/*.ts)"
+      };
+    const brackets = /\\[[\]]/u.test(pattern);
+    if (brackets && pattern.replace(/\\[[\]]/gu, "").includes("\\"))
+      return {
+        error: "mixes \\[ or \\] escapes with other backslashes, which is ambiguous: use / as the separator (app/\\[id\\]/page.tsx)"
+      };
+    if (!brackets)
+      pattern = pattern.replaceAll("\\", "/");
+  }
   while (pattern.startsWith("./"))
     pattern = pattern.slice(2);
   if (pattern === "." || pattern === "")
@@ -75890,7 +75944,7 @@ function parsePlan(raw, defaults, name) {
       id,
       branch,
       base: optional("base") ?? "",
-      worktree: optional("worktree") ?? path43.join(defaults.worktreeRoot, id),
+      worktree: path43.resolve(defaults.root, optional("worktree") ?? path43.join(defaults.worktreeRoot, id)),
       tier,
       dependsOn: [...new Set(dependsOn ?? [])],
       scope,
@@ -76066,6 +76120,30 @@ function analyzeOverlap(plan, candidates) {
   });
   return { overlaps, conflicts };
 }
+function caseIndex(files) {
+  const index = new Map;
+  for (const file of files) {
+    const parts = file.split("/");
+    for (let end = 1;end <= parts.length; end += 1) {
+      const prefix = parts.slice(0, end).join("/");
+      const key = prefix.toLowerCase();
+      (index.get(key) ?? index.set(key, new Set).get(key))?.add(prefix);
+    }
+  }
+  return index;
+}
+function caseClash(index, file) {
+  const parts = file.split("/");
+  for (let end = 1;end <= parts.length; end += 1) {
+    const prefix = parts.slice(0, end).join("/");
+    if (prefix.includes("<any>"))
+      return null;
+    const spellings = index.get(prefix.toLowerCase());
+    if (spellings && !spellings.has(prefix))
+      return { path: prefix, trunk: [...spellings].toSorted()[0] };
+  }
+  return null;
+}
 function branchRef(cwd, branch) {
   if (!branch || branch.startsWith("-"))
     return null;
@@ -76088,9 +76166,12 @@ function defaultTrunk(cwd) {
   const base = defaultBase(cwd);
   return base ? base.replace(/^origin\//u, "") : "main";
 }
-function worktreeRoot(cwd) {
+function mainCheckout(cwd) {
   const common = gitCommonDir(cwd);
-  const main = common && path43.basename(common) === ".git" ? path43.dirname(common) : cwd;
+  return common && path43.basename(common) === ".git" ? path43.dirname(common) : path43.resolve(cwd);
+}
+function worktreeRoot(cwd) {
+  const main = mainCheckout(cwd);
   return path43.join(path43.dirname(main), `${path43.basename(main)}-wt`);
 }
 function fanoutsDir(cwd) {
@@ -76226,7 +76307,11 @@ function planFanout(cwd, input, now = new Date) {
   const dir = fanoutsDir(cwd);
   if (!dir.ok)
     return dir;
-  const parsed = parsePlan(input.trunk && isRecord8(input.raw) ? { ...input.raw, trunk: input.trunk } : input.raw, { trunk: input.trunk ?? defaultTrunk(cwd), worktreeRoot: worktreeRoot(cwd) }, input.name);
+  const parsed = parsePlan(input.trunk && isRecord8(input.raw) ? { ...input.raw, trunk: input.trunk } : input.raw, {
+    trunk: input.trunk ?? defaultTrunk(cwd),
+    root: mainCheckout(cwd),
+    worktreeRoot: worktreeRoot(cwd)
+  }, input.name);
   if (!parsed.ok)
     return fanoutFail("invalid_input", `the plan is incomplete: ${parsed.problems[0]}${parsed.problems.length > 1 ? ` (+${parsed.problems.length - 1} more)` : ""}`, "fill every listed field, then run workit fanout plan again", { problems: parsed.problems });
   const plan = parsed.plan;
@@ -76241,6 +76326,20 @@ function planFanout(cwd, input, now = new Date) {
   const { overlaps, conflicts } = analyzeOverlap(plan, [...tracked, ...samples]);
   if (conflicts.length)
     return fanoutFail("blocked", `${conflicts.length} file-scope overlap${conflicts.length === 1 ? "" : "s"} between slices: ${conflicts[0].slices.join(" and ")} on ${conflicts[0].paths[0]}${conflicts[0].paths.length > 1 ? ` (+${conflicts[0].paths.length - 1})` : ""}`, conflicts[0].suggestion.text, { name: plan.name, conflicts, overlaps });
+  const trunkCase = caseIndex(tracked);
+  const clashes = [];
+  for (const slice of plan.slices) {
+    const seen = new Set;
+    for (const sample of [...slice.scope, ...slice.owns].flatMap(scopeSamples)) {
+      const clash = caseClash(trunkCase, sample);
+      if (clash && !seen.has(clash.path)) {
+        seen.add(clash.path);
+        clashes.push({ slice: slice.id, ...clash });
+      }
+    }
+  }
+  if (clashes.length)
+    return fanoutFail("blocked", `slice ${clashes[0].slice} names ${clashes[0].path}, which differs only in case from ${plan.trunk}'s ${clashes[0].trunk} (one path on macOS and Windows)`, `use ${plan.trunk}'s spelling ${clashes[0].trunk} in slice ${clashes[0].slice}'s scope, then workit fanout plan again`, { name: plan.name, caseCollisions: clashes, overlaps });
   const existing = readFanout(cwd, plan.name);
   const previous = existing.ok ? existing.data : null;
   plan.createdAt = previous?.createdAt || now.toISOString();
@@ -76315,11 +76414,11 @@ var FANOUT_VERSION = 1, TIERS, fanoutFail = (code, error, unblock, data) => ({
     edges,
     text: edges.map((edge) => `add "${edge.dependsOn}" to "dependsOn" of slice ${edge.slice}`).join("; ")
   };
-}, gitRun4 = (cwd, args) => {
+}, gitRun4 = (cwd, args, timeoutMs = GIT_TIMEOUTS.local) => {
   const run = spawnSync21("git", args, {
     cwd,
     encoding: "utf8",
-    timeout: GIT_TIMEOUTS.local,
+    timeout: timeoutMs,
     killSignal: "SIGKILL",
     windowsHide: true,
     maxBuffer: 64 * 1024 * 1024,
@@ -76352,6 +76451,200 @@ var init_fanout = __esm(() => {
   ID = /^[a-z0-9][a-z0-9._-]{0,63}$/u;
 });
 
+// packages/workit-core/src/fanout-landed.ts
+import { spawnSync as spawnSync22 } 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 && !isAncestor2(cwd, sha, head))
+      continue;
+    if (start && (sha === start || isAncestor2(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 && isAncestor2(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 = spawnSync22("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 linked(rows, input, slice, head) {
+  const since = input.since ? Date.parse(input.since) : Number.NaN;
+  return rows.some((row) => (Number.isNaN(since) || Date.parse(String(row.at)) >= since) && (row.type === "fanout.worktree.created" && row.fanout === input.fanout && row.slice === slice.id || 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 || isAncestor2(ctx.cwd, head, merged))
+          return landed("pr_merged", merged ?? head);
+        out.note = isAncestor2(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 && isAncestor2(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");
+  return row?.baseSha ?? null;
+}
+var isAncestor2 = (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, [
@@ -76385,10 +76678,15 @@ function checkFanout(cwd, plan, options = {}) {
   const tips = new Map(plan.slices.map((slice) => [slice.id, branchRef(cwd, slice.branch)]));
   const ledger = readLedger(cwd);
   const rows = ledger.ok ? ledger.value.rows : [];
+  const breaker = forgeBreaker(options.forge ?? null);
+  const landings = sliceLandings(cwd, plan, trunk, tips, rows, breaker.forge);
+  const trunkCase = caseIndex(nulList2(gitRun4(cwd, ["ls-tree", "-r", "-z", "--name-only", trunk]).stdout));
   const checks = new Map;
   const changedBy = new Map;
-  for (const slice of plan.slices)
-    checks.set(slice.id, inspect(cwd, plan, slice, trunk, tips, rows, changedBy));
+  for (const slice of plan.slices) {
+    const landing = landings.get(slice.id);
+    checks.set(slice.id, landing.landed ? landedCheck(slice, tips.get(slice.id) ?? null, landing) : inspect(cwd, plan, slice, { trunk, trunkCase, tips, landings, rows }, changedBy));
+  }
   const conflicts = [];
   for (let i = 0;i < order.length; i += 1)
     for (let j = i + 1;j < order.length; j += 1) {
@@ -76396,7 +76694,9 @@ function checkFanout(cwd, plan, options = {}) {
       const second = order[j];
       const a = tips.get(first);
       const b = tips.get(second);
-      if (!a || !b || isAncestor2(cwd, a, b) || isAncestor2(cwd, b, a))
+      if (landings.get(first)?.landed || landings.get(second)?.landed)
+        continue;
+      if (!a || !b || isAncestor3(cwd, a, b) || isAncestor3(cwd, b, a))
         continue;
       const check = checks.get(second);
       const theirs = new Map((changedBy.get(first) ?? []).map((file) => [file.toLowerCase(), file]));
@@ -76434,19 +76734,29 @@ function checkFanout(cwd, plan, options = {}) {
     }
   for (const id of order) {
     const check = checks.get(id);
-    check.waitsFor = (byId.get(id)?.dependsOn ?? []).filter((dep) => checks.get(dep)?.status !== "ready");
+    if (check.status === "landed")
+      continue;
+    check.waitsFor = (byId.get(id)?.dependsOn ?? []).filter((dep) => checks.get(dep)?.status !== "ready" && checks.get(dep)?.status !== "landed");
     if (check.waitsFor.length)
       check.reasons.push(`waits for ${check.waitsFor.join(", ")}`);
     check.status = check.reasons.length ? "blocked" : "ready";
   }
   const selected = options.only?.length ? new Set(options.only) : null;
   const slices = order.filter((id) => !selected || selected.has(id)).map((id) => checks.get(id));
-  const ready = slices.every((check) => check.status === "ready");
+  const ready = slices.every((check) => check.status !== "blocked");
   const blocked = slices.find((check) => check.status === "blocked");
   const notes = plan.v === FANOUT_VERSION ? [] : [
     `plan file version ${plan.v} is not ${FANOUT_VERSION}; read leniently (re-plan to rewrite it)`
   ];
-  const next = blocked ? unblockFor(blocked, plan) : `land in this order: ${slices.map((check) => check.id).join(", ")} (workit pr merge each once verified; stacked slices with workit stack land)`;
+  const forgeErrors = [...landings.values()].flatMap((landing) => landing.forgeError ? [landing.forgeError] : []);
+  if (!options.forge)
+    notes.push("landed slices detected with git only (no forge): a squash merge may be missed");
+  else if (breaker.down())
+    notes.push(`forge went down (${breaker.down()}); git alone decided the remaining slices`);
+  else if (forgeErrors.length)
+    notes.push(`forge lookups failed (${forgeErrors[0]}); git alone decided those slices`);
+  const toLand = slices.filter((check) => check.status === "ready").map((check) => check.id);
+  const next = blocked ? unblockFor(blocked, plan) : toLand.length ? `land in this order: ${toLand.join(", ")} (workit pr merge each once verified; stacked slices with workit stack land)` : "every slice has landed";
   return {
     ok: true,
     data: {
@@ -76462,28 +76772,61 @@ function checkFanout(cwd, plan, options = {}) {
     }
   };
 }
-function inspect(cwd, plan, slice, trunk, tips, rows, changedBy) {
-  const head = tips.get(slice.id) ?? null;
-  const check = {
-    id: slice.id,
-    branch: slice.branch,
-    head,
-    base: slice.base,
-    status: "blocked",
-    changed: 0,
-    outOfScope: [],
-    trunkConflicts: [],
-    siblingConflicts: [],
-    waitsFor: [],
-    verdict: { accepted: false, basis: "missing" },
-    reasons: []
+function sliceLandings(cwd, plan, trunk, tips, rows, forge) {
+  const ctx = { cwd, trunk, forge };
+  const out = new Map;
+  const byId = new Map(plan.slices.map((slice) => [slice.id, slice]));
+  for (const id of landingOrder(plan.slices)) {
+    const slice = byId.get(id);
+    const parent = plan.slices.find((other) => other.branch === slice.base);
+    const parentHead = parent ? tips.get(parent.id) ?? out.get(parent.id)?.landedHead ?? null : null;
+    out.set(id, detectLanding(ctx, slice, {
+      head: tips.get(id) ?? null,
+      createdFrom: sliceStart(cwd, rows, plan.name, slice),
+      parentHead,
+      fanout: plan.name,
+      since: plan.createdAt || null,
+      rows
+    }));
+  }
+  return out;
+}
+function landedCheck(slice, head, landing) {
+  return {
+    ...blank2(slice, head),
+    status: "landed",
+    landed: { how: landing.how ?? "pr_merged", pr: landing.pr?.number ?? null }
   };
+}
+function trunkCaseCollisions(cwd, ctx, head, changed) {
+  const headFiles = treeFiles(cwd, head);
+  const forkFiles = treeFiles(cwd, gitRun4(cwd, ["merge-base", head, ctx.trunk]).stdout.trim() || null);
+  if (!headFiles)
+    return [];
+  const present = (files, prefix) => Boolean(files && (files.has(prefix) || [...files].some((file) => file.startsWith(`${prefix}/`))));
+  const out = new Set;
+  for (const file of changed) {
+    if (!headFiles.has(file))
+      continue;
+    const clash = caseClash(ctx.trunkCase, file);
+    if (!clash)
+      continue;
+    if (present(forkFiles, clash.trunk) && !present(headFiles, clash.trunk))
+      continue;
+    out.add(`${clash.path} ~ ${clash.trunk}`);
+  }
+  return [...out].toSorted();
+}
+function inspect(cwd, plan, slice, ctx, changedBy) {
+  const { trunk, tips, rows } = ctx;
+  const head = tips.get(slice.id) ?? null;
+  const check = blank2(slice, head);
   if (!head) {
-    check.reasons.push(`branch ${slice.branch} not found (not started, landed, or not fetched)`);
+    check.reasons.push(`branch ${slice.branch} not found (not started, or not fetched)`);
     return check;
   }
   const parent = plan.slices.find((other) => other.branch === slice.base);
-  const baseRef = slice.base === plan.trunk ? trunk : parent ? tips.get(parent.id) ?? null : branchRef(cwd, 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);
   if (!SAFE(baseRef)) {
     check.reasons.push(`base ${slice.base} not found`);
     return check;
@@ -76501,6 +76844,9 @@ function inspect(cwd, plan, slice, trunk, tips, rows, changedBy) {
   check.outOfScope = changed.filter((file) => !inScope(plan, slice, file)).toSorted();
   if (check.outOfScope.length)
     check.reasons.push(`edits outside its scope: ${check.outOfScope.join(", ")}`);
+  check.caseCollisions = trunkCaseCollisions(cwd, ctx, head, changed);
+  if (check.caseCollisions.length)
+    check.reasons.push(`differs only in case from ${plan.trunk}: ${check.caseCollisions.join(", ")}`);
   const trunkResult = mergeConflicts(cwd, trunk, head);
   if (Array.isArray(trunkResult)) {
     check.trunkConflicts = trunkResult;
@@ -76514,9 +76860,11 @@ function inspect(cwd, plan, slice, trunk, tips, rows, changedBy) {
 }
 function unblockFor(check, plan) {
   if (!check.head)
-    return `start or fetch ${check.branch}, then workit fanout check; if it landed, re-plan without slice ${check.id}`;
+    return `start or fetch ${check.branch}, then workit fanout check (a landed slice is detected through its merged PR when the forge is reachable)`;
   if (check.outOfScope.length)
     return `move ${check.outOfScope.join(", ")} off ${check.branch} (a follow-up slice), or widen slice ${check.id}'s scope with workit fanout plan, then workit fanout check`;
+  if (check.caseCollisions.length)
+    return `rename to ${plan.trunk}'s spelling on ${check.branch} (git mv), then workit fanout check`;
   if (check.trunkConflicts.length)
     return `rebase ${check.branch} onto ${plan.trunk} and resolve ${check.trunkConflicts.join(", ")}, then workit fanout check`;
   if (check.siblingConflicts.length) {
@@ -76527,10 +76875,552 @@ function unblockFor(check, plan) {
     return `unblock ${check.waitsFor.join(", ")} first`;
   return check.reasons[0] ?? "workit fanout check";
 }
-var SAFE = (value) => Boolean(value) && !value?.startsWith("-"), isAncestor2 = (cwd, a, b) => gitRun4(cwd, ["merge-base", "--is-ancestor", a, b]).ok, resolves = (cwd, ref) => gitRun4(cwd, ["rev-parse", "--verify", "-q", `${ref}^{commit}`]).ok;
+var SAFE = (value) => Boolean(value) && !value?.startsWith("-"), isAncestor3 = (cwd, a, b) => gitRun4(cwd, ["merge-base", "--is-ancestor", a, b]).ok, resolves = (cwd, ref) => gitRun4(cwd, ["rev-parse", "--verify", "-q", `${ref}^{commit}`]).ok, blank2 = (slice, head) => ({
+  id: slice.id,
+  branch: slice.branch,
+  head,
+  base: slice.base,
+  status: "blocked",
+  changed: 0,
+  outOfScope: [],
+  caseCollisions: [],
+  trunkConflicts: [],
+  siblingConflicts: [],
+  waitsFor: [],
+  verdict: { accepted: false, basis: "missing" },
+  landed: null,
+  reasons: []
+}), treeFiles = (cwd, rev) => {
+  if (!rev)
+    return null;
+  const run = gitRun4(cwd, ["ls-tree", "-r", "-z", "--name-only", rev]);
+  return run.ok ? new Set(nulList2(run.stdout)) : null;
+};
 var init_fanout_check = __esm(() => {
   init_ledger();
   init_fanout();
+  init_fanout_landed();
+});
+
+// packages/workit-core/src/fanout-status.ts
+function timeboxMs(text) {
+  if (!text || /^\s*\d+(?:\.\d+)?\s*$/u.test(text))
+    return null;
+  const ms = parseDuration2(text);
+  return ms && ms > 0 ? ms : null;
+}
+function activity(cwd, plan, slice, rows) {
+  const head = branchRef(cwd, slice.branch);
+  const commit = head ? isoOf(gitRun4(cwd, ["log", "-1", "--format=%ct", head, "--"]).stdout) : null;
+  const moved = /@\{(\d+)\}/u.exec(gitRun4(cwd, [
+    "log",
+    "-g",
+    "-1",
+    "--date=unix",
+    "--format=%gd",
+    `refs/heads/${slice.branch}`,
+    "--"
+  ]).stdout);
+  const reflog = moved ? isoOf(moved[1]) : null;
+  const ledger = rows.filter((row) => row.branch === slice.branch || row.fanout === plan.name && row.slice === slice.id).map((row) => row.at);
+  return {
+    head,
+    commit,
+    last: newest(commit, reflog, ...ledger),
+    worktreeCreated: rows.some((row) => row.type === "fanout.worktree.created" && row.fanout === plan.name && row.slice === slice.id)
+  };
+}
+function fanoutStatus(cwd, plan, options) {
+  const now = options.now ?? new Date;
+  const breaker = forgeBreaker(options.forge);
+  const forge = breaker.forge;
+  const trunk = trunkRef(cwd, plan.trunk);
+  if (!trunk)
+    return fanoutFail("unavailable", `trunk ${plan.trunk} does not resolve here`, `git fetch origin ${plan.trunk}`);
+  const ledger = readLedger(cwd);
+  const rows = ledger.ok ? ledger.value.rows : [];
+  const notes = [];
+  if (!ledger.ok)
+    notes.push(`ledger unreadable (${ledger.error}); verdicts read as missing`);
+  if (!forge)
+    notes.push(`forge unavailable${options.forgeError ? ` (${options.forgeError})` : ""}: PR and CI not shown; landed detection uses git only, so a squash merge may be missed`);
+  const tips = new Map(plan.slices.map((slice) => [slice.id, branchRef(cwd, slice.branch)]));
+  const landings = sliceLandings(cwd, plan, trunk, tips, rows, forge);
+  const byId = new Map(plan.slices.map((slice) => [slice.id, slice]));
+  const order = landingOrder(plan.slices);
+  const out = new Map;
+  for (const id of order) {
+    const slice = byId.get(id);
+    const landing = landings.get(id);
+    const seen = activity(cwd, plan, slice, rows);
+    const threshold = options.stuckAfterMs ?? timeboxMs(slice.timebox) ?? DEFAULT_STUCK_MS;
+    const idle = seen.last ? Math.max(0, now.getTime() - Date.parse(seen.last)) : null;
+    const verdict = seen.head ? checkVerdicts(cwd, slice.branch, rows) : null;
+    const row = {
+      id,
+      branch: slice.branch,
+      base: slice.base,
+      worktree: slice.worktree,
+      dependsOn: slice.dependsOn,
+      branchExists: seen.head !== null,
+      head: seen.head,
+      lastCommitAt: seen.commit,
+      lastActivityAt: seen.last,
+      idleMinutes: idle === null ? null : Math.floor(idle / 60000),
+      stuckAfterMinutes: Math.round(threshold / 60000),
+      pr: landing?.pr ? { number: landing.pr.number, url: landing.pr.url, state: landing.pr.state } : null,
+      ci: "unknown",
+      verdict: {
+        accepted: verdict?.accepted.accepted ?? false,
+        basis: verdict?.current.basis ?? "none",
+        review: verdict?.review ?? "unreviewed"
+      },
+      landed: landing?.landed && landing.how ? { how: landing.how, pr: landing.pr?.number ?? null } : null,
+      stuck: false,
+      waitsFor: [],
+      state: "not_started",
+      reasons: [],
+      notes: [
+        ...landing?.note ? [landing.note] : [],
+        ...landing?.forgeError ? [`forge: ${landing.forgeError}`] : []
+      ]
+    };
+    const answered = forge !== null && !landing?.forgeError;
+    if (answered && landing?.pr && landing.pr.state === "open" && !row.landed) {
+      const status = forge.forge.prStatus(landing.pr.number);
+      if (status.ok)
+        row.ci = checksState(gatingChecks(status.data).checks, missingRequired(status.data));
+      else
+        row.notes.push(`forge: ${status.error}`);
+    }
+    row.waitsFor = slice.dependsOn.filter((dep) => !out.get(dep)?.landed);
+    out.set(id, row);
+    if (row.landed) {
+      row.state = "landed";
+      continue;
+    }
+    const started = row.branchExists || seen.worktreeCreated;
+    if (!row.branchExists)
+      row.reasons.push("no branch yet");
+    if (!row.verdict.accepted)
+      row.reasons.push(`verdict ${row.verdict.basis === "none" ? "missing" : row.verdict.basis} on the current head`);
+    if (answered && row.branchExists) {
+      if (!row.pr)
+        row.reasons.push("no PR");
+      else if (row.pr.state !== "open")
+        row.reasons.push(`PR ${row.pr.state}`);
+      else if (row.ci === "failing" || row.ci === "pending")
+        row.reasons.push(`CI ${row.ci}`);
+    }
+    row.stuck = started && !row.verdict.accepted && idle !== null && idle > threshold;
+    if (row.stuck)
+      row.reasons.push(`no activity for ${row.idleMinutes} min`);
+  }
+  const suggested = [];
+  for (const id of order) {
+    const row = out.get(id);
+    if (row.landed || row.reasons.length)
+      continue;
+    if (row.waitsFor.every((dep) => suggested.includes(dep)))
+      suggested.push(id);
+  }
+  const spawnable = [];
+  for (const id of order) {
+    const row = out.get(id);
+    if (row.landed)
+      continue;
+    const parent = plan.slices.find((other) => other.branch === row.base);
+    if (suggested.includes(id))
+      row.state = "ready";
+    else if (row.stuck)
+      row.state = "stuck";
+    else if (row.branchExists)
+      row.state = "active";
+    else if (row.waitsFor.length === 0 || parent && row.waitsFor.length === 1 && row.waitsFor[0] === parent.id && out.get(parent.id)?.verdict.accepted) {
+      const created = rows.some((candidate) => candidate.type === "fanout.worktree.created" && candidate.fanout === plan.name && candidate.slice === id);
+      row.state = created ? "active" : "not_started";
+      if (!created)
+        spawnable.push(id);
+    } else
+      row.state = "waiting";
+    if (row.waitsFor.length && !suggested.includes(id))
+      row.reasons.push(`waits for ${row.waitsFor.join(", ")}`);
+  }
+  const stuck = order.filter((id) => out.get(id)?.stuck);
+  const down = breaker.down();
+  if (down)
+    notes.push(`forge went down during this run (${down}): later slices show no PR or CI, and git alone decided whether they landed`);
+  const online = forge !== null && !down;
+  const noPr = order.filter((id) => {
+    const row = out.get(id);
+    return !row.landed && row.reasons.length === 1 && row.reasons[0] === "no PR";
+  });
+  const next = stuck.length ? `replace ${stuck.join(", ")}: stop the worker, then workit fanout worktree release ${stuck[0]} (records git status first) and respawn it in MODE: resume` : suggested.length ? online ? `land in this order: ${suggested.join(", ")} (workit fanout check first; workit pr merge each)` : `land in this order: ${suggested.join(", ")} once each has a PR (offline: PRs unchecked; open a missing one with workit git push && workit pr create --fill, then workit fanout status online)` : noPr.length ? `open PRs for ${noPr.join(", ")}: workit git push && workit pr create --fill on each branch` : spawnable.length ? `spawn ${spawnable.join(", ")} (workit fanout worktree create <slice> on hosts without native worktrees)` : order.every((id) => out.get(id)?.landed) ? "every slice has landed" : "wait for workers, then workit fanout status again";
+  return {
+    ok: true,
+    data: {
+      name: plan.name,
+      trunk: plan.trunk,
+      trunkRef: trunk,
+      forge: {
+        available: online,
+        error: online ? null : down ?? options.forgeError ?? null
+      },
+      slices: order.map((id) => out.get(id)),
+      landingOrder: suggested,
+      spawnable,
+      stuck,
+      next,
+      notes
+    }
+  };
+}
+var DEFAULT_STUCK_MS, isoOf = (seconds) => {
+  const value = Number(seconds.trim());
+  return Number.isFinite(value) && value > 0 ? new Date(value * 1000).toISOString() : null;
+}, newest = (...values) => values.filter((value) => Boolean(value) && !Number.isNaN(Date.parse(value ?? ""))).reduce((best, value) => best === null || Date.parse(value) > Date.parse(best) ? value : best, null);
+var init_fanout_status = __esm(() => {
+  init_duration();
+  init_report();
+  init_ledger();
+  init_fanout_check();
+  init_fanout_landed();
+  init_fanout();
+  DEFAULT_STUCK_MS = 30 * 60000;
+});
+
+// packages/workit-core/src/fanout-worktree.ts
+import fs24 from "node:fs";
+import path44 from "node:path";
+function rowSample(lines) {
+  const out = [];
+  let bytes = 0;
+  for (const line of lines) {
+    const entry = line.slice(0, 200);
+    bytes += Buffer.byteLength(entry) + 3;
+    if (bytes > DIRTY_ROW_BYTES)
+      break;
+    out.push(entry);
+  }
+  return out;
+}
+function listWorktrees(cwd) {
+  const out = [];
+  let current = null;
+  for (const field of gitRun4(cwd, ["worktree", "list", "--porcelain", "-z"]).stdout.split("\x00")) {
+    if (field.startsWith("worktree ")) {
+      current = { path: field.slice(9), head: null, branch: null, locked: false };
+      out.push(current);
+    } else if (!current)
+      continue;
+    else if (field.startsWith("HEAD "))
+      current.head = field.slice(5);
+    else if (field.startsWith("branch "))
+      current.branch = field.slice(7);
+    else if (field === "locked" || field.startsWith("locked "))
+      current.locked = true;
+  }
+  return out;
+}
+function createdRow(cwd, plan, slice, target) {
+  const ledger = readLedger(cwd);
+  if (!ledger.ok)
+    return null;
+  const atPath = (row) => row.fanout === plan.name && row.slice === slice.id && typeof row.path === "string" && samePath(row.path, target);
+  const rows = ledger.value.rows;
+  const row = rows.findLast((candidate) => candidate.type === "fanout.worktree.created" && atPath(candidate));
+  if (!row)
+    return null;
+  const removedSince = rows.some((candidate) => candidate.seq > row.seq && candidate.type === "fanout.worktree.released" && candidate.outcome === "removed" && atPath(candidate));
+  if (removedSince)
+    return null;
+  const made = adminDirTime(target);
+  if (made === null || made + CLOCK_SLACK_MS < Date.parse(row.at))
+    return null;
+  return row;
+}
+function adminDirTime(worktree) {
+  const dir = gitRun4(worktree, ["rev-parse", "--absolute-git-dir"]);
+  if (!dir.ok)
+    return null;
+  try {
+    const stat = fs24.statSync(dir.stdout.trim());
+    return stat.birthtimeMs > 0 ? stat.birthtimeMs : stat.mtimeMs;
+  } catch {
+    return null;
+  }
+}
+function findSlice(plan, id) {
+  const slice = plan.slices.find((candidate) => candidate.id === id);
+  return slice ? { ok: true, data: slice } : fanoutFail("invalid_input", `${id}: not a slice of fanout ${plan.name}`, `slices: ${plan.slices.map((candidate) => candidate.id).join(", ")}`);
+}
+function excludeScratch(cwd) {
+  const common = gitCommonDir(cwd);
+  if (!common)
+    return;
+  const file = path44.join(common, "info", "exclude");
+  let text = "";
+  try {
+    text = fs24.readFileSync(file, "utf8");
+  } catch {
+    text = "";
+  }
+  if (text.split(/\r?\n/u).includes(EXCLUDE_LINE))
+    return;
+  fs24.mkdirSync(path44.dirname(file), { recursive: true });
+  fs24.appendFileSync(file, `${text && !text.endsWith(`
+`) ? `
+` : ""}# workit fanout: per-worker scratch dirs
+${EXCLUDE_LINE}
+`);
+}
+function ensureScratch(worktree) {
+  const scratch = path44.join(worktree, SCRATCH_DIR);
+  fs24.mkdirSync(scratch, { recursive: true });
+  return scratch;
+}
+function createSliceWorktree(cwd, plan, input) {
+  const found = findSlice(plan, input.slice);
+  if (!found.ok)
+    return found;
+  const slice = found.data;
+  if (!slice.worktree)
+    return fanoutFail("invalid_input", `slice ${slice.id} has no worktree path`, "re-plan it with workit fanout plan");
+  const target = slicePath(cwd, slice);
+  const worktrees = listWorktrees(cwd);
+  const localRef = `refs/heads/${slice.branch}`;
+  const existing = worktrees.find((entry) => samePath(entry.path, target));
+  const base = {
+    fanout: plan.name,
+    slice: slice.id,
+    branch: slice.branch,
+    base: slice.base,
+    path: target
+  };
+  if (existing) {
+    if (existing.branch !== null && existing.branch !== localRef)
+      return fanoutFail("blocked", `${target} is a worktree on ${existing.branch.replace(/^refs\/heads\//u, "")}, not ${slice.branch}`, `release it first, or set slice ${slice.id}'s worktree to another path`);
+    if (!createdRow(cwd, plan, slice, target))
+      return fanoutFail("blocked", `${target} is a worktree that workit fanout worktree create did not make for slice ${slice.id}`, `remove it yourself (git worktree remove ${target}) once you know what it holds`);
+    excludeScratch(cwd);
+    return {
+      ok: true,
+      data: {
+        ...base,
+        scratch: ensureScratch(target),
+        head: existing.head ?? "",
+        mode: resolveRef(cwd, localRef) ? "resume" : "new",
+        created: false,
+        notes: ["the worktree already exists; nothing was changed"]
+      }
+    };
+  }
+  const elsewhere = worktrees.find((entry) => entry.branch === localRef);
+  if (elsewhere)
+    return fanoutFail("blocked", `${slice.branch} is checked out at ${elsewhere.path}: never two live workers on one branch`, `stop that worker, then workit fanout worktree release ${slice.id} (or git worktree remove ${elsewhere.path})`);
+  let dirExisted = false;
+  try {
+    const stat = fs24.statSync(target);
+    if (!stat.isDirectory() || fs24.readdirSync(target).length > 0)
+      return fanoutFail("blocked", `${target} exists and is ${stat.isDirectory() ? "not empty" : "not a directory"} (not a worktree of this repository)`, `move it away, or set slice ${slice.id}'s worktree to another path`);
+    dirExisted = true;
+  } catch (error) {
+    if (error.code !== "ENOENT")
+      return fanoutFail("failed", `cannot read ${target}: ${error.message}`);
+  }
+  const notes = [];
+  let mode = "resume";
+  if (resolveRef(cwd, localRef)) {
+    const added = gitRun4(cwd, ["worktree", "add", target, slice.branch], SLOW);
+    if (!added.ok)
+      return worktreeFailed(added.stderr);
+  } else {
+    const remote = pushRemoteName(cwd) ?? "origin";
+    const remoteRef = `refs/remotes/${remote}/${slice.branch}`;
+    if (resolveRef(cwd, remoteRef)) {
+      const added = gitRun4(cwd, ["worktree", "add", "-b", slice.branch, target, remoteRef], SLOW);
+      if (!added.ok)
+        return worktreeFailed(added.stderr);
+      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);
+      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 });
+      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}`);
+      }
+      notes.push(...branched.data.notes);
+    }
+  }
+  excludeScratch(cwd);
+  const scratch = ensureScratch(target);
+  const head = gitRun4(target, ["rev-parse", "HEAD"]).stdout.trim();
+  const baseSha = mode === "new" ? head : null;
+  appendObserved(cwd, {
+    type: "fanout.worktree.created",
+    actor: input.actor,
+    fanout: plan.name,
+    slice: slice.id,
+    branch: slice.branch,
+    path: target,
+    scratch,
+    mode,
+    head,
+    dirExisted,
+    planCreatedAt: plan.createdAt,
+    ...baseSha ? { baseSha } : {}
+  });
+  return { ok: true, data: { ...base, scratch, head, mode, created: true, notes } };
+}
+function releaseSliceWorktree(cwd, plan, input) {
+  const found = findSlice(plan, input.slice);
+  if (!found.ok)
+    return found;
+  const slice = found.data;
+  const target = slicePath(cwd, slice);
+  const worktrees = listWorktrees(cwd);
+  const index = worktrees.findIndex((entry) => samePath(entry.path, target));
+  const out = {
+    fanout: plan.name,
+    slice: slice.id,
+    branch: slice.branch,
+    path: target,
+    head: null,
+    dirty: [],
+    forced: input.force,
+    removed: false,
+    unpushed: null,
+    notes: []
+  };
+  if (index < 0) {
+    if (fs24.existsSync(target))
+      return fanoutFail("blocked", `${target} is not a worktree of this repository; nothing was removed`, "remove it yourself once you know what it holds");
+    out.notes.push(`no worktree at ${target}; nothing to release`);
+    return { ok: true, data: out };
+  }
+  const entry = worktrees[index];
+  if (index === 0)
+    return fanoutFail("blocked", `${target} is the main checkout; it is never released`);
+  if (inside2(cwd, entry.path))
+    return fanoutFail("blocked", `this command runs inside ${entry.path}`, `run it from the main checkout: workit --cwd <main checkout> fanout worktree release ${slice.id}`);
+  if (entry.branch !== null && entry.branch !== `refs/heads/${slice.branch}`)
+    return fanoutFail("blocked", `${entry.path} is on ${entry.branch.replace(/^refs\/heads\//u, "")}, not slice ${slice.id}'s ${slice.branch}; nothing was removed`);
+  const made = createdRow(cwd, plan, slice, entry.path);
+  if (!made)
+    return fanoutFail("blocked", `${entry.path} was not made by workit fanout worktree create for slice ${slice.id} (no ledger row); nothing was removed`, `remove it yourself (git worktree remove ${entry.path}) once you know what it holds`);
+  out.head = entry.head;
+  const status = gitRun4(entry.path, [
+    "status",
+    "--porcelain=v1",
+    "-z",
+    "--untracked-files=all",
+    "--ignore-submodules=none"
+  ]);
+  if (!status.ok)
+    return fanoutFail("failed", `git status in ${entry.path} failed: ${status.stderr.trim().split(`
+`)[0]}`, "nothing was removed; inspect the worktree by hand");
+  const entries = porcelainEntries(status.stdout);
+  const inScratch = (line) => line.slice(3).startsWith(`${SCRATCH_DIR}/`);
+  out.dirty = entries.filter((line) => !inScratch(line));
+  out.unpushed = unpushedCount(cwd, slice.branch);
+  const refused = out.dirty.length > 0 && !input.force;
+  const recorded = appendObserved(cwd, {
+    type: "fanout.worktree.released",
+    actor: input.actor,
+    fanout: plan.name,
+    slice: slice.id,
+    branch: slice.branch,
+    path: entry.path,
+    head: entry.head,
+    uncommittedCount: out.dirty.length,
+    uncommitted: rowSample(out.dirty),
+    forced: input.force,
+    outcome: refused ? "refused" : "removed"
+  });
+  if (!recorded.ok)
+    return fanoutFail("unavailable", `cannot record the worktree state in the ledger (${recorded.error}); nothing was removed`);
+  if (refused)
+    return fanoutFail("blocked", `${entry.path} has ${out.dirty.length} uncommitted change${out.dirty.length === 1 ? "" : "s"} (${out.dirty.slice(0, 3).join(", ")}${out.dirty.length > 3 ? ", …" : ""}); recorded in the ledger, nothing removed`, `commit them on ${slice.branch} (workit git commit), or pass --force to drop them`, { ...out });
+  const args = ["worktree", "remove", ...input.force ? ["--force"] : [], entry.path];
+  let removed = gitRun4(cwd, args, SLOW);
+  if (!removed.ok && entries.some(inScratch)) {
+    removeScratch(entry.path);
+    removed = gitRun4(cwd, args, SLOW);
+  }
+  if (!removed.ok)
+    return fanoutFail("failed", `git worktree remove failed: ${removed.stderr.trim().split(`
+`)[0]}`, entry.locked ? `git worktree unlock ${entry.path}, then release again` : undefined, { ...out });
+  out.removed = true;
+  if (made.dirExisted === true)
+    fs24.mkdirSync(entry.path, { recursive: true });
+  if (out.unpushed)
+    out.notes.push(`${slice.branch} is kept with ${out.unpushed} commit(s) not on the remote`);
+  return { ok: true, data: out };
+}
+function porcelainEntries(stdout) {
+  const fields = nulList2(stdout);
+  const out = [];
+  for (let index = 0;index < fields.length; index += 1) {
+    const entry = fields[index];
+    out.push(entry);
+    if (entry[0] === "R" || entry[0] === "C")
+      index += 1;
+  }
+  return out;
+}
+function unpushedCount(cwd, branch) {
+  const remote = pushRemoteName(cwd) ?? "origin";
+  const local = resolveRef(cwd, `refs/heads/${branch}`);
+  if (!local)
+    return null;
+  const tracking = resolveRef(cwd, `refs/remotes/${remote}/${branch}`);
+  if (!tracking)
+    return null;
+  const count = gitRun4(cwd, ["rev-list", "--count", `${tracking}..${local}`]);
+  return count.ok ? Number(count.stdout.trim()) : null;
+}
+function removeScratch(worktree) {
+  const scratch = path44.join(worktree, SCRATCH_DIR);
+  let stat;
+  try {
+    stat = fs24.lstatSync(scratch);
+  } catch {
+    return;
+  }
+  if (stat.isSymbolicLink() || !stat.isDirectory())
+    fs24.unlinkSync(scratch);
+  else
+    fs24.rmSync(scratch, { recursive: true, force: true, maxRetries: 2 });
+}
+var SLOW, SCRATCH_DIR = ".workit-scratch", EXCLUDE_LINE, DIRTY_ROW_BYTES = 2000, canonical2 = (target) => {
+  try {
+    return fs24.realpathSync.native(target);
+  } catch {
+    return path44.resolve(target);
+  }
+}, samePath = (a, b) => {
+  const left = canonical2(a);
+  const right = canonical2(b);
+  return process.platform === "win32" || process.platform === "darwin" ? left.toLowerCase() === right.toLowerCase() : left === right;
+}, inside2 = (child, parent) => {
+  const relative = path44.relative(canonical2(parent), canonical2(child));
+  return relative === "" || !relative.startsWith("..") && !path44.isAbsolute(relative);
+}, slicePath = (cwd, slice) => path44.isAbsolute(slice.worktree) ? slice.worktree : path44.resolve(mainCheckout(cwd), slice.worktree), CLOCK_SLACK_MS = 2000, 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();
+  SLOW = GIT_TIMEOUTS.worktree;
+  EXCLUDE_LINE = `/${SCRATCH_DIR}/`;
 });
 
 // packages/workit-cli/src/verbs/fanout.ts
@@ -76538,8 +77428,14 @@ var exports_fanout = {};
 __export(exports_fanout, {
   run: () => run15
 });
-import fs24 from "node:fs";
-import path44 from "node:path";
+import fs25 from "node:fs";
+import path45 from "node:path";
+function forgeFor(io, offline) {
+  if (offline)
+    return { forge: null, error: "--offline" };
+  const connected = connect(io, null);
+  return connected.ok ? { forge: connected.data, error: null } : { forge: null, error: connected.error };
+}
 function renderBlockedPlan(io, result) {
   if (io.json || result.code !== "blocked" && result.code !== "invalid_input")
     return;
@@ -76547,6 +77443,11 @@ function renderBlockedPlan(io, result) {
   if (Array.isArray(problems))
     for (const problem of problems)
       io.stderr(`  - ${problem}
+`);
+  const clashes = result.data?.caseCollisions;
+  if (Array.isArray(clashes))
+    for (const clash of clashes)
+      io.stderr(`  - ${clash.slice}: ${clash.path} ~ trunk's ${clash.trunk}
 `);
   const conflicts = result.data?.conflicts;
   if (Array.isArray(conflicts))
@@ -76584,10 +77485,10 @@ function plan2(argv, io) {
     return usage3(io, "pass --trunk or --track, not both (--track picks the trunk)", PLAN_USAGE2);
   if (flags.positionals.length !== 1)
     return usage3(io, flags.positionals.length ? `unexpected argument ${flags.positionals[1]}` : "missing <plan.json>", PLAN_USAGE2);
-  const file = path44.resolve(io.cwd, flags.positionals[0]);
+  const file = path45.resolve(io.cwd, flags.positionals[0]);
   let raw;
   try {
-    raw = JSON.parse(fs24.readFileSync(file, "utf8"));
+    raw = JSON.parse(fs25.readFileSync(file, "utf8"));
   } catch (error) {
     return usage3(io, `cannot read ${file} as JSON: ${error.message}`, PLAN_USAGE2);
   }
@@ -76616,7 +77517,7 @@ function plan2(argv, io) {
   ]);
 }
 function check2(argv, io) {
-  const flags = parseFlags(argv, { name: "value", base: "value" });
+  const flags = parseFlags(argv, { name: "value", base: "value", offline: "boolean" });
   if (typeof flags === "string")
     return usage3(io, flags, CHECK_USAGE);
   const selected = selectFanout(io.cwd, flags.values.name ?? null, currentBranch(io.cwd));
@@ -76624,7 +77525,8 @@ function check2(argv, io) {
     return failed(io, selected);
   const result = checkFanout(io.cwd, selected.data, {
     only: flags.positionals,
-    trunkRef: flags.values.base ?? null
+    trunkRef: flags.values.base ?? null,
+    forge: forgeFor(io, flags.booleans.has("offline")).forge
   });
   if (!result.ok)
     return failed(io, result);
@@ -76640,17 +77542,92 @@ function check2(argv, io) {
     unblock: result.data.next
   }));
 }
+function status3(argv, io) {
+  const flags = parseFlags(argv, { name: "value", "stuck-after": "value", offline: "boolean" });
+  if (typeof flags === "string")
+    return usage3(io, flags, STATUS_USAGE3);
+  if (flags.positionals.length)
+    return usage3(io, `unexpected argument ${flags.positionals[0]}`, STATUS_USAGE3);
+  const raw = flags.values["stuck-after"];
+  const stuckAfterMs = raw === undefined ? null : parseDuration2(raw);
+  if (stuckAfterMs === 0 || raw !== undefined && stuckAfterMs === null)
+    return usage3(io, "--stuck-after takes a duration such as 30m, 45m or 2h", STATUS_USAGE3);
+  const selected = selectFanout(io.cwd, flags.values.name ?? null, currentBranch(io.cwd));
+  if (!selected.ok)
+    return failed(io, selected);
+  const forge = forgeFor(io, flags.booleans.has("offline"));
+  const result = fanoutStatus(io.cwd, selected.data, {
+    forge: forge.forge,
+    forgeError: forge.error,
+    stuckAfterMs
+  });
+  if (!result.ok)
+    return failed(io, result);
+  return emit(io, ok(result.data), renderStatus2);
+}
+function worktree(argv, io) {
+  const [action, ...rest] = argv;
+  const flags = parseFlags(rest, { name: "value", force: "boolean" });
+  if (typeof flags === "string")
+    return usage3(io, flags, WORKTREE_USAGE);
+  if (action !== "create" && action !== "release")
+    return usage3(io, action ? `unknown worktree action "${action}"` : "missing create or release", WORKTREE_USAGE);
+  if (flags.positionals.length !== 1)
+    return usage3(io, flags.positionals.length ? `unexpected argument ${flags.positionals[1]}` : "missing <slice>", WORKTREE_USAGE);
+  if (action === "create" && flags.booleans.has("force"))
+    return usage3(io, "--force applies to release only", WORKTREE_USAGE);
+  const selected = selectFanout(io.cwd, flags.values.name ?? null, currentBranch(io.cwd));
+  if (!selected.ok)
+    return failed(io, selected);
+  const actor = actorFromEnv(io.env);
+  if (action === "create") {
+    const result = createSliceWorktree(io.cwd, selected.data, {
+      slice: flags.positionals[0],
+      actor
+    });
+    if (!result.ok)
+      return failed(io, result);
+    return emit(io, ok(result.data), (data) => [
+      `${data.created ? "created" : "kept"} worktree for slice ${data.slice} (${data.mode}): ${data.path}`,
+      `  branch ${data.branch} <- ${data.base} at ${short5(data.head)}`,
+      `  scratch ${data.scratch}  (put it in the worker brief: temp files go here)`,
+      ...data.notes.map((note) => `note: ${note}`)
+    ]);
+  }
+  const result = releaseSliceWorktree(io.cwd, selected.data, {
+    slice: flags.positionals[0],
+    force: flags.booleans.has("force"),
+    actor
+  });
+  if (!result.ok) {
+    const code = failed(io, result);
+    const dirty = result.data?.dirty;
+    if (!io.json && Array.isArray(dirty))
+      for (const line of dirty)
+        io.stderr(`  ${line}
+`);
+    return code;
+  }
+  return emit(io, ok(result.data), (data) => [
+    data.removed ? `released slice ${data.slice}: removed ${data.path}${data.dirty.length ? ` (dropped ${data.dirty.length} uncommitted change${data.dirty.length === 1 ? "" : "s"}, recorded in the ledger)` : ""}; branch ${data.branch} kept` : `slice ${data.slice}: nothing released`,
+    ...data.notes.map((note) => `note: ${note}`)
+  ]);
+}
 async function run15(argv, io) {
   const [sub, ...rest] = argv.filter((arg) => arg !== "--json");
   if (sub === "plan")
     return plan2(rest, io);
   if (sub === "check")
     return check2(rest, io);
+  if (sub === "status")
+    return status3(rest, io);
+  if (sub === "worktree")
+    return worktree(rest, io);
   return usage3(io, sub && !sub.startsWith("-") ? `unknown fanout subcommand "${sub}"` : "missing fanout subcommand", USAGE8);
 }
-var PLAN_USAGE2 = "workit fanout plan <plan.json> [--name <n>] [--trunk <b> | --track <t>] [--json]", CHECK_USAGE = "workit fanout check [<slice>…] [--name <n>] [--base <ref>] [--json]", USAGE8 = "workit fanout plan|check ... (workit help fanout)", failed = (io, result) => emit(io, fail(result.code, result.error, { unblock: result.unblock, data: result.data ?? {} })), renderCheck = (data) => [
+var PLAN_USAGE2 = "workit fanout plan <plan.json> [--name <n>] [--trunk <b> | --track <t>] [--json]", CHECK_USAGE = "workit fanout check [<slice>…] [--name <n>] [--base <ref>] [--offline] [--json]", STATUS_USAGE3 = "workit fanout status [--name <n>] [--stuck-after 30m] [--offline] [--json]", WORKTREE_USAGE = "workit fanout worktree create <slice> [--name <n>] | worktree release <slice> [--name <n>] [--force] [--json]", USAGE8 = "workit fanout plan|check|status|worktree ... (workit help fanout)", failed = (io, result) => emit(io, fail(result.code, result.error, { unblock: result.unblock, data: result.data ?? {} })), renderCheck = (data) => [
   `fanout ${data.name} against ${data.trunkRef}: ${data.ready ? "ready to land" : "blocked"}`,
-  ...data.slices.map((slice) => `  ${slice.status === "ready" ? "ok " : "x  "}${slice.id} (${slice.branch}) ${slice.changed} file${slice.changed === 1 ? "" : "s"} · verdict ${slice.verdict.accepted ? "accepted" : slice.verdict.basis}${slice.reasons.length ? `
+  ...data.slices.map((slice) => slice.status === "landed" ? `  -- ${slice.id} (${slice.branch}) landed (${slice.landed?.how}${slice.landed?.pr ? ` #${slice.landed.pr}` : ""})` : `  ${slice.status === "ready" ? "ok " : "x  "}${slice.id} (${slice.branch}) ${slice.changed} file${slice.changed === 1 ? "" : "s"} · verdict ${slice.verdict.accepted ? "accepted" : slice.verdict.basis}${slice.reasons.length ? `
       ${slice.reasons.join(`
       `)}` : ""}`),
   ...data.conflicts.map((conflict) => `  conflict ${conflict.first} x ${conflict.second}: ${conflict.paths.join(", ")}
@@ -76658,9 +77635,37 @@ var PLAN_USAGE2 = "workit fanout plan <plan.json> [--name <n>] [--trunk <b> | --
   `landing order: ${data.landingOrder.join(", ")}`,
   `next: ${data.next}`,
   ...data.notes.map((note) => `note: ${note}`)
-];
+], short5 = (sha) => sha ? sha.slice(0, 7) : "-", renderStatus2 = (data) => {
+  const counts = new Map;
+  for (const slice of data.slices)
+    counts.set(slice.state, (counts.get(slice.state) ?? 0) + 1);
+  return [
+    `fanout ${data.name} on ${data.trunk}: ${[...counts].map(([state, count]) => `${count} ${state.replace("_", " ")}`).join(", ")} · forge ${data.forge.available ? "on" : "off"}`,
+    ...data.slices.map((slice) => {
+      const parts = [
+        slice.branchExists ? short5(slice.head) : "no branch",
+        slice.lastCommitAt && slice.idleMinutes !== null ? `idle ${slice.idleMinutes} min` : null,
+        slice.pr ? `PR #${slice.pr.number} ${slice.pr.state}` : null,
+        slice.ci === "unknown" ? null : `CI ${slice.ci}`,
+        `verdict ${slice.verdict.accepted ? "accepted" : slice.verdict.basis === "none" ? "missing" : slice.verdict.basis}`
+      ].filter(Boolean);
+      const label = slice.state === "stuck" ? "STUCK" : slice.state.replace("_", " ");
+      const detail = slice.landed ? `landed (${slice.landed.how}${slice.landed.pr ? ` #${slice.landed.pr}` : ""})` : parts.join(" · ");
+      const why = slice.state === "landed" ? [] : [...slice.reasons, ...slice.notes];
+      return `  ${label.padEnd(11)} ${slice.id} (${slice.branch}) ${detail}${why.length ? `
+      ${why.join(`
+      `)}` : ""}`;
+    }),
+    `landing order: ${data.landingOrder.length ? data.landingOrder.join(", ") : "(none ready)"}`,
+    ...data.spawnable.length ? [`spawnable: ${data.spawnable.join(", ")}`] : [],
+    `next: ${data.next}`,
+    ...data.notes.map((note) => `note: ${note}`)
+  ];
+};
 var init_fanout2 = __esm(() => {
   init_fanout_check();
+  init_fanout_status();
+  init_fanout_worktree();
   init_fanout();
   init_rev();
   init_ledger();
@@ -91815,7 +92820,7 @@ var init_ast = __esm(() => {
 
 // packages/workit-cli/src/test-audit/rules.ts
 import { builtinModules } from "node:module";
-import path45 from "node:path";
+import path46 from "node:path";
 function testCallee(call) {
   let callee = call.callee;
   if (callee.type === "CallExpression")
@@ -92308,12 +93313,12 @@ function checkConstantsOnly(ctx, emit) {
 }
 function checkOverMocking(ctx, emit) {
   const { program } = ctx.parsed;
-  const unit = path45.basename(ctx.file).replace(/\.(?:[cm]?[jt]sx?)$/, "").replace(/\.(?:test|spec)$/, "");
+  const unit = path46.basename(ctx.file).replace(/\.(?:[cm]?[jt]sx?)$/, "").replace(/\.(?:test|spec)$/, "");
   const mocked = find2(program, (node) => node.type === "CallExpression" && MODULE_MOCK.test(calleeName(node.callee) ?? "") && node.arguments[0]?.type === "StringLiteral");
   const internal = mocked.filter((call) => /^(?:\.|@\/|~\/)/.test(call.arguments[0].value));
   for (const call of mocked) {
     const spec = call.arguments[0].value;
-    const base = path45.basename(spec.replace(/\/index(?:\.[cm]?[jt]sx?)?$/, "")).replace(/\.(?:[cm]?[jt]sx?)$/, "");
+    const base = path46.basename(spec.replace(/\/index(?:\.[cm]?[jt]sx?)?$/, "")).replace(/\.(?:[cm]?[jt]sx?)$/, "");
     if (base === unit)
       emit({
         rule: "over-mocking",
@@ -92701,11 +93706,11 @@ var init_rules = __esm(() => {
 });
 
 // packages/workit-cli/src/test-audit/audit.ts
-import { spawnSync as spawnSync22 } from "node:child_process";
+import { spawnSync as spawnSync23 } from "node:child_process";
 import { existsSync as existsSync18, readdirSync as readdirSync8, readFileSync as readFileSync19, statSync as statSync7 } from "node:fs";
-import path46 from "node:path";
+import path47 from "node:path";
 function git6(cwd, args) {
-  const run = spawnSync22("git", ["-c", "core.quotepath=off", ...args], {
+  const run = spawnSync23("git", ["-c", "core.quotepath=off", ...args], {
     cwd,
     encoding: "utf8",
     maxBuffer: 64 * 1024 * 1024
@@ -92716,7 +93721,7 @@ function walkTests(dir, out) {
   for (const entry of readdirSync8(dir, { withFileTypes: true })) {
     if (entry.name.startsWith(".") && entry.name !== "." && entry.isDirectory())
       continue;
-    const full = path46.join(dir, entry.name);
+    const full = path47.join(dir, entry.name);
     if (entry.isDirectory()) {
       if (!SKIP_DIRS.has(entry.name))
         walkTests(full, out);
@@ -92728,7 +93733,7 @@ function expandPaths(cwd, inputs) {
   const files = [];
   const missing = [];
   for (const input of inputs.length > 0 ? inputs : ["."]) {
-    const full = path46.resolve(cwd, input);
+    const full = path47.resolve(cwd, input);
     if (!existsSync18(full))
       missing.push(input);
     else if (statSync7(full).isDirectory())
@@ -92765,11 +93770,11 @@ function changedLines(cwd, base) {
       for (let offset = 0;offset < count; offset += 1)
         lines.add(start + offset);
     }
-    changed.set(path46.join(root, file), lines);
+    changed.set(path47.join(root, file), lines);
   }
   const untracked = git6(root, ["ls-files", "--others", "--exclude-standard", "-z"]);
   for (const file of untracked.stdout.split("\x00").filter(Boolean))
-    changed.set(path46.join(root, file), "all");
+    changed.set(path47.join(root, file), "all");
   return changed;
 }
 function auditFiles(files, display) {
@@ -92831,7 +93836,7 @@ function auditFiles(files, display) {
     durationMs: Math.round(performance.now() - started)
   };
 }
-var TEST_FILE, CODE_FILE, SKIP_DIRS, toPosix = (file) => file.split(path46.sep).join("/"), SEVERITY_ORDER, ruleIds;
+var TEST_FILE, CODE_FILE, SKIP_DIRS, toPosix = (file) => file.split(path47.sep).join("/"), SEVERITY_ORDER, ruleIds;
 var init_audit = __esm(() => {
   init_ast();
   init_rules();
@@ -92861,7 +93866,7 @@ import {
   copyFileSync as copyFileSync6
 } from "node:fs";
 import os14 from "node:os";
-import path47 from "node:path";
+import path48 from "node:path";
 function mutantsFor(source, file, lines) {
   const parsed = parseSource(source, file);
   const out = [];
@@ -92934,7 +93939,7 @@ function relatedTests(source, testFiles) {
     for (const match of text.matchAll(SPECIFIER)) {
       const spec = match[1];
       if (spec.startsWith(".")) {
-        if (stripExt(path47.posix.join(path47.posix.dirname(file), spec)) === target)
+        if (stripExt(path48.posix.join(path48.posix.dirname(file), spec)) === target)
           return true;
       } else if (spec.includes("/") && stripExt(spec).split("/").slice(-2).join("/") === tail)
         return true;
@@ -92954,12 +93959,12 @@ function removeStaleCopies(tmp = os14.tmpdir()) {
   for (const name of names) {
     if (!name.startsWith(TEMP_PREFIX))
       continue;
-    const dir = path47.join(tmp, name);
+    const dir = path48.join(tmp, name);
     try {
       const stat = lstatSync7(dir);
       if (!stat.isDirectory() || uid !== undefined && stat.uid !== uid)
         continue;
-      const pid = Number(readFileSync20(path47.join(dir, PID_FILE), "utf8"));
+      const pid = Number(readFileSync20(path48.join(dir, PID_FILE), "utf8"));
       if (Number.isInteger(pid) && pid > 0 && alive(pid))
         continue;
     } catch (error) {
@@ -92976,8 +93981,8 @@ function removeStaleCopies(tmp = os14.tmpdir()) {
 function linkNodeModules(origin, target, repo, copy) {
   mkdirSync9(target, { recursive: true });
   for (const entry of readdirSync9(origin, { withFileTypes: true })) {
-    const from = path47.join(origin, entry.name);
-    const to = path47.join(target, entry.name);
+    const from = path48.join(origin, entry.name);
+    const to = path48.join(target, entry.name);
     if (entry.name.startsWith("@") && entry.isDirectory()) {
       linkNodeModules(from, to, repo, copy);
       continue;
@@ -92993,9 +93998,9 @@ function linkNodeModules(origin, target, repo, copy) {
       } catch {
         continue;
       }
-      const relative = path47.relative(repo, real);
-      if (!relative.startsWith("..") && !path47.isAbsolute(relative) && !relative.split(path47.sep).includes("node_modules")) {
-        symlinkSync(path47.join(copy, relative), to, "junction");
+      const relative = path48.relative(repo, real);
+      if (!relative.startsWith("..") && !path48.isAbsolute(relative) && !relative.split(path48.sep).includes("node_modules")) {
+        symlinkSync(path48.join(copy, relative), to, "junction");
         continue;
       }
     }
@@ -93010,8 +94015,8 @@ function copySymlink(repo, tree, from, to) {
     real = null;
   }
   const realRepo = realpathSync9(repo);
-  if (real && inside2(realRepo, real)) {
-    symlinkSync(path47.relative(path47.dirname(to), path47.join(tree, path47.relative(realRepo, real))), to);
+  if (real && inside3(realRepo, real)) {
+    symlinkSync(path48.relative(path48.dirname(to), path48.join(tree, path48.relative(realRepo, real))), to);
     return;
   }
   if (real && statSync8(real).isFile())
@@ -93020,10 +94025,10 @@ function copySymlink(repo, tree, from, to) {
     symlinkSync(readlinkSync3(from), to);
 }
 function writeInside(copy, file, content) {
-  const target = path47.join(copy, file);
+  const target = path48.join(copy, file);
   try {
     const stat = lstatSync7(target);
-    if (!stat.isFile() || !inside2(realpathSync9(copy), realpathSync9(path47.dirname(target))))
+    if (!stat.isFile() || !inside3(realpathSync9(copy), realpathSync9(path48.dirname(target))))
       return false;
   } catch {
     return false;
@@ -93034,9 +94039,9 @@ function writeInside(copy, file, content) {
   return true;
 }
 function copyWorkingTree(repo) {
-  const dir = mkdtempSync4(path47.join(os14.tmpdir(), TEMP_PREFIX));
-  writeFileSync9(path47.join(dir, PID_FILE), String(process.pid));
-  const tree = path47.join(dir, "tree");
+  const dir = mkdtempSync4(path48.join(os14.tmpdir(), TEMP_PREFIX));
+  writeFileSync9(path48.join(dir, PID_FILE), String(process.pid));
+  const tree = path48.join(dir, "tree");
   const head = git6(repo, ["rev-parse", "--verify", "--quiet", "HEAD"]).stdout.trim();
   if (head && git6(dir, ["clone", "-q", "--shared", "--no-checkout", repo, tree]).ok) {
     const branch = git6(repo, ["symbolic-ref", "--quiet", "--short", "HEAD"]).stdout.trim();
@@ -93053,29 +94058,29 @@ function copyWorkingTree(repo) {
   for (const relative of listed) {
     if (!relative)
       continue;
-    const from = path47.join(repo, relative);
+    const from = path48.join(repo, relative);
     let stat;
     try {
       stat = lstatSync7(from);
     } catch {
       continue;
     }
-    const to = path47.join(tree, relative);
-    mkdirSync9(path47.dirname(to), { recursive: true });
+    const to = path48.join(tree, relative);
+    mkdirSync9(path48.dirname(to), { recursive: true });
     if (stat.isSymbolicLink())
       copySymlink(repo, tree, from, to);
     else if (stat.isFile())
       copyFileSync6(from, to);
-    let parent = path47.dirname(relative);
+    let parent = path48.dirname(relative);
     while (parent !== "." && !dirs.has(parent)) {
       dirs.add(parent);
-      parent = path47.dirname(parent);
+      parent = path48.dirname(parent);
     }
   }
   for (const parent of dirs) {
-    const modules = path47.join(repo, parent, "node_modules");
-    if (existsSync19(modules) && !existsSync19(path47.join(tree, parent, "node_modules")))
-      linkNodeModules(modules, path47.join(tree, parent, "node_modules"), repo, tree);
+    const modules = path48.join(repo, parent, "node_modules");
+    if (existsSync19(modules) && !existsSync19(path48.join(tree, parent, "node_modules")))
+      linkNodeModules(modules, path48.join(tree, parent, "node_modules"), repo, tree);
   }
   return { dir, tree };
 }
@@ -93114,14 +94119,14 @@ async function runMutation(options) {
   const tracked = git6(repo, ["ls-files", "-co", "--exclude-standard", "-z"]).stdout.split("\x00").filter(Boolean);
   const testFiles = tracked.filter((file) => TEST_FILE.test(file)).map((file) => {
     try {
-      return { file, text: readFileSync20(path47.join(repo, file), "utf8") };
+      return { file, text: readFileSync20(path48.join(repo, file), "utf8") };
     } catch {
       return { file, text: "" };
     }
   });
   const candidates = [];
   for (const [absolute, lines] of [...options.changed].toSorted(([a], [b]) => a.localeCompare(b))) {
-    const relative = toPosix(path47.relative(repo, absolute));
+    const relative = toPosix(path48.relative(repo, absolute));
     if (!CODE_FILE.test(relative) || TEST_FILE.test(relative) || relative.endsWith(".d.ts"))
       continue;
     if (NOT_SOURCE.test(relative) || !existsSync19(absolute))
@@ -93135,9 +94140,9 @@ async function runMutation(options) {
   for (const mutant of mutants)
     if (!related.has(mutant.file))
       related.set(mutant.file, relatedTests(mutant.file, testFiles));
-  const cwdRelative = path47.relative(repo, options.cwd);
+  const cwdRelative = path48.relative(repo, options.cwd);
   const asArg = (file) => {
-    const relative = toPosix(path47.relative(cwdRelative, file));
+    const relative = toPosix(path48.relative(cwdRelative, file));
     return shellQuote(relative.startsWith(".") ? relative : `./${relative}`);
   };
   const commandFor = (tests) => options.command.replaceAll("{files}", () => tests.map(asArg).join(" "));
@@ -93172,7 +94177,7 @@ async function runMutation(options) {
     return finish2(options, 0, results, counts, started);
   removeStaleCopies();
   const { dir: copyDir, tree: copy } = copyWorkingTree(repo);
-  const copyCwd = path47.join(copy, cwdRelative);
+  const copyCwd = path48.join(copy, cwdRelative);
   let current = null;
   const restore = () => {
     if (current)
@@ -93207,7 +94212,7 @@ async function runMutation(options) {
         record({ ...mutant, status: "skipped", durationMs: 0, tests, reason: "budget" });
         continue;
       }
-      const original = readFileSync20(path47.join(copy, mutant.file), "utf8");
+      const original = readFileSync20(path48.join(copy, mutant.file), "utf8");
       const mutated = original.slice(0, mutant.start) + mutant.replacement + original.slice(mutant.end);
       current = { file: mutant.file, original };
       if (!writeInside(copy, mutant.file, mutated)) {
@@ -93263,9 +94268,9 @@ var NOT_SOURCE, FLIPS, isStringy = (node) => node.type === "StringLiteral" || no
   } catch (error) {
     return error.code === "EPERM";
   }
-}, inside2 = (root, file) => {
-  const relative = path47.relative(root, file);
-  return relative === "" || !relative.startsWith("..") && !path47.isAbsolute(relative);
+}, inside3 = (root, file) => {
+  const relative = path48.relative(root, file);
+  return relative === "" || !relative.startsWith("..") && !path48.isAbsolute(relative);
 }, active, killTree = (child) => {
   try {
     if (child.pid && process.platform !== "win32")
@@ -93314,7 +94319,7 @@ __export(exports_test_audit, {
   run: () => run17
 });
 import { existsSync as existsSync20 } from "node:fs";
-import path48 from "node:path";
+import path49 from "node:path";
 function parse7(argv) {
   const options = {
     paths: [],
@@ -93414,8 +94419,8 @@ async function run17(argv, io) {
     return emit(io, fail("invalid_input", `${options}
 usage: ${USAGE10}`));
   const top = git6(io.cwd, ["rev-parse", "--show-toplevel"]);
-  const repo = top.ok ? path48.resolve(top.stdout.trim()) : null;
-  const display = (file) => toPosix(path48.relative(io.cwd, file) || file);
+  const repo = top.ok ? path49.resolve(top.stdout.trim()) : null;
+  const display = (file) => toPosix(path49.relative(io.cwd, file) || file);
   let base = null;
   let changed = null;
   if (options.diff || options.mutate) {
@@ -93658,7 +94663,7 @@ __export(exports_youtrack, {
   run: () => run19
 });
 import { readFileSync as readFileSync21 } from "node:fs";
-import path49 from "node:path";
+import path50 from "node:path";
 async function run19(argv, io) {
   const [sub, ...rest] = argv;
   if (sub !== "note" && sub !== "time" && sub !== "meeting")
@@ -93704,7 +94709,7 @@ async function run19(argv, io) {
     let markdown = flags.values.markdown ?? "";
     if (flags.values.file)
       try {
-        markdown = readFileSync21(path49.resolve(io.cwd, flags.values.file), "utf8");
+        markdown = readFileSync21(path50.resolve(io.cwd, flags.values.file), "utf8");
       } catch (error) {
         return usage3(io, `cannot read ${flags.values.file}: ${String(error)}`, USAGE12);
       }
@@ -93773,7 +94778,7 @@ __export(exports_changelog, {
   run: () => run20
 });
 import { readFileSync as readFileSync22 } from "node:fs";
-import path50 from "node:path";
+import path51 from "node:path";
 async function run20(argv, io) {
   const [sub, ...rest] = argv;
   if (sub !== "apply")
@@ -93819,7 +94824,7 @@ async function run20(argv, io) {
   ]);
 }
 var USAGE13 = "workit changelog apply (--entries <JSON|@file|-> | --normalize-only) [--path CHANGELOG.md] [--preview]", readEntries = (raw, cwd) => {
-  const text = raw === "-" ? readFileSync22(0, "utf8") : raw.startsWith("@") ? readFileSync22(path50.resolve(cwd, raw.slice(1)), "utf8") : raw;
+  const text = raw === "-" ? readFileSync22(0, "utf8") : raw.startsWith("@") ? readFileSync22(path51.resolve(cwd, raw.slice(1)), "utf8") : raw;
   return JSON.parse(text);
 };
 var init_changelog2 = __esm(() => {
@@ -93836,7 +94841,7 @@ __export(exports_handoff, {
 import { parseArgs as parseArgs2 } from "node:util";
 function human2(brief) {
   const lines = [
-    `branch: ${brief.branch ?? "(detached)"} @ ${short5(brief.head)}${brief.subject ? ` ${brief.subject}` : ""}`
+    `branch: ${brief.branch ?? "(detached)"} @ ${short6(brief.head)}${brief.subject ? ` ${brief.subject}` : ""}`
   ];
   if (brief.base)
     lines.push(`base:   ${brief.base}${brief.ahead === null ? "" : ` (ahead ${brief.ahead}, behind ${brief.behind})`}`);
@@ -93907,7 +94912,7 @@ async function run21(argv, io) {
   await Promise.resolve().then(() => init_task());
   return runTaskCommand(["handoff", ...argv]);
 }
-var USAGE14 = "workit handoff [--note <text>] [--next <text>] [--record] [--last <n>] [--json]", short5 = (sha) => sha ? sha.slice(0, 12) : "no commit";
+var USAGE14 = "workit handoff [--note <text>] [--next <text>] [--record] [--last <n>] [--json]", short6 = (sha) => sha ? sha.slice(0, 12) : "no commit";
 var init_handoff = __esm(() => {
   init_ledger();
   init_output();
@@ -93916,7 +94921,7 @@ var init_handoff = __esm(() => {
 // packages/workit-cli/src/main.ts
 init_package();
 init_output();
-import path51 from "node:path";
+import path52 from "node:path";
 
 // packages/workit-cli/src/verbs/registry.ts
 var TASK_FAMILY_NAMES = [
@@ -94031,8 +95036,8 @@ var VERBS = [
   {
     name: "fanout",
     group: "delivery",
-    usage: "workit fanout plan <plan.json> [--name <n>] [--trunk <b> | --track <t>] | fanout check [<slice>…] [--name <n>] [--base <ref>] [--json]",
-    summary: "Register parallel slices (complete briefs, disjoint scopes, shared-file owners), then gate fan-in: out-of-scope edits, trunk and sibling merge conflicts, landing order",
+    usage: "workit fanout plan <plan.json> [--name <n>] [--trunk <b> | --track <t>] | fanout check [<slice>…] [--name <n>] [--base <ref>] [--offline] | fanout status [--name <n>] [--stuck-after 30m] [--offline] | fanout worktree create|release <slice> [--force] [--json]",
+    summary: "Register parallel slices (complete briefs, disjoint scopes, shared-file owners), watch them (STUCK, PR, CI, verdict, landed, landing order), make and release slice worktrees, and gate fan-in: out-of-scope edits, trunk and sibling merge conflicts",
     load: () => Promise.resolve().then(() => (init_fanout2(), exports_fanout))
   },
   {
@@ -94160,7 +95165,7 @@ var defaultIo = (json) => ({
 });
 async function main(argv, overrides = {}, options = {}) {
   const parsed = parseGlobals(argv);
-  const cwd = path51.resolve(overrides.cwd ?? process.cwd(), parsed.cwd ?? ".");
+  const cwd = path52.resolve(overrides.cwd ?? process.cwd(), parsed.cwd ?? ".");
   const io = { ...defaultIo(parsed.json), ...overrides, json: parsed.json, cwd };
   if (parsed.error)
     return emit(io, fail("invalid_input", parsed.error));