@maycombhq/atticus 2.0.0-beta.18 → 2.0.0-beta.21

package/dist/chunk-PKJAV25S.js

@@ -0,0 +1,43 @@
+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 {
+  explainCommand,
+  learnCheck,
+  learnList,
+  learnStart,
+  sandboxCreate
+} from "./chunk-ZQLRCA2V.js";
+import "./chunk-4B6BT75O.js";
+import "./chunk-2HTEMYTB.js";
+import "./chunk-3AQ2R5NL.js";
+import "./chunk-BEPCKDCP.js";
+import "./chunk-HWD4JPU7.js";
+import "./chunk-5WERBKLE.js";
+import "./chunk-VOGCSYOI.js";
+import "./chunk-K332XW7K.js";
+import "./chunk-HSZMPH5T.js";
+import "./chunk-D2WSW4GU.js";
+import "./chunk-4KNOJC6J.js";
+import "./chunk-4SLBCEPD.js";
+import "./chunk-64AADMTW.js";
+import "./chunk-JYMIB5XY.js";
+import "./chunk-CPK7QSBG.js";
+import "./chunk-YO2PKTXT.js";
+import "./chunk-TWQRPM76.js";
+import "./chunk-VUVGX5L2.js";
+import "./chunk-XOL3GFW2.js";
+import "./chunk-QHJJMZLX.js";
+import "./chunk-7AB6OWTV.js";
+import "./chunk-PAINMSID.js";
+import "./chunk-ODMBPDDV.js";
+import "./chunk-TV45EUGM.js";
+export {
+  explainCommand,
+  learnCheck,
+  learnList,
+  learnStart,
+  sandboxCreate
+};

package/dist/{chunk-R5MNPIMD.js → chunk-PNQLCRSS.js}

@@ -5,20 +5,20 @@ var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
 var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
 import {
   readCatalog
-} from "./chunk-EZBAS5BL.js";
+} from "./chunk-4SLBCEPD.js";
 import {
   scopeWords
-} from "./chunk-KCQS52TH.js";
+} from "./chunk-64AADMTW.js";
 import {
   baseClonePath,
   loadManifest
-} from "./chunk-ZQC7MNQB.js";
+} from "./chunk-XOL3GFW2.js";
 import {
   Sources,
   catalogDirOf,
   orgPackDirOf,
   require_dist
-} from "./chunk-YK6CSODO.js";
+} from "./chunk-PAINMSID.js";
 import {
   __toESM
 } from "./chunk-TV45EUGM.js";

package/dist/{chunk-3SMMFQED.js → chunk-PQH56YF6.js}

@@ -8,10 +8,14 @@ import {
   notMetarepo
 } from "./chunk-3G4YI4ZU.js";
 import {
+  eolOf,
+  inEol,
   orgPackDirOf,
   require_dist
-} from "./chunk-YK6CSODO.js";
-import "./chunk-MMB2OHUY.js";
+} from "./chunk-PAINMSID.js";
+import {
+  writeFileIfUnchanged
+} from "./chunk-ODMBPDDV.js";
 import {
   __toESM
 } from "./chunk-TV45EUGM.js";
