@brainervirus/workit-claude-code 7.2.0 → 7.4.0

package/dist/workit.js

@@ -65,7 +65,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@brainervirus/workit-cli",
-    version: "7.2.0",
+    version: "7.4.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.2.0",
-      "@brainervirus/workit-cursor": "^7.2.0",
-      "@brainervirus/workit-opencode": "^7.2.0",
+      "@brainervirus/workit-core": "^7.4.0",
+      "@brainervirus/workit-cursor": "^7.4.0",
+      "@brainervirus/workit-opencode": "^7.4.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");
     }
@@ -73017,6 +73300,20 @@ function parseDuration2(value) {
   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,
+    ...branch ? { branch } : {}
+  });
+  if (resolved.ok === false)
+    return track !== null || String(resolved.configPath ?? "").endsWith("workspaces.json") ? { error: String(resolved.error) } : { trunk: null, tracked: false };
+  if (resolved.releaseTrack?.blocking)
+    return { error: String(resolved.releaseTrack.blocking) };
+  return {
+    trunk: String(resolved.defaultTargetBranch ?? "") || null,
+    tracked: Boolean(resolved.releaseTrack)
+  };
+}
 function connect(io, branch) {
   const resolved = resolveForge(io.cwd, {
     branch,
@@ -73084,6 +73381,7 @@ function renderStatus(doc) {
 var forgeDeps, usage3 = (io, message, line) => emit(io, fail("invalid_input", message, { unblock: line })), forgeFail = (io, result, data) => emit(io, fail(result.code, result.error, { data, unblock: result.unblock })), short = (sha) => sha ? sha.slice(0, 7) : "?";
 var init_forge_common = __esm(() => {
   init_resolve();
+  init_vcs_config();
   init_output();
   forgeDeps = {
     runner: undefined,
@@ -73099,7 +73397,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")
@@ -73170,7 +73468,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);
     }
@@ -73662,7 +73960,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 };
@@ -73875,7 +74173,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 {
@@ -73982,10 +74280,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)
@@ -74008,7 +74306,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;
@@ -74016,7 +74314,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;
@@ -74028,8 +74326,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) };
@@ -74067,10 +74365,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]);
   }
@@ -74080,7 +74378,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))
@@ -74132,10 +74430,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 };
@@ -74153,17 +74451,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}`);
   }
 }
@@ -74173,7 +74471,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: [] };
   }
@@ -74181,7 +74479,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;
     }
@@ -74228,7 +74526,7 @@ function stackLockStale(raw, age) {
 }
 function takeLock(lock) {
   try {
-    fs21.mkdirSync(lock);
+    fs22.mkdirSync(lock);
   } catch (error) {
     if (error.code === "EEXIST")
       return null;
@@ -74240,24 +74538,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;
 }
@@ -74267,8 +74565,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) {
@@ -74277,9 +74575,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}`);
   }
