@maycombhq/atticus 0.0.0-stage → 2.0.0-beta.10

package/dist/chunk-6GNS32SI.js

@@ -0,0 +1,285 @@
+import { createRequire as __atticusCreateRequire } from "node:module";
+import { fileURLToPath as __atticusFileURLToPath } from "node:url";
+var require = __atticusCreateRequire(import.meta.url);
+var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
+var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
+import {
+  compareReports,
+  findRepoRoot,
+  listReports,
+  loadDatasets,
+  readQuality,
+  runEvals,
+  saveReport,
+  writeQuality
+} from "./chunk-AWECWW5Y.js";
+import {
+  table
+} from "./chunk-VOGCSYOI.js";
+import {
+  readDocument
+} from "./chunk-NIXVDQVO.js";
+import {
+  combine,
+  createRuntime,
+  formatOf,
+  screenAbsorbed,
+  screenDiagramXml,
+  screenOfficeXml,
+  screenText
+} from "./chunk-5XDNUJ4P.js";
+import {
+  loadOrgPack,
+  orgPackDirOf,
+  readZip,
+  stateDirOf
+} from "./chunk-577AJVRS.js";
+
+// packages/cli/dist/eval-commands.js
+import { readdir, readFile, stat } from "node:fs/promises";
+import { isAbsolute, join, relative, sep } from "node:path";
+var MODES = ["mock", "replay", "live"];
+async function evalRun(root, o, io, deps = {}) {
+  const mode = o.mode ?? "mock";
+  if (!MODES.includes(mode)) {
+    io.err(`--mode is one of ${MODES.join(", ")}.`);
+    return 2;
+  }
+  if (o.runs !== void 0 && (!Number.isInteger(o.runs) || o.runs < 1)) {
+    io.err("--runs is a whole number of at least 1.");
+    return 2;
+  }
+  const env = deps.env ?? process.env;
+  let liveRuntime = deps.liveRuntime;
+  if (mode === "live" && !liveRuntime) {
+    if (env.CI) {
+      io.err("Live evals call a real model, so they never run in CI. Use --mode replay there.");
+      return 2;
+    }
+    const op = await loadOrgPack(orgPackDirOf(root));
+    try {
+      const rt = await createRuntime(op, {
+        mode: "model",
+        root,
+        ...deps.providers ? { providers: deps.providers } : {}
+      });
+      liveRuntime = () => rt;
+    } catch (e) {
+      io.err(`${e.message} Live evals need a model provider in runtime.yaml (adapters.model).`);
+      return 2;
+    }
+  }
+  const repoRoot = deps.repoRoot ?? findRepoRoot();
+  const ds = await loadDatasets({
+    ...repoRoot ? { repoRoot } : {},
+    orgPackDir: orgPackDirOf(root)
+  });
+  for (const p of ds.problems)
+    io.err(p);
+  for (const u of ds.unavailable)
+    io.err(`Left out: ${u}.`);
+  const agents = o.agent === void 0 ? void 0 : Array.isArray(o.agent) ? o.agent : [o.agent];
+  const known = new Set(ds.cases.map((c) => c.agent));
+  const unknown = (agents ?? []).filter((a) => !known.has(a));
+  if (unknown.length) {
+    io.err(`No eval cases for ${unknown.join(", ")}. Agents with cases: ${[...known].sort().join(", ")}.`);
+    return 2;
+  }
+  const previous = (await listReports(root)).filter((r) => r.mode === mode).at(-1);
+  const report = await runEvals({
+    cases: ds.cases,
+    mode,
+    ...o.runs ? { runs: o.runs } : {},
+    ...agents ? { agents } : {},
+    ...liveRuntime ? { liveRuntime } : {},
+    repoRoot: repoRoot ?? root,
+    ...deps.now ? { now: deps.now } : {}
+  });
+  const path = await saveReport(root, report);
+  await writeQuality(root, (deps.now ?? (() => /* @__PURE__ */ new Date()))());
+  const cmp = previous ? compareReports(previous, report) : void 0;
+  const failed = report.results.filter((r) => !r.pass);
+  if (o.json) {
+    io.out(JSON.stringify({ report, comparison: cmp ?? null, file: relative(root, path).split(sep).join("/") }, null, 2));
+    return failed.length || report.liveBar && !report.liveBar.pass ? 1 : 0;
+  }
+  io.out(`Eval run ${report.runId} (${mode}, ${report.runs} run${report.runs === 1 ? "" : "s"} per case):`);
+  for (const l of table(["AGENT", "CASES", "PASSED", "RUNS", "PASS RATE"], report.agents.map((a) => [
+    a.agent,
+    String(a.cases),
+    String(a.passed),
+    String(a.runs),
+    `${Math.round(a.passRate * 100)}%`
+  ])))
+    io.out(l);
+  for (const f of failed)
+    io.out(`FAIL ${f.agent}/${f.case} run ${f.run}: ${f.error ?? f.grades.filter((g) => !g.pass).map((g) => `${g.grader}${g.notes.length ? ` (${g.notes.slice(0, 3).join("; ")})` : ""}`).join(", ")}`);
+  for (const s of report.skipped)
+    io.out(`Skipped ${s.agent}/${s.case}: ${s.reason}.`);
+  if (report.liveBar)
+    io.out(`Live bar (${report.liveBar.min} of ${report.liveBar.runs} runs): ${report.liveBar.pass ? "met" : "not met"}${report.liveBar.pass ? "" : ` (${report.liveBar.cases.filter((c) => !c.ok).map((c) => `${c.agent}/${c.case} ${c.passed} of ${c.runs}`).join(", ")})`}.`);
+  if (cmp?.regressed.length)
+    io.out(`Regressed since ${previous.runId}: ${cmp.regressed.join(", ")}.`);
+  if (cmp?.fixed.length)
+    io.out(`Fixed since ${previous.runId}: ${cmp.fixed.join(", ")}.`);
+  io.out(`Saved ${relative(root, path).split(sep).join("/")}.`);
+  return failed.length || report.liveBar && !report.liveBar.pass ? 1 : 0;
+}
+async function evalReport(root, o, io) {
+  const q = await readQuality(root);
+  if (!q) {
+    io.out("No eval runs yet. Run atticus eval run (mock or replay), or --mode live with a configured model.");
+    return 0;
+  }
+  if (o.json) {
+    io.out(JSON.stringify(q, null, 2));
+    return q.agents.some((a) => a.regressed.length || a.liveBar?.pass === false) ? 1 : 0;
+  }
+  for (const l of table(["AGENT", "LAST RUN", "MODE", "CASES", "PASS RATE", "LIVE BAR", "REGRESSED"], q.agents.map((a) => [
+    a.agent,
+    a.lastRunAt,
+    a.mode,
+    String(a.cases),
+    `${Math.round(a.passRate * 100)}%`,
+    a.liveBar ? `${a.liveBar.pass ? "met" : "not met"} (${a.liveBar.min}/${a.liveBar.runs})` : "no live run",
+    a.regressed.join(", ") || "-"
+  ])))
+    io.out(l);
+  return q.agents.some((a) => a.regressed.length || a.liveBar?.pass === false) ? 1 : 0;
+}
+var TEXT = /\.(md|markdown|txt|text|html?|ya?ml|json|csv|java|kt|ts|tsx|js|jsx|mjs|py|go|cs|rb|sql|sh|properties|xml|feature|mmd|gherkin)$/i;
+var INSTRUCTION_FILE = /(^|\/)(\.github\/(prompts|agents|chatmodes|instructions)\/|\.claude\/|\.cursor\/|prompts\/)|\.(prompt|agent|chatmode|instructions)\.md$|(^|\/)(AGENTS|CLAUDE|copilot-instructions)\.md$/i;
+var ACTION = {
+  high: "quarantined: left out of every AI step until a person cleans it",
+  medium: "kept as data, suspicious lines marked",
+  low: "kept as data, invisible characters removed",
+  none: "kept as data"
+};
+async function screenFile(full, rel) {
+  const bytes = new Uint8Array(await readFile(full));
+  if (/\.(docx|pptx|xlsx)$/i.test(rel)) {
+    const parts = [];
+    try {
+      const zip = readZip(bytes);
+      for (const n of zip.names.filter((x) => /^(word\/document|word\/(header|footer)\d*|ppt\/slides\/slide\d+|ppt\/notesSlides\/notesSlide\d+)\.xml$/.test(x)))
+        parts.push(screenOfficeXml(zip.text(n) ?? ""));
+    } catch {
+    }
+    const doc = readDocument(rel, bytes);
+    parts.push(screenText(doc.text.sections.map((s) => `${s.heading}
+${s.text}`).join("\n"), {
+      format: "office"
+    }));
+    return combine(...parts);
+  }
+  if (/\.pdf$/i.test(rel)) {
+    const doc = readDocument(rel, bytes);
+    return screenText(doc.text.sections.map((s) => `${s.heading}
+${s.text}`).join("\n"), {
+      format: "pdf"
+    });
+  }
+  if (/\.drawio$/i.test(rel) || /\.xml$/i.test(rel) && new TextDecoder().decode(bytes.slice(0, 200)).includes("<mxfile"))
+    return screenDiagramXml(new TextDecoder().decode(bytes));
+  if (!TEXT.test(rel) || bytes.includes(0))
+    return void 0;
+  const text = new TextDecoder().decode(bytes);
+  if (INSTRUCTION_FILE.test(rel)) {
+    const f = screenAbsorbed([{ id: rel, path: rel, text }])[0];
+    return {
+      risk: f.risk,
+      score: 0,
+      signals: f.signals,
+      rules: [...new Set(f.signals.map((s) => s.rule))],
+      reason: f.reason
+    };
+  }
+  return screenText(text, { format: formatOf("document", rel) });
+}
+async function defencesScan(root, path, o, io) {
+  const targets = [];
+  if (path)
+    targets.push(isAbsolute(path) ? path : join(root, path));
+  else {
+    targets.push(join(stateDirOf(root), "inputs"));
+    try {
+      const op = await loadOrgPack(orgPackDirOf(root));
+      for (const w of op.sources.wikis)
+        if (w.type === "markdown-folder")
+          targets.push(join(orgPackDirOf(root), w.location));
+    } catch {
+    }
+  }
+  const files = [];
+  for (const t of targets) {
+    let info;
+    try {
+      info = await stat(t);
+    } catch {
+      if (path) {
+        io.err(`${path} doesn't exist.`);
+        return 2;
+      }
+      continue;
+    }
+    const walk = async (d) => {
+      for (const e of (await readdir(d, { withFileTypes: true })).sort((a, b) => a.name < b.name ? -1 : 1)) {
+        if (e.name === ".git" || e.name === "node_modules")
+          continue;
+        const full = join(d, e.name);
+        if (e.isDirectory())
+          await walk(full);
+        else
+          files.push({ full, rel: relative(root, full).split(sep).join("/") });
+      }
+    };
+    if (info.isDirectory())
+      await walk(t);
+    else
+      files.push({ full: t, rel: relative(root, t).split(sep).join("/") });
+  }
+  const out = [];
+  let skipped = 0;
+  for (const f of files) {
+    const s = await screenFile(f.full, f.rel).catch(() => void 0);
+    if (!s) {
+      skipped++;
+      continue;
+    }
+    out.push({
+      path: f.rel,
+      risk: s.risk,
+      action: ACTION[s.risk],
+      reason: s.reason,
+      rules: s.rules,
+      signals: s.signals.map((x) => ({
+        rule: x.rule,
+        line: x.line,
+        excerpt: x.excerpt,
+        ...x.hidden ? { hidden: true } : {},
+        ...x.encoded ? { encoded: true } : {},
+        ...x.obfuscated ? { obfuscated: true } : {}
+      }))
+    });
+  }
+  const risky = out.filter((f) => f.risk === "medium" || f.risk === "high");
+  if (o.json) {
+    io.out(JSON.stringify({ files: o.all ? out : out.filter((f) => f.risk !== "none"), scanned: out.length, skipped }, null, 2));
+    return risky.length ? 1 : 0;
+  }
+  const shown = o.all ? out : out.filter((f) => f.risk !== "none");
+  if (shown.length)
+    for (const l of table(["RISK", "FILE", "WHAT ATTICUS DOES", "WHY"], shown.map((f) => [f.risk, f.path, f.action, f.reason])))
+      io.out(l);
+  for (const f of risky)
+    for (const s of f.signals.slice(0, 5))
+      io.out(`  ${f.path}:${s.line} ${s.rule}${s.hidden ? " (hidden)" : s.encoded ? " (encoded)" : s.obfuscated ? " (disguised)" : ""}: ${s.excerpt}`);
+  io.out(`Scanned ${out.length} file${out.length === 1 ? "" : "s"}${skipped ? ` (${skipped} not text or documents)` : ""}: ${risky.filter((f) => f.risk === "high").length} high, ${risky.filter((f) => f.risk === "medium").length} medium.`);
+  return risky.length ? 1 : 0;
+}
+
+export {
+  evalRun,
+  evalReport,
+  defencesScan
+};