@@ -20,6 +24,32 @@ import {
 var import_yaml = __toESM(require_dist(), 1);
 import { readFile, writeFile } from "node:fs/promises";
 import { join, relative, sep } from "node:path";
+var OwnerEditError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+};
+var HANDLE = /^[A-Za-z0-9][A-Za-z0-9._@-]*$/;
+async function setOrgPackOwner(root, handle, was) {
+  const file = join(orgPackDirOf(root), "pack.yaml");
+  const rel = relative(root, file).split(sep).join("/");
+  const text = await readFile(file, "utf8").catch(() => void 0);
+  if (text === void 0)
+    throw new OwnerEditError("not-found", `${rel} isn't there: atticus upgrade writes it.`);
+  const h = handle.trim();
+  if (!HANDLE.test(h))
+    throw new OwnerEditError("invalid", "The owner is one handle, such as priya.nair or team-platform: letters, digits, dots, hyphens.");
+  const doc = (0, import_yaml.parseDocument)(text);
+  const now = doc.get("owner");
+  const current = typeof now === "string" && now !== "unassigned" ? now : "";
+  if (was !== void 0 && was !== current)
+    throw new OwnerEditError("conflict", `pack.yaml's owner changed since you opened the form (now ${current || "unassigned"}): look again, then save.`);
+  doc.set("owner", h);
+  await writeFileIfUnchanged(file, text, inEol(doc.toString({ lineWidth: 0 }), eolOf(text)));
+  return { file: rel, owner: h };
+}
 async function orgPackOwnerCli(root, handle, io) {
   if (!isMetarepo(root)) {
     io.err(notMetarepo(root));
@@ -39,15 +69,17 @@ async function orgPackOwnerCli(root, handle, io) {
     return 0;
   }
   const h = handle.trim();
-  if (!/^[A-Za-z0-9][A-Za-z0-9._@-]*$/.test(h)) {
+  if (!HANDLE.test(h)) {
     io.err("The owner is one handle, such as priya.nair or team-platform: letters, digits, dots, hyphens.");
     return 2;
   }
   doc.set("owner", h);
-  await writeFile(file, doc.toString({ lineWidth: 0 }), "utf8");
+  await writeFile(file, inEol(doc.toString({ lineWidth: 0 }), eolOf(text)), "utf8");
   io.out(`${h} now looks after the org pack. Commit ${rel} through a pull request; its owner approves changes to it.`);
   return 0;
 }
 export {
-  orgPackOwnerCli
+  OwnerEditError,
+  orgPackOwnerCli,
+  setOrgPackOwner
 };

package/dist/chunk-PRTBPXYA.js

@@ -0,0 +1,50 @@
+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 {
+  MIN_GIT,
+  MIN_NODE,
+  defaultOnPath,
+  doctorChecks,
+  doctorCommand,
+  stepModelChoices,
+  stepModelLine
+} from "./chunk-HGHRSF3E.js";
+import "./chunk-4B6BT75O.js";
+import "./chunk-3G4YI4ZU.js";
+import "./chunk-2HTEMYTB.js";
+import "./chunk-3AQ2R5NL.js";
+import "./chunk-BEPCKDCP.js";
+import "./chunk-HWD4JPU7.js";
+import "./chunk-5WERBKLE.js";
+import "./chunk-K332XW7K.js";
+import "./chunk-HSZMPH5T.js";
+import "./chunk-D2WSW4GU.js";
+import "./chunk-4KNOJC6J.js";
+import "./chunk-4SLBCEPD.js";
+import "./chunk-64AADMTW.js";
+import "./chunk-JYMIB5XY.js";
+import "./chunk-CPK7QSBG.js";
+import "./chunk-YO2PKTXT.js";
+import "./chunk-TWQRPM76.js";
+import {
+  versionAtLeast
+} from "./chunk-VUVGX5L2.js";
+import "./chunk-XOL3GFW2.js";
+import "./chunk-QHJJMZLX.js";
+import "./chunk-7AB6OWTV.js";
+import "./chunk-PAINMSID.js";
+import "./chunk-ODMBPDDV.js";
+import "./chunk-TV45EUGM.js";
+export {
+  MIN_GIT,
+  MIN_NODE,
+  defaultOnPath,
+  doctorChecks,
+  doctorCommand,
+  stepModelChoices,
+  stepModelLine,
+  versionAtLeast
+};

package/dist/{chunk-FF4ZMLSL.js → chunk-PRW3HXM3.js}

@@ -8,10 +8,10 @@ import {
   RuntimeError,
   estimateTokens,
   registerModelProvider
-} from "./chunk-QNMLLYTN.js";
+} from "./chunk-QHJJMZLX.js";
 import {
   redactText
-} from "./chunk-MMB2OHUY.js";
+} from "./chunk-ODMBPDDV.js";
 import {
   __commonJS,
   __require,

package/dist/chunk-PRZ7KMWL.js

@@ -0,0 +1,42 @@
+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 {
+  boxesOf,
+  candidatesOf,
+  settingsOf,
+  uiLinkRoutes
+} from "./chunk-6DQYZU2W.js";
+import "./chunk-HK3VOHIE.js";
+import "./chunk-THN26IEF.js";
+import "./chunk-GX74YWR7.js";
+import "./chunk-G6IQYM25.js";
+import "./chunk-LPV6T362.js";
+import "./chunk-TQ4TG57V.js";
+import "./chunk-5WERBKLE.js";
+import "./chunk-VOGCSYOI.js";
+import "./chunk-K332XW7K.js";
+import "./chunk-HSZMPH5T.js";
+import "./chunk-D2WSW4GU.js";
+import "./chunk-4KNOJC6J.js";
+import "./chunk-4SLBCEPD.js";
+import "./chunk-64AADMTW.js";
+import "./chunk-JYMIB5XY.js";
+import "./chunk-CPK7QSBG.js";
+import "./chunk-YO2PKTXT.js";
+import "./chunk-TWQRPM76.js";
+import "./chunk-VUVGX5L2.js";
+import "./chunk-XOL3GFW2.js";
+import "./chunk-QHJJMZLX.js";
+import "./chunk-7AB6OWTV.js";
+import "./chunk-PAINMSID.js";
+import "./chunk-ODMBPDDV.js";
+import "./chunk-TV45EUGM.js";
+export {
+  boxesOf,
+  candidatesOf,
+  settingsOf,
+  uiLinkRoutes
+};

package/dist/{chunk-IFV6MKYV.js → chunk-PTQ3ZALZ.js}

@@ -10,6 +10,7 @@ import {
   CriticError,
   act,
   checkRoundRule,
+  completeLensBatch,
   completeLensRun,
   gateStatus,
   lensAnswerProblem,
@@ -21,7 +22,7 @@ import {
   roundsUsed,
   runCritic,
   waitingLenses
-} from "./chunk-VEJYZEPC.js";
+} from "./chunk-K332XW7K.js";
 import {
   changeFolder,
   changeStore,
@@ -29,13 +30,13 @@ import {
   phaseStage,
   stageCommand,
   statePhase
-} from "./chunk-IOW6BF3U.js";
+} from "./chunk-HSZMPH5T.js";
 import {
   AiOffError,
   HandoffRuntime,
   RuntimeConfigError,
   runtimeForCli
-} from "./chunk-QNMLLYTN.js";
+} from "./chunk-QHJJMZLX.js";
 import {
   CriticQuestion,
   LEGACY_LENSES,
@@ -43,7 +44,7 @@ import {
   require_dist,
   runsDirOf,
   runsRelOf
-} from "./chunk-YK6CSODO.js";
+} from "./chunk-PAINMSID.js";
 import {
   __toESM
 } from "./chunk-TV45EUGM.js";
