@maycombhq/atticus 2.0.0-beta.2 → 2.0.0-beta.22

package/dist/{chunk-HITVBIJS.js → chunk-ZQ7SKESZ.js}

@@ -3,79 +3,60 @@ 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 {
-  generateTests,
-  matrixCsv,
-  matrixMarkdown,
-  traceMatrix,
-  writeTraceFindings
-} from "./chunk-2ANOROX3.js";
-import {
-  table
-} from "./chunk-VOGCSYOI.js";
 import {
   readChangeFiles,
   readDataChanges,
   readHops,
   reviewedGates
-} from "./chunk-3HI6Z55Y.js";
+} from "./chunk-S4PMJU6H.js";
 import {
   assess,
   changeFolder,
   changeStore,
   checkFindings,
-  loadChangeContext
-} from "./chunk-XY3P7JW7.js";
+  loadChangeContext,
+  nothingToRelease,
+  staleReleasePrs
+} from "./chunk-IDKCWSM5.js";
 import {
-  GlossaryError,
-  aliasDecision,
-  completeGlossaryDefinitions,
-  defineDecision,
-  linkDecision,
-  loadGlossary,
-  readCatalog,
-  resolveTermId,
-  scanGlossary,
-  writeDecisions
-} from "./chunk-27NKUS3X.js";
+  readCatalog
+} from "./chunk-J2JAKCIW.js";
 import {
   BUILT_IN_EXTRACTORS,
   SHIPPED_DIALECTS_DIR,
   dialectExtractor,
   loadShippedDialects,
   runDialectTests
-} from "./chunk-MC3H7736.js";
-import {
-  baseClonePath,
-  checkoutState,
-  createGit,
-  readChangeRepos
-} from "./chunk-EFHQ3TWP.js";
+} from "./chunk-CQDGOPGH.js";
 import {
   DEFAULT_IGNORES,
   fsRepo,
   scanRepo
-} from "./chunk-GQ4N4WKF.js";
+} from "./chunk-3NFFJL5D.js";
 import {
-  runtimeForCli
-} from "./chunk-CNUKCS2T.js";
+  baseClonePath,
+  checkoutState,
+  createGit,
+  readChangeRepos
+} from "./chunk-PKBHS4AA.js";
 import {
   catalogDirOf,
+  effectiveComponentTypes,
   external_exports,
+  factsDirOf,
   loadOrgPack,
   mergeCatalog,
   normalizePath,
   orgPackDirOf,
+  parseFacts
+} from "./chunk-Q2TECDIT.js";
+import {
   require_dist
-} from "./chunk-S2A7YC3Q.js";
+} from "./chunk-BQGDB6ZL.js";
 import {
   __toESM
 } from "./chunk-TV45EUGM.js";
 
-// packages/cli/dist/quality-commands.js
-import { appendFile, mkdir, writeFile } from "node:fs/promises";
-import { dirname, join as join4 } from "node:path";
-
 // packages/ci/dist/config.js
 var import_yaml = __toESM(require_dist(), 1);
 import { readFile } from "node:fs/promises";
