@maycombhq/atticus 0.0.0-stage → 2.0.0-beta.2

package/dist/chunk-QZSX3F7C.js

@@ -0,0 +1,389 @@
+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 {
+  upgradeCommand
+} from "./chunk-YISXLPHN.js";
+import {
+  AdoptError,
+  absorb,
+  acceptAbsorbed,
+  adopt,
+  checkZeroInstall,
+  init,
+  refreshAbsorbed,
+  refreshAllAbsorbed,
+  reposDiscover,
+  unadopt,
+  zeroInstallFiles
+} from "./chunk-GDLULHTC.js";
+import {
+  assistantTier,
+  readProbes,
+  tierLine
+} from "./chunk-IPKHE5D6.js";
+import "./chunk-CKSITVS4.js";
+import "./chunk-L6SGQIR3.js";
+import "./chunk-3HI6Z55Y.js";
+import "./chunk-XY3P7JW7.js";
+import "./chunk-4AK7IBVP.js";
+import "./chunk-7JUKDRSZ.js";
+import "./chunk-27NKUS3X.js";
+import "./chunk-L24C55VN.js";
+import "./chunk-PAMPPUR6.js";
+import "./chunk-23W7VWKR.js";
+import "./chunk-7EKXJZ2Y.js";
+import "./chunk-MC3H7736.js";
+import "./chunk-T6AIP7H5.js";
+import "./chunk-RZPYKDWS.js";
+import "./chunk-EFHQ3TWP.js";
+import "./chunk-GQ4N4WKF.js";
+import "./chunk-CNUKCS2T.js";
+import {
+  loadOrgPack,
+  orgPackDirOf
+} from "./chunk-S2A7YC3Q.js";
+import "./chunk-D3PO4DOZ.js";
+import "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/setup-commands.js
+import { resolve } from "node:path";
+async function tierAt(root, io) {
+  try {
+    const op = await loadOrgPack(orgPackDirOf(root));
+    const { results } = await readProbes(root);
+    io.out(`Your assistant reads a repo at: ${tierLine(assistantTier(op.runtime, { probes: results }))}`);
+  } catch {
+  }
+}
+var plural = (n, w) => `${n} ${w}${n === 1 ? "" : "s"}`;
+function fail(io, e) {
+  if (e instanceof AdoptError) {
+    io.err(e.message);
+    return e.code === "usage" ? 2 : 1;
+  }
+  io.err(e.message);
+  return 1;
+}
+async function initCommand(dir, o, io) {
+  if (!o.name || !o.platform) {
+    io.err("Usage: atticus init <name> --platform <platform> [--from <org pack folder>]");
+    return 2;
+  }
+  try {
+    const r = await init(dir, {
+      name: o.name,
+      platform: o.platform,
+      ...o.packFrom ? { packFrom: resolve(o.packFrom) } : {},
+      ...o.owner ? { owner: o.owner } : {},
+      ...o.openspecStore ? { openspecStore: true } : {}
+    });
+    if (!r.problems.length)
+      await upgradeCommand(dir, o.owner ? { by: o.owner } : {}, {
+        out: () => void 0,
+        err: (l) => io.err(l)
+      });
+    if (o.json) {
+      io.out(JSON.stringify(r, null, 2));
+      return r.problems.length ? 1 : 0;
+    }
+    io.out(`Created the ${o.name} metarepo in ${dir} (${plural(r.created.length, "file")}).`);
+    if (r.git === "initialised")
+      io.out(`Made ${dir} a git repository (git init, branch main).`);
+    if (r.gitNote)
+      io.err(r.gitNote);
+    io.out(r.openspec === "cli" ? "OpenSpec is set up with the org-flow schema." : "openspec/ was made as folders with the org-flow schema.");
+    if (r.openspecNote)
+      io.out(r.openspecNote);
+    if (r.assistantFiles > 0)
+      io.out(`Your assistant's files are written (${r.assistantFiles} of them, .claude/commands/, .github/prompts/, CLAUDE.md), so /atticus-map works here; atticus assistant-files writes them again when the org pack changes.`);
+    else
+      io.out("Your assistant's files weren't written; run atticus assistant-files to get the slash commands (/atticus-map and the rest), or use atticus map <repo> instead.");
+    if (r.openspecStore)
+      io.out(`It is also the OpenSpec store ${r.openspecStore.id} (beta, .openspec-store/store.yaml): once it is pushed, a developer runs openspec store register <their clone> to use it from plain OpenSpec.`);
+    for (const p of r.problems)
+      io.err(`org-pack/${p.file}: ${p.path ? `${p.path}: ` : ""}${p.message}`);
+    for (const q of r.questions)
+      io.out(`Question: ${q}`);
+    await tierAt(dir, io);
+    io.out("Next: atticus repos discover <folder of clones> and atticus workspace sync, then read each repo: /atticus-map <repo> in your assistant (or atticus map <repo>), then atticus verify <repo> --write.");
+    return r.problems.length ? 1 : 0;
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+async function adoptCommand(path, o, io) {
+  try {
+    const r = await adopt(path, {
+      ...o.platform ? { platform: o.platform } : {},
+      ...o.name ? { name: o.name } : {}
+    });
+    if (o.json) {
+      io.out(JSON.stringify({
+        root: r.root,
+        platform: r.platform,
+        detected: r.detected,
+        layout: r.layout,
+        repos: r.repos.map((x) => ({ ...x.entry, signals: x.detection.signals })),
+        questions: r.questions,
+        written: r.written,
+        problems: r.problems,
+        ms: r.ms
+      }, null, 2));
+      return r.problems.length ? 1 : 0;
+    }
+    const d = r.detected;
+    const found = [
+      d.openspec ? `OpenSpec in ${d.openspec}/` : void 0,
+      d.speckit ? "Spec Kit (.specify/)" : void 0,
+      d.constitution ? `a constitution (${d.constitution})` : void 0,
+      d.prompts.length ? `prompts in ${d.prompts.join(", ")}` : void 0,
+      d.agents.length ? `agents in ${d.agents.join(", ")}` : void 0,
+      d.skills.length ? `skills in ${d.skills.join(", ")}` : void 0,
+      d.catalog ? `a catalog in ${d.catalog}/` : void 0
+    ].filter(Boolean);
+    io.out(`Adopted ${r.root} in place in ${(r.ms / 1e3).toFixed(1)} s. No file of the repo was changed.`);
+    io.out(found.length ? `Found ${found.join("; ")}.` : "Found no OpenSpec, Spec Kit or assistant files.");
+    io.out(`Repos: ${r.repos.map((x) => `${x.entry.id} (${x.entry.type})`).join(", ") || "none"}.`);
+    io.out(`Everything Atticus owns is in .atticus/: the org pack points at what exists (openspec: ${r.layout.openspec}, catalog: ${r.layout.catalog}).`);
+    for (const p of r.problems)
+      io.err(`.atticus/org-pack/${p.file}: ${p.path ? `${p.path}: ` : ""}${p.message}`);
+    if (r.questions.length)
+      io.out(`${plural(r.questions.length, "question")} for people are in .atticus/proposals/repos/${r.platform}/QUESTIONS.md.`);
+    await tierAt(r.root, io);
+    io.out(`Next: atticus scan --root ${path}. To remove Atticus: atticus unadopt ${path}.`);
+    return r.problems.length ? 1 : 0;
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+async function unadoptCommand(path, io) {
+  try {
+    const r = await unadopt(path);
+    for (const f of r.removed)
+      io.out(`Removed ${f}`);
+    for (const f of r.restored)
+      io.out(`Took Atticus's section out of ${f}`);
+    for (const f of r.keptNew)
+      io.out(`Kept ${f} (added since adoption, not Atticus's)`);
+    for (const f of r.changed)
+      io.out(`Kept ${f} (changed since adoption)`);
+    for (const f of r.missing)
+      io.out(`Note: ${f} was deleted since adoption`);
+    if (!r.hadSnapshot)
+      io.out("There was no adoption snapshot, so only files that are certainly Atticus's were removed.");
+    io.out(r.changed.length || r.keptNew.length || r.missing.length ? "Atticus is removed. The files above changed after adoption and were left as they are." : "Atticus is removed; every other file is as it was before adoption.");
+    return 0;
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+async function reposDiscoverCommand(root, o, io) {
+  if (!o.from && !o.org) {
+    io.err("Usage: atticus repos discover <folder of clones> | --org <organisation>");
+    return 2;
+  }
+  if (o.org && !o.host) {
+    io.err("Listing an organisation needs a Git host adapter that can list repos, and none is configured. Point at a folder of clones instead.");
+    return 2;
+  }
+  try {
+    const r = await reposDiscover(root, o.org ? { host: o.host, org: o.org } : { dir: resolve(o.from) }, { ...o.platform ? { platform: o.platform } : {}, ...o.dryRun ? { dryRun: true } : {} });
+    if (o.json) {
+      io.out(JSON.stringify({
+        platform: r.platform,
+        repos: r.repos.map((x) => ({ ...x.entry, signals: x.detection.signals })),
+        skipped: r.skipped,
+        questions: r.questions,
+        wrote: r.wrote,
+        file: r.file
+      }, null, 2));
+      return 0;
+    }
+    for (const x of r.repos)
+      io.out(`  ${x.entry.id}: ${x.entry.type}${x.detection.signals[0] ? ` (${x.detection.signals[0]})` : ""}`);
+    for (const s of r.skipped)
+      io.out(`  Skipped ${s.path}: ${s.reason}`);
+    io.out(r.wrote === "manifest" ? `Wrote ${plural(r.repos.length, "repo")} to ${r.file}.` : r.wrote === "proposal" ? `A manifest exists, so it was left as it is; the proposal is in ${r.file}.` : `Found ${plural(r.repos.length, "repo")}; nothing written (dry run).`);
+    if (r.questions.length)
+      io.out(`${plural(r.questions.length, "question")} need a person${r.questionsFile ? `: ${r.questionsFile}` : ""}.`);
+    return 0;
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+function reportRefresh(r, io) {
+  const s = r.source;
+  const i = r.items;
+  if (!s.added.length && !s.removed.length && !s.changed.length && !i.added.length && !i.removed.length && !i.changed.length) {
+    io.out(`Refreshed ${r.id} from ${r.entry.url}: nothing changed since the last absorb.`);
+    return;
+  }
+  io.out(`Refreshed ${r.id} from ${r.entry.url}: ${plural(s.added.length, "file")} added, ${s.removed.length} removed and ${s.changed.length} changed in the source.`);
+  for (const f of s.added)
+    io.out(`  + ${f}`);
+  for (const f of s.removed)
+    io.out(`  - ${f}`);
+  for (const f of s.changed)
+    io.out(`  ~ ${f}`);
+  io.out(`Items: ${i.added.length} new, ${i.removed.length} gone, ${i.changed.length} with a different action.`);
+  for (const x of i.added)
+    io.out(`  + ${x}`);
+  for (const x of i.removed)
+    io.out(`  - ${x}`);
+  for (const x of i.changed)
+    io.out(`  ~ ${x.id}: ${x.from} to ${x.to}`);
+  if (r.result.proposal)
+    io.out(`Rewrote the proposal in ${r.result.proposal}/; review it as before.`);
+}
+async function absorbRefreshCommand(root, id, o, io) {
+  if (!id) {
+    io.err("Usage: atticus absorb --refresh <id>");
+    return 2;
+  }
+  try {
+    const r = await refreshAbsorbed(root, id);
+    if (o.json)
+      io.out(JSON.stringify({
+        id: r.id,
+        entry: r.entry,
+        source: r.source,
+        files: r.files,
+        items: r.items,
+        proposal: r.result.proposal
+      }, null, 2));
+    else
+      reportRefresh(r, io);
+    for (const p of r.result.problems)
+      io.err(`  ${p}`);
+    return r.result.problems.length ? 1 : 0;
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+async function sourcesRefreshCommand(root, o, io) {
+  try {
+    const all = await refreshAllAbsorbed(root);
+    if (o.json)
+      io.out(JSON.stringify(all.map((r) => ({ id: r.id, source: r.source, files: r.files, items: r.items })), null, 2));
+    else if (!all.length)
+      io.out("No linked absorbed sources in sources.yaml; nothing to refresh.");
+    else
+      for (const r of all)
+        reportRefresh(r, io);
+    const problems = all.flatMap((r) => r.result.problems.map((p) => `${r.id}: ${p}`));
+    for (const p of problems)
+      io.err(`  ${p}`);
+    return problems.length ? 1 : 0;
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+async function absorbAcceptCommand(root, id, o, io) {
+  if (!id) {
+    io.err("Usage: atticus absorb accept <id> [--replace] [--dry-run]");
+    return 2;
+  }
+  try {
+    const r = await acceptAbsorbed(root, id, {
+      ...o.replace ? { replace: true } : {},
+      ...o.dryRun ? { dryRun: true } : {}
+    });
+    if (o.json) {
+      io.out(JSON.stringify({ ...r, dryRun: o.dryRun === true }, null, 2));
+      return 0;
+    }
+    const would = o.dryRun ? "Would copy" : "Copied";
+    io.out(`${would} ${plural(r.copied.length, "file")} from ${r.proposal}/ into the metarepo${r.same.length ? ` (${r.same.length} already there)` : ""}; ${plural(r.linked, "item")} stay linked.`);
+    for (const f of r.copied)
+      io.out(`  ${f}`);
+    if (r.kept.length) {
+      io.out(`Kept ${plural(r.kept.length, "file")} that already differ (--replace overwrites them):`);
+      for (const f of r.kept)
+        io.out(`  ${f}`);
+    }
+    io.out(r.entry === "already" ? `${r.sourcesFile} already lists ${id}.` : `${o.dryRun ? "Would add" : r.entry === "added" ? "Added" : "Replaced"} ${id} under absorbed: in ${r.sourcesFile}.`);
+    if (!o.dryRun && (r.copied.length || r.entry !== "already"))
+      io.out("Commit these through a pull request: merging it is the approval.");
+    return 0;
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+async function absorbCommand(root, url, o, io) {
+  if (!url || !o.id) {
+    io.err("Usage: atticus absorb <git-url|path> --id <id> [--mode adopt|link|ignore]");
+    return 2;
+  }
+  if (o.mode && !["adopt", "link", "ignore"].includes(o.mode)) {
+    io.err(`--mode is adopt, link or ignore, not ${o.mode}.`);
+    return 2;
+  }
+  try {
+    const r = await absorb(root, url, {
+      id: o.id,
+      ...o.mode ? { mode: o.mode } : {},
+      ...o.ref ? { ref: o.ref } : {},
+      ...o.dryRun ? { dryRun: true } : {}
+    });
+    if (o.json) {
+      io.out(JSON.stringify({
+        id: r.id,
+        format: r.format,
+        entry: r.entry,
+        summary: r.summary,
+        items: r.items.map(({ artifact, ...i }) => ({
+          ...i,
+          ...artifact ? { artifact: artifact.path } : {}
+        })),
+        proposal: r.proposal,
+        files: r.files,
+        problems: r.problems,
+        ms: r.ms
+      }, null, 2));
+      return r.problems.length ? 1 : 0;
+    }
+    const s = r.summary;
+    io.out(`Absorbed ${url} as ${r.id} (${r.format}): ${plural(s.items, "item")}, ${s.byAction.adopt} adopt, ${s.byAction.link} link, ${s.byAction.ignore} ignore.`);
+    for (const i of r.items)
+      io.out(`  ${i.action.padEnd(6)} ${i.kind.padEnd(22)} ${i.path}${i.line ? `:${i.line}` : ""}  ${i.reason}`);
+    io.out(`Translated ${s.translated} of ${s.translatable} items (${s.translatedPercent}%).`);
+    for (const p of r.problems)
+      io.err(`  ${p}`);
+    if (r.proposal)
+      io.out(`Wrote the proposal to ${r.proposal}/ (${plural(r.files.length, "file")}): PR.md is the pull request description; nothing in the org pack was changed.`);
+    return r.problems.length ? 1 : 0;
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+async function zeroInstallCommand(root, o, io) {
+  try {
+    const r = await zeroInstallFiles(root, o);
+    for (const w of r.results.filter((x) => x.action !== "unchanged"))
+      io.out(`  ${w.action}: ${w.path}`);
+    const problems = await checkZeroInstall(root, r.files.map((f) => ({ path: f.path, content: f.content })));
+    for (const p of problems)
+      io.err(`${p.file} points at ${p.missing}, which doesn't exist.`);
+    if (o.check)
+      io.out(r.upToDate ? "The assistant files are up to date." : "The assistant files are out of date.");
+    else
+      io.out(`Wrote the assistant files (${plural(r.files.length, "file")}); commit them for zero-install use.`);
+    return problems.length || o.check && !r.upToDate ? 1 : 0;
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+export {
+  absorbAcceptCommand,
+  absorbCommand,
+  absorbRefreshCommand,
+  adoptCommand,
+  initCommand,
+  reposDiscoverCommand,
+  sourcesRefreshCommand,
+  unadoptCommand,
+  zeroInstallCommand
+};

package/dist/chunk-R6RY4Q5T.js

@@ -0,0 +1,51 @@
+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));
+
+// packages/cli/dist/context-flags.js
+function contextFlags(values) {
+  const raw = values["context-tokens"];
+  const out = {};
+  if (raw !== void 0) {
+    const n = Number(raw);
+    if (!Number.isInteger(n) || n < 100)
+      return {
+        error: "--context-tokens is a whole number of 100 or more: the room for the context."
+      };
+    out.tokens = n;
+  }
+  if (values["whole-context"] === true)
+    out.engine = false;
+  return { context: out };
+}
+function contextLines(c) {
+  if (!c)
+    return [];
+  if (!c.engine)
+    return c.note ? [`Context: ${c.note}.`] : [];
+  const full = c.picked.filter((p) => p.level === "full").length;
+  const lines = [
+    `Context: ${c.picked.length} record${c.picked.length === 1 ? "" : "s"} selected from the index (${full} in full), ${c.tokens ?? 0} of ${c.budget ?? 0} tokens${c.leftOut.length ? `; left out for room: ${c.leftOut.slice(0, 10).map((l) => l.id).join(", ")}${c.leftOut.length > 10 ? ` and ${c.leftOut.length - 10} more` : ""}` : ""}.`
+  ];
+  const gaps = c.gaps ?? [];
+  if (gaps.length) {
+    const where = c.searched === void 0 ? "nothing Atticus has read says anything about" : c.searched.length ? `neither the catalog, the knowledge, the specs nor the code of ${c.searched.join(", ")} has` : "neither the catalog, the knowledge nor the specs has (no repo is cloned, so no code was searched)";
+    lines.push(`Gaps: names the change uses that ${where}: ${gaps.map((g) => `${g.name}${g.evidence ? ` (${g.evidence})` : ""}`).join(", ")}.`);
+    for (const g of gaps.filter((x) => x.question))
+      lines.push(g.state === "answered" ? `  ${g.name}: answered (question ${g.question}).` : `  ${g.name}: the answer relies on it, so it is a question to a person, not a guess: atticus questions answer ${g.question}`);
+  }
+  if (c.inCode?.length)
+    lines.push(`In the code, not gaps: ${c.inCode.slice(0, 10).map((n) => `${n.name} (${n.at})`).join(", ")}${c.inCode.length > 10 ? ` and ${c.inCode.length - 10} more` : ""}.`);
+  const known = new Set((c.known ?? []).map((k) => k.name));
+  const unknown = c.unknown.filter((n) => !known.has(n));
+  if (!gaps.length && !c.inCode?.length && unknown.length)
+    lines.push(`Names the change uses that nothing in the index has: ${unknown.join(", ")}.`);
+  return lines;
+}
+
+export {
+  contextFlags,
+  contextLines
+};

package/dist/chunk-R6XF6UR3.js

@@ -0,0 +1,149 @@
+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 {
+  readCatalog
+} from "./chunk-27NKUS3X.js";
+import {
+  readDiagram,
+  reconcile
+} from "./chunk-7EKXJZ2Y.js";
+import {
+  loadOrgPack,
+  orgPackDirOf,
+  parseRecord,
+  recordPath,
+  serializeRecord
+} from "./chunk-S2A7YC3Q.js";
+
+// packages/cli/dist/reconcile-commands.js
+import { mkdir, readdir, readFile, writeFile } from "node:fs/promises";
+import { userInfo } from "node:os";
+import { dirname, join, relative, resolve, sep } from "node:path";
+var DEFAULT_DIR = "inputs/diagrams";
+async function findDiagrams(dir) {
+  const out = [];
+  async function walk(d) {
+    let entries;
+    try {
+      entries = await readdir(d, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+      const full = join(d, e.name);
+      if (e.isDirectory())
+        await walk(full);
+      else if (/\.(drawio|drawio\.xml|vsdx|mmd|mermaid|csv)$/i.test(e.name))
+        out.push(full);
+    }
+  }
+  await walk(dir);
+  return out;
+}
+async function reconcileCommand(root, files, o, io) {
+  const paths = files.length > 0 ? files.map((f) => resolve(root, f)) : await findDiagrams(join(root, ...DEFAULT_DIR.split("/")));
+  if (paths.length === 0) {
+    io.err(`No diagrams to reconcile: name one, or put diagrams (.drawio, .vsdx, Lucid .csv, .mmd) under ${DEFAULT_DIR}/`);
+    return 2;
+  }
+  const texts = [];
+  for (const p of paths) {
+    try {
+      texts.push({ file: relative(root, p).split(sep).join("/"), bytes: await readFile(p) });
+    } catch {
+      io.err(`Can't read ${p}`);
+      return 2;
+    }
+  }
+  const op = await loadOrgPack(join(orgPackDirOf(root)));
+  const profile = op.profiles[0]?.profile;
+  const catalogDir = join(root, op.sources.layout.catalog);
+  const generated = await readCatalog(join(catalogDir, "generated"), { cacheRoot: root });
+  const curated = await readCatalog(join(catalogDir, "curated"), { cacheRoot: root });
+  for (const p of [...generated.problems, ...curated.problems])
+    io.err(`catalog ${p.file}: ${p.message}`);
+  const records = [...generated.records, ...curated.records];
+  if (generated.records.length === 0)
+    io.err("The catalog is empty: run atticus scan first, or every edge will be diagram-only.");
+  const results = [];
+  for (const t of texts) {
+    const diagram = readDiagram(t.file, t.bytes, profile?.legend);
+    if (!diagram) {
+      io.err(`${t.file}: not a diagram Atticus can read (draw.io, Visio .vsdx, Lucid CSV, Mermaid)`);
+      continue;
+    }
+    const r = reconcile({
+      diagram,
+      file: t.file,
+      records,
+      systems: profile?.systems ?? [],
+      patterns: op.patterns
+    });
+    results.push({ file: t.file, edges: diagram.edges.length, problems: diagram.problems, ...r });
+  }
+  if (o.json)
+    io.out(JSON.stringify({
+      diagrams: results.map(({ file, edges, matches, items, names, problems }) => ({
+        file,
+        edges,
+        matches,
+        items,
+        names,
+        problems
+      }))
+    }, null, 2));
+  else
+    for (const r of results) {
+      io.out(`${r.file}: ${r.edges} edges, ${r.matches.length} matched to code, ${r.items.length} item${r.items.length === 1 ? "" : "s"}`);
+      for (const p of r.problems)
+        io.out(`  ! cell ${p.cell}: ${p.message}`);
+      for (const i of r.items) {
+        io.out(`  ${i.type} ${i.diagram ? `[${i.diagram.cell}] ` : ""}${i.summary}`);
+        if (i.suggestion)
+          io.out(`    \u2192 ${i.suggestion.text}`);
+      }
+    }
+  return results.some((r) => r.items.length > 0) ? 1 : 0;
+}
+async function aliasCommand(root, name, target, o, io) {
+  const op = await loadOrgPack(join(orgPackDirOf(root)));
+  const catalogDir = join(root, op.sources.layout.catalog);
+  const generated = await readCatalog(join(catalogDir, "generated"), { cacheRoot: root });
+  const systems = op.profiles.flatMap((p2) => p2.profile?.systems ?? []).map((s) => s.id);
+  if (!generated.records.some((r) => r.id === target) && !systems.includes(target)) {
+    io.err(`${target} isn't in the catalog. Find the id with: atticus query "${name.split(" ")[0]}"`);
+    return 1;
+  }
+  const slugName = name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  const p = parseRecord({
+    schemaVersion: 1,
+    kind: "CuratedDecision",
+    id: `alias.${slugName}`,
+    status: "current",
+    confidence: "asserted",
+    target,
+    action: "alias",
+    value: name,
+    reason: o.reason ?? `"${name}" is ${target}`,
+    by: o.by ?? userInfo().username,
+    at: (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z")
+  });
+  if (!p.ok) {
+    io.err(p.issues.map((i) => `${i.path}: ${i.message}`).join("\n"));
+    return 1;
+  }
+  const rel = `${op.sources.layout.catalog}/curated/${recordPath(p.record)}`;
+  const full = join(root, ...rel.split("/"));
+  await mkdir(dirname(full), { recursive: true });
+  await writeFile(full, serializeRecord(p.record), "utf8");
+  io.out(`Wrote ${rel}: "${name}" is ${target}. Commit it so everyone's reconcile uses it.`);
+  return 0;
+}
+
+export {
+  reconcileCommand,
+  aliasCommand
+};