@brainervirus/workit-claude-code 7.3.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.3.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.3.0",
-      "@brainervirus/workit-cursor": "^7.3.0",
-      "@brainervirus/workit-opencode": "^7.3.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"
@@ -63144,7 +63144,8 @@ var init_skill_manifests = __esm(() => {
     "workit-test-audit",
     "workit-deslop",
     "workit-fanout",
-    "workit-verify-app"
+    "workit-verify-app",
+    "workit-retro"
   ];
   if (false) {}
 });
@@ -69916,6 +69917,270 @@ var init_launch = __esm(() => {
   init_upgrade();
 });
 
+// packages/workit-core/src/knowledge.ts
+import { spawnSync as spawnSync14 } from "node:child_process";
+import fs17 from "node:fs";
+import path36 from "node:path";
+function lintKnowledge(root) {
+  const seen = new Set;
+  const unreadable = [];
+  const load = (file) => {
+    const doc = read(root, file);
+    if (doc === "unreadable")
+      unreadable.push(file);
+    if (doc === null || doc === "unreadable" || seen.has(doc.real))
+      return null;
+    seen.add(doc.real);
+    return doc;
+  };
+  const steering = STEERING_FILES.map(load).filter((doc) => doc !== null);
+  const needBased = NEED_BASED_FILES.map(load).filter((doc) => doc !== null);
+  const findings = [];
+  for (const doc of steering) {
+    const bytes = Buffer.byteLength(doc.text);
+    if (bytes > AGENTS_BYTE_BUDGET)
+      findings.push({
+        rule: "agents-budget",
+        file: doc.file,
+        line: null,
+        message: `${bytes} bytes, over the ${AGENTS_BYTE_BUDGET}-byte budget; move detail behind a pointer or into a check, and name what each addition removes`
+      });
+  }
+  for (const doc of needBased)
+    if (scaffoldOnly(doc))
+      findings.push({
+        rule: "scaffold-file",
+        file: doc.file,
+        line: null,
+        message: "holds no entry (headings, comments or placeholders only); delete it, or create it in the same edit as its first real entry"
+      });
+  const tracked = trackedTopLevel(root);
+  for (const doc of [...steering, ...needBased])
+    findings.push(...brokenLinks(root, doc, tracked));
+  const standards = needBased.find((doc) => doc.file === STANDARDS_FILE);
+  if (standards)
+    findings.push(...duplicateRules(steering, standards));
+  return {
+    root,
+    budget: AGENTS_BYTE_BUDGET,
+    files: [...steering, ...needBased].map((doc) => ({
+      file: doc.file,
+      bytes: Buffer.byteLength(doc.text)
+    })),
+    findings,
+    unreadable
+  };
+}
+var AGENTS_BYTE_BUDGET, STEERING_FILES, NEED_BASED_FILES, STANDARDS_FILE = "CODING_STANDARDS.md", MIN_RULE_WORDS = 6, FENCE, HEADING, TABLE_SEPARATOR, LIST_ITEM, PLACEHOLDER2, INDENTED_CODE, blank = (line) => (line ?? "").trim() === "", proseLines = (lines) => {
+  const out = [];
+  let fence = null;
+  let comment = false;
+  let indentedCode = false;
+  let inList = false;
+  lines.forEach((raw, index) => {
+    if (fence) {
+      const close = FENCE.exec(raw);
+      if (close && close[1][0] === fence[0] && close[1].length >= fence.length && !close[2].trim())
+        fence = null;
+      return;
+    }
+    if (!comment) {
+      const open = FENCE.exec(raw);
+      if (open && !(open[1][0] === "`" && open[2].includes("`"))) {
+        fence = open[1];
+        indentedCode = false;
+        return;
+      }
+      if (INDENTED_CODE.test(raw) && !blank(raw)) {
+        if (indentedCode || !inList && blank(lines[index - 1])) {
+          indentedCode = true;
+          return;
+        }
+      } else if (!blank(raw)) {
+        indentedCode = false;
+        inList = LIST_ITEM.test(raw) || inList && /^\s/.test(raw);
+      }
+    }
+    let text = raw;
+    if (comment) {
+      const end = text.indexOf("-->");
+      if (end === -1)
+        return;
+      comment = false;
+      text = text.slice(end + 3);
+    }
+    text = text.replace(/<!--[\s\S]*?-->/g, "");
+    const open = text.indexOf("<!--");
+    if (open !== -1) {
+      comment = true;
+      text = text.slice(0, open);
+    }
+    out.push({ index, text });
+  });
+  return out;
+}, withoutFrontMatter = (lines) => {
+  if (lines[0]?.trim() !== "---")
+    return lines;
+  const end = lines.indexOf("---", 1);
+  return end === -1 ? lines : [...lines.slice(0, end + 1).map(() => ""), ...lines.slice(end + 1)];
+}, read = (root, file) => {
+  const full = path36.join(root, file);
+  try {
+    fs17.lstatSync(full);
+  } catch {
+    return null;
+  }
+  try {
+    if (!fs17.statSync(full).isFile())
+      return null;
+    const text = fs17.readFileSync(full, "utf8");
+    return { file, text, lines: text.split(/\r?\n/), real: fs17.realpathSync(full) };
+  } catch {
+    return "unreadable";
+  }
+}, trackedTopLevel = (root) => {
+  const run = spawnSync14("git", ["ls-files", "-z", "--cached"], {
+    cwd: root,
+    encoding: "utf8",
+    maxBuffer: 256 * 1024 * 1024,
+    timeout: 20000,
+    windowsHide: true
+  });
+  if (run.status !== 0)
+    return null;
+  return new Set(run.stdout.split("\x00").filter(Boolean).map((file) => file.split("/")[0]));
+}, exists = (target) => {
+  try {
+    fs17.statSync(target);
+    return true;
+  } catch {
+    return false;
+  }
+}, LINK, REFERENCE_DEFINITION, CODE_SPAN, PATH_LIKE, isExternal = (target) => /^[a-z][a-z0-9+.-]*:/i.test(target) || target.startsWith("#") || target.startsWith("//"), localTarget = (target) => {
+  const bare = target.replace(/[#?].*$/, "");
+  try {
+    return decodeURIComponent(bare);
+  } catch {
+    return bare;
+  }
+}, brokenLinks = (root, doc, tracked) => {
+  const findings = [];
+  const base = path36.dirname(path36.join(root, doc.file));
+  const missing = (target, line, how) => findings.push({
+    rule: "broken-link",
+    file: doc.file,
+    line,
+    message: `${how} \`${target}\` points at a missing file`
+  });
+  for (const { index, text } of proseLines(doc.lines)) {
+    const prose = text.replace(CODE_SPAN, (span) => " ".repeat(span.length));
+    const targets = [...prose.matchAll(LINK)].map((match) => match[1] ?? match[2]);
+    const definition = REFERENCE_DEFINITION.exec(prose)?.[1];
+    if (definition)
+      targets.push(definition);
+    for (const target of targets) {
+      if (isExternal(target))
+        continue;
+      const local = localTarget(target);
+      if (!local)
+        continue;
+      const resolved = local.startsWith("/") ? path36.join(root, local) : path36.resolve(base, local);
+      if (!exists(resolved))
+        missing(target, index + 1, "link");
+    }
+    for (const [, span] of text.matchAll(CODE_SPAN)) {
+      const candidate = span.replace(/:\d+(?::\d+)?$/, "");
+      if (!PATH_LIKE.test(candidate))
+        continue;
+      const relative = /^\.\.?\//.test(candidate);
+      const first = candidate.split("/")[0];
+      if (!relative && !(tracked ? tracked.has(first) : exists(path36.join(root, first))))
+        continue;
+      const resolved = relative ? path36.resolve(base, candidate) : path36.join(root, candidate);
+      if (!exists(resolved))
+        missing(span, index + 1, "pointer");
+    }
+  }
+  return findings;
+}, isPlaceholder2 = (text) => PLACEHOLDER2.test(text.replace(LIST_ITEM, "").replace(/[*_`]/g, "").replace(/^\[\s?\]\s*/, "").trim()), scaffoldOnly = (doc) => {
+  const lines = proseLines(withoutFrontMatter(doc.lines));
+  return lines.every(({ text }, position) => {
+    const trimmed = text.trim();
+    if (trimmed === "" || HEADING.test(text) || /^([-*_])(\s*\1){2,}$/.test(trimmed))
+      return true;
+    if (TABLE_SEPARATOR.test(text))
+      return true;
+    const next = lines[position + 1]?.text ?? "";
+    if (trimmed.startsWith("|") && TABLE_SEPARATOR.test(next))
+      return true;
+    if (trimmed.startsWith("|"))
+      return trimmed.split("|").map((cell) => cell.trim()).every((cell) => cell === "" || isPlaceholder2(cell));
+    return isPlaceholder2(trimmed);
+  });
+}, ruleUnits = (doc) => {
+  const units = [];
+  let current = null;
+  const flush = () => {
+    if (current)
+      units.push(current);
+    current = null;
+  };
+  for (const { index, text } of proseLines(doc.lines)) {
+    const trimmed = text.trim();
+    if (trimmed === "" || HEADING.test(text) || trimmed.startsWith("|")) {
+      flush();
+      continue;
+    }
+    if (LIST_ITEM.test(text) || !current) {
+      flush();
+      current = { line: index + 1, text: trimmed.replace(LIST_ITEM, "") };
+    } else
+      current.text += ` ${trimmed}`;
+  }
+  flush();
+  return units;
+}, normalize = (sentence) => sentence.replace(/\[([^\]]*)\]\([^)]*\)/g, "$1").replace(/[*_`]/g, "").toLowerCase().replace(/\s+/g, " ").replace(/[\s.,;:!?]+$/, "").trim(), sentences = (doc) => {
+  const out = new Map;
+  for (const unit of ruleUnits(doc))
+    for (const sentence of unit.text.split(/(?<=[.!?])\s+/)) {
+      const key = normalize(sentence);
+      if (key.split(" ").length >= MIN_RULE_WORDS && !out.has(key))
+        out.set(key, unit.line);
+    }
+  return out;
+}, duplicateRules = (steering, standards) => {
+  const findings = [];
+  const rules = sentences(standards);
+  for (const doc of steering)
+    for (const [key, line] of sentences(doc)) {
+      const standardsLine = rules.get(key);
+      if (standardsLine === undefined)
+        continue;
+      findings.push({
+        rule: "duplicate-rule",
+        file: doc.file,
+        line,
+        message: `repeats ${standards.file}:${standardsLine} ("${key.slice(0, 60)}${key.length > 60 ? "…" : ""}"); keep the rule in one file`
+      });
+    }
+  return findings;
+};
+var init_knowledge = __esm(() => {
+  AGENTS_BYTE_BUDGET = 8 * 1024;
+  STEERING_FILES = ["AGENTS.md", "CLAUDE.md"];
+  NEED_BASED_FILES = ["CODING_STANDARDS.md", "GLOSSARY.md"];
+  FENCE = /^ {0,3}(`{3,}|~{3,})(.*)$/;
+  HEADING = /^\s{0,3}#{1,6}(\s|$)/;
+  TABLE_SEPARATOR = /^\s*\|?\s*:?-{3,}:?\s*(\|\s*:?-{3,}:?\s*)*\|?\s*$/;
+  LIST_ITEM = /^\s*(?:[-*+]|\d+[.)])\s+/;
+  PLACEHOLDER2 = /^(?:(?:tbd|todo|tba|fixme)\b.*|n\/a|none|none yet|coming soon|placeholder|\.\.\.|…|-)?[.:]?$/i;
+  INDENTED_CODE = /^(?: {4}|\t)/;
+  LINK = /!?\[[^\]]*\]\(\s*(?:<([^>\n]+)>|((?:[^()\s<>]|\([^()\s]*\))+))(?:\s+["'(][^)]*)?\)/g;
+  REFERENCE_DEFINITION = /^\s{0,3}\[[^\]]+\]:\s*<?(\S+?)>?(?:\s|$)/;
+  CODE_SPAN = /`([^`\n]+)`/g;
+  PATH_LIKE = /^(?:\.{1,2}\/)?[\w@.-]+(?:\/[\w@.-]+)+\/?$/;
+});
+
 // packages/workit-cli/src/prompt.ts
 import { createInterface } from "node:readline/promises";
 async function askLine(question, output = process.stdout) {
@@ -69999,8 +70264,23 @@ async function run5(argv, io) {
     fixLock = clearStaleMetadataLock(root, { force });
   }
   const report = runDoctor({ host: "cli", cwd: io.cwd, workspaceRoot: root });
+  let knowledge = null;
+  try {
+    knowledge = lintKnowledge(root);
+    if (knowledge.unreadable.length > 0)
+      knowledge = null;
+  } catch {
+    knowledge = null;
+  }
+  const agents = knowledge?.files.find((file) => file.file === "AGENTS.md");
+  const knowledgeLine = knowledge ? `info knowledge — ${agents ? `AGENTS.md ${agents.bytes} of ${knowledge.budget} bytes` : "no AGENTS.md"}; ${knowledge.findings.length} finding(s) (workit knowledge lint)` : "info knowledge — unavailable";
   if (argv.includes("--json")) {
-    io.stdout(`${JSON.stringify(fixLock ? { ...report, fixLock } : report, null, 2)}
+    const summary = knowledge ? {
+      agentsBytes: agents?.bytes ?? null,
+      budget: knowledge.budget,
+      findings: knowledge.findings.length
+    } : { unavailable: true };
+    io.stdout(`${JSON.stringify({ ...report, ...fixLock ? { fixLock } : {}, knowledge: summary }, null, 2)}
 `);
     return report.exitCode;
   }
@@ -70019,12 +70299,15 @@ async function run5(argv, io) {
       io.stdout(`     fix: ${check.fix}
 `);
   }
+  io.stdout(`${knowledgeLine}
+`);
   io.stdout(`passed ${report.summary.passed} / warned ${report.summary.warned} / failed ${report.summary.failed}
 `);
   return report.exitCode;
 }
 var init_doctor2 = __esm(() => {
   init_doctor();
+  init_knowledge();
   init_store_lock();
   init_output();
   init_prompt();
@@ -70135,11 +70418,11 @@ var init_redact = __esm(() => {
 });
 
 // packages/workit-core/src/checks.ts
-import { spawn, spawnSync as spawnSync14 } from "node:child_process";
+import { spawn, spawnSync as spawnSync15 } from "node:child_process";
 import { createHash as createHash14 } from "node:crypto";
-import fs17 from "node:fs";
+import fs18 from "node:fs";
 import os13 from "node:os";
-import path36 from "node:path";
+import path37 from "node:path";
 import { StringDecoder } from "node:string_decoder";
 function tailLines(text, lines = TAIL_LINES) {
   const all = text.replace(/\r\n?/gu, `
@@ -70259,10 +70542,10 @@ function planSpawn(argv, options) {
     return { file: argv[0], args: [], verbatim: false, shell: true };
   if (options.platform !== "win32")
     return { file: argv[0], args: argv.slice(1), verbatim: false, shell: false };
-  const win = path36.win32;
+  const win = path37.win32;
   const isFile = options.isFile ?? ((file) => {
     try {
-      return fs17.statSync(file).isFile();
+      return fs18.statSync(file).isFile();
     } catch {
       return false;
     }
@@ -70314,7 +70597,7 @@ function runCheckCommand(argv, options) {
       if (!child?.pid)
         return;
       if (windows)
-        spawnSync14("taskkill", ["/pid", String(child.pid), "/T", "/F"], {
+        spawnSync15("taskkill", ["/pid", String(child.pid), "/T", "/F"], {
           stdio: "ignore",
           windowsHide: true
         });
@@ -70416,13 +70699,13 @@ function runCheckCommand(argv, options) {
 function storeLog(storeRoot, log) {
   const digest = logDigest(log);
   const ref = `blobs/logs/${digest.slice("sha256:".length)}.log`;
-  const file = path36.join(storeRoot, ref);
+  const file = path37.join(storeRoot, ref);
   try {
-    if (!fs17.existsSync(file)) {
-      fs17.mkdirSync(path36.dirname(file), { recursive: true });
+    if (!fs18.existsSync(file)) {
+      fs18.mkdirSync(path37.dirname(file), { recursive: true });
       const temp = `${file}.${process.pid}.${Date.now()}.tmp`;
-      fs17.writeFileSync(temp, log, { mode: 384 });
-      fs17.renameSync(temp, file);
+      fs18.writeFileSync(temp, log, { mode: 384 });
+      fs18.renameSync(temp, file);
     }
     return { digest, ref };
   } catch {
@@ -70432,17 +70715,17 @@ function storeLog(storeRoot, log) {
 function pruneCheckLogs(storeRoot, options = {}) {
   const limits = { ...LOG_RETENTION, ...options.retention };
   const now = options.now ?? Date.now();
-  const dir = path36.join(storeRoot, "blobs", "logs");
+  const dir = path37.join(storeRoot, "blobs", "logs");
   const report = { removed: 0, removedBytes: 0, kept: 0 };
   let names;
   try {
-    names = fs17.readdirSync(dir);
+    names = fs18.readdirSync(dir);
   } catch {
     return report;
   }
   const files = names.flatMap((name) => {
     try {
-      const stat = fs17.statSync(path36.join(dir, name));
+      const stat = fs18.statSync(path37.join(dir, name));
       return stat.isFile() ? [{ name, size: stat.size, mtimeMs: stat.mtimeMs }] : [];
     } catch {
       return [];
@@ -70461,7 +70744,7 @@ function pruneCheckLogs(storeRoot, options = {}) {
       continue;
     if (!options.dryRun)
       try {
-        fs17.rmSync(path36.join(dir, file.name), { force: true });
+        fs18.rmSync(path37.join(dir, file.name), { force: true });
       } catch {
         continue;
       }
@@ -70712,7 +70995,7 @@ var exports_check = {};
 __export(exports_check, {
   run: () => run9
 });
-import path37 from "node:path";
+import path38 from "node:path";
 function parse5(argv) {
   const split = argv.indexOf("--");
   const head = split >= 0 ? argv.slice(0, split) : [...argv];
@@ -70895,7 +71178,7 @@ async function run9(argv, io) {
     if (options.shell && command.length !== 1)
       return emit(io, fail("invalid_input", '--shell takes the command as one string: workit check --shell -- "<cmd>"'));
   }
-  const relCwd = posix(path37.relative(top, runCwd));
+  const relCwd = posix(path38.relative(top, runCwd));
   const configured = !options.shell && matchesNamedCheck(config, name, command, relCwd);
   const actor = actorFromEnv(io.env);
   const branchKey = codeKey(io.cwd, { base: options.base });
@@ -71019,7 +71302,7 @@ async function run9(argv, io) {
     return recordError.code === "busy" ? 4 : recordError.code === "invalid_input" ? 2 : 5;
   return 0;
 }
-var USAGE3 = "workit check <name> | workit check [--name <n>] [--shell] [--timeout <s>] [--task <id>] [--json] -- <cmd…>", RECORD_TAIL_LINES = 20, RECORD_TAIL_CHARS = 200, posix = (value) => value.split(path37.sep).join("/") || ".", ENGINE_CODES2, FINGERPRINT_VARS;
+var USAGE3 = "workit check <name> | workit check [--name <n>] [--shell] [--timeout <s>] [--task <id>] [--json] -- <cmd…>", RECORD_TAIL_LINES = 20, RECORD_TAIL_CHARS = 200, posix = (value) => value.split(path38.sep).join("/") || ".", ENGINE_CODES2, FINGERPRINT_VARS;
 var init_check = __esm(() => {
   init_check_config();
   init_checks3();
@@ -71040,7 +71323,7 @@ var init_check = __esm(() => {
 var success2 = (data) => ({ ok: true, data }), failure3 = (code, error, unblock) => ({ ok: false, code, error, ...unblock ? { unblock } : {} });
 
 // packages/workit-core/src/git/ops.ts
-import { spawnSync as spawnSync15 } from "node:child_process";
+import { spawnSync as spawnSync16 } from "node:child_process";
 function dirtEntries(cwd) {
   const run = git5(cwd, ["status", "--porcelain=v1", "-z", "--untracked-files=all"]);
   if (!run.ok)
@@ -71384,7 +71667,7 @@ ${run.stdout}`;
   return /stale info|cannot lock ref|fetch first|non-fast-forward/iu.test(text) ? { ok: false, lease: true, error: "the remote branch tip changed before deletion" } : { ok: false, lease: false, error: gitError(run) };
 }
 var COMMIT_TIMEOUT_MS, PUSH_TIMEOUT_MS = 120000, git5 = (cwd, args, options = {}) => {
-  const result = spawnSync15("git", args, {
+  const result = spawnSync16("git", args, {
     cwd,
     encoding: "utf8",
     env: { ...options.env ?? process.env, GIT_TERMINAL_PROMPT: "0" },
@@ -71420,11 +71703,11 @@ var init_ops = __esm(() => {
 });
 
 // packages/workit-core/src/forge/reruns.ts
-import fs18 from "node:fs";
-import path38 from "node:path";
+import fs19 from "node:fs";
+import path39 from "node:path";
 function rerunLogPath(cwd) {
   const common = gitCommonDir(cwd);
-  return common ? path38.join(common, "workit", "ci-reruns.jsonl") : null;
+  return common ? path39.join(common, "workit", "ci-reruns.jsonl") : null;
 }
 function rerunCounts(cwd, key) {
   const counts = new Map;
@@ -71433,7 +71716,7 @@ function rerunCounts(cwd, key) {
     return counts;
   let text;
   try {
-    text = fs18.readFileSync(file, "utf8");
+    text = fs19.readFileSync(file, "utf8");
   } catch {
     return counts;
   }
@@ -71459,8 +71742,8 @@ function recordReruns(cwd, rows) {
   if (!file)
     return false;
   try {
-    fs18.mkdirSync(path38.dirname(file), { recursive: true });
-    fs18.appendFileSync(file, rows.map((row) => `${JSON.stringify(row)}
+    fs19.mkdirSync(path39.dirname(file), { recursive: true });
+    fs19.appendFileSync(file, rows.map((row) => `${JSON.stringify(row)}
 `).join(""));
     return true;
   } catch {
@@ -71472,18 +71755,18 @@ function withRerunLock(cwd, fn) {
   if (!file)
     return fn();
   const lock = `${file.slice(0, -".jsonl".length)}.lock`;
-  fs18.mkdirSync(path38.dirname(lock), { recursive: true });
+  fs19.mkdirSync(path39.dirname(lock), { recursive: true });
   const until = Date.now() + LOCK_WAIT_MS2;
   for (;; ) {
     try {
-      fs18.closeSync(fs18.openSync(lock, "wx"));
+      fs19.closeSync(fs19.openSync(lock, "wx"));
       break;
     } catch (error) {
       if (error.code !== "EEXIST")
         throw error;
       try {
-        if (Date.now() - fs18.statSync(lock).mtimeMs > LOCK_STALE_MS2) {
-          fs18.rmSync(lock, { force: true });
+        if (Date.now() - fs19.statSync(lock).mtimeMs > LOCK_STALE_MS2) {
+          fs19.rmSync(lock, { force: true });
           continue;
         }
       } catch {
@@ -71497,7 +71780,7 @@ function withRerunLock(cwd, fn) {
   try {
     return fn();
   } finally {
-    fs18.rmSync(lock, { force: true });
+    fs19.rmSync(lock, { force: true });
   }
 }
 var isRow = (value) => {
@@ -71865,7 +72148,7 @@ var init_report = __esm(() => {
 });
 
 // packages/workit-core/src/forge/pr-ops.ts
-import { spawnSync as spawnSync16 } from "node:child_process";
+import { spawnSync as spawnSync17 } from "node:child_process";
 function fillFromCommits(cwd, resolved, base) {
   const tracking = `refs/remotes/${resolved.baseRemote}/${base}`;
   if (!base.startsWith("-"))
@@ -71873,7 +72156,7 @@ function fillFromCommits(cwd, resolved, base) {
   const from = resolveRef(cwd, tracking) ?? resolveRef(cwd, `refs/heads/${base}`);
   if (!from)
     return failure3("not_found", `base ${base} is not available locally`, `git fetch ${resolved.baseRemote} ${base}`);
-  const log = spawnSync16("git", ["log", "--reverse", "--no-merges", "--format=%s%x1f%b%x1e", `${from}..HEAD`], {
+  const log = spawnSync17("git", ["log", "--reverse", "--no-merges", "--format=%s%x1f%b%x1e", `${from}..HEAD`], {
     cwd,
     encoding: "utf8",
     timeout: GIT_TIMEOUTS.local,
@@ -72148,17 +72431,17 @@ var init_pr_ops = __esm(() => {
 });
 
 // packages/workit-core/src/forge/exec.ts
-import { spawnSync as spawnSync17 } from "node:child_process";
-import fs19 from "node:fs";
-import path39 from "node:path";
+import { spawnSync as spawnSync18 } from "node:child_process";
+import fs20 from "node:fs";
+import path40 from "node:path";
 function findExecutable(bin, env) {
-  const dirs = (env.PATH ?? env.Path ?? "").split(path39.delimiter).filter(Boolean);
+  const dirs = (env.PATH ?? env.Path ?? "").split(path40.delimiter).filter(Boolean);
   const exts = process.platform === "win32" ? [".exe"] : [""];
   for (const dir of dirs)
     for (const ext of exts) {
-      const candidate = path39.join(dir, `${bin}${ext}`);
+      const candidate = path40.join(dir, `${bin}${ext}`);
       try {
-        const stat = fs19.statSync(candidate);
+        const stat = fs20.statSync(candidate);
         if (stat.isFile())
           return candidate;
       } catch {}
@@ -72183,7 +72466,7 @@ function systemRunner(kind, apiHost, env = process.env) {
     if (!exe)
       return { status: null, stdout: "", stderr: "", timedOut: false, missing: true };
     const token = options.token ? kind === "github" ? { GH_TOKEN: options.token, GH_ENTERPRISE_TOKEN: options.token } : { GITLAB_TOKEN: options.token } : {};
-    const result = spawnSync17(exe, [...args], {
+    const result = spawnSync18(exe, [...args], {
       encoding: "utf8",
       env: { ...childEnv, ...token },
       maxBuffer: MAX_BUFFER2,
@@ -72853,7 +73136,7 @@ var init_gitlab = __esm(() => {
 });
 
 // packages/workit-core/src/forge/resolve.ts
-import fs20 from "node:fs";
+import fs21 from "node:fs";
 function resolveForge(cwd, options = {}) {
   let workspace;
   try {
@@ -72882,7 +73165,7 @@ function resolveForge(cwd, options = {}) {
     if (derived.via === "host_name" && !explicit)
       return failure3("blocked", `token_host_unverified: push host ${derived.host} only looks like ${kind}; workspace ${workspace?.name ?? "?"} vcs.tokenFile is not sent to it`, `if ${apiHost} is your ${kind} server, set ${kind}.host in ~/.config/workit/vcs.json (or vcs.host for the workspace); otherwise fix the push remote`);
     try {
-      token = fs20.readFileSync(tokenFile.trim(), "utf8").trim();
+      token = fs21.readFileSync(tokenFile.trim(), "utf8").trim();
     } catch {
       return failure3("blocked", `workspace ${workspace?.name ?? "?"} vcs.tokenFile cannot be read`, "fix vcs.tokenFile in ~/.config/workit/workspaces.json");
     }
@@ -72972,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: [] };
@@ -73009,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,
@@ -73099,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,
@@ -73114,7 +73417,7 @@ __export(exports_pr, {
   run: () => run10
 });
 import { readFileSync as readFileSync18 } from "node:fs";
-import path40 from "node:path";
+import path41 from "node:path";
 async function status(argv, io) {
   const flags = parseFlags(argv, { pr: "value", branch: "value", "log-lines": "value" });
   if (typeof flags === "string")
@@ -73185,7 +73488,7 @@ async function create4(argv, io) {
   let body = flags.values.body ?? null;
   if (flags.values["body-file"] !== undefined) {
     try {
-      body = readFileSync18(path40.resolve(io.cwd, flags.values["body-file"]), "utf8");
+      body = readFileSync18(path41.resolve(io.cwd, flags.values["body-file"]), "utf8");
     } catch {
       return usage3(io, `cannot read --body-file ${flags.values["body-file"]}`, CREATE_USAGE);
     }
@@ -73677,7 +73980,7 @@ var init_git2 = __esm(() => {
 });
 
 // packages/workit-core/src/forge/verify.ts
-import { spawnSync as spawnSync18 } from "node:child_process";
+import { spawnSync as spawnSync19 } 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 };
@@ -73890,7 +74193,7 @@ var NPM_NAME, SEMVER, 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" ? spawnSync18(`${npmCmd} ${args.join(" ")}`, { ...options, shell: true }) : spawnSync18("npm", [...args], options);
+  const result = process.platform === "win32" ? spawnSync19(`${npmCmd} ${args.join(" ")}`, { ...options, shell: true }) : spawnSync19("npm", [...args], options);
   return { status: result.status, stdout: result.stdout ?? "", stderr: result.stderr ?? "" };
 }, short3 = (sha) => sha ? sha.slice(0, 12) : "(absent)", npmView = (stdout) => {
   try {
@@ -73997,10 +74300,10 @@ var init_verify_delivery = __esm(() => {
 });
 
 // packages/workit-core/src/stack.ts
-import { spawnSync as spawnSync19 } from "node:child_process";
+import { spawnSync as spawnSync20 } from "node:child_process";
 import { createHash as createHash15, randomBytes as randomBytes3 } from "node:crypto";
-import fs21 from "node:fs";
-import path41 from "node:path";
+import fs22 from "node:fs";
+import path42 from "node:path";
 function worktreeOf(cwd, branch) {
   const list = gitRun3(cwd, ["worktree", "list", "--porcelain"]);
   if (!list.ok)
@@ -74023,7 +74326,7 @@ function rebasingBranch2(dir) {
     if (!found.ok)
       continue;
     try {
-      return fs21.readFileSync(found.stdout.trim(), "utf8").trim();
+      return fs22.readFileSync(found.stdout.trim(), "utf8").trim();
     } catch {}
   }
   return null;
@@ -74031,7 +74334,7 @@ function rebasingBranch2(dir) {
 function rebaseInProgress(dir) {
   for (const name of ["rebase-merge", "rebase-apply"]) {
     const found = gitRun3(dir, ["rev-parse", "--path-format=absolute", "--git-path", name]);
-    if (found.ok && fs21.existsSync(found.stdout.trim()))
+    if (found.ok && fs22.existsSync(found.stdout.trim()))
       return true;
   }
   return false;
@@ -74043,8 +74346,8 @@ function gitRestack(cwd, input) {
     const scratch = scratchDir(cwd);
     if (!scratch)
       return { ok: false, conflict: false, worktree: cwd, error: "no store root" };
-    fs21.mkdirSync(scratch, { recursive: true });
-    dir = path41.join(scratch, `${input.branch.replace(/[^A-Za-z0-9._-]+/gu, "_").slice(0, 40)}-${randomBytes3(4).toString("hex")}`);
+    fs22.mkdirSync(scratch, { recursive: true });
+    dir = path42.join(scratch, `${input.branch.replace(/[^A-Za-z0-9._-]+/gu, "_").slice(0, 40)}-${randomBytes3(4).toString("hex")}`);
     const added = gitRun3(cwd, ["worktree", "add", "-q", dir, input.branch], GIT_TIMEOUTS.worktree);
     if (!added.ok)
       return { ok: false, conflict: false, worktree: cwd, error: firstLine(added) };
@@ -74082,10 +74385,10 @@ function gitRestack(cwd, input) {
 }
 function pruneScratch(cwd) {
   const scratch = scratchDir(cwd);
-  if (!scratch || !fs21.existsSync(scratch))
+  if (!scratch || !fs22.existsSync(scratch))
     return;
-  for (const name of fs21.readdirSync(scratch)) {
-    const dir = path41.join(scratch, name);
+  for (const name of fs22.readdirSync(scratch)) {
+    const dir = path42.join(scratch, name);
     if (!rebaseInProgress(dir) && !trackedDirt(dir))
       gitRun3(cwd, ["worktree", "remove", "--force", dir]);
   }
@@ -74095,7 +74398,7 @@ function stacksDir(cwd) {
   const root = storeRoot(cwd);
   if (!root.ok)
     return stackFail(root.code, root.error, root.unblock);
-  return { ok: true, data: path41.join(root.value.root, "stacks") };
+  return { ok: true, data: path42.join(root.value.root, "stacks") };
 }
 function parseStack(raw) {
   if (!isRecord7(raw) || !Array.isArray(raw.branches))
@@ -74147,10 +74450,10 @@ function readStack(cwd, name) {
   const dir = stacksDir(cwd);
   if (!dir.ok)
     return dir;
-  const file = path41.join(dir.data, fileFor(name));
+  const file = path42.join(dir.data, fileFor(name));
   let text;
   try {
-    text = fs21.readFileSync(file, "utf8");
+    text = fs22.readFileSync(file, "utf8");
   } catch (error) {
     if (error.code === "ENOENT")
       return { ok: true, data: null };
@@ -74168,17 +74471,17 @@ function writeStack(cwd, stack, now = new Date) {
   const dir = stacksDir(cwd);
   if (!dir.ok)
     return dir;
-  const file = path41.join(dir.data, fileFor(stack.name));
+  const file = path42.join(dir.data, fileFor(stack.name));
   const temp = `${file}.${process.pid}.tmp`;
   try {
-    fs21.mkdirSync(dir.data, { recursive: true });
+    fs22.mkdirSync(dir.data, { recursive: true });
     stack.updatedAt = now.toISOString();
-    fs21.writeFileSync(temp, `${JSON.stringify(stack, null, 2)}
+    fs22.writeFileSync(temp, `${JSON.stringify(stack, null, 2)}
 `);
-    fs21.renameSync(temp, file);
+    fs22.renameSync(temp, file);
     return { ok: true, data: undefined };
   } catch (error) {
-    fs21.rmSync(temp, { force: true });
+    fs22.rmSync(temp, { force: true });
     return stackFail("unavailable", `cannot write ${file}: ${error.message}`);
   }
 }
@@ -74188,7 +74491,7 @@ function listStacks(cwd) {
     return dir;
   let names = [];
   try {
-    names = fs21.readdirSync(dir.data).filter((name) => name.endsWith(".json"));
+    names = fs22.readdirSync(dir.data).filter((name) => name.endsWith(".json"));
   } catch {
     return { ok: true, data: [] };
   }
@@ -74196,7 +74499,7 @@ function listStacks(cwd) {
   for (const name of names) {
     let parsed = null;
     try {
-      parsed = parseStack(JSON.parse(fs21.readFileSync(path41.join(dir.data, name), "utf8")));
+      parsed = parseStack(JSON.parse(fs22.readFileSync(path42.join(dir.data, name), "utf8")));
     } catch {
       parsed = null;
     }
@@ -74243,7 +74546,7 @@ function stackLockStale(raw, age) {
 }
 function takeLock(lock) {
   try {
-    fs21.mkdirSync(lock);
+    fs22.mkdirSync(lock);
   } catch (error) {
     if (error.code === "EEXIST")
       return null;
@@ -74255,24 +74558,24 @@ function takeLock(lock) {
     host: localLockHost(),
     nonce: randomBytes3(8).toString("hex")
   };
-  fs21.writeFileSync(path41.join(lock, OWNER), JSON.stringify(owner));
+  fs22.writeFileSync(path42.join(lock, OWNER), JSON.stringify(owner));
   return owner;
 }
 function reapLock(lock, observed) {
   const tomb = `${lock}.reap-${randomBytes3(6).toString("hex")}`;
   try {
-    fs21.renameSync(lock, tomb);
+    fs22.renameSync(lock, tomb);
   } catch {
     return false;
   }
   if (readOwner(tomb).raw === observed) {
-    fs21.rmSync(tomb, { recursive: true, force: true });
+    fs22.rmSync(tomb, { recursive: true, force: true });
     return true;
   }
   try {
-    fs21.renameSync(tomb, lock);
+    fs22.renameSync(tomb, lock);
   } catch {
-    fs21.rmSync(tomb, { recursive: true, force: true });
+    fs22.rmSync(tomb, { recursive: true, force: true });
   }
   return false;
 }
@@ -74282,8 +74585,8 @@ function releaseLock(lock, owner) {
     return;
   const tomb = `${lock}.release-${randomBytes3(6).toString("hex")}`;
   try {
-    fs21.renameSync(lock, tomb);
-    fs21.rmSync(tomb, { recursive: true, force: true });
+    fs22.renameSync(lock, tomb);
+    fs22.rmSync(tomb, { recursive: true, force: true });
   } catch {}
 }
 async function withStackLock(cwd, name, fn, waitMs = LOCK_WAIT_MS3) {
@@ -74292,9 +74595,9 @@ async function withStackLock(cwd, name, fn, waitMs = LOCK_WAIT_MS3) {
     return dir;
   if (!validName(name))
     return stackFail("invalid_input", "a stack name must be 1-200 printable characters");
-  const lock = path41.join(dir.data, `${fileFor(name)}.lock`);
+  const lock = path42.join(dir.data, `${fileFor(name)}.lock`);
   try {
-    fs21.mkdirSync(dir.data, { recursive: true });
+    fs22.mkdirSync(dir.data, { recursive: true });
   } catch (error) {
     return stackFail("unavailable", `cannot create ${dir.data}: ${error.message}`);
   }
@@ -74322,7 +74625,7 @@ async function withStackLock(cwd, name, fn, waitMs = LOCK_WAIT_MS3) {
   const touch = () => {
     try {
       const now = new Date;
-      fs21.utimesSync(path41.join(lock, OWNER), now, now);
+      fs22.utimesSync(path42.join(lock, OWNER), now, now);
     } catch {}
   };
   const beat = setInterval(touch, HEARTBEAT_MS);
@@ -74510,7 +74813,7 @@ function commitKeys(cwd, range) {
   const patches = new Map;
   const diff = gitRun3(cwd, ["log", "--no-merges", "-p", "--format=commit %H", range]);
   if (diff.ok && diff.stdout.trim()) {
-    const ids = spawnSync19("git", ["patch-id", "--stable"], {
+    const ids = spawnSync20("git", ["patch-id", "--stable"], {
       cwd,
       input: diff.stdout,
       encoding: "utf8",
@@ -75118,7 +75421,7 @@ var STACK_VERSION = 1, stackFail = (code, error, unblock, data) => ({
   ...unblock ? { unblock } : {},
   ...data ? { data } : {}
 }), fromForge = (result) => stackFail(result.code, result.error, result.unblock), stackDeps, gitRun3 = (cwd, args, timeoutMs = GIT_TIMEOUTS.local) => {
-  const run = spawnSync19("git", args, {
+  const run = spawnSync20("git", args, {
     cwd,
     encoding: "utf8",
     timeout: timeoutMs,
@@ -75146,7 +75449,7 @@ var STACK_VERSION = 1, stackFail = (code, error, unblock, data) => ({
   return !status.ok || status.stdout.trim() !== "";
 }, scratchDir = (cwd) => {
   const dir = stacksDir(cwd);
-  return dir.ok ? path41.join(dir.data, "worktrees") : null;
+  return dir.ok ? path42.join(dir.data, "worktrees") : null;
 }, firstLine = (run) => (`${run.stderr}
 ${run.stdout}`.split(`
 `).find((line) => line.trim()) ?? "git failed").trim().slice(0, 300), stackFileName = (name) => `${name.replace(/[^A-Za-z0-9._-]+/gu, "_").replace(/^[._]+/u, "").slice(0, 48).toLowerCase()}-${createHash15("sha256").update(name).digest("hex").slice(0, 12)}.json`, fileFor, validName = (name) => {
@@ -75161,14 +75464,14 @@ ${run.stdout}`.split(`
 }, isRecord7 = (value) => typeof value === "object" && value !== null && !Array.isArray(value), str3 = (value) => typeof value === "string" && value ? value : null, LOCK_WAIT_MS3 = 2000, HEARTBEAT_MS = 20000, HEARTBEAT_STALE_MS, OWNERLESS_STALE_MS = 30000, OWNER = "owner", readOwner = (lock) => {
   let raw = null;
   try {
-    raw = fs21.readFileSync(path41.join(lock, OWNER), "utf8");
+    raw = fs22.readFileSync(path42.join(lock, OWNER), "utf8");
   } catch {
     raw = null;
   }
   let age = null;
-  for (const target of [path41.join(lock, OWNER), lock])
+  for (const target of [path42.join(lock, OWNER), lock])
     try {
-      age = Date.now() - fs21.statSync(target).mtimeMs;
+      age = Date.now() - fs22.statSync(target).mtimeMs;
       break;
     } catch {}
   return { raw, age };
@@ -75408,12 +75711,37 @@ var init_stack2 = __esm(() => {
 });
 
 // packages/workit-core/src/fanout.ts
-import { spawnSync as spawnSync20 } from "node:child_process";
-import fs22 from "node:fs";
-import path42 from "node:path";
+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];
@@ -75432,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 = "";
@@ -75480,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 === "")
@@ -75607,7 +75944,7 @@ function parsePlan(raw, defaults, name) {
       id,
       branch,
       base: optional("base") ?? "",
-      worktree: optional("worktree") ?? path42.join(defaults.worktreeRoot, id),
+      worktree: path43.resolve(defaults.root, optional("worktree") ?? path43.join(defaults.worktreeRoot, id)),
       tier,
       dependsOn: [...new Set(dependsOn ?? [])],
       scope,
@@ -75783,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;
@@ -75805,16 +76166,19 @@ 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 && path42.basename(common) === ".git" ? path42.dirname(common) : cwd;
-  return path42.join(path42.dirname(main), `${path42.basename(main)}-wt`);
+  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) {
   const root = storeRoot(cwd);
   if (!root.ok)
     return fanoutFail(root.code, root.error, root.unblock);
-  return { ok: true, data: path42.join(root.value.root, "fanouts") };
+  return { ok: true, data: path43.join(root.value.root, "fanouts") };
 }
 function parseStored(raw) {
   if (!isRecord8(raw) || typeof raw.name !== "string" || typeof raw.trunk !== "string")
@@ -75871,10 +76235,10 @@ function readFanout(cwd, name) {
   const dir = fanoutsDir(cwd);
   if (!dir.ok)
     return dir;
-  const file = path42.join(dir.data, stackFileName(name));
+  const file = path43.join(dir.data, stackFileName(name));
   let parsed = null;
   try {
-    parsed = parseStored(JSON.parse(fs22.readFileSync(file, "utf8")));
+    parsed = parseStored(JSON.parse(fs23.readFileSync(file, "utf8")));
   } catch (error) {
     if (error.code === "ENOENT")
       return { ok: true, data: null };
@@ -75888,7 +76252,7 @@ function listFanouts(cwd) {
     return dir;
   let names = [];
   try {
-    names = fs22.readdirSync(dir.data).filter((entry) => entry.endsWith(".json"));
+    names = fs23.readdirSync(dir.data).filter((entry) => entry.endsWith(".json"));
   } catch {
     return { ok: true, data: [] };
   }
@@ -75896,7 +76260,7 @@ function listFanouts(cwd) {
   for (const entry of names) {
     let parsed = null;
     try {
-      parsed = parseStored(JSON.parse(fs22.readFileSync(path42.join(dir.data, entry), "utf8")));
+      parsed = parseStored(JSON.parse(fs23.readFileSync(path43.join(dir.data, entry), "utf8")));
     } catch {
       parsed = null;
     }
@@ -75926,16 +76290,16 @@ function writeFanout(cwd, plan) {
   const dir = fanoutsDir(cwd);
   if (!dir.ok)
     return dir;
-  const file = path42.join(dir.data, stackFileName(plan.name));
+  const file = path43.join(dir.data, stackFileName(plan.name));
   const temp = `${file}.${process.pid}.tmp`;
   try {
-    fs22.mkdirSync(dir.data, { recursive: true });
-    fs22.writeFileSync(temp, `${JSON.stringify(plan, null, 2)}
+    fs23.mkdirSync(dir.data, { recursive: true });
+    fs23.writeFileSync(temp, `${JSON.stringify(plan, null, 2)}
 `);
-    fs22.renameSync(temp, file);
+    fs23.renameSync(temp, file);
     return { ok: true, data: file };
   } catch (error) {
-    fs22.rmSync(temp, { force: true });
+    fs23.rmSync(temp, { force: true });
     return fanoutFail("unavailable", `cannot write ${file}: ${error.message}`);
   }
 }
@@ -75943,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;
@@ -75958,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();
@@ -76014,7 +76396,7 @@ var FANOUT_VERSION = 1, TIERS, fanoutFail = (code, error, unblock, data) => ({
   error,
   ...unblock ? { unblock } : {},
   ...data ? { data } : {}
-}), DEFAULT_SHARED, escapeRegExp4 = (text) => text.replace(/[.+^$()|[\]\\{}*?]/gu, "\\$&"), unescape2 = (pattern) => pattern.replace(/\\(.)/gu, "$1"), hasWildcard = (pattern) => /[*?{]/u.test(pattern.replace(/\\./gu, "")), compiled, matchesAny = (patterns, file) => patterns.some((pattern) => matchesScope(pattern, file)), isRecord8 = (value) => typeof value === "object" && value !== null && !Array.isArray(value), PLACEHOLDER2, filled = (text) => text.trim() !== "" && !PLACEHOLDER2.test(text.trim()), textList = (value) => {
+}), DEFAULT_SHARED, escapeRegExp4 = (text) => text.replace(/[.+^$()|[\]\\{}*?]/gu, "\\$&"), unescape2 = (pattern) => pattern.replace(/\\(.)/gu, "$1"), hasWildcard = (pattern) => /[*?{]/u.test(pattern.replace(/\\./gu, "")), compiled, matchesAny = (patterns, file) => patterns.some((pattern) => matchesScope(pattern, file)), isRecord8 = (value) => typeof value === "object" && value !== null && !Array.isArray(value), PLACEHOLDER3, filled = (text) => text.trim() !== "" && !PLACEHOLDER3.test(text.trim()), textList = (value) => {
   if (typeof value === "string")
     return [value];
   if (Array.isArray(value) && value.every((item) => typeof item === "string"))
@@ -76032,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) => {
-  const run = spawnSync20("git", 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,
@@ -76065,10 +76447,204 @@ var init_fanout = __esm(() => {
     "CHANGELOG.md"
   ];
   compiled = new Map;
-  PLACEHOLDER2 = /^(?:<[^>]*>|tbd|todo|fixme|\?+|\.\.\.|…)$/iu;
+  PLACEHOLDER3 = /^(?:<[^>]*>|tbd|todo|fixme|\?+|\.\.\.|…)$/iu;
   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, [
@@ -76102,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) {
@@ -76113,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]));
@@ -76151,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: {
@@ -76179,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;
@@ -76218,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;
@@ -76231,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) {
@@ -76244,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
@@ -76255,8 +77428,14 @@ var exports_fanout = {};
 __export(exports_fanout, {
   run: () => run15
 });
-import fs23 from "node:fs";
-import path43 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;
@@ -76264,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))
@@ -76301,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 = path43.resolve(io.cwd, flags.positionals[0]);
+  const file = path45.resolve(io.cwd, flags.positionals[0]);
   let raw;
   try {
-    raw = JSON.parse(fs23.readFileSync(file, "utf8"));
+    raw = JSON.parse(fs25.readFileSync(file, "utf8"));
   } catch (error) {
     return usage3(io, `cannot read ${file} as JSON: ${error.message}`, PLAN_USAGE2);
   }
@@ -76333,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));
@@ -76341,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);
@@ -76357,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(", ")}
@@ -76375,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();
@@ -91532,7 +92820,7 @@ var init_ast = __esm(() => {
 
 // packages/workit-cli/src/test-audit/rules.ts
 import { builtinModules } from "node:module";
-import path44 from "node:path";
+import path46 from "node:path";
 function testCallee(call) {
   let callee = call.callee;
   if (callee.type === "CallExpression")
@@ -92025,12 +93313,12 @@ function checkConstantsOnly(ctx, emit) {
 }
 function checkOverMocking(ctx, emit) {
   const { program } = ctx.parsed;
-  const unit = path44.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 = path44.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",
@@ -92418,11 +93706,11 @@ var init_rules = __esm(() => {
 });
 
 // packages/workit-cli/src/test-audit/audit.ts
-import { spawnSync as spawnSync21 } 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 path45 from "node:path";
+import path47 from "node:path";
 function git6(cwd, args) {
-  const run = spawnSync21("git", ["-c", "core.quotepath=off", ...args], {
+  const run = spawnSync23("git", ["-c", "core.quotepath=off", ...args], {
     cwd,
     encoding: "utf8",
     maxBuffer: 64 * 1024 * 1024
@@ -92433,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 = path45.join(dir, entry.name);
+    const full = path47.join(dir, entry.name);
     if (entry.isDirectory()) {
       if (!SKIP_DIRS.has(entry.name))
         walkTests(full, out);
@@ -92445,7 +93733,7 @@ function expandPaths(cwd, inputs) {
   const files = [];
   const missing = [];
   for (const input of inputs.length > 0 ? inputs : ["."]) {
-    const full = path45.resolve(cwd, input);
+    const full = path47.resolve(cwd, input);
     if (!existsSync18(full))
       missing.push(input);
     else if (statSync7(full).isDirectory())
@@ -92482,11 +93770,11 @@ function changedLines(cwd, base) {
       for (let offset = 0;offset < count; offset += 1)
         lines.add(start + offset);
     }
-    changed.set(path45.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(path45.join(root, file), "all");
+    changed.set(path47.join(root, file), "all");
   return changed;
 }
 function auditFiles(files, display) {
@@ -92548,7 +93836,7 @@ function auditFiles(files, display) {
     durationMs: Math.round(performance.now() - started)
   };
 }
-var TEST_FILE, CODE_FILE, SKIP_DIRS, toPosix = (file) => file.split(path45.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();
@@ -92578,7 +93866,7 @@ import {
   copyFileSync as copyFileSync6
 } from "node:fs";
 import os14 from "node:os";
-import path46 from "node:path";
+import path48 from "node:path";
 function mutantsFor(source, file, lines) {
   const parsed = parseSource(source, file);
   const out = [];
@@ -92651,7 +93939,7 @@ function relatedTests(source, testFiles) {
     for (const match of text.matchAll(SPECIFIER)) {
       const spec = match[1];
       if (spec.startsWith(".")) {
-        if (stripExt(path46.posix.join(path46.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;
@@ -92671,12 +93959,12 @@ function removeStaleCopies(tmp = os14.tmpdir()) {
   for (const name of names) {
     if (!name.startsWith(TEMP_PREFIX))
       continue;
-    const dir = path46.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(path46.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) {
@@ -92693,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 = path46.join(origin, entry.name);
-    const to = path46.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;
@@ -92710,9 +93998,9 @@ function linkNodeModules(origin, target, repo, copy) {
       } catch {
         continue;
       }
-      const relative = path46.relative(repo, real);
-      if (!relative.startsWith("..") && !path46.isAbsolute(relative) && !relative.split(path46.sep).includes("node_modules")) {
-        symlinkSync(path46.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;
       }
     }
@@ -92727,8 +94015,8 @@ function copySymlink(repo, tree, from, to) {
     real = null;
   }
   const realRepo = realpathSync9(repo);
-  if (real && inside2(realRepo, real)) {
-    symlinkSync(path46.relative(path46.dirname(to), path46.join(tree, path46.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())
@@ -92737,10 +94025,10 @@ function copySymlink(repo, tree, from, to) {
     symlinkSync(readlinkSync3(from), to);
 }
 function writeInside(copy, file, content) {
-  const target = path46.join(copy, file);
+  const target = path48.join(copy, file);
   try {
     const stat = lstatSync7(target);
-    if (!stat.isFile() || !inside2(realpathSync9(copy), realpathSync9(path46.dirname(target))))
+    if (!stat.isFile() || !inside3(realpathSync9(copy), realpathSync9(path48.dirname(target))))
       return false;
   } catch {
     return false;
@@ -92751,9 +94039,9 @@ function writeInside(copy, file, content) {
   return true;
 }
 function copyWorkingTree(repo) {
-  const dir = mkdtempSync4(path46.join(os14.tmpdir(), TEMP_PREFIX));
-  writeFileSync9(path46.join(dir, PID_FILE), String(process.pid));
-  const tree = path46.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();
@@ -92770,29 +94058,29 @@ function copyWorkingTree(repo) {
   for (const relative of listed) {
     if (!relative)
       continue;
-    const from = path46.join(repo, relative);
+    const from = path48.join(repo, relative);
     let stat;
     try {
       stat = lstatSync7(from);
     } catch {
       continue;
     }
-    const to = path46.join(tree, relative);
-    mkdirSync9(path46.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 = path46.dirname(relative);
+    let parent = path48.dirname(relative);
     while (parent !== "." && !dirs.has(parent)) {
       dirs.add(parent);
-      parent = path46.dirname(parent);
+      parent = path48.dirname(parent);
     }
   }
   for (const parent of dirs) {
-    const modules = path46.join(repo, parent, "node_modules");
-    if (existsSync19(modules) && !existsSync19(path46.join(tree, parent, "node_modules")))
-      linkNodeModules(modules, path46.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 };
 }
@@ -92831,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(path46.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(path46.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))
@@ -92852,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 = path46.relative(repo, options.cwd);
+  const cwdRelative = path48.relative(repo, options.cwd);
   const asArg = (file) => {
-    const relative = toPosix(path46.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(" "));
@@ -92889,7 +94177,7 @@ async function runMutation(options) {
     return finish2(options, 0, results, counts, started);
   removeStaleCopies();
   const { dir: copyDir, tree: copy } = copyWorkingTree(repo);
-  const copyCwd = path46.join(copy, cwdRelative);
+  const copyCwd = path48.join(copy, cwdRelative);
   let current = null;
   const restore = () => {
     if (current)
@@ -92924,7 +94212,7 @@ async function runMutation(options) {
         record({ ...mutant, status: "skipped", durationMs: 0, tests, reason: "budget" });
         continue;
       }
-      const original = readFileSync20(path46.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)) {
@@ -92980,9 +94268,9 @@ var NOT_SOURCE, FLIPS, isStringy = (node) => node.type === "StringLiteral" || no
   } catch (error) {
     return error.code === "EPERM";
   }
-}, inside2 = (root, file) => {
-  const relative = path46.relative(root, file);
-  return relative === "" || !relative.startsWith("..") && !path46.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")
@@ -93031,7 +94319,7 @@ __export(exports_test_audit, {
   run: () => run17
 });
 import { existsSync as existsSync20 } from "node:fs";
-import path47 from "node:path";
+import path49 from "node:path";
 function parse7(argv) {
   const options = {
     paths: [],
@@ -93131,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 ? path47.resolve(top.stdout.trim()) : null;
-  const display = (file) => toPosix(path47.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) {
@@ -93233,6 +94521,38 @@ var init_test_audit = __esm(() => {
   ]);
 });
 
+// packages/workit-cli/src/verbs/knowledge.ts
+var exports_knowledge = {};
+__export(exports_knowledge, {
+  run: () => run18
+});
+async function run18(argv, io) {
+  const [sub, ...rest] = argv.filter((arg) => arg !== "--json");
+  if (sub !== "lint" || rest.length > 0)
+    return emit(io, fail("invalid_input", `usage: ${USAGE11}`));
+  const report = lintKnowledge(checkRoot(io.cwd));
+  if (report.unreadable.length > 0)
+    return emit(io, fail("unavailable", `knowledge lint: cannot read ${report.unreadable.join(", ")}`, {
+      data: report,
+      unblock: `make ${report.unreadable.join(", ")} readable, then re-run workit knowledge lint`
+    }));
+  const summary = `knowledge lint: ${report.findings.length} finding${report.findings.length === 1 ? "" : "s"} in ${report.files.length} file${report.files.length === 1 ? "" : "s"} (${report.files.map((file) => `${file.file} ${file.bytes} B`).join(", ") || "no knowledge files"}; AGENTS.md budget ${report.budget} B)`;
+  if (io.json)
+    return emit(io, report.findings.length === 0 ? ok(report) : fail("failed", summary, { data: report }));
+  for (const finding of report.findings)
+    io.stdout(`${finding.file}${finding.line === null ? "" : `:${finding.line}`} [${finding.rule}] ${finding.message}
+`);
+  io.stdout(`${summary}
+`);
+  return report.findings.length === 0 ? 0 : 1;
+}
+var USAGE11 = "workit knowledge lint [--json]";
+var init_knowledge2 = __esm(() => {
+  init_check_config();
+  init_knowledge();
+  init_output();
+});
+
 // packages/workit-core/src/core/youtrack-tools.ts
 async function logTimeUpdate(input, operation = defaultOperations) {
   try {
@@ -93340,14 +94660,14 @@ var init_youtrack_writes = __esm(() => {
 // packages/workit-cli/src/verbs/youtrack.ts
 var exports_youtrack = {};
 __export(exports_youtrack, {
-  run: () => run18
+  run: () => run19
 });
 import { readFileSync as readFileSync21 } from "node:fs";
-import path48 from "node:path";
-async function run18(argv, io) {
+import path50 from "node:path";
+async function run19(argv, io) {
   const [sub, ...rest] = argv;
   if (sub !== "note" && sub !== "time" && sub !== "meeting")
-    return usage3(io, `unknown subcommand "${sub ?? ""}"`, USAGE11);
+    return usage3(io, `unknown subcommand "${sub ?? ""}"`, USAGE12);
   const flags = parseFlags(rest, {
     markdown: "value",
     file: "value",
@@ -93356,18 +94676,18 @@ async function run18(argv, io) {
     date: "value"
   });
   if (typeof flags === "string")
-    return usage3(io, flags, USAGE11);
+    return usage3(io, flags, USAGE12);
   const [issueId, extra] = flags.positionals;
   if (!issueId || !ISSUE_RE2.test(issueId))
-    return usage3(io, "an issue id like ABC-123 is required", USAGE11);
+    return usage3(io, "an issue id like ABC-123 is required", USAGE12);
   if (extra !== undefined)
-    return usage3(io, `unexpected argument ${extra}`, USAGE11);
+    return usage3(io, `unexpected argument ${extra}`, USAGE12);
   const minutes = positiveInt(flags.values.minutes, "--minutes");
   if (typeof minutes === "string")
-    return usage3(io, minutes, USAGE11);
+    return usage3(io, minutes, USAGE12);
   const date = youTrackWorkDateMs(flags.values.date ?? "auto");
   if ("error" in date)
-    return usage3(io, date.error, USAGE11);
+    return usage3(io, date.error, USAGE12);
   const dateMs = date.data.dateMs;
   const markedDay = flags.values.date !== undefined && flags.values.date !== "auto" ? { dateMs } : {};
   const root = io.cwd;
@@ -93385,24 +94705,24 @@ async function run18(argv, io) {
   };
   if (sub === "note") {
     if (Boolean(flags.values.markdown) === Boolean(flags.values.file))
-      return usage3(io, "pass exactly one of --markdown or --file", USAGE11);
+      return usage3(io, "pass exactly one of --markdown or --file", USAGE12);
     let markdown = flags.values.markdown ?? "";
     if (flags.values.file)
       try {
-        markdown = readFileSync21(path48.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)}`, USAGE11);
+        return usage3(io, `cannot read ${flags.values.file}: ${String(error)}`, USAGE12);
       }
     if (!markdown.trim())
-      return usage3(io, "the note is empty", USAGE11);
+      return usage3(io, "the note is empty", USAGE12);
     const missing = step("comment", "comments", { operation: "note", issueId, markdown }, markdown, async (text) => commentResult(await postComment(issueId, text, root))) ?? (minutes ? step("time", "workItems", { operation: "note.time", issueId, markdown, minutes, ...markedDay }, "workit update", (text) => logTimeUpdate({ issueId, minutes, text, dateMs, workspace_root: root })) : null);
     if (missing)
       return emit(io, fail("unavailable", missing));
   } else {
     if (!minutes)
-      return usage3(io, `${sub} needs --minutes <n>`, USAGE11);
+      return usage3(io, `${sub} needs --minutes <n>`, USAGE12);
     if (sub === "meeting" && !flags.values.text)
-      return usage3(io, "meeting needs --text <what the meeting was>", USAGE11);
+      return usage3(io, "meeting needs --text <what the meeting was>", USAGE12);
     const text = flags.values.text ?? "";
     const missing = step(sub, "workItems", { operation: sub, issueId, minutes, text, ...markedDay }, text, (marked) => logTimeUpdate({ issueId, minutes, text: marked, dateMs, workspace_root: root }));
     if (missing)
@@ -93431,7 +94751,7 @@ async function run18(argv, io) {
     ...data.steps.flatMap((entry) => entry.note ? [`  note (${entry.step}): ${entry.note}`] : [])
   ]);
 }
-var USAGE11 = "workit youtrack note <ISSUE> (--markdown <t> | --file <p>) [--minutes <n>] [--date auto|YYYY-MM-DD] | youtrack time <ISSUE> --minutes <n> [--text <t>] [--date …] | youtrack meeting <ISSUE> --minutes <n> --text <t> [--date …]", commentResult = (value) => {
+var USAGE12 = "workit youtrack note <ISSUE> (--markdown <t> | --file <p>) [--minutes <n>] [--date auto|YYYY-MM-DD] | youtrack time <ISSUE> --minutes <n> [--text <t>] [--date …] | youtrack meeting <ISSUE> --minutes <n> --text <t> [--date …]", commentResult = (value) => {
   try {
     return { ok: true, data: unwrap2(value) };
   } catch (error) {
@@ -93455,14 +94775,14 @@ var init_youtrack2 = __esm(() => {
 // packages/workit-cli/src/verbs/changelog.ts
 var exports_changelog = {};
 __export(exports_changelog, {
-  run: () => run19
+  run: () => run20
 });
 import { readFileSync as readFileSync22 } from "node:fs";
-import path49 from "node:path";
-async function run19(argv, io) {
+import path51 from "node:path";
+async function run20(argv, io) {
   const [sub, ...rest] = argv;
   if (sub !== "apply")
-    return usage3(io, `unknown subcommand "${sub ?? ""}"`, USAGE12);
+    return usage3(io, `unknown subcommand "${sub ?? ""}"`, USAGE13);
   const flags = parseFlags(rest, {
     entries: "value",
     path: "value",
@@ -93470,18 +94790,18 @@ async function run19(argv, io) {
     preview: "boolean"
   });
   if (typeof flags === "string")
-    return usage3(io, flags, USAGE12);
+    return usage3(io, flags, USAGE13);
   if (flags.positionals.length)
-    return usage3(io, `unexpected argument ${flags.positionals[0]}`, USAGE12);
+    return usage3(io, `unexpected argument ${flags.positionals[0]}`, USAGE13);
   const normalizeOnly = flags.booleans.has("normalize-only");
   if (!normalizeOnly && !flags.values.entries)
-    return usage3(io, "pass --entries <JSON> or --normalize-only", USAGE12);
+    return usage3(io, "pass --entries <JSON> or --normalize-only", USAGE13);
   let entries;
   if (flags.values.entries)
     try {
       entries = readEntries(flags.values.entries, io.cwd);
     } catch (error) {
-      return usage3(io, `--entries is not valid JSON: ${String(error)}`, USAGE12);
+      return usage3(io, `--entries is not valid JSON: ${String(error)}`, USAGE13);
     }
   const input = {
     entries,
@@ -93503,8 +94823,8 @@ async function run19(argv, io) {
     `changelog updated: ${String(applied.path ?? "CHANGELOG.md")}`
   ]);
 }
-var USAGE12 = "workit changelog apply (--entries <JSON|@file|-> | --normalize-only) [--path CHANGELOG.md] [--preview]", readEntries = (raw, cwd) => {
-  const text = raw === "-" ? readFileSync22(0, "utf8") : raw.startsWith("@") ? readFileSync22(path49.resolve(cwd, raw.slice(1)), "utf8") : raw;
+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(path51.resolve(cwd, raw.slice(1)), "utf8") : raw;
   return JSON.parse(text);
 };
 var init_changelog2 = __esm(() => {
@@ -93516,12 +94836,12 @@ var init_changelog2 = __esm(() => {
 // packages/workit-cli/src/verbs/handoff.ts
 var exports_handoff = {};
 __export(exports_handoff, {
-  run: () => run20
+  run: () => run21
 });
 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})`}`);
@@ -93564,11 +94884,11 @@ async function resumeBrief(argv, io) {
       strict: true
     }));
   } catch (error) {
-    return emit(io, fail("invalid_input", error.message, { unblock: USAGE13 }));
+    return emit(io, fail("invalid_input", error.message, { unblock: USAGE14 }));
   }
   const last = values.last === undefined ? 10 : Number(values.last);
   if (!Number.isInteger(last) || last < 1)
-    return emit(io, fail("invalid_input", "--last must be a positive integer", { unblock: USAGE13 }));
+    return emit(io, fail("invalid_input", "--last must be a positive integer", { unblock: USAGE14 }));
   const built = buildHandoff(io.cwd, {
     last,
     note: values.note ?? null,
@@ -93586,13 +94906,13 @@ async function resumeBrief(argv, io) {
   }
   return emit(io, ok({ ...data, recorded }), human2);
 }
-async function run20(argv, io) {
+async function run21(argv, io) {
   if (!argv.includes("--task"))
     return resumeBrief(argv, io);
   await Promise.resolve().then(() => init_task());
   return runTaskCommand(["handoff", ...argv]);
 }
-var USAGE13 = "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();
@@ -93601,7 +94921,7 @@ var init_handoff = __esm(() => {
 // packages/workit-cli/src/main.ts
 init_package();
 init_output();
-import path50 from "node:path";
+import path52 from "node:path";
 
 // packages/workit-cli/src/verbs/registry.ts
 var TASK_FAMILY_NAMES = [
@@ -93716,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))
   },
   {
@@ -93734,6 +95054,13 @@ var VERBS = [
     summary: "Flag tautological and low-value tests with a suggested independent oracle; --mutate checks changed lines with diff-scoped mutation",
     load: () => Promise.resolve().then(() => (init_test_audit(), exports_test_audit))
   },
+  {
+    name: "knowledge",
+    group: "delivery",
+    usage: "workit knowledge lint [--json]",
+    summary: "Lint agent knowledge files: AGENTS.md byte budget, broken local links, scaffold-only files, duplicated rules (exit 1 on findings)",
+    load: () => Promise.resolve().then(() => (init_knowledge2(), exports_knowledge))
+  },
   {
     name: "youtrack",
     group: "delivery",
@@ -93838,7 +95165,7 @@ var defaultIo = (json) => ({
 });
 async function main(argv, overrides = {}, options = {}) {
   const parsed = parseGlobals(argv);
-  const cwd = path50.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));