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

package/dist/chunk-XZRON6IV.js

@@ -0,0 +1,131 @@
+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 "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/waiting-commands.js
+var CLOSED = /* @__PURE__ */ new Set(["released", "archived", "closed"]);
+async function readWaiting(run, o) {
+  const problems = [];
+  const json = async (argv, fallback) => {
+    const r = await run(argv);
+    try {
+      return JSON.parse(r.out);
+    } catch {
+      problems.push(`atticus ${argv.join(" ")}: ${r.err.trim().split("\n")[0] || "no answer"}`);
+      return fallback;
+    }
+  };
+  const questions = (await json(["questions", "list", "--state", "open", "--json"], {})).questions ?? [];
+  const needs = (await json(["needs", "--all", "--json"], [])).filter((n) => (n.status ?? "open") === "open");
+  const steps = (await json(["todo", "--json"], [])).filter((s) => (s.state ?? "open") === "open");
+  const changes = (await json(["change", "list", "--json"], [])).filter((c) => !CLOSED.has(c.state));
+  const findings = /* @__PURE__ */ new Map();
+  for (const c of changes)
+    findings.set(c.id, (await json(["findings", c.id, "--json"], [])).filter((f) => (f.state ?? "open") === "open"));
+  const unverified = await json(["knowledge", "list", "--unverified", "--json"], []);
+  const words = o.filter?.trim().toLowerCase();
+  const hit = (...fields) => !words || fields.some((f) => f !== void 0 && f.toLowerCase().includes(words));
+  const byChange = [];
+  for (const c of changes) {
+    const whole = hit(c.id, c.title);
+    const w = {
+      change: c.id,
+      title: c.title,
+      state: c.state,
+      needs: needs.filter((n) => n.change === c.id && (whole || hit(n.item, n.title, n.kind, n.handledBy))),
+      findings: (findings.get(c.id) ?? []).filter((f) => whole || hit(f.id, f.summary, f.severity)),
+      manualSteps: steps.filter((s) => s.change === c.id && (whole || hit(s.id, s.title, s.where)))
+    };
+    if (w.needs.length + w.findings.length + w.manualSteps.length)
+      byChange.push(w);
+  }
+  const blocking = (w) => w.findings.some((f) => f.severity === "blocking");
+  byChange.sort((a, b) => Number(blocking(b)) - Number(blocking(a)) || a.title.localeCompare(b.title));
+  const known = new Set(changes.map((c) => c.id));
+  const other = {
+    questions: questions.filter((q) => hit(q.id, q.repo, q.question)),
+    manualSteps: steps.filter((s) => (!s.change || !known.has(s.change)) && hit(s.id, s.title, s.where, s.change)),
+    knowledgeToVerify: words ? 0 : unverified.length
+  };
+  const sum = (f) => byChange.reduce((n, w) => n + f(w), 0);
+  return {
+    changes: byChange,
+    other,
+    counts: {
+      questions: other.questions.length,
+      needs: sum((w) => w.needs.length),
+      manualSteps: sum((w) => w.manualSteps.length) + other.manualSteps.length,
+      findings: sum((w) => w.findings.length),
+      knowledgeToVerify: other.knowledgeToVerify
+    },
+    problems
+  };
+}
+var plural = (n, w) => `${n} ${w}${n === 1 ? "" : "s"}`;
+var stepId = (s) => s.change ? `${s.change}/${s.id}` : s.id;
+function byChangeLines(w) {
+  const out = [];
+  for (const c of w.changes) {
+    const parts = [
+      c.needs.length && plural(c.needs.length, "need"),
+      c.findings.length && plural(c.findings.length, "finding"),
+      c.manualSteps.length && plural(c.manualSteps.length, "manual step")
+    ].filter(Boolean);
+    out.push(`${c.title} (${c.change}): ${parts.join(", ")}`);
+    for (const n of c.needs)
+      out.push(`  need     ${n.item}: ${n.title}`);
+    for (const f of c.findings)
+      out.push(`  finding  ${f.id} (${f.severity}): ${f.summary}`);
+    for (const s of c.manualSteps)
+      out.push(`  step     ${stepId(s)}: ${s.title}`);
+  }
+  const o = w.other;
+  if (o.questions.length || o.manualSteps.length || o.knowledgeToVerify) {
+    out.push("Not tied to a change:");
+    for (const q of o.questions)
+      out.push(`  question ${q.id} (${q.repo}): ${q.question}`);
+    for (const s of o.manualSteps)
+      out.push(`  step     ${stepId(s)}: ${s.title}`);
+    if (o.knowledgeToVerify)
+      out.push(`  ${plural(o.knowledgeToVerify, "knowledge item")} no one has verified: atticus knowledge list --unverified`);
+  }
+  return out;
+}
+function byKindLines(w) {
+  const out = [];
+  const group = (title, lines) => {
+    if (lines.length)
+      out.push(`${title} (${lines.length})`, ...lines.map((l) => `  ${l}`));
+  };
+  group("Questions", w.other.questions.map((q) => `${q.id} (${q.repo}): ${q.question}`));
+  group("Needs", w.changes.flatMap((c) => c.needs.map((n) => `${n.item} (${c.change}): ${n.title}`)));
+  group("Manual steps", [...w.changes.flatMap((c) => c.manualSteps), ...w.other.manualSteps].map((s) => `${stepId(s)}: ${s.title}`));
+  group("Findings", w.changes.flatMap((c) => c.findings.map((f) => `${f.id} (${c.change}, ${f.severity}): ${f.summary}`)));
+  if (w.other.knowledgeToVerify)
+    out.push(`Knowledge to verify (${w.other.knowledgeToVerify}): atticus knowledge list --unverified`);
+  return out;
+}
+async function waitingCli(o, io, run) {
+  const by = o.by ?? "change";
+  const w = await readWaiting(run, o.filter ? { filter: o.filter } : {});
+  if (o.json) {
+    io.out(JSON.stringify({ by, ...w }, null, 2));
+    return 0;
+  }
+  const lines = by === "kind" ? byKindLines(w) : byChangeLines(w);
+  if (!lines.length)
+    io.out(o.filter ? `Nothing waits on you that matches "${o.filter}".` : "Nothing waits on you.");
+  else
+    for (const l of lines)
+      io.out(l);
+  for (const p of w.problems)
+    io.err(`Couldn't read ${p}`);
+  return 0;
+}
+export {
+  readWaiting,
+  waitingCli
+};

