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

package/dist/chunk-UZACEG2C.js

@@ -0,0 +1,515 @@
+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 {
+  initiativesDirOf
+} from "./chunk-2V2ZPQQU.js";
+import {
+  gitHandoffPublisher,
+  mergeChangeText
+} from "./chunk-HSZMPH5T.js";
+import "./chunk-D2WSW4GU.js";
+import {
+  createAdapters,
+  fileStepStore
+} from "./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 {
+  createGit
+} from "./chunk-XOL3GFW2.js";
+import "./chunk-QHJJMZLX.js";
+import "./chunk-7AB6OWTV.js";
+import {
+  catalogDirOf,
+  changesRelOf,
+  decisionsRelOf,
+  factsDirOf,
+  loadOrgPack,
+  mapDirOf,
+  orgPackDirOf,
+  questionsDirOf,
+  specsDirOf,
+  stateDirOf
+} from "./chunk-PAINMSID.js";
+import "./chunk-ODMBPDDV.js";
+import "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/propose.js
+import { existsSync } from "node:fs";
+import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join, relative } from "node:path";
+var PROPOSE_SCOPES = [
+  "answers",
+  "corrections",
+  "audit",
+  "org-pack",
+  "owner-answers",
+  "baseline",
+  "initiatives",
+  "outcomes",
+  "work",
+  "service-desk"
+];
+var TITLES = {
+  answers: "Answers to the map's questions",
+  corrections: "Corrections to the map",
+  audit: "A sample audit's answers",
+  "org-pack": "Org pack and settings",
+  "owner-answers": "Owners' answers to the knowledge gaps",
+  baseline: "Accept the catalog as the baseline",
+  initiatives: "Initiatives and commitments",
+  outcomes: "Outcomes measured after release",
+  work: "Changes made in the Atticus app",
+  "service-desk": "Service-desk request fields"
+};
+var rel = (root, dir) => relative(root, dir).split("\\").join("/");
+function scopeDirs(root, scope) {
+  const facts = rel(root, factsDirOf(root));
+  const catalog = rel(root, catalogDirOf(root));
+  const map = rel(root, mapDirOf(root));
+  const specs = rel(root, specsDirOf(root));
+  const decisions = decisionsRelOf(root);
+  switch (scope) {
+    // Round 36: the fields filled in the app are each open change's snow.md, nothing else of
+    // the change (its other files are its stages' and its hand-off's).
+    case "service-desk":
+      return [`:(glob)${changesRelOf(root)}/*/snow.md`];
+    // An answer also writes in the org pack (a repo type's skill file, a host in the manifest,
+    // an outside system in a profile): its PR carries those too (review round 35).
+    // UX re-walk: Apply (verify --write) also writes the repo's map and specs: they go too.
+    case "answers":
+      return [
+        rel(root, questionsDirOf(root)),
+        facts,
+        catalog,
+        rel(root, orgPackDirOf(root)),
+        map,
+        specs,
+        decisions
+      ];
+    case "corrections":
+      return [facts, catalog, map, specs, decisions];
+    // An audit is its repo's audit file, not every repo's facts.
+    case "audit":
+      return [`${facts}/*.audit.yaml`];
+    // Everything the app's work writes, for the one Propose on Home (UX re-walk).
+    case "work":
+      return [
+        rel(root, questionsDirOf(root)),
+        facts,
+        catalog,
+        rel(root, orgPackDirOf(root)),
+        map,
+        specs,
+        decisions,
+        rel(root, initiativesDirOf(root)),
+        `${changesRelOf(root)}/*/review/outcomes.yaml`,
+        `${changesRelOf(root)}/*/snow.md`,
+        // Ninth UX walk: a person's corrections of a stage's drafts, and who drafted each file
+        // (ADR 0181), saved in the app; they ride the stage's hand-off too.
+        `${changesRelOf(root)}/*/stage/corrections.yaml`,
+        `${changesRelOf(root)}/*/stage/drafted.yaml`
+      ];
+    case "org-pack":
+      return [rel(root, orgPackDirOf(root))];
+    // UX review (2026-11-08): an owner's answer to a knowledge gap is a curated record.
+    case "owner-answers":
+      return [`${catalog}/curated/ownerquestion`];
+    // Accepting the baseline writes catalog/baseline.yaml, over the catalog it accepts.
+    case "baseline":
+      return [catalog];
+    // UX review: an initiative's curated records (the initiative, its commitments and the
+    // parties its plan names) and its folder (the plan, the notes, the system cards); not the
+    // rest of the curated catalog (a triage decision is its own review).
+    case "initiatives":
+      return [
+        ...["initiative", "commitment", "party"].map((k) => `${catalog}/curated/${k}`),
+        rel(root, initiativesDirOf(root))
+      ];
+    // UX review: an outcome recorded after release is the change's review/outcomes.yaml, open
+    // or archived (a pathspec's * crosses folders); nothing else of the change.
+    case "outcomes":
+      return [`${changesRelOf(root)}/*/review/outcomes.yaml`];
+  }
+}
+var proposedFile = (root) => join(stateDirOf(root), ".index", "proposed.json");
+async function readProposed(root) {
+  try {
+    return JSON.parse(await readFile(proposedFile(root), "utf8"));
+  } catch {
+    return {};
+  }
+}
+async function proposePlan(root, scope, o = {}) {
+  const git = o.git ?? createGit();
+  const dirs = scopeDirs(root, scope).filter((d) => d && !d.startsWith(".."));
+  const out = (await git([
+    "-c",
+    "core.quotePath=false",
+    "status",
+    "--porcelain=v1",
+    "-z",
+    "--untracked-files=all",
+    "--",
+    ...dirs
+  ], root)).stdout;
+  const files = [];
+  const parts = out.split("\0");
+  for (let i = 0; i < parts.length; i++) {
+    const e = parts[i];
+    if (e.length < 4)
+      continue;
+    const status = e.slice(0, 2).trim() || "M";
+    if (status.startsWith("R"))
+      files.push({ path: e.slice(3), status, from: parts[++i] });
+    else
+      files.push({ path: e.slice(3), status });
+  }
+  const was = await readProposed(root);
+  for (const f of files) {
+    const p = was[f.path];
+    if (!p)
+      continue;
+    if (p.branch && !await git(["rev-parse", "--verify", "--quiet", `refs/remotes/origin/${p.branch}`], root).then(() => true, () => false))
+      continue;
+    const blob = existsSync(join(root, f.path)) ? (await git(["hash-object", "--", f.path], root).catch(() => ({ stdout: "" }))).stdout.trim() : "";
+    if (blob === p.blob)
+      f.proposed = p.where;
+  }
+  const stamp = (o.now ?? /* @__PURE__ */ new Date()).toISOString();
+  const day = `${stamp.slice(0, 10)}-${stamp.slice(11, 19).replace(/:/g, "")}`;
+  const who = (o.by ?? "someone").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+  return {
+    scope,
+    files: files.sort((a, b) => a.path.localeCompare(b.path)),
+    branch: `propose/${scope}/${day}-${who || "someone"}`,
+    title: TITLES[scope]
+  };
+}
+async function proposeForReview(root, o, io) {
+  const plan = await proposePlan(root, o.scope, {
+    ...o.git ? { git: o.git } : {},
+    ...o.now ? { now: o.now } : {},
+    by: o.by
+  });
+  if (o.branch && new RegExp(`^propose/${o.scope}/[0-9a-z-]+$`).test(o.branch))
+    plan.branch = o.branch;
+  const seen = new Map(plan.files.map((f) => [f.path, f]));
+  const picked = o.files.filter((f) => seen.has(f));
+  const files = [
+    ...new Set(picked.flatMap((f) => [f, ...seen.get(f).from ? [seen.get(f).from] : []]))
+  ];
+  if (!picked.length) {
+    io.err("Nothing to propose: none of those files has a change now. Look at the list again.");
+    return 2;
+  }
+  const op = await loadOrgPack(orgPackDirOf(root));
+  const gitHost = o.gitHost ?? createAdapters(op.runtime, {}, { store: fileStepStore(root), root, procedures: op.procedures }).gitHost;
+  if (!gitHost) {
+    io.err("No Git host is configured. Set adapters.gitHost in org-pack/runtime.yaml.");
+    return 1;
+  }
+  const repo = op.runtime.adapters.gitHost?.settings.metarepo;
+  if (typeof repo !== "string") {
+    io.err("Say which repo on the Git host is the metarepo: set metarepo under adapters.gitHost.settings in runtime.yaml.");
+    return 1;
+  }
+  const at = (o.now ?? /* @__PURE__ */ new Date()).toISOString();
+  const approval = { by: o.by, at, ref: plan.branch };
+  const base = (await gitHost.getRepo(repo)).defaultBranch;
+  const title = o.title?.trim() || plan.title;
+  const publisher = o.publisher ?? gitHandoffPublisher();
+  try {
+    await publisher.publish({ root, branch: plan.branch, base, files, message: title, approval });
+    io.out(`Pushed ${files.length} file${files.length === 1 ? "" : "s"} to ${plan.branch}.`);
+  } catch (e) {
+    io.out(`The branch ${plan.branch} wasn't pushed (${e.message.split("\n")[0]}): push it yourself before the PR is opened.`);
+  }
+  let pr;
+  try {
+    pr = await gitHost.createPullRequest({
+      repo,
+      head: plan.branch,
+      base,
+      title,
+      body: [
+        `${title}, proposed from the Atticus app by ${o.by}.`,
+        "",
+        "Files:",
+        ...files.map((f) => `- ${f}`),
+        "",
+        "A person reviews and merges this PR; Atticus never merges."
+      ].join("\n")
+    }, approval);
+  } catch (e) {
+    io.err(`The PR wasn't opened: ${e.message.split("\n")[0]}`);
+    return 1;
+  }
+  try {
+    const was = await readProposed(root);
+    const where = pr.url.startsWith("manual:") ? plan.branch : pr.url;
+    const g2 = o.git ?? createGit();
+    for (const f of files) {
+      const blob = existsSync(join(root, f)) ? (await g2(["hash-object", "--", f], root)).stdout.trim() : "";
+      was[f] = { blob, where, branch: plan.branch };
+    }
+    await mkdir(dirname(proposedFile(root)), { recursive: true });
+    await writeFile(proposedFile(root), JSON.stringify(was, null, 2) + "\n", "utf8");
+  } catch {
+  }
+  io.out(pr.url.startsWith("manual:") ? `The PR is a step for you on Home: open it on the Git host from ${plan.branch} and record its link.` : `PR #${pr.number} is open for review: ${pr.url}`);
+  io.out("When it merges, Bring in what merged updates your copy of the metarepo.");
+  return 0;
+}
+async function bringInMerged(root, io, o = {}) {
+  const git = o.git ?? createGit();
+  const run = async (args) => (await git(args, root)).stdout;
+  const first = (e) => e.message.split("\n")[0];
+  const up = (await run(["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"]).catch(() => "")).trim();
+  if (!up) {
+    io.err("This branch follows no remote branch, so there is nothing to bring in.");
+    return 2;
+  }
+  try {
+    await run(["fetch", "--quiet", "--prune", up.split("/")[0]]);
+  } catch (e) {
+    io.err(`The remote couldn't be reached, so nothing was changed: ${first(e)}`);
+    return 1;
+  }
+  const ancestor = await run(["merge-base", "--is-ancestor", "HEAD", up]).then(() => true, () => false);
+  if (!ancestor) {
+    io.err(`Your branch has commits ${up} doesn't, so nothing was changed. Push them in a pull request, or ask someone who uses git to bring the two together.`);
+    return 1;
+  }
+  const incoming = new Set((await run(["-c", "core.quotePath=false", "diff", "--name-only", "-z", "HEAD", up])).split("\0").filter(Boolean));
+  const status = await run([
+    "-c",
+    "core.quotePath=false",
+    "status",
+    "--porcelain=v1",
+    "-z",
+    "--untracked-files=all"
+  ]);
+  const parts = status.split("\0");
+  const kept = [];
+  const tidy = [];
+  for (let i = 0; i < parts.length; i++) {
+    const e = parts[i];
+    if (e.length < 4)
+      continue;
+    const st = e.slice(0, 2);
+    const path = e.slice(3);
+    if (st.startsWith("R")) {
+      kept.push(path, parts[++i]);
+      continue;
+    }
+    const theirs = (await run(["rev-parse", "--verify", "--quiet", `${up}:${path}`]).catch(() => "")).trim();
+    const mine = existsSync(join(root, path)) ? (await run(["hash-object", "--", path]).catch(() => "")).trim() : "";
+    const bothGone = !theirs && !mine && st.includes("D");
+    if (!bothGone && (!theirs || theirs !== mine)) {
+      kept.push(path);
+      continue;
+    }
+    const inHead = await run(["cat-file", "-e", `HEAD:${path}`]).then(() => true, () => false);
+    tidy.push({ path, inHead, staged: st[0] !== " " && st[0] !== "?" });
+  }
+  const own = new RegExp(`^${changesRelOf(root).replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}/[^/]+/change\\.yaml$`);
+  const ownClash = kept.filter((k) => incoming.has(k) && own.test(k) && existsSync(join(root, k)));
+  const clash = kept.filter((k) => incoming.has(k) && !ownClash.includes(k));
+  if (clash.length) {
+    io.err(`What merged also changes files you edited, so nothing was changed: ${clash.join(", ")}. Propose your edits for review, or ask someone who uses git to bring them together.`);
+    return 1;
+  }
+  const done = [];
+  const putBack = async () => {
+    for (const p of done)
+      await run(["checkout", up, "--", p]).then(() => run(["reset", "-q", "--", p])).catch(() => void 0);
+  };
+  const held = /* @__PURE__ */ new Map();
+  const original = /* @__PURE__ */ new Map();
+  const tmp = await mkdtemp(join(tmpdir(), "atticus-bring-in-"));
+  try {
+    for (const k of ownClash) {
+      const at = async (rev) => await run(["show", `${rev}:${k}`]).catch(() => "");
+      const base = join(tmp, "base");
+      const ours = join(tmp, "ours");
+      const theirs = join(tmp, "theirs");
+      const inHead = await run(["cat-file", "-e", `HEAD:${k}`]).then(() => true, () => false);
+      const id = k.split("/").at(-2);
+      const newest = async (prefix) => (await run([
+        "for-each-ref",
+        "--sort=-committerdate",
+        "--count=1",
+        "--format=%(refname)",
+        prefix
+      ]).catch(() => "")).trim() || void 0;
+      const publishedOnRemote = async (ref) => {
+        const fork = (await run(["merge-base", "HEAD", ref]).catch(() => "")).trim();
+        if (!fork)
+          return void 0;
+        const after = (await run(["rev-list", "--first-parent", "--reverse", `${fork}..${ref}`]).catch(() => "")).trim();
+        return after.split("\n")[0] || void 0;
+      };
+      let handoff;
+      if (!inHead) {
+        handoff = await newest(`refs/heads/handoff/${id}/`);
+        if (!handoff) {
+          const remote = await newest(`refs/remotes/origin/handoff/${id}/`);
+          if (remote)
+            handoff = await publishedOnRemote(remote);
+        }
+      }
+      const baseText = inHead ? await at("HEAD") : handoff ? await at(handoff) : "";
+      const mine = await readFile(join(root, k), "utf8");
+      original.set(k, mine);
+      const theirsText = await at(up);
+      const fields = mergeChangeText(baseText, mine, theirsText);
+      if (fields && !fields.ok) {
+        io.err(`What merged also changes ${fields.field} in ${k} where your copy changed it differently, so nothing was changed. Propose your edits for review, or ask someone who uses git to bring them together.`);
+        return 1;
+      }
+      if (fields) {
+        held.set(k, fields.text);
+        continue;
+      }
+      await writeFile(base, baseText, "utf8");
+      await writeFile(ours, mine, "utf8");
+      await writeFile(theirs, theirsText, "utf8");
+      const merged = await git(["merge-file", "-p", ours, base, theirs], root).then((r) => ({ ok: true, text: r.stdout }), () => ({ ok: false, text: "" }));
+      if (!merged.ok) {
+        io.err(`What merged also changes ${k} where your copy changed it, so nothing was changed. Propose your edits for review, or ask someone who uses git to bring them together.`);
+        return 1;
+      }
+      held.set(k, merged.text);
+    }
+  } finally {
+    await rm(tmp, { recursive: true, force: true });
+  }
+  const ownEdits = kept.filter((k) => !held.has(k));
+  const editsText = (list) => list.length > 5 ? `${list.slice(0, 5).join(", ")} and ${list.length - 5} more` : list.join(", ");
+  const restoreHeld = async () => {
+    for (const [k, text] of held)
+      await writeFile(join(root, k), text, "utf8");
+  };
+  try {
+    for (const k of ownClash) {
+      const inHead = await run(["cat-file", "-e", `HEAD:${k}`]).then(() => true, () => false);
+      if (inHead)
+        await run(["checkout", "HEAD", "--", k]);
+      else {
+        await run(["rm", "--cached", "--quiet", "--ignore-unmatch", "--", k]);
+        await rm(join(root, k), { force: true });
+      }
+    }
+    for (const t of tidy) {
+      if (t.inHead)
+        await run(["checkout", "HEAD", "--", t.path]);
+      else {
+        if (t.staged)
+          await run(["rm", "--cached", "--quiet", "--", t.path]);
+        await rm(join(root, t.path), { force: true });
+      }
+      done.push(t.path);
+    }
+    await run(["merge", "--ff-only", "--quiet", up]);
+    await restoreHeld();
+  } catch (e) {
+    await putBack();
+    for (const [k, text] of original)
+      await writeFile(join(root, k), text, "utf8");
+    io.err(`Your copy couldn't be brought up to ${up}: ${first(e)}. Your files are as they were${kept.length ? `, and your own edits stay: ${editsText(kept)}` : ""}.`);
+    return 1;
+  }
+  const closed = await closeMergedSteps(root, up, run, o.now);
+  const sayClosed = () => {
+    if (closed.length)
+      io.out(`Closed the manual steps of ${closed.length === 1 ? "a pull request" : `${closed.length} pull requests`} that merged (merged, seen by Bring in): ${closed.join(", ")}.`);
+  };
+  if (!incoming.size && !done.length) {
+    io.out(`Nothing new has merged on ${up} yet: your copy is up to date with it.`);
+    if (kept.length)
+      io.out(`Your own edits stay as they were: ${editsText(kept)}.`);
+    sayClosed();
+    return 0;
+  }
+  io.out(`Brought in what merged on ${up}${done.length ? ` (${done.length === 1 ? "1 file was" : `${done.length} files were`} already the same)` : ""}.`);
+  if (held.size)
+    io.out(`Merged with your copy's newer state: ${[...held.keys()].join(", ")} (Sync's state and the reviewer's edits are both kept).`);
+  if (ownEdits.length)
+    io.out(`Your own edits stay as they were: ${editsText(ownEdits)}.`);
+  sayClosed();
+  return 0;
+}
+async function closeMergedSteps(root, up, run, now) {
+  let repo;
+  try {
+    repo = (await loadOrgPack(orgPackDirOf(root))).runtime.adapters.gitHost?.settings.metarepo;
+  } catch {
+    return [];
+  }
+  if (typeof repo !== "string")
+    return [];
+  const store = fileStepStore(root);
+  const steps = await store.list({ system: "git-host" }).catch(() => []);
+  const opens = steps.filter((s) => s.action === "open-pull-request" && s.state !== "skipped" && s.inputs.repo === repo && typeof s.inputs.head === "string");
+  if (!opens.length)
+    return [];
+  const mainLine = new Set((await run(["rev-list", "--first-parent", up]).catch(() => "")).split("\n").filter(Boolean));
+  const remote = up.split("/")[0];
+  const at = (now ?? /* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
+  const close = (s, values) => store.save({
+    ...s,
+    state: "done",
+    recorded: {
+      at,
+      by: "atticus",
+      values,
+      via: "person",
+      evidence: [],
+      note: "merged, seen by Bring in"
+    }
+  });
+  const out = [];
+  for (const open of opens) {
+    const number = open.inputs.number;
+    const related = steps.filter((s) => s.state === "open" && s.inputs.repo === repo && s.inputs.number === number && (s.action === "report-pull-request" || s.action === "merge-pull-request"));
+    if (open.state !== "open" && !related.length)
+      continue;
+    const head = String(open.inputs.head);
+    let tip = "";
+    for (const ref of [`refs/remotes/${remote}/${head}`, `refs/heads/${head}`]) {
+      tip = (await run(["rev-parse", "--verify", "--quiet", `${ref}^{commit}`]).catch(() => "")).trim();
+      if (tip)
+        break;
+    }
+    if (!tip || mainLine.has(tip))
+      continue;
+    const merged = await run(["merge-base", "--is-ancestor", tip, up]).then(() => true, () => false);
+    if (!merged)
+      continue;
+    if (open.state === "open")
+      await close(open, {
+        number: Number(number),
+        url: `manual://git-host/${repo}/pull/${String(number)}`
+      });
+    for (const s of related)
+      await close(s, s.action === "report-pull-request" ? { merged: true, checksPassing: true } : {});
+    out.push(head);
+  }
+  return out;
+}
+export {
+  PROPOSE_SCOPES,
+  bringInMerged,
+  proposeForReview,
+  proposePlan,
+  scopeDirs
+};

package/dist/{chunk-LR4XBH4L.js → chunk-VAMHOHUU.js}

@@ -14,26 +14,26 @@ import {
   scaffoldDialect,
   surveyRepos,
   testDialect
-} from "./chunk-G5BYKJIM.js";
-import "./chunk-EZBAS5BL.js";
-import "./chunk-KCQS52TH.js";
-import "./chunk-IPSFMTK2.js";
-import "./chunk-TNCROWPQ.js";
-import "./chunk-7IM4BVVH.js";
+} from "./chunk-P2VBXX7N.js";
+import "./chunk-4SLBCEPD.js";
+import "./chunk-64AADMTW.js";
+import "./chunk-JYMIB5XY.js";
+import "./chunk-CPK7QSBG.js";
+import "./chunk-YO2PKTXT.js";
 import {
   SYNTAX_LANGUAGES,
   syntaxLanguageOf,
   syntaxOutline
-} from "./chunk-RBXDHCN7.js";
-import "./chunk-ZQC7MNQB.js";
-import "./chunk-TLDL2ZZI.js";
-import "./chunk-QNMLLYTN.js";
+} from "./chunk-TWQRPM76.js";
+import "./chunk-XOL3GFW2.js";
+import "./chunk-QHJJMZLX.js";
+import "./chunk-7AB6OWTV.js";
 import {
   RecordId,
   orgPackDirOf,
   require_dist
-} from "./chunk-YK6CSODO.js";
-import "./chunk-MMB2OHUY.js";
+} from "./chunk-PAINMSID.js";
+import "./chunk-ODMBPDDV.js";
 import {
   __toESM
 } from "./chunk-TV45EUGM.js";

package/dist/{chunk-S5PSGAQ2.js → chunk-VUVGX5L2.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.18";
+var VERSION = "2.0.0-beta.21";
 function versionAtLeast(v, min) {
   const a = v.replace(/^v/, "").split(/[.+-]/).map(Number);
   const b = min.split(".").map(Number);

package/dist/{chunk-2TG2QGKW.js → chunk-VYOCPTUB.js}

@@ -5,14 +5,14 @@ var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
 var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
 import {
   intakeContext
-} from "./chunk-NGT5LLSE.js";
+} from "./chunk-TQ4TG57V.js";
 import "./chunk-VOGCSYOI.js";
 import {
   changeFolder,
   changeStore
-} from "./chunk-IOW6BF3U.js";
-import "./chunk-43E6XX67.js";
-import "./chunk-V3UEPUHT.js";
+} from "./chunk-HSZMPH5T.js";
+import "./chunk-D2WSW4GU.js";
+import "./chunk-4KNOJC6J.js";
 import {
   estateFacts,
   estateRepos,
@@ -20,19 +20,19 @@ import {
   joinReposOf,
   outsideProfileSystems,
   outsideSystems
-} from "./chunk-EZBAS5BL.js";
-import "./chunk-KCQS52TH.js";
-import "./chunk-IPSFMTK2.js";
+} from "./chunk-4SLBCEPD.js";
+import "./chunk-64AADMTW.js";
+import "./chunk-JYMIB5XY.js";
 import {
   attachToChange,
   readChangeInputs,
   readVendorSpec
-} from "./chunk-TNCROWPQ.js";
-import "./chunk-7IM4BVVH.js";
-import "./chunk-RBXDHCN7.js";
-import "./chunk-ZQC7MNQB.js";
-import "./chunk-TLDL2ZZI.js";
-import "./chunk-QNMLLYTN.js";
+} from "./chunk-CPK7QSBG.js";
+import "./chunk-YO2PKTXT.js";
+import "./chunk-TWQRPM76.js";
+import "./chunk-XOL3GFW2.js";
+import "./chunk-QHJJMZLX.js";
+import "./chunk-7AB6OWTV.js";
 import {
   PROTOTYPE_GROUPS,
   comparePrototype,
@@ -42,8 +42,8 @@ import {
   joinConventions,
   parseFacts,
   prototypeArchitectureSection
-} from "./chunk-YK6CSODO.js";
-import "./chunk-MMB2OHUY.js";
+} from "./chunk-PAINMSID.js";
+import "./chunk-ODMBPDDV.js";
 import "./chunk-TV45EUGM.js";
 
 // packages/cli/dist/prototype-commands.js
@@ -206,6 +206,8 @@ var sorted = (xs) => [...new Set(xs)].sort();
 var ATTACHED = /^prototype-(.+)\.md$/;
 async function changePrototypes(root, change) {
   const quiet = { out: () => void 0, err: () => void 0 };
+  const { op } = await intakeContext(root, quiet);
+  const candidates = estateRepos(op).filter((r) => isPrototypeType(r.type)).map((r) => r.id).sort();
   const files = (await readChangeInputs(changeFolder(root, change))).files.filter((f) => !f.supersededBy && ATTACHED.test(f.name)).sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
   const prototypes = [];
   for (const f of files) {
@@ -218,7 +220,7 @@ async function changePrototypes(root, change) {
       comparison: got.comparison
     });
   }
-  return { prototypes };
+  return { prototypes, candidates };
 }
 async function attachPrototype(root, change, repo, o, io) {
   const store = changeStore(root);