@brainervirus/workit-claude-code 7.3.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.3.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.3.0",
-      "@brainervirus/workit-cursor": "^7.3.0",
-      "@brainervirus/workit-opencode": "^7.3.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");
     }
@@ -73114,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")
@@ -73185,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);
     }
@@ -73677,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 };
@@ -73890,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 {
@@ -73997,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)
@@ -74023,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;
@@ -74031,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;
@@ -74043,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) };
@@ -74082,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]);
   }
@@ -74095,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))
@@ -74147,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 };
@@ -74168,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}`);
   }
 }
@@ -74188,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: [] };
   }
@@ -74196,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;
     }
@@ -74243,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;
@@ -74255,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;
 }
@@ -74282,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) {
@@ -74292,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}`);
   }
@@ -74322,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);
@@ -74510,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",
@@ -75118,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,
@@ -75146,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) => {
@@ -75161,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 };
@@ -75408,9 +75691,9 @@ var init_stack2 = __esm(() => {
 });
 
 // packages/workit-core/src/fanout.ts
-import { spawnSync as spawnSync20 } from "node:child_process";
-import fs22 from "node:fs";
-import path42 from "node:path";
+import { spawnSync as spawnSync21 } from "node:child_process";
+import fs23 from "node:fs";
+import path43 from "node:path";
 function scopeSamples(pattern) {
   if (!hasWildcard(pattern))
     return [unescape2(pattern)];
@@ -75607,7 +75890,7 @@ function parsePlan(raw, defaults, name) {
       id,
       branch,
       base: optional("base") ?? "",
-      worktree: optional("worktree") ?? path42.join(defaults.worktreeRoot, id),
+      worktree: optional("worktree") ?? path43.join(defaults.worktreeRoot, id),
       tier,
       dependsOn: [...new Set(dependsOn ?? [])],
       scope,
@@ -75807,14 +76090,14 @@ function defaultTrunk(cwd) {
 }
 function worktreeRoot(cwd) {
   const common = gitCommonDir(cwd);
-  const main = common && path42.basename(common) === ".git" ? path42.dirname(common) : cwd;
-  return path42.join(path42.dirname(main), `${path42.basename(main)}-wt`);
+  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: path42.join(root.value.root, "fanouts") };
+  return { ok: true, data: path43.join(root.value.root, "fanouts") };
 }
 function parseStored(raw) {
   if (!isRecord8(raw) || typeof raw.name !== "string" || typeof raw.trunk !== "string")
@@ -75871,10 +76154,10 @@ function readFanout(cwd, name) {
   const dir = fanoutsDir(cwd);
   if (!dir.ok)
     return dir;
-  const file = path42.join(dir.data, stackFileName(name));
+  const file = path43.join(dir.data, stackFileName(name));
   let parsed = null;
   try {
-    parsed = parseStored(JSON.parse(fs22.readFileSync(file, "utf8")));
+    parsed = parseStored(JSON.parse(fs23.readFileSync(file, "utf8")));
   } catch (error) {
     if (error.code === "ENOENT")
       return { ok: true, data: null };
@@ -75888,7 +76171,7 @@ function listFanouts(cwd) {
     return dir;
   let names = [];
   try {
-    names = fs22.readdirSync(dir.data).filter((entry) => entry.endsWith(".json"));
+    names = fs23.readdirSync(dir.data).filter((entry) => entry.endsWith(".json"));
   } catch {
     return { ok: true, data: [] };
   }
@@ -75896,7 +76179,7 @@ function listFanouts(cwd) {
   for (const entry of names) {
     let parsed = null;
     try {
-      parsed = parseStored(JSON.parse(fs22.readFileSync(path42.join(dir.data, entry), "utf8")));
+      parsed = parseStored(JSON.parse(fs23.readFileSync(path43.join(dir.data, entry), "utf8")));
     } catch {
       parsed = null;
     }
@@ -75926,16 +76209,16 @@ function writeFanout(cwd, plan) {
   const dir = fanoutsDir(cwd);
   if (!dir.ok)
     return dir;
-  const file = path42.join(dir.data, stackFileName(plan.name));
+  const file = path43.join(dir.data, stackFileName(plan.name));
   const temp = `${file}.${process.pid}.tmp`;
   try {
-    fs22.mkdirSync(dir.data, { recursive: true });
-    fs22.writeFileSync(temp, `${JSON.stringify(plan, null, 2)}
+    fs23.mkdirSync(dir.data, { recursive: true });
+    fs23.writeFileSync(temp, `${JSON.stringify(plan, null, 2)}
 `);
-    fs22.renameSync(temp, file);
+    fs23.renameSync(temp, file);
     return { ok: true, data: file };
   } catch (error) {
-    fs22.rmSync(temp, { force: true });
+    fs23.rmSync(temp, { force: true });
     return fanoutFail("unavailable", `cannot write ${file}: ${error.message}`);
   }
 }
@@ -76014,7 +76297,7 @@ var FANOUT_VERSION = 1, TIERS, fanoutFail = (code, error, unblock, data) => ({
   error,
   ...unblock ? { unblock } : {},
   ...data ? { data } : {}
-}), DEFAULT_SHARED, escapeRegExp4 = (text) => text.replace(/[.+^$()|[\]\\{}*?]/gu, "\\$&"), unescape2 = (pattern) => pattern.replace(/\\(.)/gu, "$1"), hasWildcard = (pattern) => /[*?{]/u.test(pattern.replace(/\\./gu, "")), compiled, matchesAny = (patterns, file) => patterns.some((pattern) => matchesScope(pattern, file)), isRecord8 = (value) => typeof value === "object" && value !== null && !Array.isArray(value), PLACEHOLDER2, filled = (text) => text.trim() !== "" && !PLACEHOLDER2.test(text.trim()), textList = (value) => {
+}), DEFAULT_SHARED, escapeRegExp4 = (text) => text.replace(/[.+^$()|[\]\\{}*?]/gu, "\\$&"), unescape2 = (pattern) => pattern.replace(/\\(.)/gu, "$1"), hasWildcard = (pattern) => /[*?{]/u.test(pattern.replace(/\\./gu, "")), compiled, matchesAny = (patterns, file) => patterns.some((pattern) => matchesScope(pattern, file)), isRecord8 = (value) => typeof value === "object" && value !== null && !Array.isArray(value), PLACEHOLDER3, filled = (text) => text.trim() !== "" && !PLACEHOLDER3.test(text.trim()), textList = (value) => {
   if (typeof value === "string")
     return [value];
   if (Array.isArray(value) && value.every((item) => typeof item === "string"))
@@ -76033,7 +76316,7 @@ var FANOUT_VERSION = 1, TIERS, fanoutFail = (code, error, unblock, data) => ({
     text: edges.map((edge) => `add "${edge.dependsOn}" to "dependsOn" of slice ${edge.slice}`).join("; ")
   };
 }, gitRun4 = (cwd, args) => {
-  const run = spawnSync20("git", args, {
+  const run = spawnSync21("git", args, {
     cwd,
     encoding: "utf8",
     timeout: GIT_TIMEOUTS.local,
@@ -76065,7 +76348,7 @@ var init_fanout = __esm(() => {
     "CHANGELOG.md"
   ];
   compiled = new Map;
-  PLACEHOLDER2 = /^(?:<[^>]*>|tbd|todo|fixme|\?+|\.\.\.|…)$/iu;
+  PLACEHOLDER3 = /^(?:<[^>]*>|tbd|todo|fixme|\?+|\.\.\.|…)$/iu;
   ID = /^[a-z0-9][a-z0-9._-]{0,63}$/u;
 });
 
@@ -76255,8 +76538,8 @@ var exports_fanout = {};
 __export(exports_fanout, {
   run: () => run15
 });
-import fs23 from "node:fs";
-import path43 from "node:path";
+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;
@@ -76301,10 +76584,10 @@ function plan2(argv, io) {
     return usage3(io, "pass --trunk or --track, not both (--track picks the trunk)", PLAN_USAGE2);
   if (flags.positionals.length !== 1)
     return usage3(io, flags.positionals.length ? `unexpected argument ${flags.positionals[1]}` : "missing <plan.json>", PLAN_USAGE2);
-  const file = path43.resolve(io.cwd, flags.positionals[0]);
+  const file = path44.resolve(io.cwd, flags.positionals[0]);
   let raw;
   try {
-    raw = JSON.parse(fs23.readFileSync(file, "utf8"));
+    raw = JSON.parse(fs24.readFileSync(file, "utf8"));
   } catch (error) {
     return usage3(io, `cannot read ${file} as JSON: ${error.message}`, PLAN_USAGE2);
   }
@@ -91532,7 +91815,7 @@ var init_ast = __esm(() => {
 
 // packages/workit-cli/src/test-audit/rules.ts
 import { builtinModules } from "node:module";
-import path44 from "node:path";
+import path45 from "node:path";
 function testCallee(call) {
   let callee = call.callee;
   if (callee.type === "CallExpression")
@@ -92025,12 +92308,12 @@ function checkConstantsOnly(ctx, emit) {
 }
 function checkOverMocking(ctx, emit) {
   const { program } = ctx.parsed;
-  const unit = path44.basename(ctx.file).replace(/\.(?:[cm]?[jt]sx?)$/, "").replace(/\.(?:test|spec)$/, "");
+  const unit = 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 = path44.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",
@@ -92418,11 +92701,11 @@ var init_rules = __esm(() => {
 });
 
 // packages/workit-cli/src/test-audit/audit.ts
-import { spawnSync as spawnSync21 } 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 path45 from "node:path";
+import path46 from "node:path";
 function git6(cwd, args) {
-  const run = spawnSync21("git", ["-c", "core.quotepath=off", ...args], {
+  const run = spawnSync22("git", ["-c", "core.quotepath=off", ...args], {
     cwd,
     encoding: "utf8",
     maxBuffer: 64 * 1024 * 1024
@@ -92433,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 = path45.join(dir, entry.name);
+    const full = path46.join(dir, entry.name);
     if (entry.isDirectory()) {
       if (!SKIP_DIRS.has(entry.name))
         walkTests(full, out);
@@ -92445,7 +92728,7 @@ function expandPaths(cwd, inputs) {
   const files = [];
   const missing = [];
   for (const input of inputs.length > 0 ? inputs : ["."]) {
-    const full = path45.resolve(cwd, input);
+    const full = path46.resolve(cwd, input);
     if (!existsSync18(full))
       missing.push(input);
     else if (statSync7(full).isDirectory())
@@ -92482,11 +92765,11 @@ function changedLines(cwd, base) {
       for (let offset = 0;offset < count; offset += 1)
         lines.add(start + offset);
     }
-    changed.set(path45.join(root, file), lines);
+    changed.set(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(path45.join(root, file), "all");
+    changed.set(path46.join(root, file), "all");
   return changed;
 }
 function auditFiles(files, display) {
@@ -92548,7 +92831,7 @@ function auditFiles(files, display) {
     durationMs: Math.round(performance.now() - started)
   };
 }
-var TEST_FILE, CODE_FILE, SKIP_DIRS, toPosix = (file) => file.split(path45.sep).join("/"), SEVERITY_ORDER, ruleIds;
+var TEST_FILE, CODE_FILE, SKIP_DIRS, toPosix = (file) => file.split(path46.sep).join("/"), SEVERITY_ORDER, ruleIds;
 var init_audit = __esm(() => {
   init_ast();
   init_rules();
@@ -92578,7 +92861,7 @@ import {
   copyFileSync as copyFileSync6
 } from "node:fs";
 import os14 from "node:os";
-import path46 from "node:path";
+import path47 from "node:path";
 function mutantsFor(source, file, lines) {
   const parsed = parseSource(source, file);
   const out = [];
@@ -92651,7 +92934,7 @@ function relatedTests(source, testFiles) {
     for (const match of text.matchAll(SPECIFIER)) {
       const spec = match[1];
       if (spec.startsWith(".")) {
-        if (stripExt(path46.posix.join(path46.posix.dirname(file), spec)) === target)
+        if (stripExt(path47.posix.join(path47.posix.dirname(file), spec)) === target)
           return true;
       } else if (spec.includes("/") && stripExt(spec).split("/").slice(-2).join("/") === tail)
         return true;
@@ -92671,12 +92954,12 @@ function removeStaleCopies(tmp = os14.tmpdir()) {
   for (const name of names) {
     if (!name.startsWith(TEMP_PREFIX))
       continue;
-    const dir = path46.join(tmp, name);
+    const dir = path47.join(tmp, name);
     try {
       const stat = lstatSync7(dir);
       if (!stat.isDirectory() || uid !== undefined && stat.uid !== uid)
         continue;
-      const pid = Number(readFileSync20(path46.join(dir, PID_FILE), "utf8"));
+      const pid = Number(readFileSync20(path47.join(dir, PID_FILE), "utf8"));
       if (Number.isInteger(pid) && pid > 0 && alive(pid))
         continue;
     } catch (error) {
@@ -92693,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 = path46.join(origin, entry.name);
-    const to = path46.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;
@@ -92710,9 +92993,9 @@ function linkNodeModules(origin, target, repo, copy) {
       } catch {
         continue;
       }
-      const relative = path46.relative(repo, real);
-      if (!relative.startsWith("..") && !path46.isAbsolute(relative) && !relative.split(path46.sep).includes("node_modules")) {
-        symlinkSync(path46.join(copy, relative), to, "junction");
+      const relative = 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;
       }
     }
@@ -92728,7 +93011,7 @@ function copySymlink(repo, tree, from, to) {
   }
   const realRepo = realpathSync9(repo);
   if (real && inside2(realRepo, real)) {
-    symlinkSync(path46.relative(path46.dirname(to), path46.join(tree, path46.relative(realRepo, real))), to);
+    symlinkSync(path47.relative(path47.dirname(to), path47.join(tree, path47.relative(realRepo, real))), to);
     return;
   }
   if (real && statSync8(real).isFile())
@@ -92737,10 +93020,10 @@ function copySymlink(repo, tree, from, to) {
     symlinkSync(readlinkSync3(from), to);
 }
 function writeInside(copy, file, content) {
-  const target = path46.join(copy, file);
+  const target = path47.join(copy, file);
   try {
     const stat = lstatSync7(target);
-    if (!stat.isFile() || !inside2(realpathSync9(copy), realpathSync9(path46.dirname(target))))
+    if (!stat.isFile() || !inside2(realpathSync9(copy), realpathSync9(path47.dirname(target))))
       return false;
   } catch {
     return false;
@@ -92751,9 +93034,9 @@ function writeInside(copy, file, content) {
   return true;
 }
 function copyWorkingTree(repo) {
-  const dir = mkdtempSync4(path46.join(os14.tmpdir(), TEMP_PREFIX));
-  writeFileSync9(path46.join(dir, PID_FILE), String(process.pid));
-  const tree = path46.join(dir, "tree");
+  const dir = mkdtempSync4(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();
@@ -92770,29 +93053,29 @@ function copyWorkingTree(repo) {
   for (const relative of listed) {
     if (!relative)
       continue;
-    const from = path46.join(repo, relative);
+    const from = path47.join(repo, relative);
     let stat;
     try {
       stat = lstatSync7(from);
     } catch {
       continue;
     }
-    const to = path46.join(tree, relative);
-    mkdirSync9(path46.dirname(to), { recursive: true });
+    const to = 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 = path46.dirname(relative);
+    let parent = path47.dirname(relative);
     while (parent !== "." && !dirs.has(parent)) {
       dirs.add(parent);
-      parent = path46.dirname(parent);
+      parent = path47.dirname(parent);
     }
   }
   for (const parent of dirs) {
-    const modules = path46.join(repo, parent, "node_modules");
-    if (existsSync19(modules) && !existsSync19(path46.join(tree, parent, "node_modules")))
-      linkNodeModules(modules, path46.join(tree, parent, "node_modules"), repo, tree);
+    const modules = 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 };
 }
@@ -92831,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(path46.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(path46.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))
@@ -92852,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 = path46.relative(repo, options.cwd);
+  const cwdRelative = path47.relative(repo, options.cwd);
   const asArg = (file) => {
-    const relative = toPosix(path46.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(" "));
@@ -92889,7 +93172,7 @@ async function runMutation(options) {
     return finish2(options, 0, results, counts, started);
   removeStaleCopies();
   const { dir: copyDir, tree: copy } = copyWorkingTree(repo);
-  const copyCwd = path46.join(copy, cwdRelative);
+  const copyCwd = path47.join(copy, cwdRelative);
   let current = null;
   const restore = () => {
     if (current)
@@ -92924,7 +93207,7 @@ async function runMutation(options) {
         record({ ...mutant, status: "skipped", durationMs: 0, tests, reason: "budget" });
         continue;
       }
-      const original = readFileSync20(path46.join(copy, mutant.file), "utf8");
+      const original = readFileSync20(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)) {
@@ -92981,8 +93264,8 @@ var NOT_SOURCE, FLIPS, isStringy = (node) => node.type === "StringLiteral" || no
     return error.code === "EPERM";
   }
 }, inside2 = (root, file) => {
-  const relative = path46.relative(root, file);
-  return relative === "" || !relative.startsWith("..") && !path46.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")
@@ -93031,7 +93314,7 @@ __export(exports_test_audit, {
   run: () => run17
 });
 import { existsSync as existsSync20 } from "node:fs";
-import path47 from "node:path";
+import path48 from "node:path";
 function parse7(argv) {
   const options = {
     paths: [],
@@ -93131,8 +93414,8 @@ async function run17(argv, io) {
     return emit(io, fail("invalid_input", `${options}
 usage: ${USAGE10}`));
   const top = git6(io.cwd, ["rev-parse", "--show-toplevel"]);
-  const repo = top.ok ? path47.resolve(top.stdout.trim()) : null;
-  const display = (file) => toPosix(path47.relative(io.cwd, file) || file);
+  const repo = top.ok ? 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) {
@@ -93233,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 {
@@ -93340,14 +93655,14 @@ var init_youtrack_writes = __esm(() => {
 // packages/workit-cli/src/verbs/youtrack.ts
 var exports_youtrack = {};
 __export(exports_youtrack, {
-  run: () => run18
+  run: () => run19
 });
 import { readFileSync as readFileSync21 } from "node:fs";
-import path48 from "node:path";
-async function run18(argv, io) {
+import 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 ?? ""}"`, USAGE11);
+    return usage3(io, `unknown subcommand "${sub ?? ""}"`, USAGE12);
   const flags = parseFlags(rest, {
     markdown: "value",
     file: "value",
@@ -93356,18 +93671,18 @@ async function run18(argv, io) {
     date: "value"
   });
   if (typeof flags === "string")
-    return usage3(io, flags, USAGE11);
+    return usage3(io, flags, USAGE12);
   const [issueId, extra] = flags.positionals;
   if (!issueId || !ISSUE_RE2.test(issueId))
-    return usage3(io, "an issue id like ABC-123 is required", USAGE11);
+    return usage3(io, "an issue id like ABC-123 is required", USAGE12);
   if (extra !== undefined)
-    return usage3(io, `unexpected argument ${extra}`, USAGE11);
+    return usage3(io, `unexpected argument ${extra}`, USAGE12);
   const minutes = positiveInt(flags.values.minutes, "--minutes");
   if (typeof minutes === "string")
-    return usage3(io, minutes, USAGE11);
+    return usage3(io, minutes, USAGE12);
   const date = youTrackWorkDateMs(flags.values.date ?? "auto");
   if ("error" in date)
-    return usage3(io, date.error, USAGE11);
+    return usage3(io, date.error, USAGE12);
   const dateMs = date.data.dateMs;
   const markedDay = flags.values.date !== undefined && flags.values.date !== "auto" ? { dateMs } : {};
   const root = io.cwd;
@@ -93385,24 +93700,24 @@ async function run18(argv, io) {
   };
   if (sub === "note") {
     if (Boolean(flags.values.markdown) === Boolean(flags.values.file))
-      return usage3(io, "pass exactly one of --markdown or --file", USAGE11);
+      return usage3(io, "pass exactly one of --markdown or --file", USAGE12);
     let markdown = flags.values.markdown ?? "";
     if (flags.values.file)
       try {
-        markdown = readFileSync21(path48.resolve(io.cwd, flags.values.file), "utf8");
+        markdown = readFileSync21(path49.resolve(io.cwd, flags.values.file), "utf8");
       } catch (error) {
-        return usage3(io, `cannot read ${flags.values.file}: ${String(error)}`, USAGE11);
+        return usage3(io, `cannot read ${flags.values.file}: ${String(error)}`, USAGE12);
       }
     if (!markdown.trim())
-      return usage3(io, "the note is empty", USAGE11);
+      return usage3(io, "the note is empty", USAGE12);
     const missing = step("comment", "comments", { operation: "note", issueId, markdown }, markdown, async (text) => commentResult(await postComment(issueId, text, root))) ?? (minutes ? step("time", "workItems", { operation: "note.time", issueId, markdown, minutes, ...markedDay }, "workit update", (text) => logTimeUpdate({ issueId, minutes, text, dateMs, workspace_root: root })) : null);
     if (missing)
       return emit(io, fail("unavailable", missing));
   } else {
     if (!minutes)
-      return usage3(io, `${sub} needs --minutes <n>`, USAGE11);
+      return usage3(io, `${sub} needs --minutes <n>`, USAGE12);
     if (sub === "meeting" && !flags.values.text)
-      return usage3(io, "meeting needs --text <what the meeting was>", USAGE11);
+      return usage3(io, "meeting needs --text <what the meeting was>", USAGE12);
     const text = flags.values.text ?? "";
     const missing = step(sub, "workItems", { operation: sub, issueId, minutes, text, ...markedDay }, text, (marked) => logTimeUpdate({ issueId, minutes, text: marked, dateMs, workspace_root: root }));
     if (missing)
@@ -93431,7 +93746,7 @@ async function run18(argv, io) {
     ...data.steps.flatMap((entry) => entry.note ? [`  note (${entry.step}): ${entry.note}`] : [])
   ]);
 }
-var USAGE11 = "workit youtrack note <ISSUE> (--markdown <t> | --file <p>) [--minutes <n>] [--date auto|YYYY-MM-DD] | youtrack time <ISSUE> --minutes <n> [--text <t>] [--date …] | youtrack meeting <ISSUE> --minutes <n> --text <t> [--date …]", commentResult = (value) => {
+var USAGE12 = "workit youtrack note <ISSUE> (--markdown <t> | --file <p>) [--minutes <n>] [--date auto|YYYY-MM-DD] | youtrack time <ISSUE> --minutes <n> [--text <t>] [--date …] | youtrack meeting <ISSUE> --minutes <n> --text <t> [--date …]", commentResult = (value) => {
   try {
     return { ok: true, data: unwrap2(value) };
   } catch (error) {
@@ -93455,14 +93770,14 @@ var init_youtrack2 = __esm(() => {
 // packages/workit-cli/src/verbs/changelog.ts
 var exports_changelog = {};
 __export(exports_changelog, {
-  run: () => run19
+  run: () => run20
 });
 import { readFileSync as readFileSync22 } from "node:fs";
-import path49 from "node:path";
-async function run19(argv, io) {
+import path50 from "node:path";
+async function run20(argv, io) {
   const [sub, ...rest] = argv;
   if (sub !== "apply")
-    return usage3(io, `unknown subcommand "${sub ?? ""}"`, USAGE12);
+    return usage3(io, `unknown subcommand "${sub ?? ""}"`, USAGE13);
   const flags = parseFlags(rest, {
     entries: "value",
     path: "value",
@@ -93470,18 +93785,18 @@ async function run19(argv, io) {
     preview: "boolean"
   });
   if (typeof flags === "string")
-    return usage3(io, flags, USAGE12);
+    return usage3(io, flags, USAGE13);
   if (flags.positionals.length)
-    return usage3(io, `unexpected argument ${flags.positionals[0]}`, USAGE12);
+    return usage3(io, `unexpected argument ${flags.positionals[0]}`, USAGE13);
   const normalizeOnly = flags.booleans.has("normalize-only");
   if (!normalizeOnly && !flags.values.entries)
-    return usage3(io, "pass --entries <JSON> or --normalize-only", USAGE12);
+    return usage3(io, "pass --entries <JSON> or --normalize-only", USAGE13);
   let entries;
   if (flags.values.entries)
     try {
       entries = readEntries(flags.values.entries, io.cwd);
     } catch (error) {
-      return usage3(io, `--entries is not valid JSON: ${String(error)}`, USAGE12);
+      return usage3(io, `--entries is not valid JSON: ${String(error)}`, USAGE13);
     }
   const input = {
     entries,
@@ -93503,8 +93818,8 @@ async function run19(argv, io) {
     `changelog updated: ${String(applied.path ?? "CHANGELOG.md")}`
   ]);
 }
-var USAGE12 = "workit changelog apply (--entries <JSON|@file|-> | --normalize-only) [--path CHANGELOG.md] [--preview]", readEntries = (raw, cwd) => {
-  const text = raw === "-" ? readFileSync22(0, "utf8") : raw.startsWith("@") ? readFileSync22(path49.resolve(cwd, raw.slice(1)), "utf8") : raw;
+var USAGE13 = "workit changelog apply (--entries <JSON|@file|-> | --normalize-only) [--path CHANGELOG.md] [--preview]", readEntries = (raw, cwd) => {
+  const text = raw === "-" ? readFileSync22(0, "utf8") : raw.startsWith("@") ? readFileSync22(path50.resolve(cwd, raw.slice(1)), "utf8") : raw;
   return JSON.parse(text);
 };
 var init_changelog2 = __esm(() => {
@@ -93516,7 +93831,7 @@ var init_changelog2 = __esm(() => {
 // packages/workit-cli/src/verbs/handoff.ts
 var exports_handoff = {};
 __export(exports_handoff, {
-  run: () => run20
+  run: () => run21
 });
 import { parseArgs as parseArgs2 } from "node:util";
 function human2(brief) {
@@ -93564,11 +93879,11 @@ async function resumeBrief(argv, io) {
       strict: true
     }));
   } catch (error) {
-    return emit(io, fail("invalid_input", error.message, { unblock: USAGE13 }));
+    return emit(io, fail("invalid_input", error.message, { unblock: USAGE14 }));
   }
   const last = values.last === undefined ? 10 : Number(values.last);
   if (!Number.isInteger(last) || last < 1)
-    return emit(io, fail("invalid_input", "--last must be a positive integer", { unblock: USAGE13 }));
+    return emit(io, fail("invalid_input", "--last must be a positive integer", { unblock: USAGE14 }));
   const built = buildHandoff(io.cwd, {
     last,
     note: values.note ?? null,
@@ -93586,13 +93901,13 @@ async function resumeBrief(argv, io) {
   }
   return emit(io, ok({ ...data, recorded }), human2);
 }
-async function run20(argv, io) {
+async function run21(argv, io) {
   if (!argv.includes("--task"))
     return resumeBrief(argv, io);
   await Promise.resolve().then(() => init_task());
   return runTaskCommand(["handoff", ...argv]);
 }
-var USAGE13 = "workit handoff [--note <text>] [--next <text>] [--record] [--last <n>] [--json]", short5 = (sha) => sha ? sha.slice(0, 12) : "no commit";
+var USAGE14 = "workit handoff [--note <text>] [--next <text>] [--record] [--last <n>] [--json]", short5 = (sha) => sha ? sha.slice(0, 12) : "no commit";
 var init_handoff = __esm(() => {
   init_ledger();
   init_output();
@@ -93601,7 +93916,7 @@ var init_handoff = __esm(() => {
 // packages/workit-cli/src/main.ts
 init_package();
 init_output();
-import path50 from "node:path";
+import path51 from "node:path";
 
 // packages/workit-cli/src/verbs/registry.ts
 var TASK_FAMILY_NAMES = [
@@ -93734,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",
@@ -93838,7 +94160,7 @@ var defaultIo = (json) => ({
 });
 async function main(argv, overrides = {}, options = {}) {
   const parsed = parseGlobals(argv);
-  const cwd = path50.resolve(overrides.cwd ?? process.cwd(), parsed.cwd ?? ".");
+  const cwd = 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));