@maycombhq/atticus 2.0.0-beta.11 → 2.0.0-beta.12.1

package/dist/{chunk-LVBPY2M6.js → chunk-6AYUBYK6.js}

@@ -4,19 +4,40 @@ var require = __atticusCreateRequire(import.meta.url);
 var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
 var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
 import {
-  readReviewed
-} from "./chunk-ASKDCMW5.js";
+  repoFor
+} from "./chunk-7VNEDDCC.js";
 import {
-  lineRangeOf
-} from "./chunk-XPWSNKF3.js";
+  frameworkFacts,
+  insideRepo,
+  lineRangeOf,
+  parseReviewed
+} from "./chunk-7VAMO66T.js";
 import {
+  changesSince,
+  createGit
+} from "./chunk-RA64IK43.js";
+import {
+  globToRegExp
+} from "./chunk-MRLCNXXR.js";
+import {
+  Conventions,
+  DEFAULT_CONVENTIONS,
+  QuestionDraft,
   citedFiles,
   external_exports,
   factsDirOf,
   factsRelOf,
+  isAdopted,
+  isSecretPath,
+  loadOrgPack,
+  orgPackDirOf,
+  parseCorrections,
   parseFacts,
-  require_dist
-} from "./chunk-JMOLB347.js";
+  parseFactsLines,
+  raiseQuestions,
+  require_dist,
+  serializeFacts
+} from "./chunk-U25OX22K.js";
 import {
   writeFileAtomic
 } from "./chunk-MMB2OHUY.js";
@@ -25,9 +46,237 @@ import {
 } from "./chunk-TV45EUGM.js";
 
 // packages/cli/dist/map-parts.js
+var import_yaml2 = __toESM(require_dist(), 1);
+import { readFile as readFile2 } from "node:fs/promises";
+import { join as join2 } from "node:path";
+
+// packages/cli/dist/facts-files.js
 var import_yaml = __toESM(require_dist(), 1);