@@ -74307,7 +74605,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);
@@ -74495,7 +74793,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",
@@ -75103,7 +75401,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,
@@ -75131,7 +75429,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) => {
@@ -75146,14 +75444,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 };
@@ -75207,7 +75505,7 @@ async function plan(argv, io) {
     return usage3(io, "pass --trunk or --track, not both (--track picks the trunk)", PLAN_USAGE);
   let trunk = flags.values.trunk ?? existing?.trunk ?? null;
   if (trunk === null || track !== null) {
-    const derived = defaultTrunk(io, track, flags.positionals[0] ?? null);
+    const derived = releaseTrunk(io, track, flags.positionals[0] ?? null);
     if ("error" in derived)
       return emit(io, fail("blocked", derived.error, {
         unblock: "workit stack plan --track <name> …  # or --trunk <branch>"
@@ -75375,17 +75673,7 @@ async function run14(argv, io) {
     return land(rest, io);
   return usage3(io, sub && !sub.startsWith("-") ? `unknown stack subcommand "${sub}"` : "missing stack subcommand", USAGE7);
 }
-var PLAN_USAGE = "workit stack plan [--name <n>] [--trunk <b> | --track <t>] [<bottom> … <top>] [--json]", STATUS_USAGE2 = "workit stack status [--name <n>] [--json]", SYNC_USAGE = "workit stack sync [--name <n>] [--local] [--dry-run] [--force <branch>]… [--json]", LAND_USAGE = "workit stack land [--name <n>] [--dry-run] [--max <n>] [--method squash|merge|rebase] [--timeout 20m] [--interval 30s] [--json]", USAGE7 = "workit stack plan|status|sync|land ... (workit help stack)", short4 = (sha) => sha ? sha.slice(0, 12) : "?", stackFailed = (io, result) => emit(io, fail(result.code, result.error, { unblock: result.unblock, data: result.data ?? {} })), defaultTrunk = (io, track, branch) => {
-  const resolved = vcsConfig("resolve", io.cwd, {
-    track,
-    ...branch ? { branch } : {}
-  });
-  if (resolved.ok === false)
-    return track !== null || String(resolved.configPath ?? "").endsWith("workspaces.json") ? { error: String(resolved.error) } : { trunk: null };
-  if (resolved.releaseTrack?.blocking)
-    return { error: String(resolved.releaseTrack.blocking) };
-  return { trunk: String(resolved.defaultTargetBranch ?? "") || null };
-}, label = (forge, pr) => pr === null ? "no PR" : `${forge === "gitlab" ? "MR !" : "PR #"}${pr}`, renderSync = (data) => [
+var PLAN_USAGE = "workit stack plan [--name <n>] [--trunk <b> | --track <t>] [<bottom> … <top>] [--json]", STATUS_USAGE2 = "workit stack status [--name <n>] [--json]", SYNC_USAGE = "workit stack sync [--name <n>] [--local] [--dry-run] [--force <branch>]… [--json]", LAND_USAGE = "workit stack land [--name <n>] [--dry-run] [--max <n>] [--method squash|merge|rebase] [--timeout 20m] [--interval 30s] [--json]", USAGE7 = "workit stack plan|status|sync|land ... (workit help stack)", short4 = (sha) => sha ? sha.slice(0, 12) : "?", stackFailed = (io, result) => emit(io, fail(result.code, result.error, { unblock: result.unblock, data: result.data ?? {} })), label = (forge, pr) => pr === null ? "no PR" : `${forge === "gitlab" ? "MR !" : "PR #"}${pr}`, renderSync = (data) => [
   `${data.dryRun ? "would sync" : "synced"} stack ${data.name}${data.merged.length ? `; merged: ${data.merged.map((item) => item.branch).join(", ")}` : ""}`,
   ...data.steps.map((step) => [
     `  ${step.branch} on ${step.parent}:`,
@@ -75397,16 +75685,993 @@ var PLAN_USAGE = "workit stack plan [--name <n>] [--trunk <b> | --track <t>] [<b
 var init_stack2 = __esm(() => {
   init_ledger();
   init_stack();
-  init_vcs_config();
   init_output();
   init_forge_common();
   METHODS3 = new Set(["squash", "merge", "rebase"]);
 });
 
+// packages/workit-core/src/fanout.ts
+import { spawnSync as spawnSync21 } from "node:child_process";
+import fs23 from "node:fs";
+import path43 from "node:path";
+function scopeSamples(pattern) {
+  if (!hasWildcard(pattern))
+    return [unescape2(pattern)];
+  let out = "";
+  for (let index = 0;index < pattern.length; index += 1) {
+    const char = pattern[index];
+    if (char === "\\" && index + 1 < pattern.length) {
+      out += pattern[index + 1];
+      index += 1;
+    } else if (char === "*" && pattern[index + 1] === "*") {
+      const atSegmentStart = index === 0 || pattern[index - 1] === "/";
+      if (atSegmentStart && pattern[index + 2] === "/")
+        index += 2;
+      else {
+        out += "<any>";
+        index += 1;
+      }
+    } else if (char === "*")
+      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
+      out += char;
+  }
+  return [out];
+}
+function globSource(pattern) {
+  let out = "";
+  for (let index = 0;index < pattern.length; index += 1) {
+    const char = pattern[index];
+    if (char === "\\" && index + 1 < pattern.length) {
+      out += escapeRegExp4(pattern[index + 1]);
+      index += 1;
+    } else if (char === "*" && pattern[index + 1] === "*") {
+      const atSegmentStart = index === 0 || pattern[index - 1] === "/";
+      if (atSegmentStart && pattern[index + 2] === "/") {
+        out += "(?:[^/]*/)*";
+        index += 2;
+      } else {
+        out += ".*";
+        index += 1;
+      }
+    } else if (char === "*")
+      out += "[^/]*";
+    else if (char === "?")
+      out += "[^/]";
+    else if (char === "{" && pattern.indexOf("}", index) > index) {
+      const close = pattern.indexOf("}", index);
+      const alternatives = pattern.slice(index + 1, close).split(",").map(globSource);
+      out += `(?:${alternatives.join("|")})`;
+      index = close;
+    } else
+      out += escapeRegExp4(char);
+  }
+  return out;
+}
+function matchesScope(pattern, file) {
+  let regex = compiled.get(pattern);
+  if (!regex) {
+    regex = new RegExp(`^${globSource(pattern)}$`, "u");
+    compiled.set(pattern, regex);
+  }
+  return regex.test(file) || !hasWildcard(pattern) && file.startsWith(`${unescape2(pattern)}/`);
+}
+function normalizePattern(raw) {
+  let pattern = raw.trim().replace(/\\(?![[\]{}*?])/gu, "/");
+  while (pattern.startsWith("./"))
+    pattern = pattern.slice(2);
+  if (pattern === "." || pattern === "")
+    pattern = raw.trim() ? "**" : "";
+  if (pattern.endsWith("/"))
+    pattern = `${pattern}**`;
+  if (!pattern)
+    return { error: "is empty" };
+  if (pattern.startsWith("/") || /^[A-Za-z]:/u.test(pattern))
+    return { error: "must be relative to the repository root" };
+  if (pattern.split("/").includes(".."))
+    return { error: "must not contain .." };
+  const bare = pattern.replace(/\\./gu, "");
+  if (/[[\]]/u.test(bare))
+    return {
+      error: 'has an unescaped [ or ]: write \\[ and \\] for literal brackets (app/\\[id\\]/page.tsx; in JSON "app/\\\\[id\\\\]/page.tsx")'
+    };
+  if (bare.startsWith("!"))
+    return { error: "uses ! (negation is not supported)" };
+  let depth = 0;
+  for (const char of bare) {
+    if (char === "{")
+      depth += 1;
+    if (char === "}")
+      depth -= 1;
+    if (depth < 0 || depth > 1)
+      return { error: "has unbalanced or nested braces" };
+  }
+  if (depth !== 0)
+    return { error: "has unbalanced or nested braces" };
+  return { pattern };
+}
+function inScope(plan, slice, file) {
+  if (matchesAny(slice.owns, file))
+    return true;
+  if (!matchesAny(slice.scope, file))
+    return false;
+  return !plan.slices.some((other) => other.id !== slice.id && matchesAny(other.owns, file));
+}
+function parsePlan(raw, defaults, name) {
+  const problems = [];
+  if (!isRecord8(raw))
+    return { ok: false, problems: ["the plan must be a JSON object"] };
+  const planName = name ?? (typeof raw.name === "string" ? raw.name.trim() : "");
+  if (!planName || planName.length > 200 || /\p{Cc}/u.test(planName))
+    problems.push('name: pass --name or set a 1-200 character "name"');
+  const trunk = typeof raw.trunk === "string" && raw.trunk.trim() ? raw.trunk.trim() : defaults.trunk;
+  const shared = [];
+  for (const entry of textList(raw.shared ?? []) ?? ["<not a list>"]) {
+    const normalized = normalizePattern(entry);
+    if ("error" in normalized)
+      problems.push(`shared "${entry}" ${normalized.error}`);
+    else
+      shared.push(normalized.pattern);
+  }
+  if (!Array.isArray(raw.slices) || raw.slices.length === 0)
+    return { ok: false, problems: [...problems, "slices: list at least one slice"] };
+  const slices = [];
+  const seenIds = new Set;
+  const seenBranches = new Map;
+  raw.slices.forEach((item, index) => {
+    const where = isRecord8(item) && typeof item.id === "string" ? `slice ${item.id}` : `slice #${index + 1}`;
+    if (!isRecord8(item)) {
+      problems.push(`${where}: must be an object`);
+      return;
+    }
+    const id = typeof item.id === "string" ? item.id : "";
+    if (!ID.test(id))
+      problems.push(`${where}: id must match ${ID.source}`);
+    else if (seenIds.has(id))
+      problems.push(`${where}: duplicate id`);
+    seenIds.add(id);
+    const branch = typeof item.branch === "string" ? item.branch.trim() : "";
+    if (!branch)
+      problems.push(`${where}: branch is empty`);
+    else if (seenBranches.has(branch))
+      problems.push(`${where}: branch ${branch} is also slice ${seenBranches.get(branch)}'s`);
+    else
+      seenBranches.set(branch, id);
+    if (branch === trunk)
+      problems.push(`${where}: branch must not be the trunk ${trunk}`);
+    const goal = typeof item.goal === "string" ? item.goal.trim() : "";
+    if (!filled(goal))
+      problems.push(`${where}: goal is empty`);
+    const brief = (field) => {
+      const list = textList(item[field]);
+      const kept = (list ?? []).map((entry) => entry.trim()).filter(filled);
+      if (kept.length === 0)
+        problems.push(`${where}: ${field} is empty`);
+      return kept;
+    };
+    const acceptance = brief("acceptance");
+    const verify = brief("verify");
+    const forbidden = brief("forbidden");
+    const scope = [];
+    const owns = [];
+    for (const [field, out] of [
+      ["scope", scope],
+      ["owns", owns]
+    ]) {
+      const list = textList(item[field] ?? []);
+      if (list === null) {
+        problems.push(`${where}: ${field} must be a list of globs`);
+        continue;
+      }
+      for (const entry of list.filter(filled)) {
+        const normalized = normalizePattern(entry);
+        if ("error" in normalized)
+          problems.push(`${where}: ${field} "${entry}" ${normalized.error}`);
+        else
+          out.push(normalized.pattern);
+      }
+    }
+    if (scope.length === 0 && textList(item.scope ?? []) !== null)
+      problems.push(`${where}: scope is empty`);
+    const tier = item.tier;
+    if (typeof tier !== "string" || !TIERS.includes(tier))
+      problems.push(`${where}: tier must be one of ${TIERS.join(", ")}`);
+    const dependsOn = textList(item.dependsOn ?? []);
+    if (dependsOn === null)
+      problems.push(`${where}: dependsOn must be a list of slice ids`);
+    const optional = (field) => typeof item[field] === "string" && filled(item[field]) ? item[field].trim() : null;
+    slices.push({
+      id,
+      branch,
+      base: optional("base") ?? "",
+      worktree: optional("worktree") ?? path43.join(defaults.worktreeRoot, id),
+      tier,
+      dependsOn: [...new Set(dependsOn ?? [])],
+      scope,
+      owns,
+      goal,
+      acceptance,
+      verify,
+      forbidden,
+      context: optional("context"),
+      timebox: optional("timebox")
+    });
+  });
+  const byId = new Map(slices.map((slice) => [slice.id, slice]));
+  const byBranch = new Map(slices.map((slice) => [slice.branch, slice]));
+  for (const slice of slices) {
+    for (const dep of slice.dependsOn) {
+      if (dep === slice.id)
+        problems.push(`slice ${slice.id}: depends on itself`);
+      else if (!byId.has(dep))
+        problems.push(`slice ${slice.id}: depends on unknown slice ${dep}`);
+    }
+    const explicitBase = slice.base;
+    if (explicitBase) {
+      const parent = byBranch.get(explicitBase);
+      if (parent && !slice.dependsOn.includes(parent.id))
+        problems.push(`slice ${slice.id}: base ${explicitBase} is slice ${parent.id}'s branch; add "${parent.id}" to its dependsOn`);
+    } else {
+      const single = slice.dependsOn.length === 1 ? byId.get(slice.dependsOn[0]) : undefined;
+      slice.base = single ? single.branch : trunk;
+    }
+  }
+  const cycle = findCycle(slices);
+  if (cycle)
+    problems.push(`dependency cycle: ${cycle.join(" -> ")}`);
+  if (problems.length)
+    return { ok: false, problems };
+  return {
+    ok: true,
+    plan: {
+      v: FANOUT_VERSION,
+      name: planName,
+      trunk,
+      shared,
+      slices,
+      createdAt: "",
+      updatedAt: ""
+    }
+  };
+}
+function findCycle(slices) {
+  const byId = new Map(slices.map((slice) => [slice.id, slice]));
+  const state = new Map;
+  const trail = [];
+  const visit = (id) => {
+    if (state.get(id) === "done")
+      return null;
+    if (state.get(id) === "open")
+      return [...trail.slice(trail.indexOf(id)), id];
+    state.set(id, "open");
+    trail.push(id);
+    for (const dep of byId.get(id)?.dependsOn ?? []) {
+      if (!byId.has(dep) || dep === id)
+        continue;
+      const found = visit(dep);
+      if (found)
+        return found;
+    }
+    trail.pop();
+    state.set(id, "done");
+    return null;
+  };
+  for (const slice of slices) {
+    const found = visit(slice.id);
+    if (found)
+      return found;
+  }
+  return null;
+}
+function landingOrder(slices) {
+  const order = [];
+  const placed = new Set;
+  const known = new Set(slices.map((slice) => slice.id));
+  while (order.length < slices.length) {
+    const next = slices.find((slice) => !placed.has(slice.id) && slice.dependsOn.every((dep) => placed.has(dep) || !known.has(dep)));
+    if (!next)
+      break;
+    order.push(next.id);
+    placed.add(next.id);
+  }
+  return order;
+}
+function waves(slices) {
+  const level = new Map;
+  const byId = new Map(slices.map((slice) => [slice.id, slice]));
+  for (const id of landingOrder(slices)) {
+    const deps = byId.get(id)?.dependsOn ?? [];
+    level.set(id, deps.length ? Math.max(...deps.map((dep) => level.get(dep) ?? 0)) + 1 : 0);
+  }
+  const out = [];
+  for (const slice of slices)
+    (out[level.get(slice.id) ?? 0] ??= []).push(slice.id);
+  return out.filter(Boolean);
+}
+function ancestors(slices) {
+  const byId = new Map(slices.map((slice) => [slice.id, slice]));
+  const out = new Map;
+  for (const id of landingOrder(slices)) {
+    const set = new Set;
+    for (const dep of byId.get(id)?.dependsOn ?? []) {
+      set.add(dep);
+      for (const deeper of out.get(dep) ?? [])
+        set.add(deeper);
+    }
+    out.set(id, set);
+  }
+  return out;
+}
+function analyzeOverlap(plan, candidates) {
+  const shared = [...DEFAULT_SHARED, ...plan.shared];
+  const before = ancestors(plan.slices);
+  const related = (a, b) => Boolean(before.get(a)?.has(b) || before.get(b)?.has(a));
+  const overlaps = [];
+  const groups = new Map;
+  const byCase = new Map;
+  for (const file of [...new Set(candidates)].toSorted())
+    (byCase.get(file.toLowerCase()) ?? byCase.set(file.toLowerCase(), []).get(file.toLowerCase()))?.push(file);
+  for (const spellings of byCase.values()) {
+    const file = spellings.join(" ~ ");
+    const any = (patterns) => spellings.some((spelling) => matchesAny(patterns, spelling));
+    const matching = plan.slices.filter((slice) => any(slice.scope) || any(slice.owns));
+    if (matching.length < 2)
+      continue;
+    const ids = matching.map((slice) => slice.id);
+    const owners = matching.filter((slice) => any(slice.owns));
+    if (owners.length === 1) {
+      overlaps.push({ path: file, slices: ids, resolution: "owner", owner: owners[0].id });
+      continue;
+    }
+    if (owners.length === 0 && matching.every((a, i) => matching.slice(i + 1).every((b) => related(a.id, b.id)))) {
+      overlaps.push({ path: file, slices: ids, resolution: "serialized" });
+      continue;
+    }
+    const members = owners.length > 1 ? owners : matching;
+    const reason = owners.length > 1 ? "several_owners" : "overlap";
+    const isShared = any(shared);
+    const key = `${reason}|${isShared}|${members.map((slice) => slice.id).join(",")}`;
+    const group = groups.get(key);
+    if (group)
+      group.paths.push(file);
+    else
+      groups.set(key, {
+        slices: members.map((slice) => slice.id),
+        paths: [file],
+        shared: isShared,
+        reason,
+        members,
+        suggestion: ownerSuggestion(members[0].id, [])
+      });
+  }
+  const conflicts = [...groups.values()].map(({ members, ...group }) => {
+    const literal = members.find((slice) => slice.scope.some((pattern) => group.paths.includes(pattern)));
+    const owner = ownerSuggestion((literal ?? members[0]).id, group.paths);
+    if (group.reason === "several_owners")
+      return {
+        ...group,
+        suggestion: {
+          ...owner,
+          text: `keep ${quoteList(group.paths)} in "owns" of slice ${owner.slice} only`
+        }
+      };
+    const serialize = serializeSuggestion(group.slices);
+    return group.shared ? { ...group, suggestion: owner, alternative: serialize } : { ...group, suggestion: serialize, alternative: owner };
+  });
+  return { overlaps, conflicts };
+}
+function branchRef(cwd, branch) {
+  if (!branch || branch.startsWith("-"))
+    return null;
+  const local = resolveRef(cwd, `refs/heads/${branch}`);
+  if (local)
+    return local;
+  const remote = pushRemoteName(cwd) ?? "origin";
+  return resolveRef(cwd, `refs/remotes/${remote}/${branch}`);
+}
+function trunkRef(cwd, trunk) {
+  if (!trunk || trunk.startsWith("-"))
+    return null;
+  const remote = pushRemoteName(cwd) ?? "origin";
+  for (const ref of [`refs/remotes/${remote}/${trunk}`, `refs/heads/${trunk}`, trunk])
+    if (resolveRef(cwd, ref))
+      return ref;
+  return null;
+}
+function defaultTrunk(cwd) {
+  const base = defaultBase(cwd);
+  return base ? base.replace(/^origin\//u, "") : "main";
+}
+function worktreeRoot(cwd) {
+  const common = gitCommonDir(cwd);
+  const main = common && path43.basename(common) === ".git" ? path43.dirname(common) : 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: path43.join(root.value.root, "fanouts") };
+}
+function parseStored(raw) {
+  if (!isRecord8(raw) || typeof raw.name !== "string" || typeof raw.trunk !== "string")
+    return null;
+  if (!Array.isArray(raw.slices))
+    return null;
+  const list = (value) => Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+  const text = (value) => typeof value === "string" ? value : "";
+  let globsValid = true;
+  const globs = (value) => list(value).map((entry) => {
+    const normalized = normalizePattern(entry);
+    if ("error" in normalized) {
+      globsValid = false;
+      return entry;
+    }
+    return normalized.pattern;
+  });
+  const slices = [];
+  for (const item of raw.slices) {
+    if (!isRecord8(item) || typeof item.id !== "string" || typeof item.branch !== "string")
+      return null;
+    slices.push({
+      id: item.id,
+      branch: item.branch,
+      base: text(item.base) || raw.trunk,
+      worktree: text(item.worktree),
+      tier: TIERS.includes(item.tier) ? item.tier : "standard",
+      dependsOn: list(item.dependsOn),
+      scope: globs(item.scope),
+      owns: globs(item.owns),
+      goal: text(item.goal),
+      acceptance: list(item.acceptance),
+      verify: list(item.verify),
+      forbidden: list(item.forbidden),
+      context: typeof item.context === "string" ? item.context : null,
+      timebox: typeof item.timebox === "string" ? item.timebox : null
+    });
+  }
+  const shared = globs(raw.shared);
+  const ids = new Set(slices.map((slice) => slice.id));
+  if (!globsValid || ids.size !== slices.length || slices.some((slice) => slice.dependsOn.some((dep) => dep === slice.id || !ids.has(dep))) || findCycle(slices))
+    return null;
+  return {
+    v: typeof raw.v === "number" ? raw.v : FANOUT_VERSION,
+    name: raw.name,
+    trunk: raw.trunk,
+    shared,
+    slices,
+    createdAt: text(raw.createdAt),
+    updatedAt: text(raw.updatedAt)
+  };
+}
+function readFanout(cwd, name) {
+  const dir = fanoutsDir(cwd);
+  if (!dir.ok)
+    return dir;
+  const file = path43.join(dir.data, stackFileName(name));
+  let parsed = null;
+  try {
+    parsed = parseStored(JSON.parse(fs23.readFileSync(file, "utf8")));
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return { ok: true, data: null };
+    parsed = null;
+  }
+  return parsed ? { ok: true, data: parsed } : fanoutFail("failed", `fanout file ${file} is not a valid plan`, `workit fanout plan <plan.json> --name ${name}  # rewrite it`);
+}
+function listFanouts(cwd) {
+  const dir = fanoutsDir(cwd);
+  if (!dir.ok)
+    return dir;
+  let names = [];
+  try {
+    names = fs23.readdirSync(dir.data).filter((entry) => entry.endsWith(".json"));
+  } catch {
+    return { ok: true, data: [] };
+  }
+  const out = [];
+  for (const entry of names) {
+    let parsed = null;
+    try {
+      parsed = parseStored(JSON.parse(fs23.readFileSync(path43.join(dir.data, entry), "utf8")));
+    } catch {
+      parsed = null;
+    }
+    if (parsed && stackFileName(parsed.name) === entry)
+      out.push(parsed);
+  }
+  return { ok: true, data: out.toSorted((a, b) => a.name.localeCompare(b.name)) };
+}
+function selectFanout(cwd, name, current) {
+  if (name) {
+    const read = readFanout(cwd, name);
+    if (!read.ok)
+      return read;
+    return read.data ? { ok: true, data: read.data } : fanoutFail("not_found", `no fanout plan named ${name}`, "workit fanout plan <plan.json>");
+  }
+  const all = listFanouts(cwd);
+  if (!all.ok)
+    return all;
+  const holding = all.data.filter((plan) => plan.slices.some((slice) => slice.branch === current));
+  if (holding.length === 1)
+    return { ok: true, data: holding[0] };
+  if (all.data.length === 1)
+    return { ok: true, data: all.data[0] };
+  return all.data.length === 0 ? fanoutFail("not_found", "no fanout plan is recorded here", "workit fanout plan <plan.json>") : fanoutFail("invalid_input", `several fanout plans match; pick one (${all.data.map((plan) => plan.name).join(", ")})`, "pass --name <plan>");
+}
+function writeFanout(cwd, plan) {
+  const dir = fanoutsDir(cwd);
+  if (!dir.ok)
+    return dir;
+  const file = path43.join(dir.data, stackFileName(plan.name));
+  const temp = `${file}.${process.pid}.tmp`;
+  try {
+    fs23.mkdirSync(dir.data, { recursive: true });
+    fs23.writeFileSync(temp, `${JSON.stringify(plan, null, 2)}
+`);
+    fs23.renameSync(temp, file);
+    return { ok: true, data: file };
+  } catch (error) {
+    fs23.rmSync(temp, { force: true });
+    return fanoutFail("unavailable", `cannot write ${file}: ${error.message}`);
+  }
+}
+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);
+  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;
+  const badBranches = plan.slices.filter((slice) => !gitRun4(cwd, ["check-ref-format", "--branch", slice.branch]).ok).map((slice) => `slice ${slice.id}: ${slice.branch} is not a valid branch name`);
+  if (badBranches.length)
+    return fanoutFail("invalid_input", badBranches[0], "rename the branch in the plan", {
+      problems: badBranches
+    });
+  const ref = trunkRef(cwd, plan.trunk);
+  const tracked = ref ? nulList2(gitRun4(cwd, ["ls-tree", "-r", "-z", "--name-only", ref]).stdout) : [];
+  const samples = plan.slices.flatMap((slice) => [...slice.scope, ...slice.owns].flatMap(scopeSamples));
+  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 existing = readFanout(cwd, plan.name);
+  const previous = existing.ok ? existing.data : null;
+  plan.createdAt = previous?.createdAt || now.toISOString();
+  plan.updatedAt = now.toISOString();
+  const written = writeFanout(cwd, plan);
+  if (!written.ok)
+    return written;
+  appendObserved(cwd, {
+    type: "fanout.planned",
+    actor: input.actor,
+    fanout: plan.name,
+    trunk: plan.trunk,
+    slices: plan.slices.length,
+    ids: plan.slices.slice(0, 20).map((slice) => slice.id)
+  });
+  const grouped = waves(plan.slices);
+  const notes = [];
+  if (!ref)
+    notes.push(`trunk ${plan.trunk} does not resolve here; only sample paths of each glob were compared`);
+  grouped.forEach((wave, index) => {
+    if (wave.length > IN_FLIGHT_CAP)
+      notes.push(`wave ${index + 1} has ${wave.length} slices; keep 4-${IN_FLIGHT_CAP} in flight and queue the rest`);
+  });
+  for (const slice of plan.slices)
+    if (slice.dependsOn.length > 1 && slice.base === plan.trunk)
+      notes.push(`slice ${slice.id} depends on ${slice.dependsOn.join(", ")}: start it from ${plan.trunk} after they land`);
+  return {
+    ok: true,
+    data: {
+      name: plan.name,
+      trunk: plan.trunk,
+      file: written.data,
+      created: previous === null,
+      slices: plan.slices.map(({ id, branch, base, worktree, tier, dependsOn, scope, owns }) => ({
+        id,
+        branch,
+        base,
+        worktree,
+        tier,
+        dependsOn,
+        scope,
+        owns
+      })),
+      overlaps,
+      waves: grouped,
+      landingOrder: landingOrder(plan.slices),
+      notes
+    }
+  };
+}
+var FANOUT_VERSION = 1, TIERS, fanoutFail = (code, error, unblock, data) => ({
+  ok: false,
+  code,
+  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), 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"))
+    return value;
+  return null;
+}, ID, quoteList = (items) => items.map((item) => `"${item}"`).join(", "), ownerSuggestion = (slice, paths) => ({
+  kind: "owner",
+  slice,
+  paths,
+  text: `add ${quoteList(paths)} to "owns" of slice ${slice}`
+}), serializeSuggestion = (ids) => {
+  const edges = ids.slice(1).map((slice, index) => ({ slice, dependsOn: ids[index] }));
+  return {
+    kind: "serialize",
+    edges,
+    text: edges.map((edge) => `add "${edge.dependsOn}" to "dependsOn" of slice ${edge.slice}`).join("; ")
+  };
+}, gitRun4 = (cwd, args) => {
+  const run = spawnSync21("git", args, {
+    cwd,
+    encoding: "utf8",
+    timeout: GIT_TIMEOUTS.local,
+    killSignal: "SIGKILL",
+    windowsHide: true,
+    maxBuffer: 64 * 1024 * 1024,
+    env: { ...process.env, GIT_TERMINAL_PROMPT: "0", LC_ALL: "C", LANGUAGE: "C" }
+  });
+  return {
+    ok: run.status === 0,
+    status: run.status,
+    stdout: run.stdout ?? "",
+    stderr: run.error ? String(run.error.message) : run.stderr ?? ""
+  };
+}, nulList2 = (text) => text.split("\x00").filter(Boolean), IN_FLIGHT_CAP = 6;
+var init_fanout = __esm(() => {
+  init_rev();
+  init_ledger();
+  init_stack();
+  TIERS = ["mundane", "standard", "hard"];
+  DEFAULT_SHARED = [
+    "**/package.json",
+    "**/{package-lock.json,npm-shrinkwrap.json,bun.lock,bun.lockb,pnpm-lock.yaml,pnpm-workspace.yaml,yarn.lock}",
+    "**/{Cargo.lock,go.mod,go.sum,poetry.lock,uv.lock,Gemfile.lock,composer.lock}",
+    "**/index.{ts,tsx,js,jsx,mjs,cjs}",
+    "**/tsconfig.json",
+    ".github/**",
+    ".gitlab-ci.yml",
+    "CHANGELOG.md"
+  ];
+  compiled = new Map;
+  PLACEHOLDER3 = /^(?:<[^>]*>|tbd|todo|fixme|\?+|\.\.\.|…)$/iu;
+  ID = /^[a-z0-9][a-z0-9._-]{0,63}$/u;
+});
+
+// packages/workit-core/src/fanout-check.ts
+function mergeConflicts(cwd, a, b) {
+  const run = gitRun4(cwd, [
+    "merge-tree",
+    "--write-tree",
+    "--name-only",
+    "--no-messages",
+    "-z",
+    a,
+    b
+  ]);
+  if (run.status === 0)
+    return [];
+  if (run.status === 1)
+    return [...new Set(nulList2(run.stdout).slice(1))];
+  const first = run.stderr.trim().split(`
+`)[0] || `git merge-tree exited ${run.status}`;
+  return {
+    error: /write-tree|usage: git merge-tree/u.test(run.stderr) ? `${first} (needs git >= 2.38 for merge-tree --write-tree)` : first
+  };
+}
+function checkFanout(cwd, plan, options = {}) {
+  const unknown = (options.only ?? []).filter((id) => !plan.slices.some((s) => s.id === id));
+  if (unknown.length)
+    return fanoutFail("invalid_input", `${unknown.join(", ")}: not a slice of fanout ${plan.name}`, `slices: ${plan.slices.map((slice) => slice.id).join(", ")}`);
+  const trunk = options.trunkRef ?? trunkRef(cwd, plan.trunk);
+  if (!SAFE(trunk) || !resolves(cwd, trunk))
+    return fanoutFail("unavailable", `trunk ${options.trunkRef ?? plan.trunk} does not resolve here`, `git fetch, or pass --base <ref>`);
+  const order = landingOrder(plan.slices);
+  const byId = new Map(plan.slices.map((slice) => [slice.id, slice]));
+  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 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));
+  const conflicts = [];
+  for (let i = 0;i < order.length; i += 1)
+    for (let j = i + 1;j < order.length; j += 1) {
+      const first = order[i];
+      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))
+        continue;
+      const check = checks.get(second);
+      const theirs = new Map((changedBy.get(first) ?? []).map((file) => [file.toLowerCase(), file]));
+      const cased = (changedBy.get(second) ?? []).flatMap((file) => {
+        const other = theirs.get(file.toLowerCase());
+        return other !== undefined && other !== file ? [`${other} ~ ${file}`] : [];
+      });
+      if (cased.length) {
+        conflicts.push({
+          first,
+          second,
+          paths: cased,
+          caseOnly: true,
+          resolution: `use ${first}'s spelling on ${second} (git mv), then workit fanout check`
+        });
+        check.siblingConflicts.push({ with: first, paths: cased });
+        check.reasons.push(`differs only in case from ${first}: ${cased.join(", ")}`);
+      }
+      const result = mergeConflicts(cwd, a, b);
+      if (!Array.isArray(result)) {
+        check.reasons.push(`cannot merge with ${first}: ${result.error}`);
+        continue;
+      }
+      if (result.length === 0)
+        continue;
+      const related = byId.get(second)?.dependsOn.includes(first);
+      conflicts.push({
+        first,
+        second,
+        paths: result,
+        resolution: related ? `rebase ${second} onto ${byId.get(first)?.branch} (its dependency), then workit fanout check` : `land ${first} first, then rebase ${second} onto ${plan.trunk} and run workit fanout check; or make ${second} depend on ${first}`
+      });
+      check.siblingConflicts.push({ with: first, paths: result });
+      check.reasons.push(`conflicts with ${first} on ${result.join(", ")}`);
+    }
+  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.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 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)`;
+  return {
+    ok: true,
+    data: {
+      name: plan.name,
+      trunk: plan.trunk,
+      trunkRef: trunk,
+      ready,
+      slices,
+      conflicts: conflicts.filter((conflict) => !selected || selected.has(conflict.first) || selected.has(conflict.second)),
+      landingOrder: order,
+      notes,
+      next
+    }
+  };
+}
+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: []
+  };
+  if (!head) {
+    check.reasons.push(`branch ${slice.branch} not found (not started, landed, 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);
+  if (!SAFE(baseRef)) {
+    check.reasons.push(`base ${slice.base} not found`);
+    return check;
+  }
+  const diff = gitRun4(cwd, ["diff", "--name-only", "--no-renames", "-z", `${baseRef}...${head}`]);
+  if (!diff.ok) {
+    check.reasons.push(`cannot diff ${slice.base}...${slice.branch}: ${diff.stderr.trim()}`);
+    return check;
+  }
+  const changed = nulList2(diff.stdout);
+  changedBy.set(slice.id, changed);
+  check.changed = changed.length;
+  if (changed.length === 0)
+    check.reasons.push(`no changes beyond ${slice.base}`);
+  check.outOfScope = changed.filter((file) => !inScope(plan, slice, file)).toSorted();
+  if (check.outOfScope.length)
+    check.reasons.push(`edits outside its scope: ${check.outOfScope.join(", ")}`);
+  const trunkResult = mergeConflicts(cwd, trunk, head);
+  if (Array.isArray(trunkResult)) {
+    check.trunkConflicts = trunkResult;
+    if (trunkResult.length)
+      check.reasons.push(`conflicts with ${plan.trunk} on ${trunkResult.join(", ")}`);
+  } else
+    check.reasons.push(`cannot merge with ${plan.trunk}: ${trunkResult.error}`);
+  const verdict = checkVerdicts(cwd, slice.branch, rows);
+  check.verdict = { accepted: verdict.accepted.accepted, basis: verdict.current.basis };
+  return check;
+}
+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}`;
+  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.trunkConflicts.length)
+    return `rebase ${check.branch} onto ${plan.trunk} and resolve ${check.trunkConflicts.join(", ")}, then workit fanout check`;
+  if (check.siblingConflicts.length) {
+    const first = check.siblingConflicts[0].with;
+    return `land ${first} first, then rebase ${check.branch} onto ${plan.trunk} and run workit fanout check`;
+  }
+  if (check.waitsFor.length)
+    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 init_fanout_check = __esm(() => {
+  init_ledger();
+  init_fanout();
+});
+
+// packages/workit-cli/src/verbs/fanout.ts
+var exports_fanout = {};
+__export(exports_fanout, {
+  run: () => run15
+});
+import fs24 from "node:fs";
+import path44 from "node:path";
+function renderBlockedPlan(io, result) {
+  if (io.json || result.code !== "blocked" && result.code !== "invalid_input")
+    return;
+  const problems = result.data?.problems;
+  if (Array.isArray(problems))
+    for (const problem of problems)
+      io.stderr(`  - ${problem}
+`);
+  const conflicts = result.data?.conflicts;
+  if (Array.isArray(conflicts))
+    for (const conflict of conflicts)
+      io.stderr(`  - ${conflict.slices.join(" + ")}: ${conflict.paths.join(", ")}
+      fix: ${conflict.suggestion.text}${conflict.alternative ? `
+      or:  ${conflict.alternative.text}` : ""}
+`);
+}
+function resolveTrunk(io, raw, flag, track) {
+  if (flag !== null)
+    return { trunk: flag };
+  const named = typeof raw === "object" && raw !== null && typeof raw.trunk === "string" ? raw.trunk.trim() || null : null;
+  if (named !== null && track === null)
+    return { trunk: null };
+  const derived = releaseTrunk(io, track, null);
+  if ("error" in derived)
+    return {
+      code: emit(io, fail("blocked", derived.error, {
+        unblock: "workit fanout plan <plan.json> --track <name>  # or --trunk <branch>"
+      }))
+    };
+  if (named !== null && derived.trunk !== named)
+    return {
+      code: usage3(io, `the plan names trunk ${named}; --track ${track} targets ${derived.trunk ?? "(none)"}`, PLAN_USAGE2)
+    };
+  return { trunk: derived.tracked || track !== null ? derived.trunk : null };
+}
+function plan2(argv, io) {
+  const flags = parseFlags(argv, { name: "value", trunk: "value", track: "value" });
+  if (typeof flags === "string")
+    return usage3(io, flags, PLAN_USAGE2);
+  const track = flags.values.track ?? null;
+  if (track !== null && flags.values.trunk !== undefined)
+    return usage3(io, "pass --trunk or --track, not both (--track picks the trunk)", PLAN_USAGE2);
+  if (flags.positionals.length !== 1)
+    return usage3(io, flags.positionals.length ? `unexpected argument ${flags.positionals[1]}` : "missing <plan.json>", PLAN_USAGE2);
+  const file = path44.resolve(io.cwd, flags.positionals[0]);
+  let raw;
+  try {
+    raw = JSON.parse(fs24.readFileSync(file, "utf8"));
+  } catch (error) {
+    return usage3(io, `cannot read ${file} as JSON: ${error.message}`, PLAN_USAGE2);
+  }
+  const trunk = resolveTrunk(io, raw, flags.values.trunk ?? null, track);
+  if ("code" in trunk)
+    return trunk.code;
+  const result = planFanout(io.cwd, {
+    raw,
+    name: flags.values.name ?? null,
+    trunk: trunk.trunk,
+    actor: actorFromEnv(io.env)
+  });
+  if (!result.ok) {
+    const code = failed(io, result);
+    renderBlockedPlan(io, result);
+    return code;
+  }
+  return emit(io, ok(result.data), (data) => [
+    `${data.created ? "planned" : "re-planned"} fanout ${data.name} on ${data.trunk}: ${data.slices.length} slice${data.slices.length === 1 ? "" : "s"}`,
+    ...data.slices.map((slice) => `  ${slice.id} [${slice.tier}] ${slice.branch} <- ${slice.base}${slice.dependsOn.length ? `  after ${slice.dependsOn.join(", ")}` : ""}
+      worktree ${slice.worktree}`),
+    ...data.overlaps.map((overlap) => `  shared ${overlap.path}: ${overlap.resolution === "owner" ? `owned by ${overlap.owner}` : `serialized (${overlap.slices.join(" -> ")})`}`),
+    `waves: ${data.waves.map((wave) => wave.join(", ")).join("  |  ")}`,
+    `landing order: ${data.landingOrder.join(", ")}`,
+    ...data.notes.map((note) => `note: ${note}`)
+  ]);
+}
+function check2(argv, io) {
+  const flags = parseFlags(argv, { name: "value", base: "value" });
+  if (typeof flags === "string")
+    return usage3(io, flags, CHECK_USAGE);
+  const selected = selectFanout(io.cwd, flags.values.name ?? null, currentBranch(io.cwd));
+  if (!selected.ok)
+    return failed(io, selected);
+  const result = checkFanout(io.cwd, selected.data, {
+    only: flags.positionals,
+    trunkRef: flags.values.base ?? null
+  });
+  if (!result.ok)
+    return failed(io, result);
+  if (result.data.ready)
+    return emit(io, ok(result.data), renderCheck);
+  if (!io.json)
+    for (const line of renderCheck(result.data))
+      io.stdout(`${line}
+`);
+  const first = result.data.slices.find((slice) => slice.status === "blocked");
+  return emit(io, fail("blocked", `slice ${first?.id ?? "?"} is not ready: ${first?.reasons[0] ?? "blocked"}`, {
+    data: result.data,
+    unblock: result.data.next
+  }));
+}
+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);
+  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) => [
+  `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 ? `
+      ${slice.reasons.join(`
+      `)}` : ""}`),
+  ...data.conflicts.map((conflict) => `  conflict ${conflict.first} x ${conflict.second}: ${conflict.paths.join(", ")}
+      fix: ${conflict.resolution}`),
+  `landing order: ${data.landingOrder.join(", ")}`,
+  `next: ${data.next}`,
+  ...data.notes.map((note) => `note: ${note}`)
+];
+var init_fanout2 = __esm(() => {
+  init_fanout_check();
+  init_fanout();
+  init_rev();
+  init_ledger();
+  init_output();
+  init_forge_common();
+});
+
 // packages/workit-cli/src/verbs/ledger.ts
 var exports_ledger = {};
 __export(exports_ledger, {
-  run: () => run15
+  run: () => run16
 });
 import { randomBytes as randomBytes4 } from "node:crypto";
 import { parseArgs } from "node:util";
@@ -75430,7 +76695,7 @@ function targetBranch(io, rows, branch, pr) {
   }
   return { ok: true, value: branch ?? null };
 }
-async function run15(argv, io) {
+async function run16(argv, io) {
   let parsed;
   try {
     parsed = parseArgs({ args: argv, options: OPTIONS, allowPositionals: true, strict: true });
@@ -75458,7 +76723,7 @@ async function run15(argv, io) {
     return usage4(io, `unknown ledger subcommand "${sub}"`);
   const ledger = readLedger(io.cwd);
   if (!ledger.ok)
-    return failed(io, ledger);
+    return failed2(io, ledger);
   const { rows } = ledger.value;
   if (sub === "list" || sub === "show") {
     if (rest.length)
@@ -75480,7 +76745,7 @@ async function run15(argv, io) {
       return usage4(io, `unexpected argument: ${rest.at(-1)}`);
     const target = targetBranch(io, rows, rest[0] ?? values.branch, pr);
     if (!target.ok)
-      return failed(io, target);
+      return failed2(io, target);
     const branch = target.value ?? currentBranch(io.cwd);
     if (!branch)
       return emit(io, fail("invalid_input", "HEAD is detached; name the branch", {
@@ -75490,7 +76755,7 @@ async function run15(argv, io) {
   }
   const target = targetBranch(io, rows, values.branch, pr);
   if (!target.ok)
-    return failed(io, target);
+    return failed2(io, target);
   const acting = actorFor(io, values);
   if (acting instanceof Error)
     return usage4(io, acting.message);
@@ -75529,7 +76794,7 @@ async function run15(argv, io) {
     ..."derivedFrom" in acting ? { derivedFrom: acting.derivedFrom } : {}
   })), (row) => `recorded verdict ${row.id}: ${row.result} [${row.kind}] for ${row.branch} @ ${(row.head ?? "").slice(0, 12)} as ${actor.session ?? "no session"}${row.self ? ` (self${row.selfReason === "no_session" ? ": WORKIT_SESSION_ID unset" : ""}; never accepted)` : ""}`);
 }
-var USAGE8 = "workit ledger decision|ruling|verdict|list|check ... (workit help ledger for the grammar)", OPTIONS, SESSION_SAFE2, ROLE_SAFE, actorFor = (io, values) => {
+var USAGE9 = "workit ledger decision|ruling|verdict|list|check ... (workit help ledger for the grammar)", OPTIONS, SESSION_SAFE2, ROLE_SAFE, actorFor = (io, values) => {
   const actor = actorFromEnv(io.env);
   if (values.session !== undefined && values.as !== undefined)
     return new Error("pass --session or --as, not both");
@@ -75553,7 +76818,7 @@ var USAGE8 = "workit ledger decision|ruling|verdict|list|check ... (workit help
     return;
   const parsed = Number(value);
   return Number.isInteger(parsed) && parsed > 0 ? parsed : new Error(`${flag} must be a positive integer`);
-}, failed = (io, result) => emit(io, fail(result.code, result.error, result.unblock ? { unblock: result.unblock } : {})), fromResult = (io, result, human) => result.ok ? emit(io, ok(result.value), human) : failed(io, result), usage4 = (io, error) => emit(io, fail("invalid_input", error, { unblock: USAGE8 })), verdictLines = (check) => {
+}, failed2 = (io, result) => emit(io, fail(result.code, result.error, result.unblock ? { unblock: result.unblock } : {})), fromResult = (io, result, human) => result.ok ? emit(io, ok(result.value), human) : failed2(io, result), usage4 = (io, error) => emit(io, fail("invalid_input", error, { unblock: USAGE9 })), verdictLines = (check) => {
   const lines = [
     `${check.branch} @ ${(check.head ?? "no commit").slice(0, 12)}: current: ${check.current.basis}${typeof check.current.verdict?.result === "string" ? ` (${check.current.verdict.result})` : ""}; ${check.accepted.accepted ? "accepted" : `not accepted (${check.accepted.reasons.join(", ")})`}; review: ${check.review}`
   ];
@@ -90550,7 +91815,7 @@ var init_ast = __esm(() => {
 
 // packages/workit-cli/src/test-audit/rules.ts
 import { builtinModules } from "node:module";
-import path42 from "node:path";
+import path45 from "node:path";
 function testCallee(call) {
   let callee = call.callee;
   if (callee.type === "CallExpression")
@@ -91043,12 +92308,12 @@ function checkConstantsOnly(ctx, emit) {
 }
 function checkOverMocking(ctx, emit) {
   const { program } = ctx.parsed;
-  const unit = path42.basename(ctx.file).replace(/\.(?:[cm]?[jt]sx?)$/, "").replace(/\.(?:test|spec)$/, "");
+  const unit = path45.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 = path42.basename(spec.replace(/\/index(?:\.[cm]?[jt]sx?)?$/, "")).replace(/\.(?:[cm]?[jt]sx?)$/, "");
+    const base = path45.basename(spec.replace(/\/index(?:\.[cm]?[jt]sx?)?$/, "")).replace(/\.(?:[cm]?[jt]sx?)$/, "");
     if (base === unit)
       emit({
         rule: "over-mocking",
@@ -91436,11 +92701,11 @@ var init_rules = __esm(() => {
 });
 
 // packages/workit-cli/src/test-audit/audit.ts
-import { spawnSync as spawnSync20 } from "node:child_process";
+import { spawnSync as spawnSync22 } from "node:child_process";
 import { existsSync as existsSync18, readdirSync as readdirSync8, readFileSync as readFileSync19, statSync as statSync7 } from "node:fs";
-import path43 from "node:path";
+import path46 from "node:path";
 function git6(cwd, args) {
-  const run = spawnSync20("git", ["-c", "core.quotepath=off", ...args], {
+  const run = spawnSync22("git", ["-c", "core.quotepath=off", ...args], {
     cwd,
     encoding: "utf8",
     maxBuffer: 64 * 1024 * 1024
@@ -91451,7 +92716,7 @@ function walkTests(dir, out) {
   for (const entry of readdirSync8(dir, { withFileTypes: true })) {
     if (entry.name.startsWith(".") && entry.name !== "." && entry.isDirectory())
       continue;
-    const full = path43.join(dir, entry.name);
+    const full = path46.join(dir, entry.name);
     if (entry.isDirectory()) {
       if (!SKIP_DIRS.has(entry.name))
         walkTests(full, out);
@@ -91463,7 +92728,7 @@ function expandPaths(cwd, inputs) {
   const files = [];
   const missing = [];
   for (const input of inputs.length > 0 ? inputs : ["."]) {
-    const full = path43.resolve(cwd, input);
+    const full = path46.resolve(cwd, input);
     if (!existsSync18(full))
       missing.push(input);
     else if (statSync7(full).isDirectory())
@@ -91500,11 +92765,11 @@ function changedLines(cwd, base) {
       for (let offset = 0;offset < count; offset += 1)
         lines.add(start + offset);
     }
-    changed.set(path43.join(root, file), lines);
+    changed.set(path46.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(path43.join(root, file), "all");
+    changed.set(path46.join(root, file), "all");
   return changed;
 }
 function auditFiles(files, display) {
@@ -91566,7 +92831,7 @@ function auditFiles(files, display) {
     durationMs: Math.round(performance.now() - started)
   };
 }
-var TEST_FILE, CODE_FILE, SKIP_DIRS, toPosix = (file) => file.split(path43.sep).join("/"), SEVERITY_ORDER, ruleIds;
+var TEST_FILE, CODE_FILE, SKIP_DIRS, toPosix = (file) => file.split(path46.sep).join("/"), SEVERITY_ORDER, ruleIds;
 var init_audit = __esm(() => {
   init_ast();
   init_rules();
@@ -91596,7 +92861,7 @@ import {
   copyFileSync as copyFileSync6
 } from "node:fs";
 import os14 from "node:os";
-import path44 from "node:path";
+import path47 from "node:path";
 function mutantsFor(source, file, lines) {
   const parsed = parseSource(source, file);
   const out = [];
@@ -91669,7 +92934,7 @@ function relatedTests(source, testFiles) {
     for (const match of text.matchAll(SPECIFIER)) {
       const spec = match[1];
       if (spec.startsWith(".")) {
-        if (stripExt(path44.posix.join(path44.posix.dirname(file), spec)) === target)
+        if (stripExt(path47.posix.join(path47.posix.dirname(file), spec)) === target)
           return true;
       } else if (spec.includes("/") && stripExt(spec).split("/").slice(-2).join("/") === tail)
         return true;
@@ -91689,12 +92954,12 @@ function removeStaleCopies(tmp = os14.tmpdir()) {
   for (const name of names) {
     if (!name.startsWith(TEMP_PREFIX))
       continue;
-    const dir = path44.join(tmp, name);
+    const dir = path47.join(tmp, name);
     try {
       const stat = lstatSync7(dir);
       if (!stat.isDirectory() || uid !== undefined && stat.uid !== uid)
         continue;
-      const pid = Number(readFileSync20(path44.join(dir, PID_FILE), "utf8"));
+      const pid = Number(readFileSync20(path47.join(dir, PID_FILE), "utf8"));
       if (Number.isInteger(pid) && pid > 0 && alive(pid))
         continue;
     } catch (error) {
@@ -91711,8 +92976,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 = path44.join(origin, entry.name);
-    const to = path44.join(target, entry.name);
+    const from = path47.join(origin, entry.name);
+    const to = path47.join(target, entry.name);
     if (entry.name.startsWith("@") && entry.isDirectory()) {
       linkNodeModules(from, to, repo, copy);
       continue;
@@ -91728,9 +92993,9 @@ function linkNodeModules(origin, target, repo, copy) {
       } catch {
         continue;
       }
-      const relative = path44.relative(repo, real);
-      if (!relative.startsWith("..") && !path44.isAbsolute(relative) && !relative.split(path44.sep).includes("node_modules")) {
-        symlinkSync(path44.join(copy, relative), to, "junction");
+      const relative = path47.relative(repo, real);
+      if (!relative.startsWith("..") && !path47.isAbsolute(relative) && !relative.split(path47.sep).includes("node_modules")) {
+        symlinkSync(path47.join(copy, relative), to, "junction");
         continue;
       }
     }
@@ -91746,7 +93011,7 @@ function copySymlink(repo, tree, from, to) {
   }
   const realRepo = realpathSync9(repo);
   if (real && inside2(realRepo, real)) {
-    symlinkSync(path44.relative(path44.dirname(to), path44.join(tree, path44.relative(realRepo, real))), to);
+    symlinkSync(path47.relative(path47.dirname(to), path47.join(tree, path47.relative(realRepo, real))), to);
     return;
   }
   if (real && statSync8(real).isFile())
@@ -91755,10 +93020,10 @@ function copySymlink(repo, tree, from, to) {
     symlinkSync(readlinkSync3(from), to);
 }
 function writeInside(copy, file, content) {
-  const target = path44.join(copy, file);
+  const target = path47.join(copy, file);
   try {
     const stat = lstatSync7(target);
-    if (!stat.isFile() || !inside2(realpathSync9(copy), realpathSync9(path44.dirname(target))))
+    if (!stat.isFile() || !inside2(realpathSync9(copy), realpathSync9(path47.dirname(target))))
       return false;
   } catch {
     return false;
@@ -91769,9 +93034,9 @@ function writeInside(copy, file, content) {
   return true;
 }
 function copyWorkingTree(repo) {
-  const dir = mkdtempSync4(path44.join(os14.tmpdir(), TEMP_PREFIX));
-  writeFileSync9(path44.join(dir, PID_FILE), String(process.pid));
-  const tree = path44.join(dir, "tree");
+  const dir = mkdtempSync4(path47.join(os14.tmpdir(), TEMP_PREFIX));
+  writeFileSync9(path47.join(dir, PID_FILE), String(process.pid));
+  const tree = path47.join(dir, "tree");
   const 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();
@@ -91788,29 +93053,29 @@ function copyWorkingTree(repo) {
   for (const relative of listed) {
     if (!relative)
       continue;
-    const from = path44.join(repo, relative);
+    const from = path47.join(repo, relative);
     let stat;
     try {
       stat = lstatSync7(from);
     } catch {
       continue;
     }
-    const to = path44.join(tree, relative);
-    mkdirSync9(path44.dirname(to), { recursive: true });
+    const to = path47.join(tree, relative);
+    mkdirSync9(path47.dirname(to), { recursive: true });
     if (stat.isSymbolicLink())
       copySymlink(repo, tree, from, to);
     else if (stat.isFile())
       copyFileSync6(from, to);
-    let parent = path44.dirname(relative);
+    let parent = path47.dirname(relative);
     while (parent !== "." && !dirs.has(parent)) {
       dirs.add(parent);
-      parent = path44.dirname(parent);
+      parent = path47.dirname(parent);
     }
   }
   for (const parent of dirs) {
-    const modules = path44.join(repo, parent, "node_modules");
-    if (existsSync19(modules) && !existsSync19(path44.join(tree, parent, "node_modules")))
-      linkNodeModules(modules, path44.join(tree, parent, "node_modules"), repo, tree);
+    const modules = path47.join(repo, parent, "node_modules");
+    if (existsSync19(modules) && !existsSync19(path47.join(tree, parent, "node_modules")))
+      linkNodeModules(modules, path47.join(tree, parent, "node_modules"), repo, tree);
   }
   return { dir, tree };
 }
@@ -91849,14 +93114,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(path44.join(repo, file), "utf8") };
+      return { file, text: readFileSync20(path47.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(path44.relative(repo, absolute));
+    const relative = toPosix(path47.relative(repo, absolute));
     if (!CODE_FILE.test(relative) || TEST_FILE.test(relative) || relative.endsWith(".d.ts"))
       continue;
     if (NOT_SOURCE.test(relative) || !existsSync19(absolute))
@@ -91870,9 +93135,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 = path44.relative(repo, options.cwd);
+  const cwdRelative = path47.relative(repo, options.cwd);
   const asArg = (file) => {
-    const relative = toPosix(path44.relative(cwdRelative, file));
+    const relative = toPosix(path47.relative(cwdRelative, file));
     return shellQuote(relative.startsWith(".") ? relative : `./${relative}`);
   };
   const commandFor = (tests) => options.command.replaceAll("{files}", () => tests.map(asArg).join(" "));
@@ -91907,7 +93172,7 @@ async function runMutation(options) {
     return finish2(options, 0, results, counts, started);
   removeStaleCopies();
   const { dir: copyDir, tree: copy } = copyWorkingTree(repo);
-  const copyCwd = path44.join(copy, cwdRelative);
+  const copyCwd = path47.join(copy, cwdRelative);
   let current = null;
   const restore = () => {
     if (current)
@@ -91942,7 +93207,7 @@ async function runMutation(options) {
         record({ ...mutant, status: "skipped", durationMs: 0, tests, reason: "budget" });
         continue;
       }
-      const original = readFileSync20(path44.join(copy, mutant.file), "utf8");
+      const original = readFileSync20(path47.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)) {
@@ -91999,8 +93264,8 @@ var NOT_SOURCE, FLIPS, isStringy = (node) => node.type === "StringLiteral" || no
     return error.code === "EPERM";
   }
 }, inside2 = (root, file) => {
-  const relative = path44.relative(root, file);
-  return relative === "" || !relative.startsWith("..") && !path44.isAbsolute(relative);
+  const relative = path47.relative(root, file);
+  return relative === "" || !relative.startsWith("..") && !path47.isAbsolute(relative);
 }, active, killTree = (child) => {
   try {
     if (child.pid && process.platform !== "win32")
@@ -92046,10 +93311,10 @@ var init_mutate = __esm(() => {
 // packages/workit-cli/src/verbs/test-audit.ts
 var exports_test_audit = {};
 __export(exports_test_audit, {
-  run: () => run16
+  run: () => run17
 });
 import { existsSync as existsSync20 } from "node:fs";
-import path45 from "node:path";
+import path48 from "node:path";
 function parse7(argv) {
   const options = {
     paths: [],
@@ -92143,14 +93408,14 @@ function human(data) {
   }
   return lines;
 }
-async function run16(argv, io) {
+async function run17(argv, io) {
   const options = parse7(argv);
   if (typeof options === "string")
     return emit(io, fail("invalid_input", `${options}