package/dist/chunk-6GWHKMQR.js

@@ -0,0 +1,405 @@
+import { createRequire as __atticusCreateRequire } from "node:module";
+import { fileURLToPath as __atticusFileURLToPath } from "node:url";
+var require = __atticusCreateRequire(import.meta.url);
+var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
+var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
+import {
+  factsRepos
+} from "./chunk-3GTZ2OON.js";
+import {
+  checkoutOf
+} from "./chunk-B3O52AUQ.js";
+import {
+  AUDIT_ANSWERS,
+  AUDIT_DEFAULT_SIZE,
+  auditCandidates,
+  auditItemHolds,
+  auditPrecision,
+  drawAudit,
+  factsDirOf,
+  factsRelOf,
+  loadOrgPack,
+  mergeDraw,
+  orgPackDirOf,
+  parseAuditFile,
+  parseFacts,
+  require_dist,
+  serializeAuditFile,
+  sumAuditPrecision
+} from "./chunk-577AJVRS.js";
+import {
+  __toESM
+} from "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/audit-commands.js
+var import_yaml = __toESM(require_dist(), 1);
+import { readFile, writeFile } from "node:fs/promises";
+import { isAbsolute, join, resolve } from "node:path";
+var AUDIT_WORDS = {
+  usage: "Usage: atticus verify audit <repo> [--size n] [--seed s] [--answers file | --right ids --wrong ids --unsure ids] [--json], atticus verify audit <repo> --report, or atticus verify audit --report for the estate",
+  noFacts: (repo, rel) => `${repo} has no facts to audit (${rel}/${repo}.jsonl). Read it first: /atticus-map ${repo}, then atticus verify ${repo}.`,
+  badFacts: (rel) => `${rel} doesn't read as facts; run atticus verify on it first.`,
+  unverified: (repo, n) => `${n} of ${repo}'s facts aren't verified yet, and an audit samples kept facts only. Run atticus verify ${repo} first.`,
+  badFile: (rel) => `${rel} isn't an audit file Atticus can read:`,
+  badAnswers: (file) => `${file} isn't a list of answers Atticus can read:`,
+  unknownIds: (ids) => `Not in this sample: ${ids.join(", ")}. Answer the ids the sample lists (atticus verify audit <repo> --json shows them).`,
+  drew: (repo, facts, links, seed, size) => `Sample audit of ${repo}: ${plural(facts, "fact")} and ${plural(links, "link")} drawn (seed ${seed}, size ${size}; the same seed draws the same sample).`,
+  nothing: (repo) => `${repo} has no kept facts a reader wrote and no links to sample, so there is nothing to audit.`,
+  question: "Right, wrong or unsure? [r/w/u; Enter skips, q stops]",
+  noteQuestion: "What is wrong with it? (one line; Enter for none)",
+  wrongFact: (repo, rel) => `  Correct it: the fact's Correct this on the Map (a line in ${rel}/${repo}.corrections.jsonl), then atticus verify ${repo} --write.`,
+  wrongLink: (repo, rel, call) => `  Say so: on the Map, the link's Why is this linked? \u203A This link is wrong corrects call ${call} in ${rel}/${repo}.corrections.jsonl (ADR 0135); then atticus verify ${repo} --write.`,
+  howToAnswer: (repo, file) => `Not on a terminal, so nothing was asked. Answer each id above as right, wrong or unsure: in ${file} (answer: right), with atticus verify audit ${repo} --answers <file>, or with --right, --wrong and --unsure lists of ids.`,
+  wrote: (file, answered, open) => `Wrote ${file}: ${answered} answered, ${open} open. It is a person's record: commit it in a pull request (git add ${file}); nothing was sent anywhere.`,
+  head: (repo, file, seeds) => `Sample audit of ${repo} (${file}; ${plural(seeds.length, "draw")}, ${seeds.length === 1 ? "seed" : "seeds"} ${seeds.join(", ")}):`,
+  estateHead: (n) => `Sample audits across the estate: ${plural(n, "repo")} audited.`,
+  noAudit: (repo) => `${repo} has no sample audit yet. Draw one: atticus verify audit ${repo}.`,
+  noAudits: "No repo has a sample audit yet. Draw one: atticus verify audit <repo>.",
+  small: (n) => `${plural(n, "answer")} in all: a sample this small says little, so read the interval, not the number. Draw more with another --seed.`,
+  gone: (n) => `${plural(n, "item")} left out: the fact or link changed since it was drawn (read again), so its answer no longer stands.`
+};
+var plural = (n, one, many = `${one}s`) => `${n} ${n === 1 ? one : many}`;
+var num = (x) => x === null ? "-" : String(x);
+function tallyWords(t) {
+  const n = t.right + t.wrong;
+  const rest = [
+    ...t.unsure ? [`${t.unsure} unsure`] : [],
+    ...t.open ? [`${t.open} open`] : [],
+    ...t.gone ? [`${t.gone} gone`] : []
+  ].join(", ");
+  if (!n)
+    return `no answers yet (${plural(t.drawn, "drawn", "drawn")}${rest ? `; ${rest}` : ""})`;
+  return `precision ${num(t.precision)}, ${t.right} of ${n} right (95% interval ${num(t.low)} to ${num(t.high)})${rest ? `; ${rest}` : ""}`;
+}
+function precisionLines(p) {
+  const out = [`Facts: ${tallyWords(p.facts)}.`];
+  for (const [k, t] of Object.entries(p.byKind))
+    out.push(`  ${k}: ${tallyWords(t)}`);
+  out.push(`Links: ${tallyWords(p.links)}.`);
+  for (const [k, t] of Object.entries(p.byHow))
+    out.push(`  ${k}: ${tallyWords(t)}`);
+  const answered = p.facts.right + p.facts.wrong + p.links.right + p.links.wrong;
+  if (answered < 30)
+    out.push(AUDIT_WORDS.small(answered));
+  const gone = p.facts.gone + p.links.gone;
+  if (gone)
+    out.push(AUDIT_WORDS.gone(gone));
+  return out;
+}
+var auditPath = (root, repo) => join(factsDirOf(root), `${repo}.audit.yaml`);
+async function readAudit(root, repo) {
+  const text = await readFile(auditPath(root, repo), "utf8").catch(() => void 0);
+  if (text === void 0)
+    return {};
+  const r = parseAuditFile(text);
+  return r.ok ? { file: r.file } : { issues: r.issues };
+}
+async function readFactsOf(root, repo) {
+  const text = await readFile(join(factsDirOf(root), `${repo}.jsonl`), "utf8").catch(() => void 0);
+  if (text === void 0 || !text.trim())
+    return { missing: true };
+  const r = parseFacts(text);
+  return r.ok ? { facts: r.facts } : { bad: true };
+}
+async function linksOf(root, repo) {
+  const { estateFacts, estateJoinOf, auditLinkCandidates } = await import("./chunk-2XM6PYQQ.js");
+  const op = await loadOrgPack(orgPackDirOf(root));
+  const estate = await estateFacts(root, op, "");
+  const join2 = estateJoinOf(op, estate.repos, estate.targets);
+  return auditLinkCandidates(join2, estate.repos, repo);
+}
+async function givenAnswers(root, o) {
+  const answers = /* @__PURE__ */ new Map();
+  const issues = [];
+  const isAnswer = (x) => typeof x === "string" && AUDIT_ANSWERS.includes(x);
+  if (o.answers) {
+    const path = isAbsolute(o.answers) ? o.answers : resolve(root, o.answers);
+    const text = await readFile(path, "utf8").catch(() => void 0);
+    let doc;
+    try {
+      doc = text === void 0 ? void 0 : (0, import_yaml.parse)(text);
+    } catch (e) {
+      issues.push(`not YAML or JSON: ${e.message.split("\n")[0]}`);
+    }
+    if (text === void 0)
+      issues.push("there is no such file");
+    else if (doc && typeof doc === "object" && !Array.isArray(doc))
+      for (const [id, v] of Object.entries(doc)) {
+        const a = typeof v === "object" && v ? v.answer : v;
+        const note = typeof v === "object" && v ? v.note : void 0;
+        if (!isAnswer(a))
+          issues.push(`${id}: the answer is right, wrong or unsure`);
+        else
+          answers.set(id, { answer: a, ...typeof note === "string" ? { note } : {} });
+      }
+    else if (!issues.length)
+      issues.push("it should map each item id to right, wrong or unsure");
+  }
+  for (const a of AUDIT_ANSWERS)
+    for (const id of o[a] ?? [])
+      answers.set(id, { answer: a });
+  return { answers, issues };
+}
+function lineReader(root, o, repo) {
+  const dirs = /* @__PURE__ */ new Map();
+  const files = /* @__PURE__ */ new Map();
+  return async (cite) => {
+    const space = cite.indexOf(" ");
+    const r = space > 0 ? cite.slice(0, space) : repo;
+    const at = space > 0 ? cite.slice(space + 1) : cite;
+    const m = /^(.*):(\d+)$/.exec(at);
+    if (!m)
+      return void 0;
+    if (!dirs.has(r))
+      dirs.set(r, checkoutOf(root, r, r === repo ? o.dir : void 0));
+    const dir = await dirs.get(r);
+    if (!dir)
+      return void 0;
+    const k = `${dir}\0${m[1]}`;
+    if (!files.has(k))
+      files.set(k, readFile(join(dir, m[1]), "utf8").then((t) => t.split(/\r?\n/), () => void 0));
+    return (await files.get(k))?.[Number(m[2]) - 1]?.trim();
+  };
+}
+async function prepareAudit(root, repo, o = {}) {
+  const rel = factsRelOf(root);
+  const read = await readFactsOf(root, repo);
+  if (read.missing)
+    return { refused: "no-facts", lines: [AUDIT_WORDS.noFacts(repo, rel)] };
+  if (read.bad || !read.facts)
+    return { refused: "bad-facts", lines: [AUDIT_WORDS.badFacts(`${rel}/${repo}.jsonl`)] };
+  const facts = read.facts;
+  const unverified = facts.filter((f) => f.verified === "none").length;
+  if (unverified)
+    return {
+      refused: "unverified",
+      lines: [AUDIT_WORDS.unverified(repo, unverified)],
+      unverified
+    };
+  const fileRel = `${rel}/${repo}.audit.yaml`;
+  const onFile = await readAudit(root, repo);
+  if (onFile.issues)
+    return {
+      refused: "bad-file",
+      lines: [AUDIT_WORDS.badFile(fileRel), ...onFile.issues.map((i) => `  ${i}`)]
+    };
+  const commit = [...new Set(facts.map((f) => f.commit))].sort()[0];
+  const size = o.size && o.size > 0 ? Math.floor(o.size) : AUDIT_DEFAULT_SIZE;
+  const seed = o.seed ?? defaultAuditSeed(repo, commit);
+  const links = await linksOf(root, repo);
+  const drawn = drawAudit({ facts: auditCandidates(facts), links, size, seed });
+  const now = (o.now ?? (() => /* @__PURE__ */ new Date()))().toISOString();
+  const audit = mergeDraw(onFile.file, repo, drawn, {
+    seed,
+    size,
+    ...commit ? { commit } : {},
+    at: now
+  });
+  return { facts, drawn, seed, size, audit, onFile: onFile.file, fileRel, now };
+}
+var defaultAuditSeed = (repo, commit) => `${repo}@${(commit ?? "").slice(0, 7)}`;
+function answerAudit(audit, answers, by, now) {
+  const byId = new Map(audit.items.map((i) => [i.id, i]));
+  const unknown = [];
+  for (const [id, a] of answers) {
+    const item = byId.get(id) ?? byId.get(`fact:${id}`) ?? byId.get(`link:${id}`);
+    if (!item) {
+      unknown.push(id);
+      continue;
+    }
+    item.answer = a.answer;
+    if (a.note)
+      item.note = a.note;
+    else
+      delete item.note;
+    item.by = by;
+    item.at = now;
+  }
+  return unknown;
+}
+async function writeAudit(root, repo, audit) {
+  await writeFile(auditPath(root, repo), serializeAuditFile(audit), "utf8");
+}
+async function auditLines(root, repo, items, dir) {
+  const lineOf = lineReader(root, dir ? { dir } : {}, repo);
+  const out = /* @__PURE__ */ new Map();
+  for (const i of items)
+    for (const c of i.cites)
+      if (!out.has(c))
+        out.set(c, await lineOf(c));
+  return out;
+}
+async function auditCommand(root, repo, o, io) {
+  if (o.report)
+    return repo ? auditReport(root, repo, o, io) : estateAuditReport(root, o, io);
+  if (!repo) {
+    io.err(AUDIT_WORDS.usage);
+    return 2;
+  }
+  const given = await givenAnswers(root, o);
+  const prepared = await prepareAudit(root, repo, {
+    ...o.size !== void 0 ? { size: o.size } : {},
+    ...o.seed !== void 0 ? { seed: o.seed } : {},
+    ...o.now ? { now: o.now } : {}
+  });
+  if ("refused" in prepared) {
+    for (const l of prepared.lines)
+      io.err(l);
+    return 2;
+  }
+  if (given.issues.length) {
+    io.err(AUDIT_WORDS.badAnswers(o.answers ?? "--right/--wrong/--unsure"));
+    for (const i of given.issues)
+      io.err(`  ${i}`);
+    return 2;
+  }
+  const { facts, drawn, seed, size, audit, fileRel, now, onFile } = prepared;
+  const rel = factsRelOf(root);
+  if (!drawn.length && !onFile) {
+    io.out(AUDIT_WORDS.nothing(repo));
+    return 0;
+  }
+  const unknown = answerAudit(audit, given.answers, o.by, now);
+  if (unknown.length) {
+    io.err(AUDIT_WORDS.unknownIds(unknown));
+    return 2;
+  }
+  const thisDraw = new Set(drawn.map((d) => d.id));
+  const shown = audit.items.filter((i) => thisDraw.has(i.id));
+  if (!o.json)
+    io.out(AUDIT_WORDS.drew(repo, shown.filter((i) => i.kind === "fact").length, shown.filter((i) => i.kind === "link").length, seed, size));
+  const lineOf = lineReader(root, o, repo);
+  const show = async (i, k) => {
+    io.out("");
+    io.out(`[${k}/${shown.length}] ${i.kind === "link" ? `link (${i.of})` : "fact"} ${i.claim}`);
+    io.out(`  id ${i.id}`);
+    for (const c of i.cites) {
+      const text = await lineOf(c);
+      io.out(`  ${c}${text ? `  ${text.length > 160 ? `${text.slice(0, 157)}...` : text}` : ""}`);
+    }
+  };
+  const pointTo = (i) => io.out(i.kind === "fact" ? AUDIT_WORDS.wrongFact(repo, rel) : AUDIT_WORDS.wrongLink(repo, rel, i.fact ?? i.id));
+  if (!o.json) {
+    let k = 0;
+    let stopped = false;
+    for (const i of shown) {
+      k++;
+      if (i.answer || stopped || !o.ask) {
+        await show(i, k);
+        if (i.answer)
+          io.out(`  ${i.answer}${i.note ? `: ${i.note}` : ""}`);
+        if (i.answer === "wrong")
+          pointTo(i);
+        continue;
+      }
+      await show(i, k);
+      const said = (await o.ask(AUDIT_WORDS.question) ?? "").trim().toLowerCase();
+      if (said === "q") {
+        stopped = true;
+        continue;
+      }
+      const answer = AUDIT_ANSWERS.find((a) => a === said || a[0] === said);
+      if (!answer)
+        continue;
+      i.answer = answer;
+      i.by = o.by;
+      i.at = now;
+      if (answer === "wrong") {
+        const note = (await o.ask(AUDIT_WORDS.noteQuestion) ?? "").trim();
+        if (note)
+          i.note = note;
+        pointTo(i);
+      }
+    }
+  }
+  await writeAudit(root, repo, audit);
+  const precision = await precisionOf(root, repo, audit, facts);
+  if (o.json) {
+    io.out(JSON.stringify({ repo, file: fileRel, seed, size, drawn: shown, precision, wrote: true }, null, 2));
+    return 0;
+  }
+  io.out("");
+  if (!o.ask && shown.some((i) => !i.answer))
+    io.out(AUDIT_WORDS.howToAnswer(repo, fileRel));
+  io.out(AUDIT_WORDS.wrote(fileRel, audit.items.filter((i) => i.answer).length, audit.items.filter((i) => !i.answer).length));
+  io.out("");
+  for (const l of precisionLines(precision))
+    io.out(l);
+  return 0;
+}
+async function precisionOf(root, repo, audit, facts) {
+  const byId = new Map(facts.map((f) => [f.id, f]));
+  const links = new Map((await linksOf(root, repo)).map((l) => [l.id, l]));
+  return auditPrecision(audit.items, (i) => i.kind === "fact" ? auditItemHolds(i, byId) : links.get(i.id)?.to === i.to);
+}
+async function auditReport(root, repo, o, io) {
+  const fileRel = `${factsRelOf(root)}/${repo}.audit.yaml`;
+  const onFile = await readAudit(root, repo);
+  if (onFile.issues) {
+    io.err(AUDIT_WORDS.badFile(fileRel));
+    for (const i of onFile.issues)
+      io.err(`  ${i}`);
+    return 2;
+  }
+  if (!onFile.file) {
+    io.err(AUDIT_WORDS.noAudit(repo));
+    return 2;
+  }
+  const precision = await precisionOf(root, repo, onFile.file, (await readFactsOf(root, repo)).facts ?? []);
+  const seeds = onFile.file.draws.map((d) => d.seed);
+  if (o.json) {
+    io.out(JSON.stringify({ repo, file: fileRel, seeds, precision }, null, 2));
+    return 0;
+  }
+  io.out(AUDIT_WORDS.head(repo, fileRel, seeds));
+  for (const l of precisionLines(precision))
+    io.out(l);
+  return 0;
+}
+async function estateAuditReport(root, o, io) {
+  const out = [];
+  for (const repo of await factsRepos(root)) {
+    const onFile = await readAudit(root, repo);
+    if (onFile.issues) {
+      io.err(AUDIT_WORDS.badFile(`${factsRelOf(root)}/${repo}.audit.yaml`));
+      for (const i of onFile.issues)
+        io.err(`  ${i}`);
+      return 2;
+    }
+    if (!onFile.file)
+      continue;
+    const facts = (await readFactsOf(root, repo)).facts ?? [];
+    out.push({ repo, precision: await precisionOf(root, repo, onFile.file, facts) });
+  }
+  if (!out.length) {
+    io.err(AUDIT_WORDS.noAudits);
+    return 2;
+  }
+  const estate = sumAuditPrecision(out.map((x) => x.precision));
+  if (o.json) {
+    io.out(JSON.stringify({ repos: out, estate }, null, 2));
+    return 0;
+  }
+  io.out(AUDIT_WORDS.estateHead(out.length));
+  for (const x of out) {
+    io.out(`  ${x.repo}: facts ${tallyWords(x.precision.facts)}`);
+    io.out(`  ${" ".repeat(x.repo.length)}  links ${tallyWords(x.precision.links)}`);
+  }
+  io.out("");
+  io.out("The estate:");
+  for (const l of precisionLines(estate))
+    io.out(l);
+  return 0;
+}
+
+export {
+  AUDIT_WORDS,
+  tallyWords,
+  prepareAudit,
+  defaultAuditSeed,
+  answerAudit,
+  writeAudit,
+  auditLines,
+  auditCommand,
+  precisionOf
+};