@@ -501,6 +482,8 @@ async function repoDrift(o) {
   const merged = mergeCatalog({
     // A fetched copy of the catalog has no manifest, so no declared hosts: route by basepath.
     ...orgPackDir ? {} : { gatewayByBasepath: true },
+    // ADR 0180: the organisation's component types, as the scan merges with them (no false drift).
+    componentTypes: new Set(effectiveComponentTypes(op.componentTypes).map((t) => t.id)),
     records: [...context, ...otherEnds(catalog.records, repoId, components), ...scan.records],
     repos: manifest.map((r) => ({
       id: r.id,
@@ -657,17 +640,17 @@ function driftMarkdown(r) {
   const n = r.items.filter((i) => i.kind !== "planned").length;
   const planned = r.counts.planned;
   const head = !r.drift ? `No drift: ${r.repo} matches the catalog${planned ? ` (${planned} planned by approved changes)` : ""}.` : `${n} drift ${n === 1 ? "finding" : "findings"} in ${r.repo}${r.mode === "warn" ? " (warn-only: the pipeline passes)" : ""}.`;
-  const lines2 = [`## Atticus drift check: ${r.repo}`, "", head];
+  const lines = [`## Atticus drift check: ${r.repo}`, "", head];
   if (r.items.length) {
-    lines2.push("", "| What | Kind | Id | Details |", "| --- | --- | --- | --- |");
+    lines.push("", "| What | Kind | Id | Details |", "| --- | --- | --- | --- |");
     for (const i of r.items)
-      lines2.push(`| ${KIND_WORD[i.kind]} | ${i.subject} | ${cell(i.id)} | ${cell(i.summary)}${where(i).length ? ` (${where(i).join(", ")})` : ""} |`);
+      lines.push(`| ${KIND_WORD[i.kind]} | ${i.subject} | ${cell(i.id)} | ${cell(i.summary)}${where(i).length ? ` (${where(i).join(", ")})` : ""} |`);
   }
   if (r.drift && r.mode === "block")
-    lines2.push("", "Fix the code, or record the change in the catalog: plan it in an approved change's design, or rescan the estate once it is merged.");
+    lines.push("", "Fix the code, or record the change in the catalog: plan it in an approved change's design, or rescan the estate once it is merged.");
   if (r.problems.length)
-    lines2.push("", "Problems:", ...r.problems.map((p) => `- ${p}`));
-  return `${lines2.join("\n")}
+    lines.push("", "Problems:", ...r.problems.map((p) => `- ${p}`));
+  return `${lines.join("\n")}
 `;
 }
 
@@ -812,6 +795,34 @@ function pipelineSnippet(kind) {
 import { existsSync as existsSync2 } from "node:fs";
 import { readFile as readFile2 } from "node:fs/promises";
 import { join as join3 } from "node:path";
+var short = (c) => c.slice(0, 12);
+var sameCommit = (a, b) => a.startsWith(b) || b.startsWith(a);
+var plural = (n, one, many = `${one}s`) => `${n} ${n === 1 ? one : many}`;
+async function factsAtMerge(root, r, merged, catalog) {
+  const where2 = `${short(merged)}, the commit its release merged into ${r.base}`;
+  const readAgain = `read it again (Map \u203A Trust \u203A Freshness: Read again, or atticus map ${r.id}), then atticus verify ${r.id} --write, so the catalog says what shipped.`;
+  const text = await readFile2(join3(factsDirOf(root), `${r.id}.jsonl`), "utf8").catch(() => "");
+  const parsed = text.trim() ? parseFacts(text) : void 0;
+  const facts = parsed?.ok ? parsed.facts : [];
+  if (!facts.length)
+    return {
+      code: "needs-reading",
+      message: `${r.id}: no facts were read at ${where2}: ${readAgain}`
+    };
+  const other = [...new Set(facts.map((f) => f.commit))].filter((c) => !sameCommit(c, merged));
+  if (other.length)
+    return {
+      code: "needs-reading",
+      message: `${r.id}: its facts were read at ${other.map(short).join(", ")}, not at ${where2}: ${readAgain}`
+    };
+  const stale = (await catalog()).filter((x) => x.evidence.some((e) => e.repo === r.id && e.commit && !sameCommit(e.commit, merged))).length;
+  if (stale)
+    return {
+      code: "catalog-stale",
+      message: `${r.id}: its facts are of the merged commit ${short(merged)}, but ${plural(stale, "catalog record")} still ${stale === 1 ? "cites" : "cite"} another commit: write them into the catalog (atticus verify ${r.id} --write, or Apply on the Map).`
+    };
+  return void 0;
+}
 async function archiveGate(root, changeId, o = {}) {
   const change = await changeStore(root).read(changeId);
   const blockers = [];
@@ -832,11 +843,26 @@ async function archiveGate(root, changeId, o = {}) {
   for (const r of await checkFindings(root, change, gates))
     blockers.push({ code: "finding", message: r.message });
   const repos = (await readChangeRepos(root, change.id))?.repos ?? [];
+  const mustMerge = config.archive.requireMergedPrs;
+  const nothing = await nothingToRelease(root, change.id, o.git ? { git: o.git } : {});
+  const stale = await staleReleasePrs(root, change.id, o.git ? { git: o.git } : {});
   for (const r of repos) {
-    if (r.pr && config.archive.requireMergedPrs && r.pr.state !== "merged" && r.pr.state !== "closed")
+    if (!r.pr && nothing.has(r.id))
+      continue;
+    if (mustMerge && (!r.pr || r.pr.state === "closed"))
+      blockers.push({
+        code: "pr-missing",
+        message: `${r.id}: ${r.pr ? `release PR #${r.pr.number} was closed without merging` : `no release PR from ${r.branch} into ${r.base} was raised`}, so the code never reached ${r.base}: raise the release PRs (Release \u203A Raise the release PRs, or atticus change release-prs ${change.id} --approve), and merge them on the Git host.`
+      });
+    else if (mustMerge && r.pr && r.pr.state !== "merged")
       blockers.push({
         code: "pr-open",
-        message: `${r.id}: PR #${r.pr.number} is ${r.pr.state}; merge it before archiving.`
+        message: `${r.id}: release PR #${r.pr.number} is ${r.pr.state}; a person merges it on the Git host before archiving.`
+      });
+    else if (mustMerge && r.pr?.state === "merged" && stale.has(r.id))
+      blockers.push({
+        code: "release-pr-stale",
+        message: `${r.id}: the change branch moved past release PR #${r.pr.number} after it merged, so the newer work isn't in ${r.base}: raise the release PRs again (atticus change release-prs ${change.id} --approve) and merge the new one.`
       });
     if (r.build.status === "failed")
       blockers.push({
@@ -845,6 +871,8 @@ async function archiveGate(root, changeId, o = {}) {
       });
     else if (r.build.status === "running")
       blockers.push({ code: "build-running", message: `${r.id}: the build is still running.` });
+    else if (r.build.status === "not-run" && r.pr?.state === "merged")
+      notes.push(`${r.id}: the Git host reported no checks on release PR #${r.pr.number}, so no build is recorded for what merged.`);
     else if (r.build.status === "not-run" && r.pr)
       blockers.push({
         code: "build-not-run",
@@ -852,48 +880,77 @@ async function archiveGate(root, changeId, o = {}) {
       });
   }
   const drift = [];
-  if (o.driftReports?.length) {
-    for (const f of o.driftReports) {
-      try {
-        drift.push(JSON.parse(await readFile2(f, "utf8")));
-      } catch (e) {
-        blockers.push({
-          code: "drift-error",
-          message: `Can't read the drift report ${f}: ${e.message.split("\n")[0]}.`
-        });
-      }
+  for (const f of o.driftReports ?? []) {
+    try {
+      drift.push(JSON.parse(await readFile2(f, "utf8")));
+    } catch (e) {
+      blockers.push({
+        code: "drift-error",
+        message: `Can't read the drift report ${f}: ${e.message.split("\n")[0]}.`
+      });
     }
-  } else {
-    for (const r of repos) {
-      const dir = o.repoDir?.(r.id) ?? [join3(root, r.worktree), baseClonePath(root, r.id)].find((d) => existsSync2(d));
-      if (!dir || !existsSync2(dir)) {
-        notes.push(`No checkout of ${r.id} here, so its drift wasn't checked; pass its pipeline's drift report.`);
-        continue;
-      }
+  }
+  const git = o.git ?? createGit();
+  const readersDecide = /* @__PURE__ */ new Set();
+  let records;
+  const catalog = async () => records ??= (await readCatalog(join3(catalogDirOf(root), "generated"))).records;
+  for (const r of repos) {
+    if (!r.pr && nothing.has(r.id))
+      continue;
+    if (mustMerge && r.pr?.state !== "merged")
+      continue;
+    const report = drift.find((d) => d.repo === r.id);
+    const dir = o.repoDir?.(r.id) ?? baseClonePath(root, r.id);
+    const there = !!dir && existsSync2(dir);
+    const merged = o.commit ?? (report && !/^0+$/.test(report.scanned.commit) ? report.scanned.commit : void 0) ?? (there ? await git(["rev-parse", "HEAD"], dir).then((x) => x.stdout.trim() || void 0).catch(() => void 0) : void 0);
+    if (!merged) {
+      notes.push(`No clone of ${r.id} here to say which commit merged, so its facts weren't compared: sync the workspace (atticus workspace sync), or pass its pipeline's drift report.`);
+      continue;
+    }
+    if (r.pr?.state === "merged" && r.baseSha && sameCommit(merged, r.baseSha)) {
+      blockers.push({
+        code: "not-synced",
+        message: `${r.id}: the clone here is still at ${short(merged)}, where the change started, though release PR #${r.pr.number} merged: sync the workspace (atticus workspace sync), then read the repo again.`
+      });
+      continue;
+    }
+    const readByAssistant = existsSync2(join3(factsDirOf(root), `${r.id}.jsonl`)) || (await catalog()).some((x) => x.evidence.some((e) => e.repo === r.id && e.by === "assistant"));
+    if (readByAssistant) {
+      const b = await factsAtMerge(root, r, merged, catalog);
+      if (b)
+        blockers.push(b);
+    } else if (report)
+      readersDecide.add(r.id);
+    if (!report && there) {
       try {
-        drift.push(await repoDrift({
-          repoDir: dir,
-          catalog: root,
-          repo: r.id,
-          ...o.commit ? { commit: o.commit } : {}
-        }));
+        drift.push(await repoDrift({ repoDir: dir, catalog: root, repo: r.id, commit: merged }));
+        if (!readByAssistant)
+          readersDecide.add(r.id);
       } catch (e) {
         if (!(e instanceof DriftError))
           throw e;
-        blockers.push({ code: "drift-error", message: `${r.id}: ${e.message}` });
+        if (readByAssistant)
+          notes.push(`Cross-check only: the built-in readers couldn't read ${r.id}: ${e.message}`);
+        else
+          blockers.push({ code: "drift-error", message: `${r.id}: ${e.message}` });
       }
-    }
-    if (!repos.length)
-      notes.push("The change has no repos (repos.yaml), so there was no code to check for drift.");
+    } else if (!report && !readByAssistant)
+      notes.push(`No clone of ${r.id} here, so its drift wasn't checked; sync the workspace, or pass its pipeline's drift report.`);
   }
+  if (!repos.length)
+    notes.push("The change has no repos (repos.yaml), so there was no code to check for drift.");
   for (const d of drift) {
     const items = d.items.filter((i) => i.kind !== "planned");
     if (!items.length)
       continue;
-    blockers.push({
-      code: "drift",
-      message: `${d.repo}: ${items.length} catalog drift ${items.length === 1 ? "finding" : "findings"} (${items.slice(0, 3).map((i) => i.summary.replace(/\.$/, "")).join("; ")}${items.length > 3 ? "; ..." : ""}).`
-    });
+    if (readersDecide.has(d.repo)) {
+      blockers.push({
+        code: "drift",
+        message: `${d.repo}: ${items.length} catalog drift ${items.length === 1 ? "finding" : "findings"} (${items.slice(0, 3).map((i) => i.summary.replace(/\.$/, "")).join("; ")}${items.length > 3 ? "; ..." : ""}).`
+      });
+      continue;
+    }
+    notes.push(`Cross-check only, not blocking: the built-in readers see ${plural(items.length, "difference")} in ${d.repo} (${items.slice(0, 3).map((i) => i.summary.replace(/\.$/, "")).join("; ")}${items.length > 3 ? "; ..." : ""}). The facts read and verified at the merged commit decide (ADR 0074).`);
   }
   const unique = [...new Map(blockers.map((b) => [b.message, b])).values()];
   return {
@@ -906,342 +963,20 @@ async function archiveGate(root, changeId, o = {}) {
   };
 }
 
-// packages/cli/dist/quality-commands.js
-var KNOWN = /* @__PURE__ */ new Set([
-  "TestgenError",
-  "PlannerError",
-  "ChangeError",
-  "ChangeFileError",
-  "GlossaryError",
-  "RuntimeConfigError"
-]);
-function fail(io, e) {
-  if (e instanceof Error && KNOWN.has(e.name)) {
-    io.err(e.message);
-    return e.code === "invalid" ? 2 : 1;
-  }
-  throw e;
-}
-var iso = (d) => d.toISOString().replace(/\.\d{3}Z$/, "Z");
-var lines = (io, text) => {
-  for (const l of text.trimEnd().split("\n"))
-    io.out(l);
-};
-var plural = (n, w) => `${n} ${w}${n === 1 ? "" : "s"}`;
-async function runtimeOf(root, mode, deps) {
-  if (deps.runtime)
-    return deps.runtime;
-  if (!mode && !process.env.ATTICUS_RUNTIME)
-    return void 0;
-  return (await runtimeForCli(root, mode ? { mode } : {})).runtime;
-}
-async function testsGenerate(root, changeId, storyId, o, io, deps = {}) {
-  if (!changeId || !storyId) {
-    io.err("Usage: atticus tests generate <change> <story> [--framework <id>] [--force] [--check] [--mode <mode>] [--json]");
-    return 2;
-  }
-  try {
-    const runtime = await runtimeOf(root, o.mode, deps);
-    const r = await generateTests(root, changeId, storyId, {
-      ...o.framework ? { framework: o.framework } : {},
-      ...o.force ? { force: true } : {},
-      ...o.check ? { check: true } : {},
-      ...o.resume ? { resume: o.resume } : {},
-      ...runtime ? { runtime } : {},
-      now: deps.now?.() ?? /* @__PURE__ */ new Date()
-    });
-    const kept = r.files.filter((f) => f.action === "kept-edited" || f.action === "kept-not-generated");
-    if (o.json) {
-      io.out(JSON.stringify({
-        change: r.change,
-        story: r.story,
-        strategy: r.model.strategy,
-        kinds: r.model.kinds,
-        names: r.names.by,
-        ...r.names.waiting ? { waiting: r.names.waiting } : {},
-        files: r.files,
-        manifest: r.manifest,
-        notes: r.notes,
-        gaps: r.gaps
-      }, null, 2));
-      return kept.length ? 1 : 0;
-    }
-    const count = (a) => r.files.filter((f) => f.action === a).length;
-    const cases = r.model.repos.reduce((n, x) => n + x.cases.length, 0);
-    io.out(`${o.check ? "Would write" : "Generated"} ${plural(cases, "test case")} for ${r.story} in ${plural(r.files.length, "file")}: ${count("created")} new, ${count("updated")} updated, ${count("unchanged")} unchanged${kept.length ? `, ${kept.length} kept` : ""}.`);
-    for (const l of table(["ACTION", "REPO", "FRAMEWORK", "FILE"], r.files.map((f) => [f.action, f.repo || "-", f.generator, f.path])))
-      io.out(l);
-    for (const k of r.model.kinds.filter((x) => !x.generated))
-      io.out(`No ${k.type} tests: ${k.why}`);
-    for (const n of r.notes)
-      io.out(n);
-    for (const g of r.gaps)
-      io.out(`Gap: ${g}`);
-    if (r.names.waiting)
-      io.out(`The test writer is with your assistant (run ${r.names.waiting}); the files use plain names until you run: atticus tests generate ${changeId} ${storyId} --resume ${r.names.waiting}`);
-    if (!o.check)
-      io.out(`Manifest: ${r.manifest}`);
-    return kept.length ? 1 : 0;
-  } catch (e) {
-    return fail(io, e);
-  }
-}
-async function traceCommand(root, changeId, o, io, deps = {}) {
-  if (!changeId) {
-    io.err("Usage: atticus trace <change> [--json | --csv] [--no-write]");
-    return 2;
-  }
-  try {
-    const m = await traceMatrix(root, changeId, { git: deps.git ?? createGit() });
-    for (const p of m.problems)
-      io.err(p);
-    const w = o.write === false ? void 0 : await writeTraceFindings(root, m, iso(deps.now?.() ?? /* @__PURE__ */ new Date()));
-    if (o.json)
-      io.out(JSON.stringify({ ...m, ...w ? { round: w.round ?? null } : {} }, null, 2));
-    else if (o.csv)
-      lines(io, matrixCsv(m));
-    else {
-      lines(io, matrixMarkdown(m));
-      if (w)
-        io.out(w.unchanged ? `Findings on the trace gate are unchanged (round ${w.round ?? "none"}).` : `Wrote ${plural(w.findings.length, "finding")} to review/trace/${w.round}/.`);
-    }
-    return m.gaps.some((g) => g.kind !== "test-without-requirement") ? 1 : 0;
-  } catch (e) {
-    return fail(io, e);
-  }
-}
-async function ciDrift(repoDir, o, io, deps = {}) {
-  if (!o.catalog) {
-    io.err("Usage: atticus ci drift [repo-dir] --catalog <metarepo or catalog folder> [--repo <id>] [--json [file]] [--junit <file>] [--summary <file>] [--warn-only]");
-    return 2;
-  }
-  try {
-    const r = await repoDrift({
-      repoDir,
-      catalog: o.catalog,
-      ...o.repo ? { repo: o.repo } : {},
-      ...o.warnOnly ? { warnOnly: true } : {},
-      ...deps.commit ? { commit: deps.commit } : {},
-      ...deps.git ? { git: deps.git } : {}
-    });
-    const put = async (file, text) => {
-      await mkdir(dirname(file), { recursive: true });
-      await writeFile(file, text, "utf8");
-    };
-    if (typeof o.json === "string")
-      await put(o.json, driftJson(r));
-    if (o.junit)
-      await put(o.junit, driftJUnit(r));
-    if (o.summary) {
-      await mkdir(dirname(o.summary), { recursive: true });
-      await appendFile(o.summary, driftMarkdown(r), "utf8");
-    }
-    if (o.json === true)
-      io.out(driftJson(r).trimEnd());
-    else
-      lines(io, driftMarkdown(r));
-    return driftExitCode(r);
-  } catch (e) {
-    if (e instanceof DriftError) {
-      io.err(e.message);
-      return 2;
-    }
-    throw e;
-  }
-}
-async function ciSnippet(kind, io, o = {}) {
-  const s = kind ? pipelineSnippet(kind) : void 0;
-  if (!s) {
-    io.err(`Usage: atticus ci snippet <${SNIPPET_KINDS.join("|")}> [--write <repo-dir>]`);
-    return 2;
-  }
-  if (o.write) {
-    const file = join4(o.write, ...s.path.split("/"));
-    await mkdir(dirname(file), { recursive: true });
-    await writeFile(file, s.content, "utf8");
-    io.out(`Wrote ${s.path}. Set the variables its first lines name, then commit it.`);
-    return 0;
-  }
-  lines(io, s.content);
-  return 0;
-}
-async function ciArchiveGate(root, changeId, o, io, deps = {}) {
-  if (!changeId) {
-    io.err("Usage: atticus ci archive-gate <change> [--drift <report.json>...] [--json]");
-    return 2;
-  }
-  let r;
-  try {
-    r = await archiveGate(root, changeId, {
-      ...o.drift?.length ? { driftReports: o.drift } : {},
-      ...deps.commit ? { commit: deps.commit } : {}
-    });
-  } catch (e) {
-    if (e instanceof Error && e.name === "ChangeFileError") {
-      io.err(e.message);
-      return 2;
-    }
-    throw e;
-  }
-  if (o.json)
-    io.out(JSON.stringify(r, null, 2));
-  else {
-    io.out(r.pass ? `${changeId} may be archived: no blockers, builds passed and the catalog matches its repos.` : `${changeId} can't be archived yet (${plural(r.blockers.length, "blocker")}):`);
-    for (const b of r.blockers)
-      io.out(`- ${b.message}`);
-    for (const n of r.notes)
-      io.out(n);
-  }
-  return r.pass ? 0 : 1;
-}
-var short = (s, n = 70) => s.length <= n ? s : `${s.slice(0, n - 3)}...`;
-var sourceOf = (flags, confidence) => confidence === "asserted" ? "person" : flags?.includes("ai-proposed") ? "ai" : flags?.includes("undefined") ? "code" : "wiki";
-async function glossaryList(root, o, io) {
-  const g = await loadGlossary(root);
-  for (const p of g.problems)
-    io.err(p);
-  if (o.json) {
-    io.out(JSON.stringify({
-      terms: g.terms,
-      conflicts: g.build.conflicts,
-      hints: g.build.hints,
-      synonyms: Object.fromEntries(g.build.entries.filter((e) => e.aliases.length).map((e) => [e.id, e.aliases]))
-    }, null, 2));
-    return 0;
-  }
-  if (!g.terms.length) {
-    io.out("The glossary is empty: no wiki page defines a term and the catalog has no domain words yet.");
-    return 0;
-  }
-  for (const l of table(["TERM", "ID", "FROM", "FLAGS", "DEFINITION"], g.terms.map((t) => [
-    t.term,
-    t.id,
-    sourceOf(t.flags, t.confidence),
-    (t.flags ?? []).join(","),
-    short(t.definition)
-  ])))
-    io.out(l);
-  io.out(`${plural(g.terms.length, "term")}, ${plural(g.build.conflicts.filter((c) => !c.resolved).length, "conflict")}.`);
-  return 0;
-}
-async function glossaryScan(root, o, io, deps = {}) {
-  try {
-    const runtime = await runtimeOf(root, o.mode, deps);
-    const r = await scanGlossary(root, {
-      ...runtime ? { runtime } : {},
-      ...deps.now ? { now: deps.now() } : {}
-    });
-    if (o.json) {
-      for (const p of r.problems)
-        io.err(p);
-      io.out(JSON.stringify({
-        terms: r.terms.length,
-        written: r.written,
-        removed: r.removed,
-        conflicts: r.build.conflicts,
-        hints: r.build.hints,
-        ...r.propose ? { proposals: r.propose.proposals.length, discarded: r.propose.discarded } : {}
-      }, null, 2));
-      return 0;
-    }
-    printGlossaryScan(r, io);
-    return 0;
-  } catch (e) {
-    return fail(io, e);
-  }
-}
-function printGlossaryScan(r, io) {
-  for (const p of r.problems)
-    io.err(p);
-  const open = r.build.conflicts.filter((c) => !c.resolved);
-  io.out(`The glossary has ${plural(r.terms.length, "term")}; ${plural(r.written.length, "file")} written and ${plural(r.removed.length, "file")} removed in catalog/generated.`);
-  if (r.propose)
-    io.out(r.propose.waiting ? `The glossary definer is with your assistant (run ${r.propose.waiting}). When it is done, run: atticus handoff done ${r.propose.waiting}` : `The glossary definer proposed ${plural(r.propose.proposals.length, "definition")} (kept inferred until a person defines the term).`);
-  for (const d of r.propose?.discarded ?? [])
-    if (d.term && !r.propose?.waiting)
-      io.err(`Discarded ${d.term}: ${d.reason}`);
-  for (const c of open)
-    io.out(`Conflict: ${c.message}`);
-  for (const h of r.build.hints)
-    io.out(`Naming: ${h.message}`);
-}
-async function completeGlossaryScan(root, run, io, deps = {}) {
-  try {
-    const r = await completeGlossaryDefinitions(root, run, deps.now ? { now: deps.now } : {});
-    printGlossaryScan(r, io);
-    return 0;
-  } catch (e) {
-    return fail(io, e);
-  }
-}
-async function decide(root, io, make, said) {
-  try {
-    const g = await loadGlossary(root);
-    const ds = make(g);
-    const files = await writeDecisions(join4(g.catalogDir, "curated"), ds);
-    await scanGlossary(root);
-    io.out(`Wrote ${files.map((f) => `catalog/curated/${f}`).join(" and ")}: ${said}. Commit it so every scan keeps it.`);
-    return 0;
-  } catch (e) {
-    if (e instanceof GlossaryError) {
-      io.err(e.message);
-      return e.code === "invalid" ? 2 : 1;
-    }
-    throw e;
-  }
-}
-async function glossaryDefine(root, term, definition, o, io) {
-  if (!term || !definition || !o.by) {
-    io.err('Usage: atticus glossary define <term> "<definition>" [--by <handle>] [--owner <team>]');
-    return 2;
-  }
-  return decide(root, io, (g) => {
-    const existing = g.terms.find((t) => t.id === resolveTermId(term));
-    return [
-      defineDecision(term, definition, {
-        by: o.by,
-        ...o.owner ? { owner: o.owner } : {},
-        ...existing ? { existing } : {}
-      })
-    ];
-  }, `${resolveTermId(term)} is defined and asserted`);
-}
-async function glossaryLink(root, term, recordId, o, io) {
-  if (!term || !recordId || !o.by) {
-    io.err("Usage: atticus glossary link <term> <record-id | schema#field> [--by <handle>]");
-    return 2;
-  }
-  return decide(root, io, (g) => {
-    const id = resolveTermId(term);
-    const t = g.terms.find((x) => x.id === id);
-    if (!t)
-      throw new GlossaryError("not-found", `There is no term ${id}. Define it first: atticus glossary define`);
-    return [linkDecision(t, recordId, g.base, { by: o.by })];
-  }, `${recordId} is linked to ${resolveTermId(term)}`);
-}
-async function glossaryAlias(root, term, names, o, io) {
-  if (!term || !names.length || !o.by) {
-    io.err('Usage: atticus glossary alias <term> "<other name>"... [--by <handle>]');
-    return 2;
-  }
-  return decide(root, io, (g) => {
-    const id = resolveTermId(term);
-    const before = g.build.entries.find((e) => e.id === id)?.aliases ?? [];
-    return [aliasDecision(id, [...before, ...names], { by: o.by })];
-  }, `${names.join(", ")} ${names.length === 1 ? "is another name" : "are other names"} for ${resolveTermId(term)}`);
-}
-
 export {
-  archiveGate,
-  testsGenerate,
-  traceCommand,
-  ciDrift,
-  ciSnippet,
-  ciArchiveGate,
-  glossaryList,
-  glossaryScan,
-  completeGlossaryScan,
-  glossaryDefine,
-  glossaryLink,
-  glossaryAlias
+  CiConfig,
+  DEFAULT_CI_CONFIG,
+  loadCiConfig,
+  ignored,
+  DRIFT_SCHEMA_VERSION,
+  DriftError,
+  resolveCatalog,
+  repoDrift,
+  driftExitCode,
+  driftJson,
+  driftJUnit,
+  driftMarkdown,
+  SNIPPET_KINDS,
+  pipelineSnippet,
+  archiveGate
 };