-usage: ${USAGE9}`));
+usage: ${USAGE10}`));
   const top = git6(io.cwd, ["rev-parse", "--show-toplevel"]);
-  const repo = top.ok ? path45.resolve(top.stdout.trim()) : null;
-  const display = (file) => toPosix(path45.relative(io.cwd, file) || file);
+  const repo = top.ok ? path48.resolve(top.stdout.trim()) : null;
+  const display = (file) => toPosix(path48.relative(io.cwd, file) || file);
   let base = null;
   let changed = null;
   if (options.diff || options.mutate) {
@@ -92233,7 +93498,7 @@ usage: ${USAGE9}`));
   }
   return emit(io, ok(data), human);
 }
-var USAGE9 = "workit test-audit [paths…] [--diff [base]] [--rule <ids>] [--min-severity <level>] [--fail-on <level>] [--mutate [--test-cmd <cmd>] [--max-mutants <n>] [--budget <s>] [--timeout <s>]] [--json]", LEVELS, VALUE_FLAGS2, quote = (arg) => /^[\w./@:=+-]+$/.test(arg) ? arg : `'${arg.replace(/'/g, "'\\''")}'`;
+var USAGE10 = "workit test-audit [paths…] [--diff [base]] [--rule <ids>] [--min-severity <level>] [--fail-on <level>] [--mutate [--test-cmd <cmd>] [--max-mutants <n>] [--budget <s>] [--timeout <s>]] [--json]", LEVELS, VALUE_FLAGS2, quote = (arg) => /^[\w./@:=+-]+$/.test(arg) ? arg : `'${arg.replace(/'/g, "'\\''")}'`;
 var init_test_audit = __esm(() => {
   init_audit();
   init_mutate();
@@ -92251,6 +93516,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 {
@@ -92358,14 +93655,14 @@ var init_youtrack_writes = __esm(() => {
 // packages/workit-cli/src/verbs/youtrack.ts
 var exports_youtrack = {};
 __export(exports_youtrack, {
-  run: () => run17
+  run: () => run19
 });
 import { readFileSync as readFileSync21 } from "node:fs";
-import path46 from "node:path";
-async function run17(argv, io) {
+import path49 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 ?? ""}"`, USAGE10);
+    return usage3(io, `unknown subcommand "${sub ?? ""}"`, USAGE12);
   const flags = parseFlags(rest, {
     markdown: "value",
     file: "value",
@@ -92374,18 +93671,18 @@ async function run17(argv, io) {
     date: "value"
   });
   if (typeof flags === "string")
-    return usage3(io, flags, USAGE10);
+    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", USAGE10);
+    return usage3(io, "an issue id like ABC-123 is required", USAGE12);
   if (extra !== undefined)
-    return usage3(io, `unexpected argument ${extra}`, USAGE10);
+    return usage3(io, `unexpected argument ${extra}`, USAGE12);
   const minutes = positiveInt(flags.values.minutes, "--minutes");
   if (typeof minutes === "string")
-    return usage3(io, minutes, USAGE10);
+    return usage3(io, minutes, USAGE12);
   const date = youTrackWorkDateMs(flags.values.date ?? "auto");
   if ("error" in date)
-    return usage3(io, date.error, USAGE10);
+    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;
@@ -92403,24 +93700,24 @@ async function run17(argv, io) {
   };
   if (sub === "note") {
     if (Boolean(flags.values.markdown) === Boolean(flags.values.file))
-      return usage3(io, "pass exactly one of --markdown or --file", USAGE10);
+      return usage3(io, "pass exactly one of --markdown or --file", USAGE12);
     let markdown = flags.values.markdown ?? "";
     if (flags.values.file)
       try {
-        markdown = readFileSync21(path46.resolve(io.cwd, flags.values.file), "utf8");
+        markdown = readFileSync21(path49.resolve(io.cwd, flags.values.file), "utf8");
       } catch (error) {
-        return usage3(io, `cannot read ${flags.values.file}: ${String(error)}`, USAGE10);
+        return usage3(io, `cannot read ${flags.values.file}: ${String(error)}`, USAGE12);
       }
     if (!markdown.trim())
-      return usage3(io, "the note is empty", USAGE10);
+      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>`, USAGE10);
+      return usage3(io, `${sub} needs --minutes <n>`, USAGE12);
     if (sub === "meeting" && !flags.values.text)
-      return usage3(io, "meeting needs --text <what the meeting was>", USAGE10);
+      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)
@@ -92449,7 +93746,7 @@ async function run17(argv, io) {
     ...data.steps.flatMap((entry) => entry.note ? [`  note (${entry.step}): ${entry.note}`] : [])
   ]);
 }
-var USAGE10 = "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) {
@@ -92473,14 +93770,14 @@ var init_youtrack2 = __esm(() => {
 // packages/workit-cli/src/verbs/changelog.ts
 var exports_changelog = {};
 __export(exports_changelog, {
-  run: () => run18
+  run: () => run20
 });
 import { readFileSync as readFileSync22 } from "node:fs";
-import path47 from "node:path";
-async function run18(argv, io) {
+import path50 from "node:path";
+async function run20(argv, io) {
   const [sub, ...rest] = argv;
   if (sub !== "apply")
-    return usage3(io, `unknown subcommand "${sub ?? ""}"`, USAGE11);
+    return usage3(io, `unknown subcommand "${sub ?? ""}"`, USAGE13);
   const flags = parseFlags(rest, {
     entries: "value",
     path: "value",
@@ -92488,18 +93785,18 @@ async function run18(argv, io) {
     preview: "boolean"
   });
   if (typeof flags === "string")
-    return usage3(io, flags, USAGE11);
+    return usage3(io, flags, USAGE13);
   if (flags.positionals.length)
-    return usage3(io, `unexpected argument ${flags.positionals[0]}`, USAGE11);
+    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", USAGE11);
+    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)}`, USAGE11);
+      return usage3(io, `--entries is not valid JSON: ${String(error)}`, USAGE13);
     }
   const input = {
     entries,
@@ -92521,8 +93818,8 @@ async function run18(argv, io) {
     `changelog updated: ${String(applied.path ?? "CHANGELOG.md")}`
   ]);
 }
-var USAGE11 = "workit changelog apply (--entries <JSON|@file|-> | --normalize-only) [--path CHANGELOG.md] [--preview]", readEntries = (raw, cwd) => {
-  const text = raw === "-" ? readFileSync22(0, "utf8") : raw.startsWith("@") ? readFileSync22(path47.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(path50.resolve(cwd, raw.slice(1)), "utf8") : raw;
   return JSON.parse(text);
 };
 var init_changelog2 = __esm(() => {
@@ -92534,7 +93831,7 @@ var init_changelog2 = __esm(() => {
 // packages/workit-cli/src/verbs/handoff.ts
 var exports_handoff = {};
 __export(exports_handoff, {
-  run: () => run19
+  run: () => run21
 });
 import { parseArgs as parseArgs2 } from "node:util";
 function human2(brief) {
@@ -92582,11 +93879,11 @@ async function resumeBrief(argv, io) {
       strict: true
     }));
   } catch (error) {
-    return emit(io, fail("invalid_input", error.message, { unblock: USAGE12 }));
+    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: USAGE12 }));
+    return emit(io, fail("invalid_input", "--last must be a positive integer", { unblock: USAGE14 }));
   const built = buildHandoff(io.cwd, {
     last,
     note: values.note ?? null,
@@ -92604,13 +93901,13 @@ async function resumeBrief(argv, io) {
   }
   return emit(io, ok({ ...data, recorded }), human2);
 }
-async function run19(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 USAGE12 = "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]", short5 = (sha) => sha ? sha.slice(0, 12) : "no commit";
 var init_handoff = __esm(() => {
   init_ledger();
   init_output();
@@ -92619,7 +93916,7 @@ var init_handoff = __esm(() => {
 // packages/workit-cli/src/main.ts
 init_package();
 init_output();
-import path48 from "node:path";
+import path51 from "node:path";
 
 // packages/workit-cli/src/verbs/registry.ts
 var TASK_FAMILY_NAMES = [
@@ -92731,6 +94028,13 @@ var VERBS = [
     summary: "Plan, restack (lease push + retarget) and land a base-branch stack of PRs, root first",
     load: () => Promise.resolve().then(() => (init_stack2(), exports_stack))
   },
+  {
+    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",
+    load: () => Promise.resolve().then(() => (init_fanout2(), exports_fanout))
+  },
   {
     name: "ledger",
     group: "delivery",
@@ -92745,6 +94049,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",
@@ -92849,7 +94160,7 @@ var defaultIo = (json) => ({
 });
 async function main(argv, overrides = {}, options = {}) {
   const parsed = parseGlobals(argv);
-  const cwd = path48.resolve(overrides.cwd ?? process.cwd(), parsed.cwd ?? ".");
+  const cwd = path51.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));