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

package/dist/chunk-J2H7YG3K.js

@@ -0,0 +1,34 @@
+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 {
+  addressRefusal,
+  asTheApp,
+  atProvidersOwnAddress,
+  confirmedAddress,
+  guardModelAddress,
+  recordConfirmedAddress,
+  requireConfirmedModel,
+  servingTheApp,
+  whereKeyGoes,
+  whoStarts
+} from "./chunk-RGZFOKVO.js";
+import "./chunk-KVVNAUIG.js";
+import "./chunk-FPBUTZI5.js";
+import "./chunk-B4AEL3RF.js";
+import "./chunk-BQGDB6ZL.js";
+import "./chunk-TV45EUGM.js";
+export {
+  addressRefusal,
+  asTheApp,
+  atProvidersOwnAddress,
+  confirmedAddress,
+  guardModelAddress,
+  recordConfirmedAddress,
+  requireConfirmedModel,
+  servingTheApp,
+  whereKeyGoes,
+  whoStarts
+};

package/dist/{chunk-O4IKAIZ2.js → chunk-J32IPTVQ.js}

@@ -15,29 +15,33 @@ import {
   changeReturn,
   changeStatus,
   changeSync,
+  handoffPrStep,
   handoffPublisherFor,
-  parseOwners
-} from "./chunk-COYN3UAN.js";
-import "./chunk-LQH4P45K.js";
-import "./chunk-BEPCKDCP.js";
-import "./chunk-HWD4JPU7.js";
-import "./chunk-5WERBKLE.js";
+  parseOwners,
+  syncAfterManualStep
+} from "./chunk-V7PEHQZU.js";
+import "./chunk-73CC73I4.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-XOL3GFW2.js";
-import "./chunk-QHJJMZLX.js";
-import "./chunk-7AB6OWTV.js";
-import "./chunk-PAINMSID.js";
-import "./chunk-ODMBPDDV.js";
+import "./chunk-MLGWSBF4.js";
+import "./chunk-CA3DKO4D.js";
+import "./chunk-D6BVLTDV.js";
+import "./chunk-RCG5IAAT.js";
+import "./chunk-WZYM5M4U.js";
+import "./chunk-NC755EKE.js";
+import "./chunk-FL344WQD.js";
+import "./chunk-IKAW2KJU.js";
+import "./chunk-CZ2ZS7AT.js";
+import "./chunk-4GAB5ZOZ.js";
+import "./chunk-A4JXVO5O.js";
+import "./chunk-TDSCKP3V.js";
+import "./chunk-G6EFXTUO.js";
+import "./chunk-PQQKZPBU.js";
+import "./chunk-3EWKO457.js";
+import "./chunk-3424TLIJ.js";
+import "./chunk-QA4O2GGC.js";
+import "./chunk-FPBUTZI5.js";
+import "./chunk-B4AEL3RF.js";
+import "./chunk-BQGDB6ZL.js";
 import "./chunk-TV45EUGM.js";
 export {
   captureLine,
@@ -51,6 +55,8 @@ export {
   changeReturn,
   changeStatus,
   changeSync,
+  handoffPrStep,
   handoffPublisherFor,
-  parseOwners
+  parseOwners,
+  syncAfterManualStep
 };

package/dist/{chunk-3AQ2R5NL.js → chunk-J4CPHJUL.js}

@@ -6,7 +6,7 @@ var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
 import {
   loadRepos,
   readChangeRepos
-} from "./chunk-XOL3GFW2.js";
+} from "./chunk-3EWKO457.js";
 import {
   AssistantId,
   RecordId,
@@ -15,13 +15,15 @@ import {
   external_exports,
   factsJsonSchemas,
   loadOrgPack,
-  orgPackDirOf,
-  require_dist
-} from "./chunk-PAINMSID.js";
+  orgPackDirOf
+} from "./chunk-FPBUTZI5.js";
 import {
   ensureLocalIgnore,
   renameRetrying
-} from "./chunk-ODMBPDDV.js";
+} from "./chunk-B4AEL3RF.js";
+import {
+  require_dist
+} from "./chunk-BQGDB6ZL.js";
 import {
   __toESM
 } from "./chunk-TV45EUGM.js";
