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

package/dist/chunk-J5LHDJU4.js

@@ -0,0 +1,400 @@
+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 {
+  table
+} from "./chunk-VOGCSYOI.js";
+import {
+  storeSpecLookup
+} from "./chunk-XQ3YIV5R.js";
+import {
+  createAdapters
+} from "./chunk-NGPU2ARF.js";
+import {
+  readCatalog
+} from "./chunk-AY2IUF4K.js";
+import {
+  FeatureError,
+  FlowGraph,
+  featureCoverage,
+  featureFlows,
+  featureLinkDecision,
+  featureMergeDecision,
+  featureNameDecision,
+  featureSplitDecisions,
+  featureTagDecision,
+  featureToSpec,
+  featuresForScan,
+  nameFeatures,
+  parseExternalRef,
+  parseFinishedNamingRun,
+  suggestFeatureLinks,
+  workItemsFromTracker,
+  writeNameProposals
+} from "./chunk-6JLPXDWN.js";
+import {
+  readWorkItemExports
+} from "./chunk-R4TBNKKC.js";
+import {
+  applyCurated,
+  loadOrgPack,
+  migrateCatalog,
+  orgPackDirOf,
+  recordPath,
+  serializeRecord
+} from "./chunk-577AJVRS.js";
+import {
+  SCHEMA_VERSION
+} from "./chunk-D3PO4DOZ.js";
+
+// packages/cli/dist/feature-commands.js
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { userInfo } from "node:os";
+import { dirname, join } from "node:path";
+async function load(root, io) {
+  const op = await loadOrgPack(join(orgPackDirOf(root)));
+  for (const p of op.problems)
+    io.err(`org-pack/${p.file}: ${p.path ? `${p.path}: ` : ""}${p.message}`);
+  const catalogRel = op.sources.layout.catalog;
+  const catalogDir = join(root, catalogRel);
+  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 base = generated.records.filter((r) => r.kind !== "Capability");
+  const found = await featuresForScan({
+    records: base,
+    decisions: curated.records,
+    proposalsDir: join(catalogDir, "proposals")
+  });
+  for (const p of found.problems)
+    io.err(`${p.decision}: ${p.message}`);
+  const featureDecisions = curated.records.filter((d) => d.kind === "CuratedDecision" && d.target.startsWith("feature."));
+  const applied = applyCurated(found.features, featureDecisions);
+  for (const p of applied.problems)
+    io.err(`${p.decision}: ${p.message}`);
+  const features = applied.records.filter((r) => r.kind === "Capability");
+  return {
+    op,
+    catalogDir,
+    catalogRel,
+    records: [...base, ...features],
+    features,
+    decisions: curated.records
+  };
+}
+var featureId = (id) => id.startsWith("feature.") ? id : `feature.${id}`;
+function find(l, id, io) {
+  const f = l.features.find((x) => x.id === featureId(id));
+  if (!f)
+    io.err(`There is no feature ${featureId(id)}. List them with: atticus feature list`);
+  return f;
+}
+async function writeDecisions(l, root, ds) {
+  const out = [];
+  for (const d of ds) {
+    const rel = `${l.catalogRel}/curated/${recordPath(d)}`;
+    const full = join(root, ...rel.split("/"));
+    await mkdir(dirname(full), { recursive: true });
+    await writeFile(full, serializeRecord(d), "utf8");
+    out.push(rel);
+  }
+  return out;
+}
+async function decide(root, io, make, said) {
+  const l = await load(root, io);
+  let ds;
+  try {
+    ds = make(l);
+  } catch (e) {
+    if (e instanceof FeatureError) {
+      io.err(e.message);
+      return 2;
+    }
+    throw e;
+  }
+  if (!ds)
+    return 1;
+  const files = await writeDecisions(l, root, ds);
+  io.out(`Wrote ${files.join(" and ")}: ${said(files)}. Commit ${files.length > 1 ? "them" : "it"} so every scan keeps ${files.length > 1 ? "them" : "it"}.`);
+  return 0;
+}
+var by = (o) => o.by ?? userInfo().username;
+async function featureList(root, o, io) {
+  const l = await load(root, io);
+  if (l.records.length === 0) {
+    io.err("The catalog is empty: read the repos first (atticus map <repo>, then atticus verify <repo> --write).");
+    return 2;
+  }
+  const cov = featureCoverage(l.records);
+  if (o.json) {
+    io.out(JSON.stringify({ features: l.features, coverage: cov }, null, 2));
+    return 0;
+  }
+  if (l.features.length === 0)
+    io.out("No features found yet.");
+  else
+    for (const line of table(["ID", "NAME", "NAMED BY", "OWNER", "ENTRY POINTS", "LINKS"], l.features.map((f) => [
+      f.id,
+      f.name,
+      f.namedBy,
+      f.owner ?? "-",
+      String(f.entryPoints.length),
+      String(f.externalRefs.length)
+    ])))
+      io.out(line);
+  const n = l.features.length;
+  io.out(`${n} feature${n === 1 ? "" : "s"}: ${cov.confirmed.length} confirmed, ${cov.detectedOnly.length} detected only.${cov.unknown.length ? ` No feature covers ${cov.unknown.join(", ")}.` : ""}`);
+  return 0;
+}
+async function featureShow(root, id, o, io) {
+  const l = await load(root, io);
+  const f = find(l, id, io);
+  if (!f)
+    return 1;
+  const flows = featureFlows(l.records).find((x) => x.feature.id === f.id);
+  const looseEnds = flows?.looseEnds ?? [];
+  if (o.json) {
+    io.out(JSON.stringify({ feature: f, system: flows?.system, looseEnds }, null, 2));
+    return 0;
+  }
+  const g = new FlowGraph(l.records);
+  const what = (x) => {
+    const e = g.endpoints.get(x);
+    if (e)
+      return `${e.method ? `${e.method} ` : ""}${e.pathOrTopic} on ${e.component}`;
+    const i = g.interfaces.get(x);
+    if (i)
+      return i.sync === "async" ? `event ${i.normalizedPath} from ${i.from} to ${i.to}` : `call from ${i.from}: ${i.method ?? ""} ${i.normalizedPath}`.trim();
+    const s = g.settings.get(x);
+    if (s)
+      return `schedule ${s.valueOrRef} on ${s.component}`;
+    return g.components.has(x) ? `batch job ${x}` : x;
+  };
+  io.out(`${f.name} (${f.id})`);
+  io.out(`  named by: ${f.namedBy}, ${f.confidence}`);
+  io.out(`  owner: ${f.owner ?? "-"}`);
+  io.out(`  tags: ${f.tags.length ? f.tags.join(", ") : "-"}`);
+  io.out(`  links: ${f.externalRefs.length ? f.externalRefs.map((r) => `${r.system}:${r.id}`).join(", ") : "-"}`);
+  if (f.description)
+    io.out(`  ${f.description}`);
+  io.out("Entry points:");
+  for (const line of table(["", ""], f.entryPoints.map((e) => [e, what(e)])).slice(1))
+    io.out(`  ${line}`);
+  io.out("Spans:");
+  const byKind = /* @__PURE__ */ new Map();
+  for (const r of f.records) {
+    const kind = g.records.get(r)?.kind ?? "Unknown";
+    byKind.set(kind, [...byKind.get(kind) ?? [], r]);
+  }
+  for (const kind of [...byKind.keys()].sort())
+    io.out(`  ${kind}: ${byKind.get(kind).join(", ")}`);
+  if (looseEnds.length) {
+    io.out("Loose ends:");
+    for (const e of looseEnds)
+      io.out(`  ${e.text}`);
+  }
+  return 0;
+}
+async function featureName(root, id, name, o, io) {
+  return decide(root, io, (l) => {
+    const f = find(l, id, io);
+    return f ? [
+      featureNameDecision(f, {
+        name,
+        by: by(o),
+        ...o.description ? { description: o.description } : {},
+        ...o.owner ? { owner: o.owner } : {}
+      })
+    ] : void 0;
+  }, () => `${featureId(id)} is "${name.trim()}"`);
+}
+async function featureTag(root, id, tags, o, io) {
+  let set = [];
+  return decide(root, io, (l) => {
+    const f = find(l, id, io);
+    if (!f)
+      return void 0;
+    const d = featureTagDecision(f, tags, { by: by(o) });
+    set = d.value.tags;
+    return [d];
+  }, () => `${featureId(id)} is tagged ${set.length ? set.join(", ") : "with nothing"}`);
+}
+async function featureMerge(root, into, from, o, io) {
+  return decide(root, io, (l) => {
+    const target = find(l, into, io);
+    const others = from.map((x) => find(l, x, io));
+    if (!target || others.some((x) => !x))
+      return void 0;
+    return [featureMergeDecision(target, others, { by: by(o) })];
+  }, () => `${from.map(featureId).join(", ")} ${from.length === 1 ? "is" : "are"} now part of ${featureId(into)}`);
+}
+async function featureSplit(root, id, entryPoints, o, io) {
+  let into = "";
+  return decide(root, io, (l) => {
+    const f = find(l, id, io);
+    if (!f)
+      return void 0;
+    const ds = featureSplitDecisions(f, entryPoints, {
+      by: by(o),
+      records: l.records,
+      ...o.name ? { name: o.name } : {},
+      ...o.into ? { into: featureId(o.into) } : {}
+    });
+    into = ds[0].target;
+    if (l.features.some((x) => x.id === into))
+      throw new FeatureError(`${into} already exists; merge into it instead, or pick another name.`);
+    return ds;
+  }, () => `${entryPoints.join(", ")} now ${entryPoints.length === 1 ? "starts" : "start"} ${into}`);
+}
+async function featureLink(root, id, ref, o, io) {
+  let label = "";
+  return decide(root, io, (l) => {
+    const f = find(l, id, io);
+    if (!f)
+      return void 0;
+    const r = parseExternalRef(ref, o.title);
+    label = `${r.system} ${r.id}`;
+    return [featureLinkDecision(f, r, { by: by(o) })];
+  }, () => `${featureId(id)} is linked to ${label}`);
+}
+async function featureSuggestLinks(root, o, io) {
+  const l = await load(root, io);
+  const items = [];
+  let tracker = o.workTracker;
+  if (!tracker && l.op.runtime.adapters.workTracker) {
+    try {
+      tracker = createAdapters(l.op.runtime).workTracker;
+    } catch (e) {
+      io.err(`The work tracker can't be reached (${e.message}); using the work-item exports in inputs/ instead.`);
+    }
+  }
+  if (tracker) {
+    try {
+      items.push(...await workItemsFromTracker(tracker));
+    } catch (e) {
+      io.err(`The work tracker can't be reached (${e.message}); using the work-item exports in inputs/ instead.`);
+    }
+  }
+  const exported = await readWorkItemExports({ root });
+  for (const p of exported.problems)
+    io.err(`${p.path}: ${p.message}`);
+  const seen = new Set(items.map((i) => `${i.system ?? "ado"}|${i.id}`));
+  for (const i of exported.items)
+    if (!seen.has(`${i.system}|${i.id}`))
+      items.push(i);
+  const suggestions = suggestFeatureLinks({
+    features: l.features,
+    items,
+    records: l.records,
+    decisions: l.decisions
+  });
+  if (o.json) {
+    io.out(JSON.stringify({ items: suggestions }, null, 2));
+    return suggestions.length ? 1 : 0;
+  }
+  if (!suggestions.length) {
+    io.out(items.length ? "No links to suggest." : "No work items to compare: the tracker gave none and inputs/ has no work-item export.");
+    return 0;
+  }
+  io.out(`${suggestions.length} link${suggestions.length === 1 ? "" : "s"} to confirm.`);
+  for (const s of suggestions) {
+    const ref = s.options[0].decision.value.externalRefs.at(-1);
+    io.out("");
+    io.out(s.id);
+    io.out(`  ${s.summary}`);
+    io.out(`  at ${s.source.path}${s.source.line ? `:${s.source.line}` : ""}`);
+    io.out(`  \u2192 atticus feature link ${s.records[0]} ${ref.system}:${ref.id}`);
+  }
+  return 1;
+}
+async function featureSpec(root, id, io) {
+  const l = await load(root, io);
+  const f = find(l, id, io);
+  if (!f)
+    return 1;
+  let draft;
+  try {
+    draft = featureToSpec(f, l.records);
+  } catch (e) {
+    if (e instanceof FeatureError) {
+      io.err(e.message);
+      return 1;
+    }
+    throw e;
+  }
+  const rel = draft.path.replace(/^openspec\//, `${l.op.sources.layout.openspec}/`);
+  const full = join(root, ...rel.split("/"));
+  if (await readFile(full).then(() => true, () => false)) {
+    io.err(`${rel} already exists; Atticus never overwrites a spec.`);
+    return 1;
+  }
+  await mkdir(dirname(full), { recursive: true });
+  await writeFile(full, draft.text, { encoding: "utf8", flag: "wx" });
+  io.out(`Wrote ${rel}, a draft from ${f.id}: check its requirements, then commit it in a pull request.`);
+  for (const s of await storeSpecLookup(root, draft.capability))
+    io.out(`The OpenSpec store ${s.store} (read-only) has a ${s.id} spec too: ${s.file}${s.purpose ? ` ("${s.purpose}")` : ""}. Check the two agree before the draft is merged.`);
+  return 0;
+}
+async function featureSuggestNames(root, o, io) {
+  const l = await load(root, io);
+  const res = await nameFeatures(l.features, l.records, o.runtime, { orgPack: l.op });
+  const written = await writeNameProposals(join(l.catalogDir, "proposals"), res.proposals);
+  if (o.json) {
+    io.out(JSON.stringify({ ...res, written }, null, 2));
+  } else {
+    res.proposals.forEach((p, i) => io.out(`Wrote ${l.catalogRel}/proposals/${written[i]}: ${p.feature} could be called "${p.name}".`));
+    for (const d of res.discarded)
+      io.err(`Discarded${d.feature ? ` ${d.feature}` : ""}: ${d.reason}`);
+    for (const r of res.runs.filter((x) => x.state === "failed"))
+      io.err(`The ${r.agent} run failed: ${r.reason ?? "no reason given"}`);
+    for (const r of res.runs.filter((x) => x.state === "waiting"))
+      io.out(`Handed the names of ${r.features.length} feature${r.features.length === 1 ? "" : "s"} to your assistant. When it is done, run: atticus handoff done ${r.runId}`);
+    const n = res.proposals.length;
+    io.out(`${n} proposal${n === 1 ? "" : "s"} from ${res.runs[0]?.agent ?? "feature-namer"}; confirm one with: atticus feature name <feature> <name>`);
+  }
+  return res.runs.some((r) => r.state === "failed") ? 1 : 0;
+}
+async function completeFeatureNaming(root, run, io, o = {}) {
+  const l = await load(root, io);
+  const at = (o.now ?? /* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
+  const res = parseFinishedNamingRun(run, l.features, at);
+  const written = await writeNameProposals(join(l.catalogDir, "proposals"), res.proposals);
+  res.proposals.forEach((p, i) => io.out(`Wrote ${l.catalogRel}/proposals/${written[i]}: ${p.feature} could be called "${p.name}".`));
+  for (const d of res.discarded)
+    io.err(`Discarded${d.feature ? ` ${d.feature}` : ""}: ${d.reason}`);
+  const n = res.proposals.length;
+  io.out(`${n} proposal${n === 1 ? "" : "s"} from ${run.request.agent.id}; confirm one with: atticus feature name <feature> <name>`);
+  return 0;
+}
+async function catalogMigrate(root, io, o = {}) {
+  const op = await loadOrgPack(join(orgPackDirOf(root)));
+  const rel = op.sources.layout.catalog;
+  const res = await migrateCatalog(join(root, rel), o);
+  for (const f of res.migrated)
+    io.out(`  ${rel}/${f}`);
+  for (const p of res.problems)
+    io.err(`${rel}/${p.file}: ${p.message}`);
+  if (!res.migrated.length && !res.problems.length)
+    io.out(`Every catalog file is already at schema version ${SCHEMA_VERSION}.`);
+  else if (res.migrated.length)
+    io.out(`${o.dryRun ? "Would migrate" : "Migrated"} ${res.migrated.length} file${res.migrated.length === 1 ? "" : "s"} to catalog schema version ${SCHEMA_VERSION}; ${res.current.length} already current.${o.dryRun ? "" : " Commit the change."}`);
+  return res.problems.length ? 1 : 0;
+}
+
+export {
+  featureList,
+  featureShow,
+  featureName,
+  featureTag,
+  featureMerge,
+  featureSplit,
+  featureLink,
+  featureSuggestLinks,
+  featureSpec,
+  featureSuggestNames,
+  completeFeatureNaming,
+  catalogMigrate
+};

package/dist/chunk-JAA53T23.js

@@ -0,0 +1,172 @@
+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 {
+  targetFlowsOf
+} from "./chunk-67J3VZBA.js";
+import "./chunk-P3TKKBAH.js";
+import {
+  MAX_CHAIN_DEPTH,
+  changeImpact,
+  loadEstate
+} from "./chunk-KC5DROFC.js";
+import "./chunk-RK6MKKKP.js";
+import "./chunk-47QE246J.js";
+import "./chunk-XQ3YIV5R.js";
+import "./chunk-MGVYVW7Q.js";
+import "./chunk-NGPU2ARF.js";
+import "./chunk-AY2IUF4K.js";
+import "./chunk-6JLPXDWN.js";
+import "./chunk-4GZXS6S2.js";
+import "./chunk-R4TBNKKC.js";
+import "./chunk-NIXVDQVO.js";
+import "./chunk-UR7RMZ3R.js";
+import "./chunk-N4QZJJVB.js";
+import {
+  loadRepos
+} from "./chunk-PGKHJYOB.js";
+import "./chunk-MKRBG5EF.js";
+import "./chunk-5XDNUJ4P.js";
+import {
+  readTeams
+} from "./chunk-577AJVRS.js";
+import "./chunk-D3PO4DOZ.js";
+import "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/change-impact.js
+var CHANGE_IMPACT_WORDS = {
+  usage: "Name the change: atticus change impact <change> [--json]",
+  noChange: (id) => `There is no change ${id}: atticus change list shows them.`,
+  noTargets: (id) => `${id} has no target flows yet, so there is nothing to weigh: run atticus change architecture ${id} first.`,
+  nothing: (id) => `${id}'s target flows break nothing the map shows: no entry or table they change loses a field, a caller or its type.`,
+  counts: (id, i) => `${id}: ${n(i.breaks, "caller")} ${i.breaks === 1 ? "breaks" : "break"}, ${n(i.mayBreak, "caller")} may break (link guessed), ${n(i.routes, "gateway route")} to update.`,
+  upstream: (u) => `Up the chain (who calls the callers): ${u.breaks} more ${u.breaks === 1 ? "breaks" : "break"}, ${u.mayBreak} may break (resting on a guessed link).`,
+  hopBreaks: (depth, via, who, owner, where) => `${"  ".repeat(depth)}Breaks via ${via}: ${who}, owned by ${owner}${where ? `; ${where}` : ""}.`,
+  hopMayBreak: (depth, via, who, owner, rests, where) => `${"  ".repeat(depth)}May break via ${via} (${rests}): ${who}, owned by ${owner}${where ? `; ${where}` : ""}. Not counted as a break.`,
+  restsOwn: (how) => `its own link guessed ${how}`,
+  restsOn: (who, how) => `rests on ${who}'s link, guessed ${how}`,
+  capped: (depth) => `  The walk up the chain stops at ${depth} hops; more callers are above the last ones listed.`,
+  item: (name, where, owner, why) => `${name} (${where}), owned by ${owner}: ${why.join("; ")}.`,
+  gone: (fields) => `  Stops crossing: ${fields.join(", ")}.`,
+  required: (fields) => `  Callers must now send: ${fields.join(", ")}.`,
+  breaks: (who, owner, where) => `  Breaks: ${who}, owned by ${owner}${where ? `; ${where}` : ""}.`,
+  mayBreak: (who, owner, how, where) => `  May break (link guessed ${how}): ${who}, owned by ${owner}${where ? `; ${where}` : ""}. Not counted as a break until someone confirms the link.`,
+  confirm: (rule, id) => `  The critic's ${rule} asks the caller's owner to confirm each guessed link: atticus critic ${id}.`,
+  nobody: "  The map shows nobody calling or using it.",
+  route: (id, what, owner, callers) => `  Gateway route to update: ${id}${what}, owned by ${owner}; ${callers.join(", ")} ${callers.length === 1 ? "calls" : "call"} through it.`,
+  teams: "Teams to involve:",
+  team: (owner, repos) => `  ${owner}: ${repos.join(", ")}`,
+  problem: (p) => `Note: ${p}`
+};
+var GUESS_WORDS = {
+  "joined-by-path": "by path",
+  "joined-by-label": "by a host's first label",
+  "joined-by-platform-setting": "by a platform-wide setting",
+  "joined-by-folder-name": "by a setting's folder name",
+  "joined-despite-conflict": "despite an open host conflict",
+  "joined-by-service-name": "by a Service's short name"
+};
+function n(count, what) {
+  return `${count} ${what}${count === 1 ? "" : "s"}`;
+}
+function ownerText(o) {
+  if ("none" in o)
+    return `no team (${o.none})`;
+  return o.name ? `${o.team} (${o.name})` : o.team;
+}
+async function changeImpactOf(root, change) {
+  const t = await targetFlowsOf(root, change);
+  if (!t)
+    return void 0;
+  const problems = [...t.problems];
+  const owners = /* @__PURE__ */ new Map();
+  try {
+    for (const r of await loadRepos(root))
+      owners.set(r.id, r.owner);
+  } catch (e) {
+    problems.push(`the repo manifests: ${e.message.split("\n")[0]}`);
+  }
+  const read = await readTeams(root);
+  const teams = read.teams;
+  if (read.problem)
+    problems.push(read.problem);
+  const impact = changeImpact(change, t.deltas, await loadEstate(root, t.records), {
+    owners,
+    teams
+  });
+  return { ...impact, flows: t.deltas.length, problems };
+}
+function impactLines(i) {
+  const W = CHANGE_IMPACT_WORDS;
+  if (!i.flows)
+    return [W.noTargets(i.change), ...i.problems.map(W.problem)];
+  if (!i.items.length)
+    return [W.nothing(i.change), ...i.problems.map(W.problem)];
+  const out = [W.counts(i.change, i)];
+  if (i.upstream && (i.upstream.breaks || i.upstream.mayBreak))
+    out.push(W.upstream(i.upstream));
+  for (const it of i.items) {
+    out.push(W.item(it.name, it.kind === "table" ? `a table ${it.flow} writes` : it.flow, ownerText(it.owner), it.why));
+    if (it.fields.gone.length)
+      out.push(W.gone(it.fields.gone));
+    if (it.fields.required.length)
+      out.push(W.required(it.fields.required));
+    if (!it.callers.length)
+      out.push(W.nobody);
+    for (const c of it.callers) {
+      const where = [
+        ...c.at.map((a) => `at ${a}`),
+        ...c.flows.map((f) => `its flow ${f}`),
+        ...c.routes.map((r) => `through ${r}`)
+      ].join(", ");
+      out.push(c.verdict === "breaks" ? W.breaks(c.component, ownerText(c.owner), where) : W.mayBreak(c.component, ownerText(c.owner), GUESS_WORDS[c.guessed ?? ""] ?? "", where));
+    }
+    for (const h of it.chain ?? []) {
+      const via = `${h.via.join(", ")}${h.entries.length ? ` (${h.entries.join(", ")})` : ""}`;
+      const where = [
+        ...h.at.map((a) => `at ${a}`),
+        ...h.flows.map((f) => `its flow ${f}`),
+        ...h.routes.map((r) => `through ${r}`)
+      ].join(", ");
+      const how = GUESS_WORDS[h.guessed ?? ""] ?? "";
+      out.push(h.verdict === "breaks" ? W.hopBreaks(h.depth, via, h.component, ownerText(h.owner), where) : W.hopMayBreak(h.depth, via, h.component, ownerText(h.owner), h.restsOn ? W.restsOn(h.restsOn, how) : W.restsOwn(how), where));
+    }
+    if (it.capped)
+      out.push(W.capped(MAX_CHAIN_DEPTH));
+    if ([...it.callers, ...it.chain ?? []].some((c) => c.verdict === "may-break"))
+      out.push(W.confirm(i.rule, i.change));
+    for (const r of it.routes) {
+      const what = [r.proxy, r.basepath, r.repo ? `in ${r.repo}` : void 0].filter(Boolean).join(", ");
+      out.push(W.route(r.id, what ? ` (${what})` : "", ownerText(r.owner), r.callers));
+    }
+  }
+  out.push(W.teams, ...i.owners.map((o) => W.team(ownerText(o.owner), o.repos)));
+  out.push(...i.problems.map(W.problem));
+  return out;
+}
+async function changeImpactCli(root, change, o, io) {
+  if (!change) {
+    io.err(CHANGE_IMPACT_WORDS.usage);
+    return 2;
+  }
+  const i = await changeImpactOf(root, change);
+  if (!i) {
+    io.err(CHANGE_IMPACT_WORDS.noChange(change));
+    return 1;
+  }
+  if (o.json)
+    io.out(JSON.stringify(i, null, 2));
+  else
+    for (const l of impactLines(i))
+      io.out(l);
+  return 0;
+}
+export {
+  CHANGE_IMPACT_WORDS,
+  changeImpactCli,
+  changeImpactOf,
+  impactLines,
+  ownerText
+};

package/dist/chunk-JF2NSTFO.js

@@ -0,0 +1,47 @@
+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 {
+  contextToolBox,
+  defaultCodeDir,
+  namesInCode,
+  openIndex,
+  workspaceRepos
+} from "./chunk-N4QZJJVB.js";
+
+// packages/cli/dist/code-tools.js
+var offered = /* @__PURE__ */ new Map();
+function offerCodeDir(repo, dir) {
+  offered.set(repo, dir);
+}
+function codeToolOptions(root) {
+  return {
+    codeDir: (r) => offered.get(r) ?? defaultCodeDir(root, r),
+    repos: () => [.../* @__PURE__ */ new Set([...workspaceRepos(root), ...offered.keys()])].sort(),
+    // Loaded on first use: the readers are large, and most commands never outline a file.
+    outline: async (path, text) => (await import("./chunk-JQ7XQPQS.js")).declarationOutline(path, text)
+  };
+}
+function metarepoToolBox(root, calls) {
+  return contextToolBox(root, () => openIndex(root), {
+    ...codeToolOptions(root),
+    ...calls ? { calls } : {}
+  });
+}
+async function criticCodeSearch(root, names) {
+  const x = await import("./chunk-JQ7XQPQS.js");
+  const r = await namesInCode(root, names, {
+    ...codeToolOptions(root),
+    outlines: (path) => x.syntaxLanguageOf(path) !== void 0
+  });
+  return r.found;
+}
+
+export {
+  offerCodeDir,
+  codeToolOptions,
+  metarepoToolBox,
+  criticCodeSearch
+};

package/dist/chunk-JMSEEBN4.js

@@ -0,0 +1,41 @@
+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 "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/draft-check-tool.js
+function draftCheckTool(root, request) {
+  if (!request.selfCheck || !/^(feature|architecture|stories|small)-answer\.yaml$/.test(request.outputPath))
+    return void 0;
+  let box;
+  const planner = () => box ??= import("./chunk-UF7TAFJM.js").then((p) => p.draftCheckBox(root, request));
+  return {
+    definitions: [
+      {
+        name: "check_draft",
+        description: "Check your draft the way the stage will: give your whole answer, as YAML. Returns each problem with its line and what is allowed, or that it is clean. Call it before you answer, and again after each fix, until it is clean.",
+        inputSchema: {
+          type: "object",
+          properties: { draft: { type: "string", description: "Your whole answer, as YAML." } },
+          required: ["draft"]
+        }
+      }
+    ],
+    call: async (name, input) => (await planner()).call(name, input)
+  };
+}
+function bothTools(a, b) {
+  if (!b)
+    return a;
+  const own = new Set(b.definitions.map((d) => d.name));
+  return {
+    definitions: [...a.definitions.filter((d) => !own.has(d.name)), ...b.definitions],
+    call: (name, input) => own.has(name) ? b.call(name, input) : a.call(name, input)
+  };
+}
+export {
+  bothTools,
+  draftCheckTool
+};