@geonosis/ledger 1.0.0

package/dist/chunk-WI3N5B3J.js

@@ -0,0 +1,1538 @@
+// src/args.ts
+var parseArgs = (argv, valued) => {
+  const flags = {};
+  const positional = [];
+  const switches = /* @__PURE__ */ new Set();
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index] ?? "";
+    if (!token.startsWith("--")) {
+      positional.push(token);
+      continue;
+    }
+    const inline = token.indexOf("=");
+    if (inline !== -1) {
+      const name = token.slice(0, inline);
+      if (!valued.has(name)) throw new Error(`${name} takes no value`);
+      flags[name] = token.slice(inline + 1);
+      continue;
+    }
+    if (!valued.has(token)) {
+      switches.add(token);
+      continue;
+    }
+    const value = argv[index + 1];
+    if (value === void 0) throw new Error(`${token} needs a value`);
+    flags[token] = value;
+    index += 1;
+  }
+  return { flags, positional, switches };
+};
+var required = (args, flag) => {
+  const value = args.flags[flag];
+  if (value === void 0 || value === "") throw new Error(`${flag} is required`);
+  return value;
+};
+var rejectUnknownSwitches = (args, known) => {
+  for (const one of args.switches) {
+    if (!known.has(one)) throw new Error(`unknown argument "${one}"`);
+  }
+};
+
+// src/config.ts
+import { existsSync, readFileSync } from "fs";
+import { resolve } from "path";
+var RUNTIME_DEFAULT = {
+  exclude: [
+    "\\.(?:test|spec)\\.",
+    "\\.stories\\.",
+    "\\.d\\.ts$",
+    "(?:^|/)(?:__tests__|__mocks__|__fixtures__|__snapshots__|__perf__)/",
+    "(?:^|/)(?:docs?|tests?|e2e)/",
+    "(?:^|/)\\.[^/]+/"
+  ],
+  include: ["\\.(?:ts|tsx|js|jsx|mjs|cjs|mts|cts|css|scss|sass|less|svg|vue|svelte|astro)$"]
+};
+var PLAN_DEFAULT = {
+  criteria: "^- When .+ shall .+",
+  // `\b`, not `$`: real plans qualify the heading — "## Acceptance criteria (EARS)" is what all 21
+  // of this repo's carry, and anchoring to end-of-line reported every one of them as missing it.
+  criteriaHeading: "^#{2,3} +Acceptance criteria\\b",
+  // The capture group, when there is one, is the STATUS WORD — what `status` and `handoff` group
+  // plans by. A pattern with no group still validates; those plans simply have no named status.
+  statusHeader: "^> \\*\\*Status\\*\\*: *(\\S+)",
+  verificationHeading: "^#{2,3} +Verification\\b"
+};
+var LEDGER_DEFAULT = {
+  agents: "AGENTS.md",
+  architecture: "docs/architecture.md",
+  // Subject plus three body lines. A delivery whose message needs a fourth is a delivery that
+  // should have been two, or a paragraph that belongs in a proof file.
+  commitMessageLines: 4,
+  decisions: "docs/decisions.md",
+  handoff: "HANDOFF.md",
+  journal: "docs/journal/fallbacks.md",
+  law: "CLAUDE.md",
+  // The heading, not the whole file: AGENTS.md carries the rules, and a copy of the law is a
+  // second law. `\\b` rather than `$` for the same reason `criteriaHeading` uses it — real
+  // headings are qualified.
+  lawSection: "^#{2,3} +The laws\\b",
+  maxLines: 200,
+  plan: PLAN_DEFAULT,
+  plans: "plans",
+  progress: "plans/PROGRESS.md",
+  proofs: "proofs",
+  rules: ".claude/rules",
+  runtime: RUNTIME_DEFAULT,
+  skills: ".claude/skills"
+};
+var PATH_KEYS = [
+  "agents",
+  "architecture",
+  "decisions",
+  "handoff",
+  "journal",
+  "law",
+  "plans",
+  "progress",
+  "proofs",
+  "rules",
+  "skills"
+];
+var NUMBER_KEYS = ["commitMessageLines", "maxLines"];
+var KNOWN = /* @__PURE__ */ new Set([...PATH_KEYS, ...NUMBER_KEYS, "lawSection", "plan", "runtime"]);
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var compileAll = (patterns, where) => {
+  for (const pattern of patterns) {
+    try {
+      RegExp(pattern);
+    } catch {
+      throw new Error(`${where}: "${pattern}" is not a regular expression`);
+    }
+  }
+};
+var readPatterns = (value, fallback, where) => {
+  if (value === void 0) return fallback;
+  if (!isRecord(value)) throw new Error(`${where} must be an object with include/exclude`);
+  const read = (key) => {
+    const raw = value[key];
+    if (raw === void 0) return fallback[key];
+    if (!Array.isArray(raw) || raw.some((one) => typeof one !== "string")) {
+      throw new Error(`${where}.${key} must be a list of regular expressions`);
+    }
+    const list = raw;
+    compileAll(list, `${where}.${key}`);
+    return list;
+  };
+  return { exclude: read("exclude"), include: read("include") };
+};
+var readPlan = (value) => {
+  if (value === void 0) return PLAN_DEFAULT;
+  if (!isRecord(value)) throw new Error("ledger.plan must be an object");
+  const out = { ...PLAN_DEFAULT };
+  for (const key of Object.keys(value)) {
+    if (!(key in PLAN_DEFAULT)) {
+      throw new Error(`ledger.plan.${key} is not a key of the plan contract`);
+    }
+    const pattern = value[key];
+    if (typeof pattern !== "string") throw new Error(`ledger.plan.${key} must be a string`);
+    compileAll([pattern], `ledger.plan.${key}`);
+    out[key] = pattern;
+  }
+  return out;
+};
+var loadLedgerConfig = (root) => {
+  const file = resolve(root, "geonosis.json");
+  if (!existsSync(file)) return LEDGER_DEFAULT;
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(file, "utf8"));
+  } catch (error) {
+    throw new Error(`geonosis.json is not valid JSON: ${error.message}`, {
+      cause: error
+    });
+  }
+  if (!isRecord(parsed)) throw new Error("geonosis.json must hold an object");
+  const block = parsed["ledger"];
+  if (block === void 0) return LEDGER_DEFAULT;
+  if (!isRecord(block)) throw new Error("ledger must be an object");
+  for (const key of Object.keys(block)) {
+    if (!KNOWN.has(key)) throw new Error(`ledger.${key} is not a key of the ledger block`);
+  }
+  const config = { ...LEDGER_DEFAULT };
+  for (const key of PATH_KEYS) {
+    const value = block[key];
+    if (value === void 0) continue;
+    if (typeof value !== "string") throw new Error(`ledger.${key} must be a path`);
+    config[key] = value;
+  }
+  for (const key of NUMBER_KEYS) {
+    const value = block[key];
+    if (value === void 0) continue;
+    if (typeof value !== "number" || !Number.isInteger(value) || value < 1) {
+      throw new Error(`ledger.${key} must be a whole number of at least 1`);
+    }
+    config[key] = value;
+  }
+  const section = block["lawSection"];
+  if (section !== void 0) {
+    if (typeof section !== "string") throw new Error("ledger.lawSection must be a string");
+    compileAll([section], "ledger.lawSection");
+    config.lawSection = section;
+  }
+  config.plan = readPlan(block["plan"]);
+  config.runtime = readPatterns(block["runtime"], RUNTIME_DEFAULT, "ledger.runtime");
+  return config;
+};
+var ledgerOwned = (config) => [
+  config.architecture,
+  config.decisions,
+  config.handoff,
+  config.journal,
+  config.plans,
+  config.progress,
+  config.proofs
+];
+var matchesRuntime = (file, runtime) => {
+  const path = file.replaceAll("\\", "/");
+  if (!runtime.include.some((pattern) => new RegExp(pattern).test(path))) return false;
+  return !runtime.exclude.some((pattern) => new RegExp(pattern).test(path));
+};
+
+// src/markdown.ts
+var HEADING = /^(#{1,6}) +(.*)$/;
+var headingsOf = (lines2) => {
+  const found = [];
+  let fenced = false;
+  for (const [index, line] of lines2.entries()) {
+    if (line.startsWith("```") || line.startsWith("~~~")) fenced = !fenced;
+    if (fenced) continue;
+    const match = HEADING.exec(line);
+    if (match?.[1] !== void 0 && match[2] !== void 0) {
+      found.push({ depth: match[1].length, index, text: match[2].trim() });
+    }
+  }
+  return found;
+};
+var sectionUnder = (lines2, pattern) => {
+  const test = new RegExp(pattern);
+  const headings = headingsOf(lines2);
+  const at = headings.find((heading) => test.test(lines2[heading.index] ?? ""));
+  if (at === void 0) return void 0;
+  const next = headings.find((heading) => heading.index > at.index && heading.depth <= at.depth);
+  return lines2.slice(at.index + 1, next?.index ?? lines2.length);
+};
+var cellsOf = (line) => line.trim().replace(/^\|/, "").replace(/\|$/, "").split("|").map((cell2) => cell2.trim());
+var isDivider = (line) => /^\|?[\s:|-]+\|[\s:|-]*$/.test(line.trim()) && line.includes("-");
+var firstTable = (lines2) => {
+  for (const [index, line] of lines2.entries()) {
+    if (!line.trim().startsWith("|")) continue;
+    const divider = lines2[index + 1];
+    if (divider === void 0 || !isDivider(divider)) continue;
+    const rows = [];
+    for (let at = index + 2; at < lines2.length; at += 1) {
+      const row = lines2[at];
+      if (row === void 0) break;
+      if (row.trim() === "") {
+        if (lines2[at + 1]?.trim().startsWith("|") !== true) break;
+        continue;
+      }
+      if (!row.trim().startsWith("|")) break;
+      rows.push(at);
+    }
+    return { align: divider, header: cellsOf(line), headerIndex: index, rows };
+  }
+  return void 0;
+};
+var rowCells = (line) => cellsOf(line);
+var plainCell = (cell2) => cell2.replace(/^\*\*(.*)\*\*$/, "$1").replaceAll("`", "").trim();
+var renderRow = (cells) => `| ${cells.join(" | ")} |`;
+
+// src/plan.ts
+import { existsSync as existsSync2, mkdirSync, readdirSync, readFileSync as readFileSync2, statSync, writeFileSync } from "fs";
+import { basename, join, relative, resolve as resolve2 } from "path";
+var PLAN_FILE = /^(\d{3,})-([a-z\d][a-z\d.-]*)\.md$/;
+var planFilesIn = (dir) => readdirSync(dir).filter((name) => PLAN_FILE.test(name)).toSorted().map((name) => join(dir, name));
+var numberOf = (file) => Number(PLAN_FILE.exec(basename(file))?.[1] ?? Number.NaN);
+var headingName = (pattern) => pattern.replace(/^\^?#\{[\d,]+\} ?\+? ?/, "").replace(/\\b.*$/, "").replace(/ ?\*?\$$/, "").replaceAll("\\", "").trim();
+var violationsOf = (file, body, config) => {
+  const lines2 = body.split("\n");
+  const found = [];
+  const { criteria, criteriaHeading, statusHeader, verificationHeading } = config.plan;
+  const status = new RegExp(statusHeader);
+  if (!lines2.some((line) => status.test(line))) found.push(`${file}: no status header`);
+  const criteriaSection = sectionUnder(lines2, criteriaHeading);
+  if (criteriaSection === void 0) {
+    found.push(`${file}: no "${headingName(criteriaHeading)}" heading`);
+  } else if (!criteriaSection.some((line) => new RegExp(criteria).test(line))) {
+    found.push(`${file}: no EARS criterion under "${headingName(criteriaHeading)}"`);
+  }
+  if (sectionUnder(lines2, verificationHeading) === void 0) {
+    found.push(`${file}: no "${headingName(verificationHeading)}" heading`);
+  }
+  return found;
+};
+var checkPlans = ({ config, root, since, target }) => {
+  const where = resolve2(root, target ?? config.plans);
+  if (!existsSync2(where)) throw new Error(`${target ?? config.plans}: no such file or directory`);
+  const files = statSync(where).isDirectory() ? planFilesIn(where) : [where];
+  const legacy = [];
+  const violations = [];
+  let checked = 0;
+  for (const file of files) {
+    const named = relative(root, file).replaceAll("\\", "/");
+    if (since !== void 0 && numberOf(file) < since) {
+      legacy.push(named);
+      continue;
+    }
+    checked += 1;
+    violations.push(...violationsOf(named, readFileSync2(file, "utf8"), config));
+  }
+  return { checked, legacy, violations };
+};
+var planStatuses = ({
+  config,
+  root
+}) => {
+  const dir = resolve2(root, config.plans);
+  if (!existsSync2(dir)) return [];
+  const test = new RegExp(config.plan.statusHeader);
+  return planFilesIn(dir).map((file) => {
+    const found = readFileSync2(file, "utf8").split("\n").map((line) => test.exec(line)).find((match) => match !== null);
+    return {
+      file: relative(root, file).replaceAll("\\", "/"),
+      status: found?.[1] ?? (found === void 0 ? "UNDECLARED" : "\u2014")
+    };
+  });
+};
+var nextNumber = (dir) => {
+  const highest = existsSync2(dir) ? planFilesIn(dir).reduce((most, file) => Math.max(most, numberOf(file)), 0) : 0;
+  return String(highest + 1).padStart(3, "0");
+};
+var KEBAB = /^[a-z\d][a-z\d-]*$/;
+var newPlan = ({
+  config,
+  root,
+  slug
+}) => {
+  if (!KEBAB.test(slug)) throw new Error(`"${slug}" is not a kebab-case slug`);
+  const dir = resolve2(root, config.plans);
+  mkdirSync(dir, { recursive: true });
+  const taken = planFilesIn(dir).find((file) => PLAN_FILE.exec(basename(file))?.[2] === slug);
+  if (taken !== void 0) {
+    throw new Error(`${relative(root, taken).replaceAll("\\", "/")} already has this slug`);
+  }
+  const number = nextNumber(dir);
+  const named = `${number}-${slug}.md`;
+  const body = [
+    `# Plan ${number}: ${slug.replaceAll("-", " ")}`,
+    "",
+    "> **Status**: DRAFT \xB7 **Milestone**: \u2014",
+    "",
+    "## Acceptance criteria",
+    "",
+    "<!-- Replace this line with EARS criteria. `plan check` refuses until you do. -->",
+    "",
+    "## Verification",
+    "",
+    "<!-- The commands that decide it, and what their output has to be. -->",
+    ""
+  ].join("\n");
+  writeFileSync(join(dir, named), body);
+  return `${relative(root, dir).replaceAll("\\", "/")}/${named}`;
+};
+
+// src/rows.ts
+import { appendFileSync, existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3 } from "fs";
+import { dirname, resolve as resolve3 } from "path";
+var isoDate = (now) => now.toISOString().slice(0, 10);
+var cell = (text) => text.replaceAll("|", "\\|").replaceAll("\n", " ").trim();
+var appendRow = (file, root, header, cells) => {
+  const at = resolve3(root, file);
+  mkdirSync2(dirname(at), { recursive: true });
+  const row = `| ${cells.map((one) => cell(one)).join(" | ")} |
+`;
+  if (!existsSync3(at)) {
+    const divider = header.map(() => "---").join(" | ");
+    appendFileSync(at, `| ${header.join(" | ")} |
+| ${divider} |
+${row}`);
+    return row;
+  }
+  const body = readFileSync3(at, "utf8");
+  appendFileSync(at, body.endsWith("\n") ? row : `
+${row}`);
+  return row;
+};
+
+// src/journal.ts
+var FALLBACK_KINDS = ["stub", "mock", "guess", "skip"];
+var JOURNAL_HEADER = ["date", "kind", "where", "why"];
+var WHERE = /^\S+:\d+$/;
+var appendFallback = ({ config, kind, now, root, where, why }) => {
+  if (!FALLBACK_KINDS.includes(kind)) {
+    throw new Error(`"${kind}" is not a fallback kind \u2014 one of ${FALLBACK_KINDS.join(", ")}`);
+  }
+  if (!WHERE.test(where.trim())) throw new Error(`"${where}" is not a path:line`);
+  if (why.trim() === "") throw new Error("why is required \u2014 an unexplained fallback is invisible");
+  return appendRow(config.journal, root, JOURNAL_HEADER, [isoDate(now), kind, where.trim(), why]);
+};
+
+// src/git.ts
+import { spawnSync } from "child_process";
+var git = (args, cwd) => {
+  const done = spawnSync("git", args, { cwd, encoding: "utf8" });
+  if (done.error !== void 0) throw done.error;
+  return { code: done.status ?? -1, stderr: done.stderr ?? "", stdout: done.stdout ?? "" };
+};
+var lines = (out) => out.split("\n").map((line) => line.trim()).filter((line) => line !== "");
+var commitHash = (ref, cwd) => {
+  const done = git(["rev-parse", "--verify", "--quiet", `${ref}^{commit}`], cwd);
+  return done.code === 0 ? done.stdout.trim() : void 0;
+};
+var filesChangedBy = (hash, cwd) => {
+  const parent = git(["rev-parse", "--verify", "--quiet", `${hash}~1^{commit}`], cwd);
+  if (parent.code === 0) return lines(git(["diff", "--name-only", `${hash}~1`, hash], cwd).stdout);
+  return lines(
+    git(["diff-tree", "--root", "--no-commit-id", "--name-only", "-r", hash], cwd).stdout
+  );
+};
+var patchOf = (hash, cwd) => {
+  const parent = git(["rev-parse", "--verify", "--quiet", `${hash}~1^{commit}`], cwd);
+  if (parent.code === 0) {
+    return git(["diff", "-U0", "--no-color", `${hash}~1`, hash], cwd);
+  }
+  return git(["diff-tree", "--root", "-p", "-U0", "--no-color", "-r", hash], cwd);
+};
+var stagedPatch = (cwd) => git(["diff", "--cached", "-U0", "--no-color"], cwd);
+var porcelain = (cwd) => git(["status", "--porcelain"], cwd).stdout.split("\n").filter((line) => line.trim() !== "");
+var headOf = (cwd) => {
+  const done = git(["log", "-1", "--format=%H%n%s"], cwd);
+  if (done.code !== 0) return void 0;
+  const [hash, subject] = done.stdout.split("\n");
+  if (hash === void 0 || hash.trim() === "") return void 0;
+  return { hash: hash.trim(), subject: (subject ?? "").trim() };
+};
+var messageOf = (ref, cwd) => {
+  const done = git(["log", "-1", "--format=%B", ref], cwd);
+  return done.code === 0 ? done.stdout : void 0;
+};
+var isRepo = (cwd) => git(["rev-parse", "--is-inside-work-tree"], cwd).stdout.trim() === "true";
+
+// src/proof.ts
+import { spawnSync as spawnSync2 } from "child_process";
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, readdirSync as readdirSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join2, resolve as resolve4 } from "path";
+var KEBAB2 = /^[a-z\d][a-z\d-]*$/;
+var NUMBERED = /^(\d{3,})-/;
+var nextNumber2 = (dir) => {
+  const highest = existsSync4(dir) ? readdirSync2(dir).reduce(
+    (most, name) => Math.max(most, Number(NUMBERED.exec(name)?.[1] ?? 0)),
+    0
+  ) : 0;
+  return String(highest + 1).padStart(3, "0");
+};
+var bound = (output, maxLines) => {
+  const lines2 = output.split("\n");
+  if (lines2.length <= maxLines) return output;
+  const dropped = lines2.length - maxLines;
+  return `${lines2.slice(0, maxLines).join("\n")}
+\u2026 ${dropped} more line${dropped === 1 ? "" : "s"}`;
+};
+var captureProof = ({ command, config, root, slug, url }) => {
+  if (!KEBAB2.test(slug)) throw new Error(`"${slug}" is not a kebab-case slug`);
+  const dir = resolve4(root, config.proofs);
+  mkdirSync3(dir, { recursive: true });
+  const file = `${nextNumber2(dir)}-${slug}.md`;
+  const done = spawnSync2(command, { cwd: root, encoding: "utf8", shell: true });
+  const exitCode = done.status ?? -1;
+  const head = headOf(root);
+  const output = `${done.stdout ?? ""}${done.stderr ?? ""}`;
+  const body = [
+    `# proof \u2014 ${slug}`,
+    "",
+    `- **HEAD**: \`${head?.hash ?? "no commit"}\` \u2014 ${head?.subject ?? "\u2014"}`,
+    `- **Command**: \`${command}\``,
+    ...url === void 0 ? [] : [`- **URL**: ${url}`],
+    `- **Result**: exit ${exitCode}`,
+    "",
+    "```",
+    bound(output.replace(/\n$/, ""), config.maxLines),
+    "```",
+    ""
+  ].join("\n");
+  writeFileSync2(join2(dir, file), body);
+  return { exitCode, file: `${config.proofs}/${file}` };
+};
+
+// src/delivery.ts
+var SCISSORS = "# ------------------------ >8 ------------------------";
+var TRAILER = /^[A-Za-z][\dA-Za-z-]*: \S/;
+var countedLines = (message) => {
+  const cut = message.indexOf(SCISSORS);
+  const kept = (cut === -1 ? message : message.slice(0, cut)).split("\n").filter((line) => !line.startsWith("#")).map((line) => line.trimEnd());
+  while (kept.length > 0 && (kept.at(-1) ?? "").trim() === "") kept.pop();
+  while (kept.length > 1 && TRAILER.test(kept.at(-1) ?? "")) kept.pop();
+  return kept.filter((line) => line.trim() !== "");
+};
+var checkCommitMessage = (message, config) => {
+  const lines2 = countedLines(message);
+  if (lines2.length === 0) return { refusal: "the commit message is empty" };
+  if (lines2.length <= config.commitMessageLines) return {};
+  return {
+    refusal: `the commit message is ${lines2.length} line(s); ledger.commitMessageLines is ${config.commitMessageLines} (subject + ${config.commitMessageLines - 1} body). Put the rest in a proof file, or split the commit.`
+  };
+};
+var COMMENTS = [
+  {
+    comments: { block: ["/*", "*/", "*", "{/*", "*/}"], line: ["//"] },
+    extensions: [
+      "c",
+      "cc",
+      "cpp",
+      "cjs",
+      "cts",
+      "go",
+      "h",
+      "java",
+      "js",
+      "jsx",
+      "kt",
+      "less",
+      "mjs",
+      "mts",
+      "rs",
+      "scss",
+      "swift",
+      "ts",
+      "tsx"
+    ]
+  },
+  { comments: { block: ["/*", "*/", "*"], line: [] }, extensions: ["css"] },
+  {
+    comments: { block: [], line: ["#"] },
+    extensions: [
+      "bash",
+      "cfg",
+      "conf",
+      "env",
+      "gitignore",
+      "ini",
+      "mk",
+      "properties",
+      "py",
+      "rb",
+      "sh",
+      "toml",
+      "zsh"
+    ]
+  },
+  { comments: { block: [], line: ["#"] }, extensions: ["yaml", "yml"] },
+  {
+    comments: { block: ["<!--", "-->"], line: [] },
+    extensions: ["astro", "html", "md", "mdx", "svelte", "svg", "vue", "xml"]
+  },
+  { comments: { block: ["/*", "*/", "*"], line: ["--"] }, extensions: ["sql"] }
+];
+var BY_NAME = {
+  dockerfile: { block: [], line: ["#"] },
+  makefile: { block: [], line: ["#"] }
+};
+var commentsFor = (file) => {
+  const name = (file.split("/").at(-1) ?? "").toLowerCase();
+  const byName = BY_NAME[name];
+  if (byName !== void 0) return byName;
+  const extension = name.includes(".") ? name.split(".").at(-1) ?? "" : "";
+  return COMMENTS.find((one) => one.extensions.includes(extension))?.comments;
+};
+var isCommentary = (line, comments) => {
+  const text = line.trim();
+  if (text === "") return true;
+  if (comments === void 0) return false;
+  return [...comments.line, ...comments.block].some((token) => text.startsWith(token));
+};
+var FILE_LINE = /^\+\+\+ b\/(.*)$/;
+var checkDelivery = ({ commit, root, staged }) => {
+  const done = staged ? stagedPatch(root) : patchOf(commit ?? "HEAD", root);
+  if (done.code !== 0) return { refusal: `the diff could not be read: ${done.stderr.trim()}` };
+  let file = "";
+  let comments;
+  let changed = 0;
+  const commentary = [];
+  const code = [];
+  for (const line of done.stdout.split("\n")) {
+    const named = FILE_LINE.exec(line);
+    if (named?.[1] !== void 0) {
+      file = named[1];
+      comments = commentsFor(file);
+      continue;
+    }
+    if (line.startsWith("+++") || line.startsWith("---") || line.startsWith("@@")) continue;
+    if (!line.startsWith("+") && !line.startsWith("-")) continue;
+    changed += 1;
+    const body = line.slice(1);
+    if (isCommentary(body, comments)) commentary.push(file);
+    else code.push(file);
+  }
+  if (changed === 0) return { refusal: "the diff changes nothing at all" };
+  if (code.length > 0) return {};
+  return {
+    refusal: `every changed line is a comment or whitespace \u2014 that is not a delivery. Files: ${[...new Set(commentary)].join(", ")}`
+  };
+};
+
+// src/tick.ts
+import { existsSync as existsSync5, readdirSync as readdirSync3, readFileSync as readFileSync4 } from "fs";
+import { resolve as resolve5 } from "path";
+var PROGRESS_HEADER = ["tick", "date", "plan", "commit", "proof", "note"];
+var planFileFor = (number, dir) => {
+  if (!existsSync5(dir)) return void 0;
+  const padded = number.padStart(3, "0");
+  return readdirSync3(dir).find((name) => name.startsWith(`${padded}-`) && name.endsWith(".md"));
+};
+var nextTick = (file) => {
+  if (!existsSync5(file)) return 1;
+  return readFileSync4(file, "utf8").split("\n").reduce((most, line) => {
+    const first = /^\| *(\d+) *\|/.exec(line)?.[1];
+    return first === void 0 ? most : Math.max(most, Number(first) + 1);
+  }, 1);
+};
+var runTick = ({
+  commit,
+  config,
+  note,
+  now,
+  plan,
+  proof,
+  root
+}) => {
+  if (!isRepo(root)) throw new Error(`${root} is not a git repository`);
+  const hash = commitHash(commit, root);
+  if (hash === void 0) return { refusal: `${commit} is not a commit` };
+  const plansDir = resolve5(root, config.plans);
+  const planFile = planFileFor(plan, plansDir);
+  if (planFile === void 0) return { refusal: `no plan ${plan} in ${config.plans}` };
+  const report = checkPlans({ config, root, target: `${config.plans}/${planFile}` });
+  if (report.violations.length > 0) {
+    return { refusal: `plan ${plan} does not pass plan check:
+${report.violations.join("\n")}` };
+  }
+  if (!existsSync5(resolve5(root, proof))) return { refusal: `${proof} does not exist` };
+  const changed = filesChangedBy(hash, root);
+  const owned = ledgerOwned(config);
+  const runtime = changed.filter(
+    (file) => !owned.some((one) => file === one || file.startsWith(`${one.replace(/\/$/, "")}/`)) && matchesRuntime(file, config.runtime)
+  );
+  if (runtime.length === 0) {
+    return {
+      refusal: `${hash.slice(0, 8)} ships no runtime code (G0). Its diff:
+${changed.map((file) => `  ${file}`).join("\n")}`
+    };
+  }
+  const written = checkCommitMessage(messageOf(hash, root) ?? "", config);
+  if (written.refusal !== void 0) return { refusal: written.refusal };
+  const delivered = checkDelivery({ commit: hash, root, staged: false });
+  if (delivered.refusal !== void 0) return { refusal: delivered.refusal };
+  const number = nextTick(resolve5(root, config.progress));
+  const row = appendRow(config.progress, root, PROGRESS_HEADER, [
+    String(number),
+    isoDate(now),
+    plan,
+    hash.slice(0, 8),
+    proof,
+    note ?? "\u2014"
+  ]);
+  return { number, row };
+};
+
+// src/decide.ts
+import { existsSync as existsSync6, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "fs";
+import { resolve as resolve6 } from "path";
+var REVISIT_COLUMN = "Revisit trigger";
+var ID = /^D-\d{3,}$/;
+var FOR = [
+  { key: "id", prefix: "id" },
+  { key: "text", prefix: "decision" },
+  { key: "status", prefix: "status" },
+  { key: "why", prefix: "why" },
+  { key: "evidence", prefix: "evidence" },
+  { key: "revisit", prefix: "revisit" }
+];
+var normal = (heading) => heading.toLowerCase().replaceAll(/[^a-z]/g, "");
+var runDecide = ({
+  config,
+  evidence,
+  id,
+  revisit,
+  root,
+  status,
+  text,
+  why
+}) => {
+  if (!ID.test(id.trim())) return { refusal: `"${id}" is not an id of the form D-NNN` };
+  if (revisit.trim() === "") {
+    return {
+      refusal: "a decision needs a revisit trigger \u2014 the event that reopens it. A register without one is a diary, not an instrument (C10)."
+    };
+  }
+  const at = resolve6(root, config.decisions);
+  if (!existsSync6(at)) return { refusal: `${config.decisions} does not exist` };
+  const body = readFileSync5(at, "utf8");
+  const lines2 = body.split("\n");
+  const table = firstTable(lines2);
+  if (table === void 0) return { refusal: `${config.decisions} has no table in it` };
+  const columns = table.header.map((heading) => normal(heading));
+  if (!columns.some((heading) => heading.startsWith("revisit"))) {
+    return {
+      refusal: `${config.decisions} has no "${REVISIT_COLUMN}" column (C10). Its header has to become:
+${renderRow([...table.header, REVISIT_COLUMN])}`
+    };
+  }
+  const taken = table.rows.find((index) => rowCells(lines2[index] ?? "")[0]?.trim() === id.trim());
+  if (taken !== void 0) return { refusal: `${config.decisions} already carries ${id}` };
+  const values = {
+    evidence,
+    id: id.trim(),
+    revisit,
+    status: status ?? "\u2014",
+    text,
+    why
+  };
+  const cells = columns.map((heading) => {
+    const found = FOR.find((one) => heading.startsWith(one.prefix));
+    return cell(found === void 0 ? "\u2014" : values[found.key] ?? "\u2014");
+  });
+  const row = renderRow(cells);
+  const last = table.rows.at(-1) ?? table.headerIndex + 1;
+  writeFileSync3(at, [...lines2.slice(0, last + 1), row, ...lines2.slice(last + 1)].join("\n"));
+  return { row };
+};
+
+// src/gate-report.ts
+import { existsSync as existsSync7, readFileSync as readFileSync6 } from "fs";
+import { resolve as resolve7 } from "path";
+var GATE_REPORT = ".geonosis/gate-report.json";
+var isRecord2 = (value) => typeof value === "object" && value !== null;
+var gateSummary = (root) => {
+  const at = resolve7(root, GATE_REPORT);
+  if (!existsSync7(at)) return void 0;
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync6(at, "utf8"));
+  } catch {
+    return void 0;
+  }
+  if (!isRecord2(parsed)) return void 0;
+  return {
+    finishedAt: typeof parsed["finishedAt"] === "string" ? parsed["finishedAt"] : "\u2014",
+    ok: parsed["ok"] === true,
+    tier: typeof parsed["tier"] === "string" ? parsed["tier"] : "\u2014"
+  };
+};
+var BASELINE_DEFAULT = "gate-baseline.json";
+var stringAt = (value, key) => {
+  if (!isRecord2(value)) return void 0;
+  const found = value[key];
+  return typeof found === "string" ? found : void 0;
+};
+var baselineKeyCount = (root) => {
+  const named = (() => {
+    const config = resolve7(root, "geonosis.json");
+    if (existsSync7(config)) {
+      try {
+        const ratchet = JSON.parse(readFileSync6(config, "utf8"))["ratchet"];
+        const found = stringAt(ratchet, "baseline");
+        if (found !== void 0) return found;
+      } catch {
+        return BASELINE_DEFAULT;
+      }
+    }
+    const own = resolve7(root, "geonosis.ratchet.json");
+    if (existsSync7(own)) {
+      try {
+        return stringAt(JSON.parse(readFileSync6(own, "utf8")), "baseline") ?? BASELINE_DEFAULT;
+      } catch {
+        return BASELINE_DEFAULT;
+      }
+    }
+    return BASELINE_DEFAULT;
+  })();
+  const at = resolve7(root, named);
+  if (!existsSync7(at)) return void 0;
+  try {
+    const parsed = JSON.parse(readFileSync6(at, "utf8"));
+    return isRecord2(parsed) ? Object.keys(parsed).length : void 0;
+  } catch {
+    return void 0;
+  }
+};
+var lastRow = (file, root) => {
+  const at = resolve7(root, file);
+  if (!existsSync7(at)) return void 0;
+  return readFileSync6(at, "utf8").split("\n").filter((line) => /^\| *\d+ *\|/.test(line)).at(-1);
+};
+var rowCount = (file, root) => {
+  const at = resolve7(root, file);
+  if (!existsSync7(at)) return 0;
+  return readFileSync6(at, "utf8").split("\n").filter((line) => /^\| \d{4}-\d{2}-\d{2} \|/.test(line)).length;
+};
+
+// src/handoff.ts
+import { existsSync as existsSync8, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "fs";
+import { resolve as resolve8 } from "path";
+var CLOSE_START = "<!-- geonosis-ledger:session-close -->";
+var CLOSE_END = "<!-- /geonosis-ledger:session-close -->";
+var DONE = /* @__PURE__ */ new Set(["DONE", "SHIPPED", "CLOSED", "ABANDONED"]);
+var bullets = (list, empty) => list.length === 0 ? [`- ${empty}`] : list.map((one) => `- ${one}`);
+var runHandoff = ({ config, root, write }) => {
+  const head = headOf(root);
+  const dirty = porcelain(root).filter((line) => !line.endsWith(` ${config.handoff}`));
+  const gate = gateSummary(root);
+  const tick = lastRow(config.progress, root);
+  const open = planStatuses({ config, root }).filter((plan) => !DONE.has(plan.status.toUpperCase()));
+  const block = [
+    CLOSE_START,
+    "## SESSION CLOSE",
+    "",
+    "**HEAD**",
+    ...bullets(head === void 0 ? [] : [`\`${head.hash}\` \u2014 ${head.subject}`], "no commit yet"),
+    "",
+    "**Uncommitted**",
+    ...bullets(dirty, "nothing uncommitted"),
+    "",
+    "**Last tick**",
+    ...bullets(tick === void 0 ? [] : [tick], "no tick recorded"),
+    "",
+    "**Last gate report**",
+    ...bullets(
+      gate === void 0 ? [] : [`${gate.tier} \u2014 ${gate.ok ? "ok" : "FAILED"} at ${gate.finishedAt}`],
+      "no gate report"
+    ),
+    "",
+    "**Open plans**",
+    ...bullets(
+      open.map((plan) => `${plan.file} \u2014 ${plan.status}`),
+      "no open plans"
+    ),
+    "",
+    CLOSE_END
+  ].join("\n");
+  if (!write) return { block, written: false };
+  const at = resolve8(root, config.handoff);
+  const body = existsSync8(at) ? readFileSync7(at, "utf8") : "";
+  const from = body.indexOf(CLOSE_START);
+  const to = body.indexOf(CLOSE_END);
+  const next = from === -1 || to === -1 ? `${body.endsWith("\n") || body === "" ? body : `${body}
+`}
+${block}
+` : `${body.slice(0, from)}${block}${body.slice(to + CLOSE_END.length)}`;
+  writeFileSync4(at, next);
+  return { block, written: true };
+};
+
+// src/status.ts
+var STATUS_MAX_LINES = 6;
+var readStatus = ({ config, root }) => {
+  const counts = /* @__PURE__ */ new Map();
+  for (const plan of planStatuses({ config, root })) {
+    counts.set(plan.status, (counts.get(plan.status) ?? 0) + 1);
+  }
+  const head = headOf(root);
+  const gate = gateSummary(root);
+  const tick = lastRow(config.progress, root);
+  const keys = baselineKeyCount(root);
+  return {
+    ...keys === void 0 ? {} : { baselineKeys: keys },
+    ...gate === void 0 ? {} : { gate },
+    ...head === void 0 ? {} : { head: head.subject },
+    journalRows: rowCount(config.journal, root),
+    ...tick === void 0 ? {} : { lastTick: tick },
+    plans: [...counts].map(([status, count]) => ({ count, status })).toSorted((a, b) => a.status.localeCompare(b.status))
+  };
+};
+var label = (text) => text.padEnd(9, " ");
+var formatStatus = (digest) => [
+  `${label("HEAD")} ${digest.head ?? "no commit yet"}`,
+  `${label("plans")} ${digest.plans.length === 0 ? "no plans" : digest.plans.map((one) => `${one.status} ${one.count}`).join(" \xB7 ")}`,
+  `${label("last tick")} ${digest.lastTick ?? "no tick yet"}`,
+  `${label("gate")} ${digest.gate === void 0 ? "no gate report" : `${digest.gate.tier} \u2014 ${digest.gate.ok ? "ok" : "FAILED"} at ${digest.gate.finishedAt}`}`,
+  `${label("baseline")} ${digest.baselineKeys === void 0 ? "no baseline" : `${digest.baselineKeys} counter(s)`}`,
+  `${label("journal")} ${digest.journalRows} fallback(s)`
+].join("\n");
+
+// src/architecture.ts
+import { existsSync as existsSync9, readdirSync as readdirSync4, readFileSync as readFileSync8, statSync as statSync2 } from "fs";
+import { join as join3, resolve as resolve9 } from "path";
+var EDGES_HEADER = "| tag | packages | may depend on |";
+var normal2 = (heading) => heading.toLowerCase().replaceAll(/[^a-z]/g, "");
+var WANTED = ["tag", "packages", "maydependon"];
+var listOf = (cell2) => cell2.split(",").map((one) => plainCell(one)).filter((one) => one !== "" && one !== "\u2014" && one !== "-");
+var readEdges = (lines2) => {
+  const bodies = [lines2, ...headingsOf(lines2).map((heading) => lines2.slice(heading.index))];
+  for (const body of bodies) {
+    const table = firstTable(body);
+    if (table === void 0) continue;
+    const columns = table.header.map((one) => normal2(one));
+    if (columns.length < 3 || !WANTED.every((wanted, at) => columns[at] === wanted)) continue;
+    return table.rows.map((index) => {
+      const cells = rowCells(body[index] ?? "");
+      const notes = [];
+      const mayDependOn = (cells[2] ?? "").split(",").map((one) => plainCell(one)).filter((one) => one !== "" && one !== "\u2014" && one !== "-").map((one) => {
+        const annotated = /^(.*?)\s*\((.+)\)$/.exec(one);
+        if (annotated?.[1] === void 0 || annotated[2] === void 0) return one;
+        notes.push(`may depend on ${annotated[1]}: ${annotated[2]}`);
+        return annotated[1];
+      });
+      return {
+        mayDependOn,
+        notes,
+        packages: listOf(cells[1] ?? ""),
+        tag: plainCell(cells[0] ?? "")
+      };
+    });
+  }
+  return void 0;
+};
+var globsOf = (root) => {
+  const pnpm = resolve9(root, "pnpm-workspace.yaml");
+  if (existsSync9(pnpm)) {
+    const found = [];
+    let inside = false;
+    for (const line of readFileSync8(pnpm, "utf8").split("\n")) {
+      if (line.startsWith("packages:")) {
+        inside = true;
+        continue;
+      }
+      if (inside && /^\s*-\s+/.test(line)) {
+        found.push(
+          line.replace(/^\s*-\s+/, "").replaceAll(/['"]/g, "").trim()
+        );
+        continue;
+      }
+      if (inside && line.trim() !== "" && !line.startsWith(" ")) inside = false;
+    }
+    if (found.length > 0) return found;
+  }
+  const manifest = resolve9(root, "package.json");
+  if (!existsSync9(manifest)) return void 0;
+  const parsed = JSON.parse(readFileSync8(manifest, "utf8"));
+  const declared = parsed.workspaces;
+  if (Array.isArray(declared)) return declared;
+  return declared?.packages;
+};
+var workspacePackages = (root) => {
+  const globs = globsOf(root);
+  if (globs === void 0) return void 0;
+  const found = [];
+  for (const glob of globs) {
+    const dirs = glob.endsWith("/*") ? (() => {
+      const parent = resolve9(root, glob.slice(0, -2));
+      if (!existsSync9(parent)) return [];
+      return readdirSync4(parent).filter((name) => statSync2(join3(parent, name)).isDirectory()).map((name) => `${glob.slice(0, -2)}/${name}`);
+    })() : [glob];
+    for (const dir of dirs) {
+      const manifest = resolve9(root, dir, "package.json");
+      if (!existsSync9(manifest)) continue;
+      const name = JSON.parse(readFileSync8(manifest, "utf8")).name;
+      found.push({ dir, name: name ?? dir });
+    }
+  }
+  return found;
+};
+var matchPackage = (named, packages) => packages.find(
+  (one) => one.dir === named || one.dir.split("/").at(-1) === named || one.name === named || one.name.split("/").at(-1) === named
+);
+var checkArchitecture = ({
+  config,
+  root,
+  workspace
+}) => {
+  const at = resolve9(root, config.architecture);
+  if (!existsSync9(at)) {
+    return { edges: [], notes: [], violations: [`${config.architecture} does not exist`] };
+  }
+  const edges = readEdges(readFileSync8(at, "utf8").split("\n"));
+  if (edges === void 0) {
+    return {
+      edges: [],
+      notes: [],
+      violations: [`${config.architecture} has no edges table with the header \`${EDGES_HEADER}\``]
+    };
+  }
+  const violations = [];
+  const notes = [];
+  const declared = new Set(edges.map((edge) => edge.tag));
+  const seen = /* @__PURE__ */ new Set();
+  const packages = workspace ? workspacePackages(root) : void 0;
+  if (workspace && packages === void 0) {
+    violations.push("no workspace declaration found \u2014 use --no-workspace to check the tags alone");
+  }
+  for (const edge of edges) {
+    if (seen.has(edge.tag)) violations.push(`${edge.tag}: declared twice`);
+    seen.add(edge.tag);
+    if (packages !== void 0) {
+      for (const named of edge.packages) {
+        if (matchPackage(named, packages) === void 0) {
+          violations.push(`${edge.tag}: "${named}" is not a workspace package`);
+        }
+      }
+    }
+    for (const depends of edge.mayDependOn) {
+      if (!declared.has(depends)) violations.push(`${edge.tag}: "${depends}" is not a declared tag`);
+    }
+    notes.push(...edge.notes.map((note) => `${edge.tag}: ${note}`));
+  }
+  return { edges, notes, ...packages === void 0 ? {} : { packages }, violations };
+};
+
+// src/json-splice.ts
+var WHITESPACE = /* @__PURE__ */ new Set([" ", "	", "\n", "\r"]);
+var skipSpace = (source, from) => {
+  let at = from;
+  while (at < source.length && WHITESPACE.has(source[at] ?? "")) at += 1;
+  return at;
+};
+var endOfString = (source, from) => {
+  let at = from + 1;
+  while (at < source.length) {
+    const char = source[at];
+    if (char === "\\") {
+      at += 2;
+      continue;
+    }
+    if (char === '"') return at + 1;
+    at += 1;
+  }
+  throw new Error("unterminated string");
+};
+var endOfValue = (source, from) => {
+  const first = source[from];
+  if (first === '"') return endOfString(source, from);
+  if (first === "{" || first === "[") {
+    const close = first === "{" ? "}" : "]";
+    let depth = 0;
+    let at2 = from;
+    while (at2 < source.length) {
+      const char = source[at2];
+      if (char === '"') {
+        at2 = endOfString(source, at2);
+        continue;
+      }
+      if (char === first) depth += 1;
+      if (char === close) {
+        depth -= 1;
+        if (depth === 0) return at2 + 1;
+      }
+      at2 += 1;
+    }
+    throw new Error("unterminated object or array");
+  }
+  let at = from;
+  while (at < source.length && ![",", "}", "]"].includes(source[at] ?? "")) at += 1;
+  return at;
+};
+var elementSpan = (source, from, index) => {
+  let at = from + 1;
+  let seen = 0;
+  while (at < source.length) {
+    at = skipSpace(source, at);
+    if (source[at] === "]") return void 0;
+    if (source[at] === ",") {
+      at += 1;
+      continue;
+    }
+    const end = endOfValue(source, at);
+    if (seen === index) return { end, start: at };
+    seen += 1;
+    at = end;
+  }
+  return void 0;
+};
+var memberSpan = (source, from, key) => {
+  if (source[from] === "[") {
+    const index = Number(key);
+    return Number.isInteger(index) ? elementSpan(source, from, index) : void 0;
+  }
+  if (source[from] !== "{") throw new Error("not an object");
+  let at = from + 1;
+  while (at < source.length) {
+    at = skipSpace(source, at);
+    if (source[at] === "}") return void 0;
+    if (source[at] === ",") {
+      at += 1;
+      continue;
+    }
+    if (source[at] !== '"') throw new Error(`unexpected ${source[at] ?? "end"} in object`);
+    const nameEnd = endOfString(source, at);
+    const name = JSON.parse(source.slice(at, nameEnd));
+    const colon = skipSpace(source, nameEnd);
+    if (source[colon] !== ":") throw new Error("expected :");
+    const valueStart = skipSpace(source, colon + 1);
+    const valueEnd = endOfValue(source, valueStart);
+    if (name === key) return { end: valueEnd, start: valueStart };
+    at = valueEnd;
+  }
+  return void 0;
+};
+var replaceJsonValue = (source, path, rendered) => {
+  let start = skipSpace(source, 0);
+  let end = endOfValue(source, start);
+  for (const key of path) {
+    const found = memberSpan(source, start, key);
+    if (found === void 0) throw new Error(`"${path.join(".")}": no such key ("${key}")`);
+    start = found.start;
+    end = found.end;
+  }
+  return `${source.slice(0, start)}${rendered}${source.slice(end)}`;
+};
+var readJsonValue = (source, path) => {
+  let start = skipSpace(source, 0);
+  let end = endOfValue(source, start);
+  for (const key of path) {
+    const found = memberSpan(source, start, key);
+    if (found === void 0) return void 0;
+    start = found.start;
+    end = found.end;
+  }
+  return JSON.parse(source.slice(start, end));
+};
+var render = (value, indent) => JSON.stringify(value, void 0, 2).split("\n").map((line, at) => at === 0 ? line : `${" ".repeat(indent)}${line}`).join("\n");
+var walk = (source, path) => {
+  let start = skipSpace(source, 0);
+  let end = endOfValue(source, start);
+  for (const [depth, key] of path.entries()) {
+    const opens = source[start];
+    if (opens !== "{" && opens !== "[") {
+      throw new Error(
+        `"${path.join(".")}": "${key}" would sit inside ${source.slice(start, end)}, which is neither an object nor an array`
+      );
+    }
+    const found = memberSpan(source, start, key);
+    if (found === void 0) return { depth, end, start };
+    start = found.start;
+    end = found.end;
+  }
+  return { depth: path.length, end, start };
+};
+var indentAt = (source, at) => {
+  const line = source.slice(source.lastIndexOf("\n", at) + 1, at);
+  return line.length - line.trimStart().length;
+};
+var insertMember = (source, span, key, value) => {
+  if (source[span.start] !== "{") {
+    throw new Error(`"${key}" cannot be added to ${source.slice(span.start, span.end)}`);
+  }
+  const between = source.slice(span.start + 1, span.end - 1);
+  const outer = indentAt(source, span.start);
+  const empty = between.trim() === "";
+  const inner = empty ? outer + 2 : indentAt(source, skipSpace(source, span.start + 1));
+  const member = `"${key}": ${render(value, inner)}`;
+  if (empty) {
+    return [
+      source.slice(0, span.start),
+      `{
+${" ".repeat(inner)}${member}
+${" ".repeat(outer)}}`,
+      source.slice(span.end)
+    ].join("");
+  }
+  const after = span.start + 1 + between.trimEnd().length;
+  return [source.slice(0, after), `,
+${" ".repeat(inner)}${member}`, source.slice(after)].join("");
+};
+var upsertJsonValue = (source, path, value, grow2) => {
+  const found = walk(source, path);
+  if (found.depth === path.length) {
+    return [
+      source.slice(0, found.start),
+      render(value, indentAt(source, found.start)),
+      source.slice(found.end)
+    ].join("");
+  }
+  const [key = "", ...under] = path.slice(found.depth);
+  return insertMember(source, found, key, grow2(under, value));
+};
+
+// src/sync-docs.ts
+import { existsSync as existsSync10, readdirSync as readdirSync5, readFileSync as readFileSync9, statSync as statSync3 } from "fs";
+import { join as join4, resolve as resolve10 } from "path";
+var DOC_TARGETS = ["agents-md", "cursor"];
+var isDocTarget = (target) => DOC_TARGETS.includes(target);
+var frontmatterOf = (source) => /^---\n([\S\s]*?)\n---/.exec(source)?.[1] ?? "";
+var scalar = (block, key) => new RegExp(`^${key}: *(.*)$`, "m").exec(block)?.[1]?.trim() ?? "";
+var pathsOf = (source) => {
+  const lines2 = frontmatterOf(source).split("\n");
+  const at = lines2.findIndex((line) => line.trim() === "paths:");
+  if (at === -1) return ["**"];
+  const found = lines2.slice(at + 1).map((line) => /^ *- *"?([^"]+?)"? *$/.exec(line)?.[1]).reduce((all, one) => one === void 0 ? all : [...all, one], []);
+  return found.length === 0 ? ["**"] : found;
+};
+var titleOf = (source) => source.split("\n").find((line) => line.startsWith("# "))?.slice(2).trim() ?? "";
+var bodyOf = (source) => {
+  const block = /^---\n[\S\s]*?\n---\n/.exec(source)?.[0];
+  return (block === void 0 ? source : source.slice(block.length)).replace(/^\n+/, "");
+};
+var filesIn = (dir, ending) => existsSync10(dir) && statSync3(dir).isDirectory() ? readdirSync5(dir).filter((name) => name.endsWith(ending) && name !== "README.md").toSorted() : [];
+var rulesOf = (root, config) => filesIn(resolve10(root, config.rules), ".md").map((name) => {
+  const source = readFileSync9(resolve10(root, config.rules, name), "utf8");
+  return {
+    globs: pathsOf(source),
+    name: name.replace(/\.md$/, ""),
+    source,
+    title: titleOf(source)
+  };
+});
+var skillsOf = (root, config) => {
+  const dir = resolve10(root, config.skills);
+  if (!existsSync10(dir) || !statSync3(dir).isDirectory()) return [];
+  return readdirSync5(dir).toSorted().flatMap((entry) => {
+    const at = join4(dir, entry, "SKILL.md");
+    if (!existsSync10(at)) return [];
+    const block = frontmatterOf(readFileSync9(at, "utf8"));
+    return [{ description: scalar(block, "description"), name: scalar(block, "name") || entry }];
+  });
+};
+var buildAgentsMd = ({ config, root }) => {
+  const at = resolve10(root, config.law);
+  if (!existsSync10(at)) throw new Error(`${config.law} does not exist \u2014 there is no law to project`);
+  const lines2 = readFileSync9(at, "utf8").split("\n");
+  const laws = sectionUnder(lines2, config.lawSection);
+  if (laws === void 0) {
+    throw new Error(
+      `${config.law} has no section matching ledger.lawSection (${config.lawSection}) \u2014 nothing to put in AGENTS.md`
+    );
+  }
+  const skills = skillsOf(root, config);
+  const rules = rulesOf(root, config);
+  const parts = [
+    "# AGENTS.md",
+    `**GENERATED \u2014 do not edit.** Written by \`geonosis-ledger sync --target agents-md\` from ${config.law}, ${config.skills}/ and ${config.rules}/. Edit those; this file is their projection, and \`--check\` fails the build when it has drifted.`,
+    "## The laws",
+    laws.join("\n").trim()
+  ];
+  if (skills.length > 0) {
+    parts.push(
+      "## Skills \u2014 load the one that matches before you start",
+      skills.map((one) => `- **${one.name}** \u2014 ${one.description}`).join("\n")
+    );
+  }
+  if (rules.length > 0) {
+    parts.push(
+      "## Scoped rules \u2014 what binds where",
+      ["| Files | Rule |", "| --- | --- |"].concat(
+        rules.map(
+          (one) => `| ${one.globs.map((glob) => `\`${glob}\``).join(" \xB7 ")} | ${one.title} (\`${config.rules}/${one.name}.md\`) |`
+        )
+      ).join("\n")
+    );
+  }
+  return `${parts.join("\n\n")}
+`;
+};
+var buildCursorRules = ({
+  config,
+  root
+}) => {
+  const rules = rulesOf(root, config);
+  if (rules.length === 0) {
+    throw new Error(`${config.rules}/ holds no rule files \u2014 there is nothing to translate`);
+  }
+  return rules.map((rule) => {
+    const always = rule.globs.length === 1 && rule.globs[0] === "**";
+    const front = [
+      "---",
+      `description: ${rule.title}`,
+      ...always ? [] : [`globs: ${rule.globs.join(", ")}`],
+      `alwaysApply: ${String(always)}`,
+      "---"
+    ];
+    return {
+      contents: `${front.join("\n")}
+
+${bodyOf(rule.source)}`,
+      name: `geonosis-${rule.name}.mdc`
+    };
+  });
+};
+var buildDoc = ({
+  config,
+  root,
+  target
+}) => target === "agents-md" ? [{ contents: buildAgentsMd({ config, root }), name: config.agents }] : buildCursorRules({ config, root });
+
+// src/sync.ts
+import { existsSync as existsSync11, mkdirSync as mkdirSync4, readFileSync as readFileSync10, writeFileSync as writeFileSync5 } from "fs";
+import { dirname as dirname2, relative as relative2, resolve as resolve11 } from "path";
+var SYNC_TARGETS = ["turbo", "layer-walls", "restricted-imports", ...DOC_TARGETS];
+var LAYER_WALLS_RULE = "biological-architecture/layer-walls";
+var TURBO_PATH = ["boundaries"];
+var LAYERS_PATH = ["rules", LAYER_WALLS_RULE, "1", "layers"];
+var RESTRICTED_PATH = ["rules", "no-restricted-imports", "1", "paths"];
+var turboOf = (edges) => ({
+  tags: Object.fromEntries(
+    edges.toSorted((a, b) => a.tag.localeCompare(b.tag)).map((edge) => [edge.tag, { dependencies: { allow: edge.mayDependOn } }])
+  )
+});
+var layersOf = (edges, packages) => edges.map((edge) => ({
+  mayImport: edge.mayDependOn,
+  name: edge.tag,
+  paths: edge.packages.flatMap((named) => {
+    const found = matchPackage(named, packages);
+    return found === void 0 ? [] : [`^${found.name}`, `${found.dir}/`];
+  })
+}));
+var restrictedOf = (edges, packages) => {
+  const named = (tag) => (edges.find((edge) => edge.tag === tag)?.packages ?? []).flatMap((one) => {
+    const found = matchPackage(one, packages);
+    return found === void 0 ? [] : [found];
+  });
+  const everything = edges.flatMap((edge) => named(edge.tag));
+  const out = {};
+  for (const edge of edges) {
+    const allowed = new Set(
+      [edge.tag, ...edge.mayDependOn].flatMap((tag) => named(tag)).map((one) => one.name)
+    );
+    for (const one of named(edge.tag)) {
+      out[one.name] = everything.map((other) => other.name).filter((name) => !allowed.has(name));
+    }
+  }
+  return out;
+};
+var packageAt = (file, root, packages) => {
+  const dir = relative2(root, dirname2(resolve11(root, file))).replaceAll("\\", "/");
+  return packages.find((one) => one.dir === dir)?.name;
+};
+var grow = (missing, value) => {
+  const [key, ...rest] = missing;
+  if (key === void 0) return value;
+  if (!/^\d+$/.test(key)) return { [key]: grow(rest, value) };
+  if (key !== "1") {
+    throw new Error(`element ${key} of a rule cannot be created \u2014 a rule is ["error", { \u2026 }]`);
+  }
+  return ["error", grow(rest, value)];
+};
+var MARKER = (name) => `--- ${name}`;
+var runDocSync = ({ check, config, root, target, write }) => {
+  if (!isDocTarget(target)) throw new Error(`"${target}" is not a document target`);
+  const files = buildDoc({ config, root, target });
+  const many = files.length > 1 || target === "cursor";
+  const generated = files.map((file) => many ? `${MARKER(file.name)}
+${file.contents}` : file.contents).join("\n");
+  const at = (where, file) => many ? resolve11(root, where, file.name) : resolve11(root, where);
+  if (write !== void 0) {
+    for (const file of files) {
+      const path = at(write, file);
+      mkdirSync4(dirname2(path), { recursive: true });
+      writeFileSync5(path, file.contents);
+    }
+    return { generated, ok: true, written: write };
+  }
+  if (check !== void 0) {
+    const differing = files.flatMap((file) => {
+      const path = at(check, file);
+      const committed = existsSync11(path) ? readFileSync10(path, "utf8") : void 0;
+      return committed === file.contents ? [] : [
+        [
+          `${relative2(root, path).replaceAll("\\", "/")} \u2014 ${committed === void 0 ? "is not there" : "differs"}`,
+          "committed:",
+          committed ?? "(nothing)",
+          "generated:",
+          file.contents
+        ].join("\n")
+      ];
+    });
+    return {
+      ...differing.length === 0 ? {} : { diff: differing.join("\n\n") },
+      generated,
+      ok: differing.length === 0
+    };
+  }
+  return { generated, ok: true };
+};
+var runSync = ({
+  check,
+  config,
+  packageName,
+  root,
+  target,
+  write
+}) => {
+  if (!SYNC_TARGETS.includes(target)) {
+    throw new Error(`"${target}" is not a target \u2014 one of ${SYNC_TARGETS.join(", ")}`);
+  }
+  if (isDocTarget(target)) {
+    return runDocSync({
+      ...check === void 0 ? {} : { check },
+      config,
+      root,
+      target,
+      ...write === void 0 ? {} : { write }
+    });
+  }
+  const report = checkArchitecture({ config, root, workspace: target !== "turbo" });
+  if (report.violations.length > 0) {
+    throw new Error(`${config.architecture} does not check out:
+${report.violations.join("\n")}`);
+  }
+  const packages = report.packages ?? [];
+  const path = target === "turbo" ? TURBO_PATH : target === "layer-walls" ? LAYERS_PATH : RESTRICTED_PATH;
+  const wholeValue = target === "turbo" ? turboOf(report.edges) : target === "layer-walls" ? layersOf(report.edges, packages) : restrictedOf(report.edges, packages);
+  const forFile = (file) => {
+    if (target !== "restricted-imports") return wholeValue;
+    const owner = packageName ?? packageAt(file, root, packages);
+    if (owner === void 0) throw new Error(`${file} is not inside a workspace package`);
+    const banned = wholeValue[owner];
+    if (banned === void 0) throw new Error(`${owner} carries no tag in the edges table`);
+    return banned;
+  };
+  const generated = JSON.stringify(wholeValue, void 0, 2);
+  if (write !== void 0) {
+    const at = resolve11(root, write);
+    if (!existsSync11(at)) throw new Error(`${write} does not exist`);
+    const source = readFileSync10(at, "utf8");
+    writeFileSync5(at, upsertJsonValue(source, path, forFile(write), grow));
+    return { generated, ok: true, written: write };
+  }
+  if (check !== void 0) {
+    const at = resolve11(root, check);
+    if (!existsSync11(at)) throw new Error(`${check} does not exist`);
+    const committed = readJsonValue(readFileSync10(at, "utf8"), path);
+    const wanted = forFile(check);
+    const ok = JSON.stringify(committed) === JSON.stringify(wanted);
+    return {
+      ...ok ? {} : {
+        diff: [
+          `${check} \u2014 ${path.join(".")}`,
+          "committed:",
+          JSON.stringify(committed, void 0, 2),
+          "generated:",
+          JSON.stringify(wanted, void 0, 2)
+        ].join("\n")
+      },
+      generated,
+      ok
+    };
+  }
+  return { generated, ok: true };
+};
+
+// src/prove.ts
+import { spawnSync as spawnSync3 } from "child_process";
+import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync5, mkdtempSync, rmSync, writeFileSync as writeFileSync6 } from "fs";
+import { tmpdir } from "os";
+import { dirname as dirname3, join as join5 } from "path";
+var run = (args, cwd) => {
+  const done = spawnSync3("git", args, {
+    cwd,
+    encoding: "utf8",
+    env: { ...process.env, GIT_CONFIG_GLOBAL: "/dev/null", GIT_CONFIG_SYSTEM: "/dev/null" }
+  });
+  if (done.status !== 0) throw new Error(`git ${args.join(" ")}: ${done.stderr}`);
+};
+var put = (root, file, body) => {
+  mkdirSync5(dirname3(join5(root, file)), { recursive: true });
+  writeFileSync6(join5(root, file), body);
+};
+var scratch = () => {
+  const root = mkdtempSync(join5(tmpdir(), "geonosis-ledger-prove-"));
+  run(["init", "--initial-branch=main"], root);
+  appendFileSync2(
+    join5(root, ".git/config"),
+    "[user]\n	email = ledger@example.test\n	name = Ledger Prove\n[commit]\n	gpgsign = false\n"
+  );
+  return root;
+};
+var runProve = (config) => {
+  const probes = [];
+  const long = [
+    "feat(x): a thing",
+    "",
+    ...Array.from({ length: 39 }, (_, at) => `narration line ${at + 1}.`)
+  ].join("\n");
+  probes.push({
+    finding: "a 40-line commit message",
+    gate: "commit-msg",
+    ...checkCommitMessage(long, config)
+  });
+  const root = scratch();
+  try {
+    put(root, "src/a.ts", "export const a = 1\n");
+    run(["add", "-A"], root);
+    run(["commit", "-m", "feat: base"], root);
+    put(root, "src/a.ts", "// what a is\n/* and why */\nexport const a = 1\n");
+    run(["add", "-A"], root);
+    probes.push({
+      finding: "a diff whose every changed line is a comment",
+      gate: "delivery check",
+      ...checkDelivery({ root, staged: true })
+    });
+  } finally {
+    rmSync(root, { force: true, recursive: true });
+  }
+  return { ok: probes.every((probe) => probe.refusal !== void 0), probes };
+};
+var formatProve = (report) => [
+  ...report.probes.map(
+    (probe) => probe.refusal === void 0 ? `  CANNOT FAIL ${probe.gate}: took ${probe.finding}` : `  PROVEN ${probe.gate}: refuses ${probe.finding}`
+  ),
+  "",
+  report.ok ? "prove PASS \u2014 every delivery gate refused the thing it forbids." : "prove FAIL \u2014 a gate took what it forbids. It is not a gate.",
+  ""
+].join("\n");
+
+export {
+  parseArgs,
+  required,
+  rejectUnknownSwitches,
+  LEDGER_DEFAULT,
+  loadLedgerConfig,
+  matchesRuntime,
+  headingsOf,
+  sectionUnder,
+  firstTable,
+  rowCells,
+  plainCell,
+  renderRow,
+  checkPlans,
+  planStatuses,
+  nextNumber,
+  newPlan,
+  isoDate,
+  appendRow,
+  FALLBACK_KINDS,
+  JOURNAL_HEADER,
+  appendFallback,
+  messageOf,
+  captureProof,
+  countedLines,
+  checkCommitMessage,
+  checkDelivery,
+  PROGRESS_HEADER,
+  runTick,
+  REVISIT_COLUMN,
+  runDecide,
+  GATE_REPORT,
+  gateSummary,
+  baselineKeyCount,
+  CLOSE_START,
+  CLOSE_END,
+  runHandoff,
+  STATUS_MAX_LINES,
+  readStatus,
+  formatStatus,
+  EDGES_HEADER,
+  readEdges,
+  workspacePackages,
+  checkArchitecture,
+  replaceJsonValue,
+  readJsonValue,
+  DOC_TARGETS,
+  isDocTarget,
+  buildAgentsMd,
+  buildCursorRules,
+  buildDoc,
+  SYNC_TARGETS,
+  LAYER_WALLS_RULE,
+  runSync,
+  runProve,
+  formatProve
+};