package/dist/chunk-Y5AYBGLB.js

@@ -0,0 +1,368 @@
+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 {
+  notesAt
+} from "./chunk-52WCHTVZ.js";
+import {
+  recordReadProgress
+} from "./chunk-LVBPY2M6.js";
+import {
+  carryOf,
+  checkoutOf,
+  conventionsAt,
+  estateComponentsOf,
+  excludesOf,
+  headOf,
+  raiseReadQuestions,
+  readCorrections,
+  readReviewed,
+  reviewedProblemsOf,
+  slipNoteLines,
+  writeVerifyFiles
+} from "./chunk-ASKDCMW5.js";
+import {
+  dirSource,
+  frameworkFacts,
+  frameworksToLearn,
+  repairFormSlips,
+  verifyFacts
+} from "./chunk-XPWSNKF3.js";
+import {
+  NoRoomError,
+  roomGuard,
+  streamFacts
+} from "./chunk-RJDP642F.js";
+import {
+  factsDirOf,
+  factsRelOf,
+  listQuestions,
+  loadOrgPack,
+  orgPackDirOf,
+  stackHelpersOff
+} from "./chunk-JMOLB347.js";
+
+// packages/cli/dist/verify-commands.js
+import { existsSync } from "node:fs";
+import { readdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+async function frameworksKnownTo(root) {
+  const op = await loadOrgPack(orgPackDirOf(root)).catch(() => void 0);
+  return (op?.frameworks ?? []).flatMap((f) => [f.name, ...f.artifacts]);
+}
+var SHOWN = 5;
+function questionLines(text) {
+  const lines = [];
+  const problems = [];
+  for (const raw of text.split(/\r?\n/)) {
+    if (!raw.trim())
+      continue;
+    try {
+      lines.push(JSON.parse(raw));
+    } catch (e) {
+      problems.push({
+        line: JSON.stringify(raw),
+        message: `not JSON: ${e.message}`
+      });
+    }
+  }
+  return { lines, problems };
+}
+var FACTS_SIDE_FILES = /\.(questions|reviewed|rejected|corrections)\.jsonl$/;
+async function factsRepos(root) {
+  const names = await readdir(factsDirOf(root)).catch(() => []);
+  return names.filter((n) => n.endsWith(".jsonl") && !FACTS_SIDE_FILES.test(n)).map((n) => n.slice(0, -".jsonl".length)).sort();
+}
+async function verifyAllCommand(root, o, io) {
+  const repos = await factsRepos(root);
+  if (!repos.length) {
+    io.err(`No repo has facts yet (${factsRelOf(root)}/<repo>.jsonl). Read one first: /atticus-map <repo> in your assistant.`);
+    return 2;
+  }
+  const failed = [];
+  for (const repo of repos) {
+    const code = await verifyCommand(root, repo, o, io);
+    if (code !== 0)
+      failed.push(repo);
+  }
+  const passed = repos.length - failed.length;
+  io.out(`Verified ${repos.length === 1 ? "1 repo" : `${repos.length} repos`}: ${passed} passed${failed.length ? `, ${failed.length} with something to fix (${failed.join(", ")})` : ""}.`);
+  return failed.length ? 1 : 0;
+}
+async function verifyInputsOf(root, repo, dir) {
+  return {
+    // ADR 0163: the org notes the read was handed, so a term's note is one of them.
+    notes: (await notesAt(root, repo, dir)).notes,
+    corrections: await readCorrections(root, repo),
+    reviewed: await readReviewed(root, repo),
+    estate: await estateComponentsOf(root),
+    conventions: await conventionsAt(root),
+    exclude: await excludesOf(root, repo)
+  };
+}
+async function verifyCommand(root, repo, o, io) {
+  const off = stackHelpersOff();
+  const rel = factsRelOf(root);
+  const file = join(factsDirOf(root), `${repo}.jsonl`);
+  if (!existsSync(file)) {
+    io.err(`No facts for ${repo} at ${rel}/${repo}.jsonl. Run /atticus-map ${repo} in your assistant first (or atticus map ${repo} to read it in batches); it writes that file.`);
+    return 2;
+  }
+  const room = roomGuard({
+    what: `${repo}'s facts`,
+    ...o.ceilingBytes !== void 0 ? { ceilingBytes: o.ceilingBytes } : {}
+  });
+  let parsed;
+  try {
+    parsed = await streamFacts(file, room);
+  } catch (e) {
+    if (!(e instanceof NoRoomError))
+      throw e;
+    io.err(`atticus verify ${repo}: ${e.message}`);
+    return 2;
+  }
+  const repaired = repairFormSlips(parsed.facts, parsed.bad);
+  parsed = { facts: repaired.facts, bad: repaired.bad };
+  const slips = repaired.slips;
+  if (!parsed.facts.length && parsed.bad.length) {
+    io.err(`${rel}/${repo}.jsonl does not read as facts:`);
+    for (const b of parsed.bad.slice(0, 20))
+      io.err(`  line ${b.line}: ${b.issues.map((i) => i.message).join("; ")}`);
+    if (parsed.bad.length > 20)
+      io.err(`  ... and ${parsed.bad.length - 20} more (no line of the file is a fact)`);
+    return 2;
+  }
+  const dir = await checkoutOf(root, repo, o.dir);
+  if (!dir) {
+    io.err(`No checkout of ${repo}: clone it (atticus workspace sync) or give its folder with --dir.`);
+    return 2;
+  }
+  const commit = o.commit ?? await headOf(dir);
+  const source = dirSource(dir);
+  const { carry, missing } = await carryOf(dir, parsed.facts, commit, o.git);
+  const inputs = await verifyInputsOf(root, repo, dir);
+  const { corrections, reviewed, estate, conventions } = inputs;
+  for (const b of corrections.bad.slice(0, SHOWN))
+    io.err(`${rel}/${repo}.corrections.jsonl line ${b.line} isn't a correction: ${b.message}`);
+  if (corrections.bad.length > SHOWN)
+    io.err(`... and ${corrections.bad.length - SHOWN} more lines of ${rel}/${repo}.corrections.jsonl that aren't corrections`);
+  let report;
+  try {
+    report = await verifyFacts({
+      facts: parsed.facts,
+      source,
+      // G4: the stack helpers this run switched off (ATTICUS_HELPERS_OFF).
+      ...off.has("derived-names") ? { derivedNames: false } : {},
+      ...off.has("readers") ? { readers: false } : {},
+      ...commit ? { commit, carry } : {},
+      ...o.routed ? { routed: o.routed } : {},
+      exclude: inputs.exclude,
+      corrections: corrections.corrections,
+      reviewed: reviewed.entries,
+      room,
+      // J1 (ADR 0143): an exposure read here names a component the manifest lists.
+      ...estate ? { estate } : {},
+      conventions,
+      notes: inputs.notes
+    });
+  } catch (e) {
+    if (!(e instanceof NoRoomError))
+      throw e;
+    io.err(`atticus verify ${repo}: ${e.message}`);
+    return 2;
+  }
+  const reviewedBad = reviewedProblemsOf(reviewed.bad, report).map((p) => ({
+    ...p,
+    message: `${rel}/${repo}.reviewed.jsonl ${p.message}`
+  }));
+  const qFile = join(factsDirOf(root), `${repo}.questions.jsonl`);
+  let raised = 0;
+  let known = 0;
+  let qLines = 0;
+  const qProblems = [];
+  const hasQuestions = existsSync(qFile);
+  if (hasQuestions) {
+    const q = questionLines(await readFile(qFile, "utf8"));
+    qLines = q.lines.length + q.problems.length;
+    qProblems.push(...q.problems);
+    const r = await raiseReadQuestions(root, repo, q.lines, source, {
+      command: `atticus verify ${repo}`,
+      at: (o.now?.() ?? /* @__PURE__ */ new Date()).toISOString()
+    });
+    raised = r.raised.length;
+    known = r.known.length;
+    qProblems.push(...r.problems);
+  }
+  const open = hasQuestions ? (await listQuestions(root, { repo, state: "open" })).questions : [];
+  const badLines = parsed.bad.map((b) => ({
+    line: b.line,
+    raw: b.raw,
+    message: `line ${b.line} isn't a fact: ${b.issues.map((i) => i.message).join("; ")}`
+  }));
+  const summary = await writeVerifyFiles(root, repo, report, commit, qProblems, badLines, reviewedBad, slips);
+  const failed = report.rejected.length + qProblems.length + badLines.length + reviewedBad.length > 0;
+  await recordReadProgress(root, repo, {
+    commit,
+    kept: report.accepted.length,
+    ...o.now ? {
+      now: o.now().toISOString().replace(/\.\d{3}Z$/, "Z")
+    } : {}
+  });
+  const rejectedNote = `Nothing written to the catalog: ${report.rejected.length} facts were rejected. Fix them and run atticus verify ${repo} --write again.`;
+  if (o.json) {
+    let written2;
+    if (o.write && !failed) {
+      const { writeFactsIntoCatalog: writeFactsIntoCatalog2 } = await import("./chunk-KLKENMWQ.js");
+      written2 = await writeFactsIntoCatalog2(root, repo, report.accepted, { dir, command: `atticus verify ${repo} --write` }, { ...io, out: () => void 0 });
+      if (!written2)
+        return 1;
+    } else if (o.write)
+      io.err(rejectedNote);
+    io.out(JSON.stringify({
+      ...summary,
+      questions: {
+        lines: qLines,
+        raised,
+        known,
+        refused: qProblems.length,
+        open: open.length,
+        problems: qProblems
+      },
+      ...reviewedBad.length ? { reviewedProblems: reviewedBad } : {},
+      ...written2 ? { written: written2 } : {}
+    }, null, 2));
+    return failed ? 1 : 0;
+  }
+  const pct = Math.round(report.coverage.ratio * 100);
+  const cov = report.coverage;
+  io.out(`${repo}: ${report.accepted.length} facts kept, ${report.rejected.length} rejected; coverage ${pct}% (${cov.read.length} read, ${cov.reviewed.length ? `${cov.reviewed.length} reviewed with nothing to record, ` : ""}${cov.unknown.length} unknown${cov.excluded.length ? `, ${cov.excluded.length} excluded` : ""}).`);
+  const verifyYaml = `${rel}/${repo}.verify.yaml`;
+  const rejectedFile = `${rel}/${repo}.rejected.jsonl`;
+  const show = (lines, more) => {
+    for (const l of lines.slice(0, SHOWN))
+      io.out(`  ${l}`);
+    if (lines.length > SHOWN)
+      io.out(`  ... and ${lines.length - SHOWN} more ${more}`);
+  };
+  if (report.carried.length) {
+    const from = [...new Set(report.carried.map((c) => c.from.slice(0, 12)))];
+    io.out(`${report.carried.length} of them carried to ${commit.slice(0, 12)} from ${from.slice(0, SHOWN).join(", ")}${from.length > SHOWN ? ` and ${from.length - SHOWN} more commits` : ""}: every file they cite is unchanged since, and their lines were checked again (listed under carried in ${verifyYaml}).`);
+  }
+  const changed = report.rejected.filter((r) => r.code === "cite-changed").length;
+  if (changed)
+    io.out(`${changed} cite a file that changed since they were read: read those files again (atticus map ${repo} --estimate lists them), then rewrite or drop each fact.`);
+  if (missing.length) {
+    io.out(`Facts of ${missing.length === 1 ? "a commit" : `${missing.length} commits`} this clone doesn't have can't be compared with ${commit.slice(0, 12)}: they are rejected as wrong-commit; read them again.`);
+    show(missing.map((c) => c.slice(0, 12)), "commits");
+  }
+  const fixed = report.corrections.applied;
+  if (fixed.length) {
+    io.out(`${fixed.length} ${fixed.length === 1 ? "correction" : "corrections"} by a person applied (${rel}/${repo}.corrections.jsonl; listed under corrections in ${verifyYaml}):`);
+    show(fixed.map((a) => `${a.fact} ${a.action === "wrong" ? "left out as wrong" : "as corrected"}`), `(corrections in ${verifyYaml})`);
+  }
+  const stale = report.corrections.stale;
+  if (stale.length)
+    show(stale.map((s) => `correction: ${s.message}`), `corrections meeting no fact (corrections.stale in ${verifyYaml})`);
+  show(report.rejected.map((r) => `${r.code}: ${r.message}`), `rejected (all in ${rejectedFile})`);
+  if (hasQuestions) {
+    io.out(`${raised} question${raised === 1 ? "" : "s"} raised for a person now${known ? `, ${known} raised before` : ""}${qProblems.length ? `, ${qProblems.length} refused` : ""} (of ${qLines} line${qLines === 1 ? "" : "s"} in ${rel}/${repo}.questions.jsonl).`);
+    if (open.length) {
+      io.out(`${open.length} question${open.length === 1 ? "" : "s"} open for ${repo}, waiting for a person's answer (atticus questions list --state open lists them all; a person answers, never the assistant):`);
+      show(open.map((q) => `${q.id}: ${q.question}`), "open");
+    }
+  }
+  show(qProblems.map((q) => `bad-question: ${q.message}`), `refused questions (all in ${rejectedFile})`);
+  show(badLines.map((b) => `schema: ${b.message}`), `lines that aren't facts (all in ${rejectedFile})`);
+  show(reviewedBad.map((b) => `bad-reviewed: ${b.message}`), `refused reviewed lines (all in ${rejectedFile})`);
+  if (failed)
+    io.out(`Fix them from ${rel}/${repo}.rejected.jsonl (read the lines again, then rewrite or drop each fact, question or reviewed line) and run atticus verify ${repo} again.`);
+  else if (cov.unknown.length)
+    io.out(`Next: read the ${cov.unknown.length} unknown files (listed in ${rel}/${repo}.verify.yaml). A file you read and found nothing to record in goes in ${rel}/${repo}.reviewed.jsonl ({"path": "<file or glob>", "why": "..."} per line); generated code is excluded in org-pack/scan/${repo}.yaml.`);
+  else
+    io.out(`The read is complete: every source file is read (${cov.read.length})${cov.reviewed.length ? ` or reviewed with nothing to record (${cov.reviewed.length}, each with why in ${rel}/${repo}.verify.yaml)` : ""}.`);
+  for (const l of slipNoteLines(slips, verifyYaml, SHOWN))
+    io.out(l);
+  const dropped = report.reviewedDropped;
+  if (dropped.length) {
+    io.out(`${dropped.length} reviewed ${dropped.length === 1 ? "glob matches" : "globs match"} no file and ${dropped.length === 1 ? "was" : "were"} dropped (a note, not a refusal; under reviewedDropped in ${verifyYaml}):`);
+    show(dropped.map((d) => d.message), `(reviewedDropped in ${verifyYaml})`);
+  }
+  const unseen = report.methodUnseen;
+  if (unseen.length) {
+    io.out(`${unseen.length} ${unseen.length === 1 ? "entry or call claims" : "entries or calls claim"} an HTTP method ${unseen.length === 1 ? "its" : "their"} lines don't write (a warning, not a rejection; under methodUnseen in ${verifyYaml}):`);
+    show(unseen.map((m) => m.message), `(methodUnseen in ${verifyYaml})`);
+  }
+  const all = o.skipped === true;
+  const list = (lines, more) => {
+    if (all)
+      for (const l of lines)
+        io.out(`  ${l}`);
+    else
+      show(lines, more);
+  };
+  const seeAll = `atticus verify ${repo} --skipped prints every one`;
+  const skippedLines = report.skipped;
+  if (skippedLines.length) {
+    io.out(`${skippedLines.length} ${skippedLines.length === 1 ? "line of the files read writes" : "lines of the files read write"} a path, URL or topic no fact cites (a note for the reader to check, not a rejection; under skipped in ${verifyYaml}; ${seeAll}):`);
+    list(skippedLines.map((x) => `${x.cite} ${x.kind} ${x.value}`), `(${seeAll})`);
+  }
+  const holds = report.reviewedHolds;
+  if (holds.length) {
+    io.out(`${holds.length} reviewed ${holds.length === 1 ? "glob holds" : "globs hold"} lines that write a path, URL or topic (a note; under reviewedHolds in ${verifyYaml}): read them, then write their facts or say why there are none:`);
+    list(holds.map((h) => h.message), `(reviewedHolds in ${verifyYaml})`);
+  }
+  const ops = report.specOpsUncovered;
+  if (ops.length) {
+    io.out(`${ops.length} ${ops.length === 1 ? "operation the repo's OpenAPI spec declares has" : "operations the repo's OpenAPI specs declare have"} no entry (a note, not a rejection; under specOpsUncovered in ${verifyYaml}; ${seeAll}):`);
+    list(ops.map((x) => x.message), `(${seeAll})`);
+  }
+  if (report.redacted)
+    io.out(`${report.redacted} quotes had a secret value redacted.`);
+  if (report.quotesDropped)
+    io.out(`${report.quotesDropped} ${report.quotesDropped === 1 ? "quote was" : "quotes were"} left off (the cited line is minified, a notebook, binary or over 1,000 characters, and the quote doesn't match it); the claim itself was still checked on the line.`);
+  const noAuth = report.authUncited;
+  if (noAuth.length) {
+    io.out(`${noAuth.length} ${noAuth.length === 1 ? "entry's" : "entries'"} auth rests on no cited line (all under authUncited in ${verifyYaml}). ${noAuth.length === 1 ? "It is" : "They are"} kept in ${rel}/${repo}.jsonl, as the reader wrote ${noAuth.length === 1 ? "it" : "them"}, and left out of the catalog, so the map never says an auth nothing shows. To record ${noAuth.length === 1 ? "it" : "them"}: give each entry an authCite \u2014 the file and line that sets the auth and what it writes there \u2014 and run atticus verify ${repo} again:`);
+    show(noAuth.map((a) => `${a.id} (${a.auth}, ${a.cite})`), `(authUncited in ${verifyYaml})`);
+  }
+  const unfollowed = report.entriesNoFlowFollows;
+  if (unfollowed.length) {
+    io.out(`${unfollowed.length} ${unfollowed.length === 1 ? "entry" : "entries"} no flow follows (a note, not a rejection; listed under entriesNoFlowFollows in ${verifyYaml}): write a flow for each that does real work.`);
+    show(unfollowed.map((e) => `${e.entryType === "rest" && e.method ? e.method : e.entryType} ${e.path} (${e.id}, ${e.cite})`), `(entriesNoFlowFollows in ${verifyYaml})`);
+  }
+  const fws = frameworkFacts(report.accepted);
+  if (fws.length)
+    io.out(`Built on ${fws.map((f) => `${f.name}${f.version ? ` ${f.version}` : ""}`).join(", ")} (frameworks in ${verifyYaml}).`);
+  const gaps = report.frameworkGaps;
+  if (gaps.length) {
+    io.out(`${gaps.length} ${gaps.length === 1 ? "framework" : "frameworks"} this repo declares ${gaps.length === 1 ? "shows" : "show"} none of its patterns in the facts (a question for a person, not a rejection; under frameworkGaps in ${verifyYaml}):`);
+    show(gaps.map((g) => g.question), `(frameworkGaps in ${verifyYaml})`);
+  }
+  const learn = off.has("framework-models") ? [] : frameworksToLearn(report.accepted, await frameworksKnownTo(root), (await conventionsAt(root)).frameworks);
+  if (learn.length) {
+    io.out(`${learn.length} ${learn.length === 1 ? "framework" : "frameworks"} of the house nothing here can read yet: teach ${learn.length === 1 ? "it" : "them"} once, rather than having each repo's annotations read as ordinary code.`);
+    show(learn.map((l) => `${l.why} Learn it: ${l.command}`), "");
+  }
+  if (failed) {
+    if (o.write)
+      io.err(rejectedNote);
+    return 1;
+  }
+  if (!o.write) {
+    io.out(`When the read is complete: atticus verify ${repo} --write puts the facts in the catalog, the flows in specs/${repo}/, and renders the map.`);
+    return 0;
+  }
+  const { writeFactsIntoCatalog } = await import("./chunk-KLKENMWQ.js");
+  const written = await writeFactsIntoCatalog(root, repo, report.accepted, { dir, command: `atticus verify ${repo} --write`, verbose: o.verbose === true }, io);
+  return written ? 0 : 1;
+}
+
+export {
+  SHOWN,
+  factsRepos,
+  verifyAllCommand,
+  verifyInputsOf,
+  verifyCommand
+};

package/dist/chunk-YLAM4HZH.js

@@ -0,0 +1,95 @@
+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 {
+  ANTHROPIC_SETTINGS,
+  AnthropicProvider,
+  BEDROCK_SETTINGS,
+  BaseProvider,
+  BedrockProvider,
+  COMMON_SETTINGS,
+  DEFAULT_RETRY,
+  ModelProviderConfigError,
+  ModelProviderError,
+  OPENAI_SETTINGS,
+  OpenAiCompatibleProvider,
+  PROVIDER_SETTINGS,
+  PluginProvider,
+  SHIPPED_MODEL_PROVIDER_PLUGINS,
+  SettingsReader,
+  TransportError,
+  VERTEX_PLUGIN,
+  amzDates,
+  backoffMs,
+  builtInModelProviders,
+  bypassesProxy,
+  caList,
+  copy,
+  defaultKeyStore,
+  detailOf,
+  isCertCode,
+  looksLikeKey,
+  mask,
+  postJson,
+  proxyFor,
+  readKey,
+  realClock,
+  registerBuiltInModelProviders,
+  retryAfterMs,
+  showProxy,
+  sigV4Parts,
+  signV4,
+  signingKey,
+  systemKeyStore,
+  undiciTransport,
+  uriEncode
+} from "./chunk-GMJXC5AL.js";
+import "./chunk-BKFGGJKA.js";
+import "./chunk-JMOLB347.js";
+import "./chunk-MMB2OHUY.js";
+import "./chunk-TV45EUGM.js";
+export {
+  ANTHROPIC_SETTINGS,
+  AnthropicProvider,
+  BEDROCK_SETTINGS,
+  BaseProvider,
+  BedrockProvider,
+  COMMON_SETTINGS,
+  DEFAULT_RETRY,
+  ModelProviderConfigError,
+  ModelProviderError,
+  OPENAI_SETTINGS,
+  OpenAiCompatibleProvider,
+  PROVIDER_SETTINGS,
+  PluginProvider,
+  SHIPPED_MODEL_PROVIDER_PLUGINS,
+  SettingsReader,
+  TransportError,
+  VERTEX_PLUGIN,
+  amzDates,
+  backoffMs,
+  builtInModelProviders,
+  bypassesProxy,
+  caList,
+  copy,
+  defaultKeyStore,
+  detailOf,
+  isCertCode,
+  looksLikeKey,
+  mask,
+  postJson,
+  proxyFor,
+  readKey,
+  realClock,
+  registerBuiltInModelProviders,
+  retryAfterMs,
+  showProxy,
+  sigV4Parts,
+  signV4,
+  signingKey,
+  systemKeyStore,
+  undiciTransport,
+  uriEncode
+};

package/dist/chunk-YVCOQ5TZ.js

@@ -0,0 +1,47 @@
+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 {
+  contextToolBox,
+  defaultCodeDir,
+  namesInCode,
+  openIndex,
+  workspaceRepos
+} from "./chunk-XNRPCI23.js";
+
+// packages/cli/dist/code-tools.js
+var offered = /* @__PURE__ */ new Map();
+function offerCodeDir(repo, dir) {
+  offered.set(repo, dir);
+}
+function codeToolOptions(root) {
+  return {
+    codeDir: (r) => offered.get(r) ?? defaultCodeDir(root, r),
+    repos: () => [.../* @__PURE__ */ new Set([...workspaceRepos(root), ...offered.keys()])].sort(),
+    // Loaded on first use: the readers are large, and most commands never outline a file.
+    outline: async (path, text) => (await import("./chunk-MKIULIUQ.js")).declarationOutline(path, text)
+  };
+}
+function metarepoToolBox(root, calls) {
+  return contextToolBox(root, () => openIndex(root), {
+    ...codeToolOptions(root),
+    ...calls ? { calls } : {}
+  });
+}
+async function criticCodeSearch(root, names) {
+  const x = await import("./chunk-MKIULIUQ.js");
+  const r = await namesInCode(root, names, {
+    ...codeToolOptions(root),
+    outlines: (path) => x.syntaxLanguageOf(path) !== void 0
+  });
+  return r.found;
+}
+
+export {
+  offerCodeDir,
+  codeToolOptions,
+  metarepoToolBox,
+  criticCodeSearch
+};