@maycombhq/atticus 2.0.0-beta.10 → 2.0.0-beta.12

package/dist/{chunk-KM2FBM3T.js → chunk-PVW2N63M.js}

@@ -3,26 +3,48 @@ 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 {
+  repoTypeOf
+} from "./chunk-ZS47PQ3O.js";
+import {
+  estateFreshness
+} from "./chunk-I2PNEG3M.js";
+import "./chunk-HJUEQERG.js";
+import {
+  writeRepoSpecs
+} from "./chunk-B6X5PJSA.js";
+import {
+  checkoutOf,
+  readPlanProgress
+} from "./chunk-P76AW3PA.js";
+import "./chunk-7VNEDDCC.js";
+import "./chunk-6S27MUQQ.js";
+import "./chunk-EU7VTBAI.js";
 import {
   linkEvidenceAbout,
   linkEvidenceLines,
   loadLinkEvidence,
   writeRepoContracts
-} from "./chunk-GXJVY6WT.js";
+} from "./chunk-NCONDPHH.js";
 import {
   diffLines
-} from "./chunk-7TGYNOXD.js";
+} from "./chunk-CW5SEPUT.js";
 import {
   askHosts
-} from "./chunk-LRS573EX.js";
-import "./chunk-IDGSU7JF.js";
-import "./chunk-LK44ULGI.js";
-import "./chunk-47QE246J.js";
-import "./chunk-XQ3YIV5R.js";
-import "./chunk-MGVYVW7Q.js";
-import "./chunk-NGPU2ARF.js";
+} from "./chunk-GKPOCUQR.js";
+import "./chunk-3G4YI4ZU.js";
+import "./chunk-7TH6I6TL.js";
+import "./chunk-GHSVJNVL.js";
+import "./chunk-VOGCSYOI.js";
+import "./chunk-GMDOXWIS.js";
+import "./chunk-U5T4A2QV.js";
+import "./chunk-JQG4VO47.js";
+import "./chunk-DW4BM73R.js";
 import {
   TARGETS_STEP,
+  answerReconfirmed,
+  answerRuleOffers,
+  answeredQuestionOfCall,
   catalogWithFacts,
   diffCatalogs,
   diffIsEmpty,
@@ -37,33 +59,42 @@ import {
   staleTargetQuestions,
   targetQuestionFor,
   targetsFromAnswers,
+  topicQuestionDrafts,
   writeCatalog
-} from "./chunk-AY2IUF4K.js";
-import "./chunk-6JLPXDWN.js";
+} from "./chunk-22GLUHGE.js";
+import "./chunk-QR65C3DV.js";
 import {
   codeLinkerFor,
   frameworkFacts,
   frameworkGaps,
   renderMap,
   trustOf
-} from "./chunk-4GZXS6S2.js";
-import "./chunk-R4TBNKKC.js";
-import "./chunk-NIXVDQVO.js";
-import "./chunk-UR7RMZ3R.js";
+} from "./chunk-MLAACAES.js";
+import "./chunk-HY2VVVFZ.js";
+import "./chunk-PJRMMWU4.js";
+import "./chunk-34NWVIBC.js";
+import "./chunk-TWHZU36X.js";
 import {
   baseClonePath,
   loadRepos
-} from "./chunk-PGKHJYOB.js";
-import "./chunk-MKRBG5EF.js";
-import "./chunk-5XDNUJ4P.js";
+} from "./chunk-RA64IK43.js";
+import "./chunk-MRLCNXXR.js";
+import "./chunk-CQD26SMZ.js";
 import {
+  CALL_SECURITY_CHECK,
   SPEC_HEADER_SCHEMA_VERSION,
+  TERM_STEP,
+  TOPICS_STEP_ID,
+  callSecurityParams,
   catalogDirOf,
+  checkCallSecurity,
+  factIdPart,
   factsDirOf,
   factsRelOf,
   flowFiles,
   isAdopted,
   isGuessedJoin,
+  joinFlagsOf,
   listQuestions,
   loadOrgPack,
   mapDirOf,
@@ -77,18 +108,21 @@ import {
   readRepoSpec,
   readSharedMaps,
   removeFlow,
+  reopenQuestion,
   require_dist,
   retireQuestion,
   specFileHash,
   specRelOf,
+  termOfQuestion,
+  termQuestionDrafts,
   writeFlow,
   writeSpecHeader
-} from "./chunk-577AJVRS.js";
+} from "./chunk-U25OX22K.js";
 import {
   LockHeldError,
   acquireLock,
   writeFileAtomic
-} from "./chunk-D3PO4DOZ.js";
+} from "./chunk-MMB2OHUY.js";
 import {
   __toESM
 } from "./chunk-TV45EUGM.js";