@@ -253,6 +254,35 @@ async function completeCriticLens(root, run, io, o = {}) {
     return fail(io, e);
   }
 }
+async function completeCriticBatch(root, batch, result, io, o = {}) {
+  let read;
+  try {
+    read = await completeLensBatch(root, batch, result, o.now ? { now: o.now } : {});
+  } catch (e) {
+    return fail(io, e);
+  }
+  for (const c of read) {
+    const where2 = `The ${c.lens.lens} lens of round ${c.round} at the ${c.gate} gate`;
+    io.out(c.lens.state === "ran" ? `${where2} raised ${plural(c.findings.length, "finding", "findings")}.` : `${where2} ${c.lens.state}: ${c.lens.reason ?? ""}`.trimEnd());
+    for (const d of c.discarded)
+      io.err(`Discarded: ${d.reason}`);
+    if (c.lens.state === "ran" && c.lens.reason)
+      io.out(`  ${c.lens.reason}`);
+  }
+  if (batch.state !== "validated") {
+    for (const e of batch.errors)
+      io.err(e);
+    io.err(`Fix what is listed in ${runsRelOf(root)}/${batch.request.change}/${batch.runId}/${batch.request.outputPath} and run atticus handoff done ${batch.runId} again: only the lenses still out are checked. Or answer a lens alone with its own run.`);
+  }
+  const last = read.at(-1);
+  if (last) {
+    if (last.waiting.length)
+      io.out(`${plural(last.waiting.length, "AI lens", "AI lenses")} ${last.waiting.length === 1 ? "is" : "are"} still with your assistant: ${last.waiting.map((w) => w.lens).join(", ")}.`);
+    else
+      io.out(statusLine(last.status));
+  }
+  return batch.state === "validated" && read.every((c) => c.lens.state === "ran") ? 0 : 1;
+}
 async function resumeLenses(root, changeId, o, io, deps) {
   try {
     await changeStore(root).read(changeId).catch((e) => {
@@ -370,6 +400,13 @@ async function findingAction(root, changeId, findingId, action, o, io, deps = {}
       ...deps.now ? { now: deps.now } : {}
     });
     io.out(r.message);
+    if (r.finding.state !== "open") {
+      const { retireChangeEscalations } = await import("./chunk-NTAVOWYD.js");
+      const at = deps.now ?? (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
+      const stages = await retireChangeEscalations(root, changeId, at).catch(() => []);
+      if (stages.length)
+        io.out(`Retired the ${stages.join(" and ")} stage's question about it: the finding is settled.`);
+    }
     return 0;
   } catch (e) {
     return fail(io, e);
@@ -409,6 +446,7 @@ export {
   statusLine,
   critic,
   completeCriticLens,
+  completeCriticBatch,
   findings,
   findingAction,
   criticStats

package/dist/{chunk-ELQSLAP6.js → chunk-PUEWDYGP.js}

@@ -5,8 +5,8 @@ var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
 var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
 import {
   assistantActor
-} from "./chunk-YK6CSODO.js";
-import "./chunk-MMB2OHUY.js";
+} from "./chunk-PAINMSID.js";
+import "./chunk-ODMBPDDV.js";
 import "./chunk-TV45EUGM.js";
 
 // packages/cli/dist/assistant-session.js

package/dist/{chunk-F2ZCZYIK.js → chunk-Q26LDIUV.js}

@@ -7,39 +7,40 @@ import {
   modelsData,
   reachPlanOf,
   readPathsOf
-} from "./chunk-QKMDT7VU.js";
+} from "./chunk-455SYIIE.js";
 import {
   globHolds,
   modelsModeOf,
   recordNotReached
-} from "./chunk-AB5E5HCN.js";
-import "./chunk-LGDW4G73.js";
+} from "./chunk-MD7KUEJ3.js";
+import "./chunk-Q46QDDMF.js";
+import "./chunk-TGVVUKTG.js";
 import {
   MODELS_RULE
-} from "./chunk-BAXM3JFQ.js";
+} from "./chunk-3AQ2R5NL.js";
 import {
   lineRangeOf,
   planGaps,
   sameCommit
-} from "./chunk-IPSFMTK2.js";
-import "./chunk-RBXDHCN7.js";
-import "./chunk-ZQC7MNQB.js";
-import "./chunk-TLDL2ZZI.js";
+} from "./chunk-JYMIB5XY.js";
+import "./chunk-TWQRPM76.js";
+import "./chunk-XOL3GFW2.js";
 import {
   DATA_RULE,
   estimateTokens,
   neutralise,
   wrapData
-} from "./chunk-QNMLLYTN.js";
+} from "./chunk-QHJJMZLX.js";
+import "./chunk-7AB6OWTV.js";
 import {
   factsDirOf,
   factsRelOf,
   parseFacts,
   require_dist
-} from "./chunk-YK6CSODO.js";
+} from "./chunk-PAINMSID.js";
 import {
   writeFileAtomic
-} from "./chunk-MMB2OHUY.js";
+} from "./chunk-ODMBPDDV.js";
 import {
   __toESM
 } from "./chunk-TV45EUGM.js";