-import { readFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import { join } from "node:path";
+async function checkoutOf(root, repo, dir) {
+  return dir ?? (isAdopted(root) ? root : (await repoFor(root, repo))?.dir ?? void 0);
+}
+async function headOf(dir) {
+  try {
+    const r = await createGit({ timeoutMs: 3e4 })(["rev-parse", "HEAD"], dir);
+    return r.stdout.trim() || void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function carryOf(dir, facts, commit, git) {
+  if (!commit)
+    return { carry: {}, missing: [] };
+  const r = await changesSince(dir, facts.map((f) => f.commit), commit, git);
+  return { carry: r.changes, missing: r.missing };
+}
+async function conventionsAt(root) {
+  const file = join(orgPackDirOf(root), "conventions.yaml");
+  if (!existsSync(file))
+    return DEFAULT_CONVENTIONS;
+  try {
+    const r = Conventions.safeParse((0, import_yaml.parse)(await readFile(file, "utf8")));
+    return r.success ? r.data : DEFAULT_CONVENTIONS;
+  } catch {
+    return DEFAULT_CONVENTIONS;
+  }
+}
+async function excludesOf(root, repo) {
+  const file = join(orgPackDirOf(root), "scan", `${repo}.yaml`);
+  if (!existsSync(file))
+    return [];
+  try {
+    const doc = (0, import_yaml.parse)(await readFile(file, "utf8"));
+    return (doc?.exclude ?? []).map((e) => e.path).filter((p) => !!p);
+  } catch {
+    return [];
+  }
+}
+async function raiseReadQuestions(root, repo, lines, source, by) {
+  const drafts = [];
+  const problems = [];
+  for (const raw of lines) {
+    const line = JSON.stringify(raw);
+    const r2 = QuestionDraft.safeParse(raw);
+    if (!r2.success) {
+      problems.push({
+        line,
+        message: `not a question: ${r2.error.issues.map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`).join("; ")}`
+      });
+      continue;
+    }
+    const bad = r2.data.evidence.find((e) => {
+      const file = e.slice(0, e.lastIndexOf(":"));
+      const n = Number(e.slice(e.lastIndexOf(":") + 1));
+      if (!insideRepo(file) || isSecretPath(file))
+        return true;
+      const text = source.read(file);
+      return text === void 0 || n < 1 || n > text.split(/\r?\n/).length;
+    });
+    if (bad) {
+      problems.push({ line, message: `its evidence ${bad} is no line of the repo` });
+      continue;
+    }
+    drafts.push(r2.data);
+  }
+  if (!drafts.length)
+    return { raised: [], known: [], problems };
+  const r = await raiseQuestions(root, drafts, {
+    step: "map",
+    repo,
+    command: by.command,
+    rerun: `atticus map ${repo}`,
+    ...by.run ? { run: by.run } : {},
+    at: by.at
+  });
+  return { raised: r.raised, known: [...r.known, ...r.reused], problems };
+}
+async function estateComponentsOf(root) {
+  const op = await loadOrgPack(orgPackDirOf(root)).catch(() => void 0);
+  const repos = (op?.profiles ?? []).flatMap((p) => p.repos?.repos ?? []);
+  if (!repos.length)
+    return void 0;
+  const components = repos.flatMap((r) => [
+    r.id,
+    ...r.component ? [r.component] : [],
+    ...(r.modules ?? []).map((m) => m.component)
+  ]);
+  const repoComponents = {};
+  for (const r of repos) {
+    const text = await readFile(join(factsDirOf(root), `${r.id}.jsonl`), "utf8").catch(() => void 0);
+    if (text === void 0)
+      continue;
+    const named = parseFactsLines(text).facts.flatMap((f) => f.component ? [f.component] : []);
+    repoComponents[r.id] = [
+      .../* @__PURE__ */ new Set([r.component ?? r.id, ...(r.modules ?? []).map((m) => m.component), ...named])
+    ].sort();
+  }
+  return { components: [...new Set(components)].sort(), repoComponents };
+}
+var SKIPPED_LISTED = 100;
+function slipNoteLines(slips, verifyYaml, shown = 5) {
+  if (!slips.length)
+    return [];
+  return [
+    `${slips.length} ${slips.length === 1 ? "slip" : "slips"} of form fixed in the facts (a note, not a rejection; under slips in ${verifyYaml}):`,
+    ...slips.slice(0, shown).map((x) => `  ${x.message}`),
+    ...slips.length > shown ? [`  ... and ${slips.length - shown} more (slips in ${verifyYaml})`] : []
+  ];
+}
+async function writeVerifyFiles(root, repo, report, commit, questionProblems = [], badLines = [], reviewedProblems = [], slips = []) {
+  const dir = factsDirOf(root);
+  await mkdir(dir, { recursive: true });
+  await writeFile(join(dir, `${repo}.jsonl`), serializeFacts(report.accepted), "utf8");
+  const rejectedFile = join(dir, `${repo}.rejected.jsonl`);
+  const lines = [
+    ...report.rejected.map((r) => JSON.stringify({ code: r.code, message: r.message, fact: r.fact })),
+    ...questionProblems.map((q) => JSON.stringify({ code: "bad-question", message: q.message, question: JSON.parse(q.line) })),
+    ...badLines.map((b) => JSON.stringify({ code: "schema", message: b.message, raw: b.raw })),
+    ...reviewedProblems.map((r) => JSON.stringify({ code: "bad-reviewed", message: r.message, reviewed: r.raw }))
+  ];
+  if (lines.length)
+    await writeFile(rejectedFile, lines.join("\n") + "\n", "utf8");
+  else
+    await rm(rejectedFile, { force: true });
+  const summary = {
+    repo,
+    ...commit ? { commit } : {},
+    accepted: report.accepted.length,
+    rejected: report.rejected.length,
+    redacted: report.redacted,
+    ...report.quotesDropped ? { quotesDropped: report.quotesDropped } : {},
+    coverage: {
+      ratio: report.coverage.ratio,
+      read: report.coverage.read.length,
+      ...report.coverage.reviewed.length ? { reviewed: report.coverage.reviewed.length } : {},
+      unknown: report.coverage.unknown,
+      excluded: report.coverage.excluded,
+      ...report.coverage.notReached.length ? { notReached: report.coverage.notReached } : {}
+    },
+    rejections: report.rejected.map((r) => ({ id: r.fact.id, code: r.code, message: r.message })),
+    // ADR 0124 addendum D-app: a person's corrections, said only when there are some.
+    ...report.corrections.applied.length || report.corrections.stale.length ? {
+      corrections: {
+        applied: report.corrections.applied,
+        stale: report.corrections.stale.map((s) => ({
+          fact: s.correction.fact,
+          why: s.why,
+          message: s.message
+        }))
+      }
+    } : {}
+  };
+  if (report.carried.length) {
+    const by = /* @__PURE__ */ new Map();
+    for (const c of report.carried)
+      by.set(c.from, [...by.get(c.from) ?? [], c.id]);
+    summary.carried = [...by.entries()].sort((a, b) => a[0] < b[0] ? -1 : 1).map(([from, facts]) => ({ from, facts: facts.sort() }));
+  }
+  if (report.entriesNoFlowFollows.length)
+    summary.entriesNoFlowFollows = report.entriesNoFlowFollows;
+  if (report.reviewed.length)
+    summary.reviewed = report.reviewed;
+  if (report.reviewedDropped.length)
+    summary.reviewedDropped = report.reviewedDropped;
+  if (report.methodUnseen.length) {
+    summary.methodUnseenCount = report.methodUnseen.length;
+    summary.methodUnseen = report.methodUnseen;
+  }
+  if (report.skipped.length) {
+    summary.skippedCount = report.skipped.length;
+    summary.skipped = report.skipped.slice(0, SKIPPED_LISTED);
+  }
+  if (report.reviewedHolds.length)
+    summary.reviewedHolds = report.reviewedHolds;
+  if (report.specOpsUncovered.length) {
+    summary.specOpsUncoveredCount = report.specOpsUncovered.length;
+    summary.specOpsUncovered = report.specOpsUncovered.slice(0, SKIPPED_LISTED);
+  }
+  if (slips.length)
+    summary.slips = [...slips];
+  if (report.authUncited.length)
+    summary.authUncited = report.authUncited;
+  const fws = frameworkFacts(report.accepted);
+  if (fws.length)
+    summary.frameworks = fws.map((f) => ({
+      name: f.name,
+      ...f.version ? { version: f.version } : {},
+      cite: `${f.cite.file}:${f.cite.line}`,
+      ...f.component ? { component: f.component } : {}
+    }));
+  if (report.frameworkGaps.length)
+    summary.frameworkGaps = report.frameworkGaps;
+  await writeFile(join(dir, `${repo}.verify.yaml`), (0, import_yaml.stringify)(summary), "utf8");
+  return summary;
+}
+async function readCorrections(root, repo) {
+  const text = await readFile(join(factsDirOf(root), `${repo}.corrections.jsonl`), "utf8").catch(() => void 0);
+  return text === void 0 ? { corrections: [], bad: [] } : parseCorrections(text);
+}
+async function readReviewed(root, repo) {
+  const text = await readFile(join(factsDirOf(root), `${repo}.reviewed.jsonl`), "utf8").catch(() => void 0);
+  if (text === void 0)
+    return { entries: [], bad: [] };
+  const r = parseReviewed(text);
+  return {
+    entries: r.entries,
+    bad: r.bad.map((b) => ({ line: b.line, raw: b.raw, message: b.message }))
+  };
+}
+function reviewedProblemsOf(bad, report) {
+  return [
+    ...bad,
+    ...report.reviewedProblems.map((p) => ({
+      ...p.line !== void 0 ? { line: p.line } : {},
+      raw: { path: p.path, why: p.why },
+      message: p.message
+    }))
+  ].sort((a, b) => (a.line ?? 0) - (b.line ?? 0));
+}
+
+// packages/cli/dist/map-parts.js
 var ReadStamp = external_exports.strictObject({ at: external_exports.string().min(1), commit: external_exports.string().min(1) });
 var Part = external_exports.strictObject({
   part: external_exports.number().int().positive(),
@@ -57,6 +306,34 @@ var Reported = external_exports.strictObject({
   /** Who reported it (--by), when given. */
   by: external_exports.string().min(1).optional()
 });
+var RulesRecord = external_exports.strictObject({
+  hash: external_exports.string().min(1),
+  sets: external_exports.array(external_exports.string().min(1))
+});
+var TopUpSession = external_exports.strictObject({
+  paths: external_exports.array(external_exports.string().min(1)).min(1),
+  sets: external_exports.array(external_exports.string().min(1)).min(1),
+  files: external_exports.number().int().nonnegative(),
+  tokens: external_exports.number().int().nonnegative(),
+  /** When `atticus map <repo> --rules` last gave it to a reader. */
+  given: external_exports.string().min(1).optional(),
+  /** When a verify that passed after it was given found it done. */
+  done: ReadStamp.optional()
+});
+var TopUp = external_exports.strictObject({
+  commit: external_exports.string().min(1),
+  hash: external_exports.string().min(1),
+  sets: external_exports.array(external_exports.string().min(1)),
+  session: external_exports.number().int().positive(),
+  plannedAt: external_exports.string().min(1),
+  sessions: external_exports.array(TopUpSession)
+});
+var MODELS_MODES = ["reachable", "all"];
+var NotReached = external_exports.strictObject({
+  why: external_exports.string().min(1),
+  files: external_exports.array(external_exports.string().min(1)),
+  tokens: external_exports.number().int().nonnegative()
+});
 var ReadPlanFile = external_exports.strictObject({
   /** 2 since ADR 0141 (a v1 file reads as v2: `migrateReadPlan`). */
   schemaVersion: external_exports.literal(2),
@@ -82,7 +359,18 @@ var ReadPlanFile = external_exports.strictObject({
   /** ADR 0141: when `atticus verify` first found the whole plan in the facts. */
   read: ReadStamp.extend({ sessions: external_exports.number().int().positive() }).optional(),
   /** ADR 0141: what the reader reported the read took (`atticus map <repo> --spent`). */
-  reported: external_exports.array(Reported).optional()
+  reported: external_exports.array(Reported).optional(),
+  /** ADR 0167: the reading rules the read was given; none when read before they were recorded. */
+  rules: RulesRecord.optional(),
+  /** ADR 0167: a top-up for the rule sets the read lacked, under way. */
+  topUp: TopUp.optional(),
+  /**
+   * ADR 0169: `all` when a person asked for every model class (`--models all`); left out, the
+   * read takes those its entry points and calls reach.
+   */
+  models: external_exports.enum(MODELS_MODES).optional(),
+  /** ADR 0169: the model files the read leaves out, nothing reaching them. */
+  notReached: NotReached.optional()
 });
 function migrateReadPlan(raw) {
   const v2 = ReadPlanFile.safeParse(raw);
@@ -94,7 +382,7 @@ function migrateReadPlan(raw) {
   return { ...v1.data, schemaVersion: 2 };
 }
 var readPlanRelOf = (root, repo) => `${factsRelOf(root)}/${repo}.read-plan.yaml`;
-var readPlanPath = (root, repo) => join(factsDirOf(root), `${repo}.read-plan.yaml`);
+var readPlanPath = (root, repo) => join2(factsDirOf(root), `${repo}.read-plan.yaml`);
 function unitOf(glob) {
   const range = lineRangeOf(glob);
   if (range)
@@ -107,7 +395,7 @@ function unitOf(glob) {
     return { glob, dir: "", deep: false };
   if (glob.endsWith("/*"))
     return { glob, dir: glob.slice(0, -2), deep: false };
-  return { glob, dir: glob.replace(/\/?[^/]*$/, ""), deep: false };
+  return { glob, dir: glob.replace(/\/?[^/]*$/, ""), deep: false, file: glob };
 }
 function folderOf(path) {
   const star = path.search(/[*?]/);
@@ -115,6 +403,7 @@ function folderOf(path) {
     return { dir: path.replace(/\/?[^/]*$/, ""), deep: false };
   return { dir: path.slice(0, star).replace(/\/$/, ""), deep: true };
 }
+var isGlobPath = (p) => /[*?]/.test(p);
 var under = (dir, of) => of === "" || dir === of || dir.startsWith(`${of}/`);
 function globHolds(glob, file) {
   const u = unitOf(glob);
@@ -127,7 +416,7 @@ function globHolds(glob, file) {
 }
 var HEADER = "# The parts this repo is read in (ADR 0124 addendum A-ledger), as atticus map --estimate planned them,\n# and what the read cost (ADR 0141): tokens are estimates, reported numbers are the reader's word.\n# Which part is next is read back from the facts; atticus next says it. Atticus writes this file.\n";
 async function saveReadPlan(root, plan) {
-  await writeFileAtomic(readPlanPath(root, plan.repo), `${HEADER}${(0, import_yaml.stringify)(ReadPlanFile.parse(plan), { lineWidth: 0 })}`);
+  await writeFileAtomic(readPlanPath(root, plan.repo), `${HEADER}${(0, import_yaml2.stringify)(ReadPlanFile.parse(plan), { lineWidth: 0 })}`);
 }
 async function writeReadPlan(root, repo, o) {
   const plan = {
@@ -143,18 +432,45 @@ async function writeReadPlan(root, repo, o) {
       files: p.files,
       tokens: p.tokens
     })),
-    ...o.reported?.length ? { reported: [...o.reported] } : {}
+    ...o.reported?.length ? { reported: [...o.reported] } : {},
+    ...o.rules ? { rules: { hash: o.rules.hash, sets: [...o.rules.sets] } } : {},
+    ...o.models === "all" ? { models: "all" } : {},
+    ...o.notReached?.files.length ? { notReached: o.notReached } : {}
   };
   await saveReadPlan(root, plan);
   return plan;
 }
 var stamp = () => (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
+async function recordNotReached(root, repo, o) {
+  const plan = await loadReadPlan(root, repo);
+  const { notReached: _n, models: _m, ...rest } = plan ?? {
+    schemaVersion: 2,
+    repo,
+    commit: o.commit,
+    session: o.session,
+    plannedAt: stamp(),
+    parts: []
+  };
+  const next = {
+    ...rest,
+    ...o.models === "all" ? { models: "all" } : {},
+    ...o.notReached?.files.length ? { notReached: o.notReached } : {}
+  };
+  if (plan && JSON.stringify(plan) === JSON.stringify(next))
+    return;
+  if (!plan && !next.notReached && !next.models)
+    return;
+  await saveReadPlan(root, next);
+}
+async function modelsModeOf(root, repo, asked) {
+  return asked ?? (await loadReadPlan(root, repo))?.models ?? "reachable";
+}
 async function loadReadPlan(root, repo) {
-  const text = await readFile(readPlanPath(root, repo), "utf8").catch(() => void 0);
+  const text = await readFile2(readPlanPath(root, repo), "utf8").catch(() => void 0);
   if (text === void 0)
     return void 0;
   try {
-    return migrateReadPlan((0, import_yaml.parse)(text));
+    return migrateReadPlan((0, import_yaml2.parse)(text));
   } catch {
     return void 0;
   }
@@ -178,7 +494,7 @@ async function coveredOf(root, repo) {
   const reviewed = /* @__PURE__ */ new Set();
   const lines = [];
   const ranges = /* @__PURE__ */ new Set();
-  const text = await readFile(join(factsDirOf(root), `${repo}.jsonl`), "utf8").catch(() => void 0);
+  const text = await readFile2(join2(factsDirOf(root), `${repo}.jsonl`), "utf8").catch(() => void 0);
   if (text !== void 0) {
     const parsed = parseFacts(text);
     const facts = parsed.ok ? parsed.facts : [];
@@ -235,6 +551,8 @@ function progressOf(plan, of, o) {
         return of.ranges.has(u.glob) || of.lines.some((l) => l.file === r.file && l.line >= start && l.line <= r.to) || // The whole file reviewed, or a folder glob reviewed over it.
         of.reviewed.has(r.file) || [...of.reviewed].some((c) => folderOf(c).deep && under(u.dir, folderOf(c).dir));
       }
+      if (u.file)
+        return of.paths.includes(u.file) || [...of.reviewed].some((c) => isGlobPath(c) && globToRegExp(c).test(u.file));
       return covered.some((c) => u.deep ? under(c.dir, u.dir) : c.dir === u.dir || c.deep && under(u.dir, c.dir));
     };
     const yes = units.filter(hit).map((u) => u.glob);
@@ -387,12 +705,27 @@ async function mapSpent(root, repo, o, io) {
 }
 
 export {
+  checkoutOf,
+  headOf,
+  carryOf,
+  conventionsAt,
+  excludesOf,
+  raiseReadQuestions,
+  estateComponentsOf,
+  slipNoteLines,
+  writeVerifyFiles,
+  readCorrections,
+  readReviewed,
+  reviewedProblemsOf,
+  MODELS_MODES,
   ReadPlanFile,
   migrateReadPlan,
   readPlanRelOf,
   globHolds,
   saveReadPlan,
   writeReadPlan,
+  recordNotReached,
+  modelsModeOf,
   loadReadPlan,
   readPlanProgress,
   ownStarts,

package/dist/{chunk-IY4PHPHT.js → chunk-6HSRGY4B.js}

@@ -4,12 +4,14 @@ var require = __atticusCreateRequire(import.meta.url);
 var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
 var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
 import {
-  routeQuestions
-} from "./chunk-5RUMHLIS.js";
-import "./chunk-XZJE6WIT.js";
-import "./chunk-JMOLB347.js";
+  routeQuestions,
+  ruleOffers
+} from "./chunk-P3VBYYAS.js";
+import "./chunk-RA64IK43.js";
+import "./chunk-U25OX22K.js";
 import "./chunk-MMB2OHUY.js";
 import "./chunk-TV45EUGM.js";
 export {
-  routeQuestions
+  routeQuestions,
+  ruleOffers
 };

package/dist/{chunk-Y5AYBGLB.js → chunk-6IKYFARG.js}

@@ -4,11 +4,11 @@ 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";
+  recordTopUpVerified
+} from "./chunk-QOF7U6BI.js";
 import {
-  recordReadProgress
-} from "./chunk-LVBPY2M6.js";
+  notesAt
+} from "./chunk-CGF4LKXR.js";
 import {
   carryOf,
   checkoutOf,
@@ -16,25 +16,27 @@ import {
   estateComponentsOf,
   excludesOf,
   headOf,
+  loadReadPlan,
   raiseReadQuestions,
   readCorrections,
   readReviewed,
+  recordReadProgress,
   reviewedProblemsOf,
   slipNoteLines,
   writeVerifyFiles
-} from "./chunk-ASKDCMW5.js";
+} from "./chunk-6AYUBYK6.js";
 import {
   dirSource,
   frameworkFacts,
   frameworksToLearn,
   repairFormSlips,
   verifyFacts
-} from "./chunk-XPWSNKF3.js";
+} from "./chunk-7VAMO66T.js";
 import {
   NoRoomError,
   roomGuard,
   streamFacts
-} from "./chunk-RJDP642F.js";
+} from "./chunk-ARLH2ZMD.js";
 import {
   factsDirOf,
   factsRelOf,
@@ -42,7 +44,7 @@ import {
   loadOrgPack,
   orgPackDirOf,
   stackHelpersOff
-} from "./chunk-JMOLB347.js";
+} from "./chunk-U25OX22K.js";
 
 // packages/cli/dist/verify-commands.js
 import { existsSync } from "node:fs";
@@ -99,7 +101,9 @@ async function verifyInputsOf(root, repo, dir) {
     reviewed: await readReviewed(root, repo),
     estate: await estateComponentsOf(root),
     conventions: await conventionsAt(root),
-    exclude: await excludesOf(root, repo)
+    exclude: await excludesOf(root, repo),
+    // ADR 0169: the model files the read plan leaves out, counted apart in coverage.
+    notReached: (await loadReadPlan(root, repo))?.notReached?.files ?? []
   };
 }
 async function verifyCommand(root, repo, o, io) {
@@ -165,7 +169,8 @@ async function verifyCommand(root, repo, o, io) {
       // J1 (ADR 0143): an exposure read here names a component the manifest lists.
       ...estate ? { estate } : {},
       conventions,
-      notes: inputs.notes
+      notes: inputs.notes,
+      notReached: inputs.notReached
     });
   } catch (e) {
     if (!(e instanceof NoRoomError))
@@ -210,11 +215,13 @@ async function verifyCommand(root, repo, o, io) {
       now: o.now().toISOString().replace(/\.\d{3}Z$/, "Z")
     } : {}
   });
+  if (!failed)
+    await recordTopUpVerified(root, repo, { commit });
   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");
+      const { writeFactsIntoCatalog: writeFactsIntoCatalog2 } = await import("./chunk-CUD4I2U6.js");
       written2 = await writeFactsIntoCatalog2(root, repo, report.accepted, { dir, command: `atticus verify ${repo} --write` }, { ...io, out: () => void 0 });
       if (!written2)
         return 1;
@@ -237,7 +244,9 @@ async function verifyCommand(root, repo, o, io) {
   }
   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` : ""}).`);
+  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` : ""}${cov.notReached.length ? `, ${cov.notReached.length} model files no entry or call reaches` : ""}).`);
+  if (cov.notReached.length)
+    io.out(`${cov.notReached.length} model files no entry or call reaches; atticus map ${repo} --models all reads them.`);
   const verifyYaml = `${rel}/${repo}.verify.yaml`;
   const rejectedFile = `${rel}/${repo}.rejected.jsonl`;
   const show = (lines, more) => {
@@ -354,7 +363,7 @@ async function verifyCommand(root, repo, o, io) {
     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 { writeFactsIntoCatalog } = await import("./chunk-CUD4I2U6.js");
   const written = await writeFactsIntoCatalog(root, repo, report.accepted, { dir, command: `atticus verify ${repo} --write`, verbose: o.verbose === true }, io);
   return written ? 0 : 1;
 }

package/dist/{chunk-7KXYMC2P.js → chunk-6R2OM6Y3.js}

@@ -10,22 +10,22 @@ import {
   findingAction,
   findings,
   statusLine
-} from "./chunk-HGQZTUAC.js";
+} from "./chunk-5I5JDJ3R.js";
 import "./chunk-VOGCSYOI.js";
-import "./chunk-T6ESD5KM.js";
-import "./chunk-3LU6YCSQ.js";
-import "./chunk-L7I5PKGD.js";
-import "./chunk-CAN3EBE5.js";
-import "./chunk-IILZ7J3L.js";
-import "./chunk-TEBBD4XH.js";
-import "./chunk-XPWSNKF3.js";
-import "./chunk-WIMOJMAK.js";
-import "./chunk-5V5BJACL.js";
-import "./chunk-GVFUEGGM.js";
-import "./chunk-XZJE6WIT.js";
-import "./chunk-FMRMTI7W.js";
-import "./chunk-BKFGGJKA.js";
-import "./chunk-JMOLB347.js";
+import "./chunk-KPHPVOME.js";
+import "./chunk-G5SKNMPC.js";
+import "./chunk-JQG4VO47.js";
+import "./chunk-DW4BM73R.js";
+import "./chunk-DBZNQAMN.js";
+import "./chunk-QR65C3DV.js";
+import "./chunk-7VAMO66T.js";
+import "./chunk-HY2VVVFZ.js";
+import "./chunk-PJRMMWU4.js";
+import "./chunk-34NWVIBC.js";
+import "./chunk-RA64IK43.js";
+import "./chunk-MRLCNXXR.js";
+import "./chunk-CQD26SMZ.js";
+import "./chunk-U25OX22K.js";
 import "./chunk-MMB2OHUY.js";
 import "./chunk-TV45EUGM.js";
 export {

package/dist/{chunk-GWSWS264.js → chunk-6ROZRBWH.js}

@@ -5,17 +5,17 @@ var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
 var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
 import {
   metarepoToolBox
-} from "./chunk-YVCOQ5TZ.js";
+} from "./chunk-TEHH47TG.js";
 import {
   CONTEXT_TOOLS
-} from "./chunk-XNRPCI23.js";
+} from "./chunk-77UOXZVM.js";
 import {
   TOOL_LIMITS,
   ToolSession,
   readToolCalls,
   recordToolCalls
-} from "./chunk-BKFGGJKA.js";
-import "./chunk-JMOLB347.js";
+} from "./chunk-CQD26SMZ.js";
+import "./chunk-U25OX22K.js";
 import "./chunk-MMB2OHUY.js";
 import "./chunk-TV45EUGM.js";
 

package/dist/{chunk-TZXHUDI6.js → chunk-72DY5NCN.js}

@@ -8,7 +8,7 @@ import {
   executorsCheck,
   inputsSha256,
   runStep
-} from "./chunk-7J7UY46S.js";
+} from "./chunk-ZTIMXVV5.js";
 import {
   table
 } from "./chunk-VOGCSYOI.js";
@@ -17,7 +17,7 @@ import {
   exportStep,
   fileStepStore,
   recordStep
-} from "./chunk-CAN3EBE5.js";
+} from "./chunk-DW4BM73R.js";
 
 // packages/cli/dist/todo-commands.js
 var iso = (d) => d.toISOString().replace(/\.\d{3}Z$/, "Z");