@@ -97,7 +131,127 @@ import {
 var import_yaml = __toESM(require_dist(), 1);
 import { existsSync } from "node:fs";
 import { readFile, readdir, rm } from "node:fs/promises";
-import { join, relative, sep } from "node:path";
+import { join as join2, relative, sep } from "node:path";
+
+// packages/cli/dist/answer-reopen.js
+import { stat } from "node:fs/promises";
+import { join } from "node:path";
+function repoOfTarget(op, target) {
+  const t = factIdPart(target);
+  const r = estateRepos(op).find((x) => factIdPart(x.id) === t || x.component !== void 0 && factIdPart(x.component) === t || (x.modules ?? []).some((m) => factIdPart(m.component) === t));
+  return r?.id ?? target;
+}
+var mtimeOf = async (path) => (await stat(path).catch(() => void 0))?.mtimeMs;
+async function readNotSettled(root, repo, o = {}) {
+  const plan = await readPlanProgress(root, repo);
+  if (plan && (plan.stale || plan.done < plan.total))
+    return plan.stale ? `its read plan is of another commit (${plan.commit})` : `${plan.total - plan.done} of the ${plan.total} parts of its read plan are not read yet`;
+  const dir = factsDirOf(root);
+  const gaps = await mtimeOf(join(dir, `${repo}.gaps.md`));
+  const facts = await mtimeOf(join(dir, `${repo}.jsonl`));
+  if (gaps !== void 0 && (facts === void 0 || gaps >= facts))
+    return `its second pass (atticus map ${repo} --gaps) is planned and not read yet`;
+  const fresh = (await estateFreshness(root, { repos: [repo], ...o.git ? { git: o.git } : {} })).repos[0];
+  if (!fresh || fresh.state !== "fresh" && fresh.state !== "rules-changed")
+    return `its facts aren't fresh (atticus estate fresh says ${fresh?.state ?? "not-read"})`;
+  return void 0;
+}
+
+// packages/cli/dist/term-lines.js
+async function termsWrite(root, repo, o) {
+  const lines = [];
+  const raised = [];
+  const t = o.terms;
+  if (t) {
+    for (const a of t.access) {
+      const mine = a.repo === repo || (a.reason === "listed-no-call" ? a.owner.repo : a.call.repo) === repo;
+      if (!mine)
+        continue;
+      lines.push(a.reason === "caller-not-listed" ? `Access: ${a.message}. Add it to the list, or say why it calls (a finding for ${ownerOf(o.op, a.call.repo)}).` : a.reason === "caller-no-id" ? `Access (a note): ${a.message}; whether it is listed is unknown until a fact of ${a.call.repo} names its own id.` : `Access (a note): ${a.message}.`);
+    }
+    for (const p of t.possible) {
+      if (!p.seen.some((s) => s.repo === repo))
+        continue;
+      lines.push(`Possible link (a guess, ${p.flag}): ${p.value} is written in ${[...new Set(p.seen.map((s) => `${s.repo} (${s.at})`))].join(", ")}; a note on the repo type saying what it means links them.`);
+    }
+    const types = /* @__PURE__ */ new Map();
+    for (const r of new Set(t.terms.map((x) => x.repo)))
+      types.set(r, (await repoTypeOf(o.op, r, await o.dirOf(r)))?.id);
+    const all = termQuestionDrafts(t, (r) => types.get(r));
+    const drafts = all.filter((d) => d.terms.some((x) => x.repo === repo));
+    const asked = /* @__PURE__ */ new Map();
+    for (const d of drafts) {
+      const r = await raiseQuestions(root, [d.draft], {
+        step: TERM_STEP,
+        repo: d.repo,
+        command: o.command,
+        rerun: o.rerun,
+        at: o.at
+      });
+      const q0 = r.of[0];
+      if (q0)
+        asked.set(`${d.repo}\0${d.term}\0${d.file}`, q0.id);
+      for (const q of r.raised) {
+        raised.push(q);
+        lines.push(`A term nothing says the meaning of: asked ${q.id}: ${q.question} Answer it: atticus questions answer ${q.id} --option <n>${d.repoType ? `, and save the answer as a note on ${d.repoType} with atticus repo-type note ${d.repoType} --add "..."` : ""}; then ${o.rerun}.`);
+      }
+    }
+    for (const q of (await listQuestions(root, { step: TERM_STEP })).questions) {
+      if (q.state !== "open")
+        continue;
+      const about = termOfQuestion(q.question);
+      if (!about)
+        continue;
+      const k = `${q.repo}\0${about.term}\0${about.file}`;
+      const now = asked.get(k);
+      if (now === q.id)
+        continue;
+      const inGroup = all.find((d) => d.repo === q.repo && d.term === about.term && d.file === about.file);
+      if (q.repo !== repo && !(inGroup && inGroup.terms.some((x) => x.repo === repo)))
+        continue;
+      const why = now ? "the same term is asked across a changed set of repos" : "the facts now give every value it asked about a role";
+      await retireQuestion(root, q.id, { why, at: o.at, ...now ? { replacedBy: [now] } : {} });
+      lines.push(`Retired ${q.id}: ${why}.`);
+    }
+  }
+  if (o.join)
+    for (const pack of o.op.checklists)
+      for (const rule of pack.rules) {
+        if (rule.status !== "active")
+          continue;
+        if (rule.check.type !== "deterministic" || rule.check.check !== CALL_SECURITY_CHECK)
+          continue;
+        const params = callSecurityParams(rule.check.params);
+        if ("problem" in params) {
+          lines.push(`Rule ${rule.id} (${pack.name}) can't be checked: ${params.problem}.`);
+          continue;
+        }
+        for (const r of checkCallSecurity(params, {
+          repos: o.repos,
+          join: o.join,
+          systems: o.op.profiles.flatMap((p) => p.profile?.systems ?? [])
+        }))
+          if (r.call.repo === repo || r.callers.some((c) => c.repo === repo))
+            lines.push(ruleLine(rule.id, r, o.op));
+      }
+  return { lines, raised };
+}
+function ownerOf(op, repo) {
+  const owner = estateRepos(op).find((r) => r.id === repo)?.owner;
+  return owner ? `${repo}'s owner, ${owner}` : `${repo}'s owner`;
+}
+function ruleLine(rule, r, op) {
+  switch (r.outcome) {
+    case "pass":
+      return `Rule ${rule}: passes, ${r.message}.`;
+    case "declared":
+      return `Rule ${rule}: declared, ${r.message}.`;
+    case "finding":
+      return `Rule ${rule}: a finding for ${ownerOf(op, r.call.repo)}: ${r.message}.`;
+  }
+}
+
+// packages/cli/dist/map-render-commands.js
 var FACTS_TEMPLATE = "facts@1";
 var posix = (p) => p.split(sep).join("/");
 var HOW_WORDS = {
@@ -108,16 +262,27 @@ var HOW_WORDS = {
   path: "path",
   topic: "topic"
 };
-function linkChanges(repo, join2, before, after) {
+function linkChanges(repo, join3, before, after) {
   const mine = (xs) => (xs ?? []).filter((x) => x.call.repo === repo);
-  const joined = mine(join2?.joins);
-  const how = new Map((join2?.joins ?? []).map((j) => [j.interface, j.how]));
+  const joined = mine(join3?.joins);
+  const joinsOf = /* @__PURE__ */ new Map();
+  for (const j of [...joined, ...(join3?.joins ?? []).filter((x) => !joined.includes(x))])
+    joinsOf.set(j.interface, [...joinsOf.get(j.interface) ?? [], j]);
+  const howOf = (r) => {
+    const all = joinsOf.get(r.id) ?? [];
+    const own = all.filter((j) => joined.includes(j));
+    const best = own.find((j) => !isGuessedJoin(j)) ?? own[0] ?? all[0];
+    if (!best)
+      return void 0;
+    const byOther = r.confidence === "verified" && own.length > 0 && isGuessedJoin(best);
+    return { how: best.how, ...byOther ? { byOther, guesses: joinFlagsOf(best) } : {} };
+  };
   const ifaces = (rs) => new Map(rs.filter((r) => r.kind === "Interface").map((r) => [r.id, r]));
   const was = ifaces(before);
   const now = ifaces(after);
   const linked = new Set([...now.values()].flatMap((r) => r.evidence.filter((e) => e.side !== "callee").map((e) => `${e.repo}|${e.path}:${e.line}`)));
   const line = (r, found) => {
-    const h = found ? how.get(r.id) : void 0;
+    const h = found ? howOf(r) : void 0;
     return {
       id: r.id,
       from: r.from,
@@ -125,8 +290,9 @@ function linkChanges(repo, join2, before, after) {
       ...r.method ? { method: r.method } : {},
       path: r.normalizedPath,
       confidence: r.confidence,
-      ...h ? { how: h } : {},
-      ...r.flags?.length ? { flags: [...r.flags] } : {}
+      ...h ? { how: h.how } : {},
+      ...r.flags?.length ? { flags: [...r.flags] } : {},
+      ...h?.byOther ? { byOther: true, guesses: h.guesses } : {}
     };
   };
   const byId = (a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
@@ -148,9 +314,9 @@ function linkChanges(repo, join2, before, after) {
     calls: {
       joined: joined.length,
       inferred: joined.filter(isGuessedJoin).length,
-      asked: mine(join2?.asks).filter((a) => !linked.has(`${a.call.repo}|${a.call.at}`)).length,
-      outside: mine(join2?.outside).length,
-      missed: mine(join2?.misses).length
+      asked: mine(join3?.asks).filter((a) => !linked.has(`${a.call.repo}|${a.call.at}`)).length,
+      outside: mine(join3?.outside).length,
+      missed: mine(join3?.misses).length
     },
     added: [...now.values()].filter((r) => !was.has(r.id)).map((r) => line(r, true)).sort(byId),
     removed: [...was.values()].filter((r) => !now.has(r.id)).map((r) => line(r, false)).sort(byId),
@@ -172,6 +338,11 @@ function linkLines(l, report, o = {}) {
   const text = (sign, x) => {
     const what = [x.method, x.path].filter(Boolean).join(" ");
     const conf = x.was ? `${x.confidence}, was ${x.was.confidence}` : x.confidence;
+    if (x.byOther && x.how) {
+      const g = x.guesses?.join(", ");
+      const was = x.was ? `, was ${x.was.confidence}` : "";
+      return `    ${sign} ${x.from} \u2192 ${x.to} ${what} (${x.confidence} by another call${was}; this one by ${HOW_WORDS[x.how]}${g ? `: ${g}` : ""})`;
+    }
     const flags = x.flags?.join(", ");
     const found = x.how ? `found by ${HOW_WORDS[x.how]}${flags ? `: ${flags}` : ""}` : flags ?? "";
     return `    ${sign} ${x.from} \u2192 ${x.to} ${what} (${conf}${found ? `; ${found}` : ""})`;
@@ -188,7 +359,7 @@ function linkLines(l, report, o = {}) {
   return out;
 }
 async function writeLinksIntoReport(root, repo, links, exposure = [], evidence, shared) {
-  const file = join(factsDirOf(root), `${repo}.verify.yaml`);
+  const file = join2(factsDirOf(root), `${repo}.verify.yaml`);
   const text = await readFile(file, "utf8").catch(() => void 0);
   if (text === void 0)
     return;
@@ -287,8 +458,8 @@ function kindLine(byKind) {
 async function projectFactsIntoCatalog(root, repo, facts, given = {}) {
   const op = given.op ?? await loadOrgPack(orgPackDirOf(root));
   const cacheOpts = given.cache === false ? {} : { cacheRoot: root };
-  const existing = given.existing ?? (await readCatalog(join(catalogDirOf(root), "generated"), cacheOpts)).records;
-  const curated = await readCatalog(join(catalogDirOf(root), "curated"), cacheOpts);
+  const existing = given.existing ?? (await readCatalog(join2(catalogDirOf(root), "generated"), cacheOpts)).records;
+  const curated = await readCatalog(join2(catalogDirOf(root), "curated"), cacheOpts);
   const everyTarget = (await listQuestions(root, { step: TARGETS_STEP })).questions;
   const answered = everyTarget.filter((q) => q.repo === repo);
   const repoType = estateRepos(op).find((r) => r.id === repo)?.type;
@@ -327,6 +498,7 @@ async function projectFactsIntoCatalog(root, repo, facts, given = {}) {
     op,
     existing,
     answered,
+    everyTarget,
     targets,
     ruled,
     estate,
@@ -350,7 +522,7 @@ async function writeFactsIntoCatalog(root, repo, facts, o, io) {
   }
   try {
     const op = await loadOrgPack(orgPackDirOf(root));
-    const generated = join(catalogDirOf(root), "generated");
+    const generated = join2(catalogDirOf(root), "generated");
     const existing = await readCatalog(generated, { cacheRoot: root });
     if (isPrototypeRepo(op, repo)) {
       for (const n of prototypeLeftOut({ repo, facts, existing: [], op, decisions: [] }).notes)
@@ -372,7 +544,8 @@ async function writeFactsIntoCatalog(root, repo, facts, o, io) {
     }
     const rerun = `atticus verify ${repo} --write`;
     await writeRepoContracts(root, repo, o.dir, facts, (n) => io.err(n));
-    const { answered, targets, ruled, estate, result, diff, links, evidenceProblems, sharedMaps } = await projectFactsIntoCatalog(root, repo, facts, { op, existing: existing.records });
+    await writeRepoSpecs(root, repo, o.dir, facts, (n) => io.err(n));
+    const { answered, everyTarget, targets, ruled, estate, result, diff, links, evidenceProblems, sharedMaps } = await projectFactsIntoCatalog(root, repo, facts, { op, existing: existing.records });
     for (const p of evidenceProblems)
       io.err(p);
     for (const i of result.invalid)
@@ -396,7 +569,7 @@ async function writeFactsIntoCatalog(root, repo, facts, o, io) {
     const files = {};
     for (const f of flows)
       for (const p of flowFiles(f)) {
-        const text = await readFile(join(o.dir, ...p.split("/")), "utf8").catch(() => void 0);
+        const text = await readFile(join2(o.dir, ...p.split("/")), "utf8").catch(() => void 0);
         if (text !== void 0)
           files[p] = specFileHash(text);
       }
@@ -424,11 +597,25 @@ async function writeFactsIntoCatalog(root, repo, facts, o, io) {
     const asked = new Set([...loose, ...ambiguous].filter((id) => targets[id] === void 0 && !answered.some((q) => q.state === "answered" && q.id === targetId(facts, repo, id))));
     const drafted = groupedTargetDrafts(facts, result.records, op, result.join?.asks, {
       ask: asked,
-      split: splitTargetGroups(answered)
+      split: splitTargetGroups(answered),
+      // ADR 0162 (F8): the suggestions read the estate's facts and the earlier answers.
+      estate: estate.repos,
+      questions: everyTarget
     });
+    const refreshed = [];
     for (const t of drafted) {
+      const r = await raiseQuestions(root, [t.draft], { step: TARGETS_STEP, repo, command: o.command, rerun, at }, { refresh: true });
+      refreshed.push(...r.refreshed);
+      for (const q of r.raised) {
+        raised.push(q);
+        lines.push(t.factIds.length > 1 ? `${t.factIds.length} calls go the same way and name no target the estate has: asked once, ${q.id}: ${q.question} One answer names the target of all of them. Answer it: atticus questions answer ${q.id} --option <n>, then ${rerun}.` : named.has(t.factId) ? `A call names a target the estate doesn't have, and more than one entry serves it: asked ${q.id}: ${q.question} Answer it: atticus questions answer ${q.id} --option <n>, then ${rerun}.` : `A call names no target: asked ${q.id}: ${q.question} Answer it: atticus questions answer ${q.id} --option <n>, then ${rerun}.`);
+      }
+    }
+    if (refreshed.length)
+      lines.push(`Refreshed ${refreshed.length === 1 ? "1 open question" : `${refreshed.length} open questions`} asked before (${refreshed.map((q) => q.id).join(", ")}): the same id, with today's options, ranked by the estate as read now, each saying why it is suggested.`);
+    for (const t of topicQuestionDrafts(repo, result.records)) {
       const r = await raiseQuestions(root, [t.draft], {
-        step: TARGETS_STEP,
+        step: TOPICS_STEP_ID,
         repo,
         command: o.command,
         rerun,
@@ -436,7 +623,7 @@ async function writeFactsIntoCatalog(root, repo, facts, o, io) {
       });
       for (const q of r.raised) {
         raised.push(q);
-        lines.push(t.factIds.length > 1 ? `${t.factIds.length} calls go the same way and name no target the estate has: asked once, ${q.id}: ${q.question} One answer names the target of all of them. Answer it: atticus questions answer ${q.id} --option <n>, then ${rerun}.` : named.has(t.factId) ? `A call names a target the estate doesn't have, and more than one entry serves it: asked ${q.id}: ${q.question} Answer it: atticus questions answer ${q.id} --option <n>, then ${rerun}.` : `A call names no target: asked ${q.id}: ${q.question} Answer it: atticus questions answer ${q.id} --option <n>, then ${rerun}.`);
+        lines.push(`No repo of the estate serves the other side of ${t.topic}: asked ${q.id}: ${q.question} If another team or a vendor owns it, name them: atticus questions answer ${q.id} --target <system or team id> (it goes under the system's topics in the profile, for review), then ${rerun}.`);
       }
     }
     for (const s of staleTargetQuestions({
@@ -455,6 +642,50 @@ async function writeFactsIntoCatalog(root, repo, facts, o, io) {
       });
       lines.push(`Retired ${s.id}: ${s.why}.`);
     }
+    const reopened = /* @__PURE__ */ new Set();
+    const unsettled = /* @__PURE__ */ new Map();
+    for (const m of result.answerMisses ?? []) {
+      const callerFacts = m.call.repo === repo ? facts : estate.repos.find((x) => x.repo === m.call.repo)?.facts;
+      const q = callerFacts ? answeredQuestionOfCall(m.call.repo, callerFacts, everyTarget, m.call.fact) : void 0;
+      if (!q || reopened.has(q.id))
+        continue;
+      if (answerReconfirmed(q))
+        continue;
+      const named2 = repoOfTarget(op, m.target);
+      if (!unsettled.has(named2))
+        unsettled.set(named2, await readNotSettled(root, named2));
+      const notYet = unsettled.get(named2);
+      if (notYet) {
+        lines.push(`${m.target} is read, but ${notYet}: ${q.id}'s answer is checked against it once the read is whole and fresh.`);
+        continue;
+      }
+      reopened.add(q.id);
+      const why = `${m.target} is read now, and no route of it serves the call: ${m.message} (${m.call.at})`;
+      await reopenQuestion(root, q.id, { why, at });
+      lines.push(`Asked again ${q.id}: ${why}. Answer it again: atticus questions answer ${q.id} --option <n> | --target <id>, then atticus verify ${m.call.repo} --write.`);
+    }
+    const typeOf = new Map(estateRepos(op).map((r) => [r.id, r.type]));
+    for (const offer of answerRuleOffers({
+      repos: [{ repo, facts }, ...estate.repos].map((r) => ({
+        ...r,
+        ...typeOf.get(r.repo) ? { type: typeOf.get(r.repo) } : {}
+      })),
+      questions: everyTarget.filter((q) => !reopened.has(q.id))
+    }))
+      if (offer.repos.includes(repo))
+        lines.push(offer.line);
+    const termed = await termsWrite(root, repo, {
+      op,
+      terms: result.terms,
+      repos: [{ repo, facts }, ...estate.repos],
+      join: result.join,
+      command: o.command,
+      rerun,
+      at,
+      dirOf: (r) => r === repo ? Promise.resolve(o.dir) : checkoutOf(root, r)
+    });
+    raised.push(...termed.raised);
+    lines.push(...termed.lines);
     const byKind = countByKind(diff);
     io.out(`Wrote the catalog for ${repo}: ${written.written} files written, ${written.removed} removed, ${written.unchanged} unchanged.`);
     io.out(diffIsEmpty(diff) ? "  No catalog changes." : `  Records: ${kindLine(byKind)}.`);
@@ -509,15 +740,15 @@ function targetId(facts, repo, id) {
   const q = f ? targetQuestionFor(f) : void 0;
   return q ? questionId({ step: TARGETS_STEP, repo, ...q }) : void 0;
 }
-function joinLines(repo, join2, notes = [], o = {}) {
-  if (!join2)
+function joinLines(repo, join3, notes = [], o = {}) {
+  if (!join3)
     return [...notes];
   const out = [...notes];
-  const mine = join2.joins.filter((j) => j.call.repo === repo && j.call.repo !== j.entry.repo);
-  const into = join2.joins.filter((j) => j.entry.repo === repo && j.call.repo !== repo);
+  const mine = join3.joins.filter((j) => j.call.repo === repo && j.call.repo !== j.entry.repo);
+  const into = join3.joins.filter((j) => j.entry.repo === repo && j.call.repo !== repo);
   if (mine.length || into.length)
     out.push(`Joined across repos: ${mine.length} of ${repo}'s calls to the entries that serve them, ${into.length} calls of other repos into ${repo}, each citing both ends.`);
-  const guessed = join2.joins.filter((j) => j.call.repo === repo && j.inferred);
+  const guessed = join3.joins.filter((j) => j.call.repo === repo && j.inferred);
   if (guessed.length) {
     const own = guessed.filter((j) => j.inferred.within === "repo").length;
     const where = [
@@ -533,16 +764,16 @@ function joinLines(repo, join2, notes = [], o = {}) {
         out.push(`  ${j.call.at} ${what}${named} \u2192 ${j.entry.component}${there}`);
       }
   }
-  for (const m of join2.misses)
+  for (const m of join3.misses)
     out.push(`Not joined: ${m.message} (${m.call.at}).`);
-  for (const x of join2.exposure ?? [])
+  for (const x of join3.exposure ?? [])
     out.push(`Exposure: ${x.message}.`);
-  for (const g of join2.gaps.slice(0, 10))
+  for (const g of join3.gaps.slice(0, 10))
     out.push(`Field gap: ${g.message}.`);
   return out;
 }
 async function renderRepoMap(root, repo, io) {
-  const records = (await readCatalog(join(catalogDirOf(root), "generated"), { cacheRoot: root })).records;
+  const records = (await readCatalog(join2(catalogDirOf(root), "generated"), { cacheRoot: root })).records;
   const spec = await readRepoSpec(root, repo, { cacheRoot: root });
   const ofRepo = records.some((r) => r.kind === "Component" && r.repo === repo);
   if (!ofRepo && spec.flows.length === 0) {
@@ -550,7 +781,7 @@ async function renderRepoMap(root, repo, io) {
     return void 0;
   }
   let trust;
-  const report = join(factsDirOf(root), `${repo}.verify.yaml`);
+  const report = join2(factsDirOf(root), `${repo}.verify.yaml`);
   if (existsSync(report)) {
     try {
       trust = trustOf((0, import_yaml.parse)(await readFile(report, "utf8")));
@@ -564,6 +795,7 @@ async function renderRepoMap(root, repo, io) {
   const url = manifest?.url && manifest.url !== "." && !manifest.url.startsWith("./") ? manifest.url : void 0;
   const codeLink = codeLinkerFor(url ? { url } : { dir: adopted ? "" : posix(relative(root, baseClonePath(root, repo))) });
   const rel = `${mapRelOf(root)}/${repo}`;
+  const kept = await factsOf(root, repo);
   const files = renderMap({
     repo,
     records,
@@ -579,17 +811,19 @@ async function renderRepoMap(root, repo, io) {
     } : {},
     // What the repo is built on (ADR 0124 addendum A-framework): read from the facts, since no
     // catalog record holds a framework.
-    ...builtOnOf(await factsOf(root, repo)),
+    ...builtOnOf(kept),
+    // ADR 0163: the organisation's terms it writes, read from the facts as the frameworks are.
+    ...termsOfFacts(kept),
     questions: open.map((q) => ({ id: q.id, question: q.question, evidence: q.evidence })),
     paths: { map: rel, questions: questionsRelOf(root), specs: specRelOf(root, repo) },
     codeLink
   });
-  const dir = join(mapDirOf(root), repo);
+  const dir = join2(mapDirOf(root), repo);
   for (const old of await listFiles(dir))
     if (!(old in files))
-      await rm(join(dir, ...old.split("/")), { force: true });
+      await rm(join2(dir, ...old.split("/")), { force: true });
   for (const [path, text] of Object.entries(files)) {
-    const full = join(dir, ...path.split("/"));
+    const full = join2(dir, ...path.split("/"));
     const now = await readFile(full, "utf8").catch(() => void 0);
     if (now !== text)
       await writeFileAtomic(full, text);
@@ -599,7 +833,7 @@ async function renderRepoMap(root, repo, io) {
   return paths;
 }
 async function factsOf(root, repo) {
-  const text = await readFile(join(factsDirOf(root), `${repo}.jsonl`), "utf8").catch(() => void 0);
+  const text = await readFile(join2(factsDirOf(root), `${repo}.jsonl`), "utf8").catch(() => void 0);
   if (text === void 0)
     return [];
   const p = parseFacts(text);
@@ -617,6 +851,18 @@ function builtOnOf(facts) {
   const gaps = frameworkGaps(facts).map((g) => ({ framework: g.framework, question: g.question }));
   return { frameworks: { built, ...gaps.length ? { gaps } : {} } };
 }
+function termsOfFacts(facts) {
+  const terms = facts.flatMap((f) => f.kind === "term" ? [
+    {
+      term: f.term,
+      value: f.value,
+      role: f.role,
+      cite: { path: f.cite.file, line: f.cite.line, commit: f.commit },
+      ...f.meaning ? { meaning: { path: f.meaning.file, line: f.meaning.line, commit: f.commit } } : {}
+    }
+  ] : []);
+  return terms.length ? { terms } : {};
+}
 async function listFiles(dir) {
   const out = [];
   const walk = async (d, prefix) => {
@@ -628,7 +874,7 @@ async function listFiles(dir) {
     }
     for (const e of entries)
       if (e.isDirectory())
-        await walk(join(d, e.name), `${prefix}${e.name}/`);
+        await walk(join2(d, e.name), `${prefix}${e.name}/`);
       else
         out.push(`${prefix}${e.name}`);
   };
@@ -655,5 +901,6 @@ export {
   projectFactsIntoCatalog,
   sharedLines,
   sharedReport,
+  termsOfFacts,
   writeFactsIntoCatalog
 };