package/dist/chunk-Q46QDDMF.js

@@ -0,0 +1,277 @@
+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 {
+  repoFor
+} from "./chunk-TGVVUKTG.js";
+import {
+  frameworkFacts,
+  insideRepo,
+  parseReviewed
+} from "./chunk-JYMIB5XY.js";
+import {
+  changesSince,
+  createGit
+} from "./chunk-XOL3GFW2.js";
+import {
+  Conventions,
+  DEFAULT_CONVENTIONS,
+  QuestionDraft,
+  factsDirOf,
+  isAdopted,
+  isSecretPath,
+  loadOrgPack,
+  orgPackDirOf,
+  parseCorrections,
+  parseFactsLines,
+  raiseQuestions,
+  require_dist,
+  serializeFacts
+} from "./chunk-PAINMSID.js";
+import {
+  __toESM
+} from "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/facts-files.js
+var import_yaml = __toESM(require_dist(), 1);
+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 });
+  const otherCommit = report.rejected.filter((r) => r.code === "wrong-commit").map((r) => r.fact);
+  await writeFile(join(dir, `${repo}.jsonl`), serializeFacts([...report.accepted, ...otherCommit]), "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));
+}
+
+export {
+  checkoutOf,
+  headOf,
+  carryOf,
+  conventionsAt,
+  excludesOf,
+  raiseReadQuestions,
+  estateComponentsOf,
+  slipNoteLines,
+  writeVerifyFiles,
+  readCorrections,
+  readReviewed,
+  reviewedProblemsOf
+};