@@ -315,7 +317,7 @@ var FACT_RULE_PARTS = [
   [
     {
       when: ["routes", "frontend"],
-      text: "An entry's `path` is the full path a caller uses: class-level and group prefixes, and a context or base path the code or config sets (`server.servlet.context-path`, `UsePathBase`), joined; record that base as a `config` fact too. A route served as HTML (a server-rendered page or form post) is `entryType: rest` with its method, and so is a route that receives webhooks; `screen` is for a front end's own routes."
+      text: "An entry's `path` is the full path a caller uses: class-level and group prefixes, and a context or base path the code or config sets (`server.servlet.context-path`, `UsePathBase`), joined; record each such setting as a `config` fact too, its whole key and value as written (`server.servlet.context-path`, `spring.mvc.servlet.path`, `spring.webflux.base-path`), whether or not the entries' paths include it. A route served as HTML (a server-rendered page or form post) is `entryType: rest` with its method, and so is a route that receives webhooks; `screen` is for a front end's own routes."
     },
     {
       when: ["routes", "protocols", "gateway"],
@@ -474,7 +476,7 @@ var FACT_RULE_PARTS = [
   [
     {
       when: ["gateway"],
-      text: "An Apigee proxy (`apiproxy/`): each conditional `<Flow>` is a `rest` entry, `method` from `request.verb` (`ANY` without one), `path` the `<BasePath>` and the `proxy.pathsuffix` pattern joined, each `*` a parameter (`/forge/v1/accounts/{id}`), `handler` `<proxy>/<flow>`, cited on the `<Condition>` with the `<BasePath>` line in `cite.with`; a proxy with no conditional flow is one `ANY` entry at `<BasePath>/**`."
+      text: "An Apigee proxy (`apiproxy/`): each conditional `<Flow>` is a `rest` entry, `method` from `request.verb` (`ANY` without one), `path` the `<BasePath>` and the `proxy.pathsuffix` pattern joined, each `*` a parameter (`/forge/v1/accounts/{id}`), `handler` `<proxy>/<flow>`, cited on the `<Condition>` with the `<BasePath>` line in `cite.with`; a proxy with no conditional flow is one `ANY` entry at `<BasePath>/**` cited on the `<BasePath>` line, its forwarding call's `path` `/**` (the target's `<Path>` or `<URL>` path before it, if it has one) cited on the target's `<URL>` line or the `<RouteRule>` line, the `<Server>` line in `cite.with`."
     },
     {
       when: ["gateway"],
@@ -482,7 +484,7 @@ var FACT_RULE_PARTS = [
     },
     {
       when: ["gateway"],
-      text: "Each route has a forwarding `call` (`from` the entry, no `to`) to its `RouteRule`'s target. Its `path` is what the service receives: the target's `<Path>` and the suffix (base path dropped), or, when `target.copy.pathsuffix` is false or an AssignMessage or JavaScript policy sets the path, the path set there. Cite it where the path comes from (the rewrite, else the `<Condition>`), with the target's `<Server>` or `<URL>` line and the rewrite's other lines in `cite.with`. `base` is the TargetServer's name (or the KVM key), with a `config` fact of that `key` whose `value` is its host, cited on the host line; a `<URL>`'s host goes in `host`."
+      text: "Each route has a forwarding `call` (`from` the entry, no `to`) to its `RouteRule`'s target. Its `path` is what the service receives: the target's `<Path>` and the suffix (base path dropped), or, when `target.copy.pathsuffix` is false or an AssignMessage or JavaScript policy sets the path, the path set there. Cite it where the path comes from (the rewrite, else the `<Condition>`), with the target's `<Server>` or `<URL>` line and the rewrite's other lines in `cite.with`. `base` is the TargetServer's name (or the KVM key), with a `config` fact of that `key` whose `value` is its host, cited on the host line; a `<URL>`'s host goes in `host`. Where you can't put the path together, it is the target's `<URL>` or `<Path>` path as written: Apigee adds each route's suffix after it, and so does the join. `target.copy.pathsuffix` set false is a `config` fact (`key` `target.copy.pathsuffix`, `value` `false`, `target` the proxy) cited on the line that sets it: an `<AssignVariable>`'s `<Name>` line, a JavaScript policy's `context.setVariable`."
     },
     {
       when: ["gateway"],
@@ -547,7 +549,7 @@ var FACT_RULE_PARTS = [
   [
     {
       when: ["backend", "frontend", "deploy", "config"],
-      text: "A config fact's `key` is written as it appears on its line (the last part of a YAML path, a `:` or `__` key, or a flag is enough: `path` for `livenessProbe.httpGet.path`)."
+      text: "A config fact's `key` is the setting's full name: a YAML or properties key's whole dotted path (`gateway.url`, `livenessProbe.httpGet.path`, not `url` or `path`), a `:` or `__` key as written, or a flag; two settings in one file never share a key."
     },
     {
       when: ["deploy", "config"],

package/dist/{chunk-VUVGX5L2.js → chunk-JFFKHIM6.js}

@@ -5,7 +5,7 @@ var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
 var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
 
 // packages/cli/dist/version.js
-var VERSION = "2.0.0-beta.21";
+var VERSION = "2.0.0-beta.23";
 function versionAtLeast(v, min) {
   const a = v.replace(/^v/, "").split(/[.+-]/).map(Number);
   const b = min.split(".").map(Number);

package/dist/chunk-JMEWJPF2.js

@@ -0,0 +1,384 @@
+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 {
+  generateTests,
+  matrixCsv,
+  matrixMarkdown,
+  traceMatrix,
+  writeTraceFindings
+} from "./chunk-EMVZIOOD.js";
+import {
+  table
+} from "./chunk-VOGCSYOI.js";
+import {
+  DriftError,
+  SNIPPET_KINDS,
+  archiveGate,
+  driftExitCode,
+  driftJUnit,
+  driftJson,
+  driftMarkdown,
+  pipelineSnippet,
+  repoDrift
+} from "./chunk-ZR6J4QFQ.js";
+import {
+  GlossaryError,
+  aliasDecision,
+  completeGlossaryDefinitions,
+  defineDecision,
+  linkDecision,
+  loadGlossary,
+  resolveTermId,
+  scanGlossary,
+  writeDecisions
+} from "./chunk-IKAW2KJU.js";
+import {
+  createGit
+} from "./chunk-3EWKO457.js";
+import {
+  runtimeForCli
+} from "./chunk-3424TLIJ.js";
+
+// packages/cli/dist/quality-commands.js
+import { appendFile, mkdir, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+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 = join(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, its release PRs merged and built, and the catalog says what shipped.` : `${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(join(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 {
+  testsGenerate,
+  traceCommand,
+  ciDrift,
+  ciSnippet,
+  ciArchiveGate,
+  glossaryList,
+  glossaryScan,
+  completeGlossaryScan,
+  glossaryDefine,
+  glossaryLink,
+  glossaryAlias
+};

package/dist/{chunk-LO3BLMVG.js → chunk-JSP73CDW.js}

@@ -5,16 +5,19 @@ var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
 var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
 import {
   quantize
-} from "./chunk-QHJJMZLX.js";
+} from "./chunk-3424TLIJ.js";
+import "./chunk-QA4O2GGC.js";
 import {
   Runtime,
   external_exports,
   orgPackDirOf,
   readTarGz,
-  require_dist,
   retrievalOf
-} from "./chunk-PAINMSID.js";
-import "./chunk-ODMBPDDV.js";
+} from "./chunk-FPBUTZI5.js";
+import "./chunk-B4AEL3RF.js";
+import {
+  require_dist
+} from "./chunk-BQGDB6ZL.js";
 import {
   __toESM
 } from "./chunk-TV45EUGM.js";
@@ -341,7 +344,12 @@ function installedModelDir() {
 var embeddingsOffByEnv = () => process.env.ATTICUS_EMBEDDINGS === "off";
 async function settingsOf(root) {
   const text = await readFile2(join2(orgPackDirOf(root), "runtime.yaml"), "utf8").catch(() => void 0);
-  const raw = text ? (0, import_yaml2.parse)(text) : void 0;
+  let raw;
+  try {
+    raw = text ? (0, import_yaml2.parse)(text) : void 0;
+  } catch {
+    raw = void 0;
+  }
   const r = raw === void 0 ? void 0 : Runtime.safeParse(raw);
   const e = retrievalOf(r?.success ? r.data : void 0).embeddings;
   const said = raw?.retrieval?.embeddings?.model;

package/dist/chunk-JXAKYP45.js

@@ -0,0 +1,63 @@
+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 {
+  READS_AS_RULE,
+  dataBlock,
+  draftPrompt,
+  missedOf,
+  rulesAddCommand,
+  rulesDraftCommand,
+  rulesImportCommand,
+  rulesListCommand,
+  rulesNotesCommand,
+  rulesSetCommand,
+  rulesTryCommand,
+  scopeFile,
+  tryDiff
+} from "./chunk-DSHRA72L.js";
+import "./chunk-66AQ2JIU.js";
+import "./chunk-L3RCQWVQ.js";
+import "./chunk-TXNSQ24G.js";
+import "./chunk-PXW2RZGQ.js";
+import "./chunk-EHXDB3SA.js";
+import "./chunk-IMZFOMVX.js";
+import "./chunk-CT6NINGR.js";
+import "./chunk-K4RNVDR4.js";
+import "./chunk-ZLQEQR3D.js";
+import "./chunk-OPWGPQ2N.js";
+import "./chunk-73GFVW2L.js";
+import "./chunk-XOMEQVLK.js";
+import "./chunk-J4CPHJUL.js";
+import "./chunk-IKAW2KJU.js";
+import "./chunk-CZ2ZS7AT.js";
+import "./chunk-4GAB5ZOZ.js";
+import "./chunk-A4JXVO5O.js";
+import "./chunk-TDSCKP3V.js";
+import "./chunk-G6EFXTUO.js";
+import "./chunk-PQQKZPBU.js";
+import "./chunk-JFFKHIM6.js";
+import "./chunk-3EWKO457.js";
+import "./chunk-3424TLIJ.js";
+import "./chunk-QA4O2GGC.js";
+import "./chunk-FPBUTZI5.js";
+import "./chunk-B4AEL3RF.js";
+import "./chunk-BQGDB6ZL.js";
+import "./chunk-TV45EUGM.js";
+export {
+  READS_AS_RULE,
+  dataBlock,
+  draftPrompt,
+  missedOf,
+  rulesAddCommand,
+  rulesDraftCommand,
+  rulesImportCommand,
+  rulesListCommand,
+  rulesNotesCommand,
+  rulesSetCommand,
+  rulesTryCommand,
+  scopeFile,
+  tryDiff
+};