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

package/dist/{chunk-YISXLPHN.js → chunk-P2V7QW4D.js}

@@ -7,19 +7,19 @@ import {
   ATTICUS_FOLDER_IGNORE,
   CHECKLISTS_README,
   STARTER_CHECKLISTS_README
-} from "./chunk-GDLULHTC.js";
+} from "./chunk-Z5IA3WDR.js";
 import {
   openspecRootOf,
   rewriteStories
-} from "./chunk-CKSITVS4.js";
+} from "./chunk-R7NYHMUU.js";
 import {
   STARTER_REVIEW_PATH,
   readPackFiles,
   starterReviewText
-} from "./chunk-3HI6Z55Y.js";
+} from "./chunk-S4PMJU6H.js";
 import {
   metarepoOrigin
-} from "./chunk-XY3P7JW7.js";
+} from "./chunk-IDKCWSM5.js";
 import {
   ORG_FLOW_VERSION,
   STORE_MARKER,
@@ -28,16 +28,15 @@ import {
   storeIdOf,
   writeOrgFlowSchema,
   writeStoreMarker
-} from "./chunk-4AK7IBVP.js";
+} from "./chunk-UUU4CLJG.js";
 import {
-  VERSION,
-  versionAtLeast
-} from "./chunk-RZPYKDWS.js";
+  VERSION
+} from "./chunk-F3P7N7SF.js";
 import {
   IGNORED,
   ensureGitignore,
   gitUser
-} from "./chunk-EFHQ3TWP.js";
+} from "./chunk-PKBHS4AA.js";
 import {
   MetarepoStamp,
   WORKSPACE_SCHEMA_VERSION,
@@ -49,21 +48,27 @@ import {
   loadOrgPack,
   migrateCatalog,
   migrateChangeTypesText,
+  migrateCorrections,
   migrateGatesText,
   migrateManifests,
   migrateQuestions,
+  migrateRolesText,
   migrateRuntimeText,
+  migrateRuntimeV3Text,
+  migrateRuntimeV4Text,
   migrateSourcesText,
   orgPackDirOf,
-  require_dist,
   specsDirOf,
   specsRelOf
-} from "./chunk-S2A7YC3Q.js";
+} from "./chunk-Q2TECDIT.js";
 import {
   LOCAL_ONLY,
   ensureLocalIgnore,
   writeFileAtomic
-} from "./chunk-D3PO4DOZ.js";
+} from "./chunk-TUULXQRW.js";
+import {
+  require_dist
+} from "./chunk-BQGDB6ZL.js";
 import {
   __toESM
 } from "./chunk-TV45EUGM.js";
@@ -71,7 +76,7 @@ import {
 // packages/cli/dist/upgrade.js
 var import_yaml = __toESM(require_dist(), 1);
 import { cp, mkdir, readdir, readFile, stat } from "node:fs/promises";
-import { join } from "node:path";
+import { join, relative, sep } from "node:path";
 var STAMP_FILE = join(".atticus", "metarepo.yaml");
 var rel = (prefix, files) => files.map((f) => `${prefix}/${f}`);
 var MIGRATIONS = [
@@ -80,6 +85,7 @@ var MIGRATIONS = [
   {
     id: "local-files-ignored",
     summary: "This machine's files kept out of Git (.atticus/.gitignore, ADR 0050)",
+    creates: true,
     async pending(root) {
       const text = await readFile(join(root, ".atticus", ".gitignore"), "utf8").catch(() => "");
       const have = new Set(text.split(/\r?\n/).map((l) => l.trim()));
@@ -93,6 +99,7 @@ var MIGRATIONS = [
   {
     id: "state-folders-ignored",
     summary: "Base clones, the index and run folders kept out of Git (metarepo .gitignore)",
+    creates: true,
     async pending(root) {
       if (isAdopted(root))
         return [];
@@ -158,14 +165,21 @@ var MIGRATIONS = [
     }
   },
   {
-    id: "questions-v2",
-    summary: "Questions at schema version 2: a question can name the earlier one it may be the same as (ADR 0117)",
+    // The id is kept as it was first shipped (stamps record it); the step writes the current version.
+    id: "questions-v3",
+    summary: "Questions at schema version 5: a question can name the earlier one it may be the same as (ADR 0117), an answer can carry its rule and the proposal it accepted (ADR 0153), a question the code later disagreed with keeps why it reopened and the answer it had (ADR 0162), and a change's question carries the role that owns it, derived from the stage that asked when the file doesn't say (ADR 0181)",
     pending: (root) => migrateQuestions(root, { dryRun: true }),
-    apply: (root) => migrateQuestions(root)
+    apply: (root) => migrateQuestions(root),
+    async problems(root) {
+      const out = [];
+      await migrateQuestions(root, { dryRun: true, problems: out });
+      return out.map((p) => `${p.file}: ${p.message}`);
+    }
   },
   {
     id: "starter-review",
     summary: "The starter review: AI rules for the critic's lenses in checklists/review.yaml, for an org pack with no AI review of its own (ADR 0120)",
+    creates: true,
     async pending(root) {
       return (await starterReviewPlan(root)).map((f) => f.rel);
     },
@@ -180,6 +194,8 @@ var MIGRATIONS = [
   },
   // The version-2 files: only the number changes, no field gains a required (ADR 0125).
   catalogStep("catalog-schema-v3", "Catalog records at schema version 3: a Schema field can say whether it is required (ADR 0125)", [2]),
+  // The version-3 files: only the number changes; version 4 adds a Schema format (ADR 0164).
+  catalogStep("catalog-schema-v4", "Catalog records at schema version 4: a Schema can be a protobuf message (ADR 0164)", [3]),
   sourcesStep("sources-v2", "sources.yaml at version 2: a wiki can include and exclude pages by pattern; every wiki still reads every page (ADR 0083)", { from: 1, to: 2 }),
   // ADR 0132: from version 1 or 2 (a version 1 file is moved to 2 by the step before, then here).
   sourcesStep("sources-v3", "sources.yaml at version 3: a wiki can say how much its word counts (authority) and where it applies (appliesTo); every wiki still ranks as a team's and applies everywhere (ADR 0132)", { to: 3 }),
@@ -224,6 +240,48 @@ var MIGRATIONS = [
       return [rel2];
     }
   },
+  {
+    // ADR 0171: a runtime.yaml that names copilot-acp (a mode or its copilotAcp section) needs
+    // version 3; any other file means the same at 1 or 2 and is left as it is.
+    id: "runtime-v3",
+    summary: "runtime.yaml at version 3 where it names copilot-acp: GitHub Copilot driven unattended through its Agent Client Protocol (ADR 0171); the number only",
+    async pending(root) {
+      const rel2 = packRel(root, "runtime.yaml");
+      const text = await readFile(join(root, rel2), "utf8").catch(() => void 0);
+      return text !== void 0 && migrateRuntimeV3Text(text).changed ? [rel2] : [];
+    },
+    async apply(root) {
+      const rel2 = packRel(root, "runtime.yaml");
+      const text = await readFile(join(root, rel2), "utf8").catch(() => void 0);
+      if (text === void 0)
+        return [];
+      const r = migrateRuntimeV3Text(text);
+      if (!r.changed)
+        return [];
+      await writeFileAtomic(join(root, rel2), r.text);
+      return [rel2];
+    }
+  },
+  {
+    id: "roles-v2",
+    summary: "roles.yaml at version 2: it can name the teams repos are owned by and who is on each, so questions go to their owner; no team is named until a person writes one (ADR 0140)",
+    async pending(root) {
+      const rel2 = packRel(root, "roles.yaml");
+      const text = await readFile(join(root, rel2), "utf8").catch(() => void 0);
+      return text !== void 0 && migrateRolesText(text).changed ? [rel2] : [];
+    },
+    async apply(root) {
+      const rel2 = packRel(root, "roles.yaml");
+      const text = await readFile(join(root, rel2), "utf8").catch(() => void 0);
+      if (text === void 0)
+        return [];
+      const r = migrateRolesText(text);
+      if (!r.changed)
+        return [];
+      await writeFileAtomic(join(root, rel2), r.text);
+      return [rel2];
+    }
+  },
   {
     // ADR 0006 addendum (2026-10-25): org-flow version 2 lists Atticus 2's artifacts (proposal,
     // design, stories, specs, tasks), so `openspec status` and `validate` agree with Atticus.
@@ -249,22 +307,67 @@ var MIGRATIONS = [
     // call: short story files, task prompts in tasks/, tasks numbered per story, OpenSpec specs.
     id: "stories-b-short",
     summary: "Each change's stories in the short form, with OpenSpec spec deltas and a proposal, from the kept stories answer (no model call; ADR 0124 addendum B-short)",
+    // The whole change folder: writing the stories again also writes stories.md, tasks.md,
+    // requests.md, the proposal, specs/, the task prompts and the needs files, all backed up.
     async pending(root) {
-      return (await longStories(root)).map((c) => `${changesRelOf(root)}/${c}/stories`);
+      return (await longStories(root)).map((c) => `${changesRelOf(root)}/${c}`);
     },
     async apply(root) {
       const out = [];
-      for (const c of await longStories(root))
-        for (const f of await rewriteStories(root, c).catch(() => []))
+      for (const c of await longStories(root)) {
+        const files = await rewriteStories(root, c).catch((e) => {
+          throw new Error(`The stories of ${c} couldn't be written again (${e instanceof Error ? e.message : String(e)}).`, { cause: e });
+        });
+        for (const f of files)
           out.push(`${changesRelOf(root)}/${c}/${f}`);
+      }
       return out;
     }
   },
   {
     id: "manifest-schema-v2",
     summary: "repos.manifest.yaml at version 2: a repo can say what it is, in a person's words (ADR 0128)",
-    pending: (root) => migrateManifests(root, { dryRun: true }),
-    apply: (root) => migrateManifests(root)
+    pending: (root) => migrateManifests(root, { dryRun: true, to: 2 }),
+    apply: (root) => migrateManifests(root, { to: 2 })
+  },
+  {
+    id: "manifest-schema-v3",
+    summary: "repos.manifest.yaml at version 3: a repo can give the base path it answers under on a shared host (ADR 0134)",
+    pending: (root) => migrateManifests(root, { dryRun: true, to: 3 }),
+    apply: (root) => migrateManifests(root, { to: 3 })
+  },
+  // ADR 0181: the version-4 files: only the number changes; version 5 adds the evidence source
+  // `ai` with its run (a link the AI decided, flagged joined-by-ai).
+  catalogStep("catalog-schema-v5", "Catalog records at schema version 5: a link can be the AI's, with the run that decided it (ADR 0181)", [4]),
+  {
+    // ADR 0181: a runtime.yaml that sets `decide` needs version 4; any other file means the same
+    // at 1 to 3 and is left as it is.
+    id: "runtime-v4",
+    summary: "runtime.yaml at version 4 where it sets decide: whether the AI decides pairings and option questions itself (ADR 0181); the number only",
+    async pending(root) {
+      const rel2 = packRel(root, "runtime.yaml");
+      const text = await readFile(join(root, rel2), "utf8").catch(() => void 0);
+      return text !== void 0 && migrateRuntimeV4Text(text).changed ? [rel2] : [];
+    },
+    async apply(root) {
+      const rel2 = packRel(root, "runtime.yaml");
+      const text = await readFile(join(root, rel2), "utf8").catch(() => void 0);
+      if (text === void 0)
+        return [];
+      const r = migrateRuntimeV4Text(text);
+      if (!r.changed)
+        return [];
+      await writeFileAtomic(join(root, rel2), r.text);
+      return [rel2];
+    }
+  },
+  {
+    // ADR 0181: a corrections line that uses version 2's fields (ai, batch, rule, match, unlink)
+    // but says version 1 (written by hand) says 2; every other line means the same at 1.
+    id: "corrections-v2",
+    summary: "Corrections lines at version 2 where they use its fields: an AI pairing, a batch, a rule, an unlink (ADR 0181); the number only",
+    pending: (root) => migrateCorrections(root, { dryRun: true }),
+    apply: (root) => migrateCorrections(root)
   }
 ];
 var orgFlowRel = (root) => `${layoutOf(root).openspec.replace(/\/+$/, "")}/schemas/org-flow/schema.yaml`;
@@ -317,7 +420,7 @@ function catalogStep(id, summary, versions) {
         versions,
         pendingOnly: dryRun
       });
-      out.push(...rel(`catalog/${sub}`, r.migrated));
+      out.push(...rel(`${layoutOf(root).catalog.replace(/\/+$/, "")}/${sub}`, r.migrated));
     }
     return out;
   };
@@ -353,25 +456,104 @@ function gatesRel(root) {
   return packRel(root, "gates.yaml");
 }
 async function readStamp(root) {
+  return (await readStampFile(root)).stamp;
+}
+async function readStampFile(root) {
+  let text;
   try {
-    const r = MetarepoStamp.safeParse((0, import_yaml.parse)(await readFile(join(root, STAMP_FILE), "utf8")));
-    return r.success ? r.data : void 0;
+    text = await readFile(join(root, STAMP_FILE), "utf8");
   } catch {
-    return void 0;
+    return {};
   }
+  let data;
+  try {
+    data = (0, import_yaml.parse)(text);
+  } catch (e) {
+    return { unread: { why: `not YAML: ${e.message.split("\n")[0]}` } };
+  }
+  const r = MetarepoStamp.safeParse(data);
+  if (r.success)
+    return { stamp: r.data };
+  const atticus = data?.atticus;
+  const why = r.error.issues.map((i) => `${i.path.join(".") || "(top)"}: ${i.message}`).join("; ");
+  return {
+    unread: {
+      ...typeof atticus === "string" && atticus.trim() ? { atticus: atticus.trim() } : {},
+      why
+    }
+  };
+}
+function newerAtticusOf(c) {
+  const u = c.unreadStamp?.atticus;
+  return c.stamp?.atticus ?? (u && newerThan(u, c.atticus) ? u : void 0);
+}
+function newerWords(c) {
+  const u = c.unreadStamp;
+  const v = newerAtticusOf(c);
+  if (v)
+    return `This metarepo was upgraded by Atticus ${v}; this is ${c.atticus}. Install ${v} or later before working in it, so nothing it wrote is lost.`;
+  return `This metarepo was upgraded by a newer or unknown Atticus${u?.atticus ? ` (${u.atticus})` : ""}: .atticus/metarepo.yaml isn't a stamp Atticus ${c.atticus} reads (${u?.why ?? "unreadable"}). Install it${u?.atticus ? ` (Atticus ${u.atticus} or later)` : ""} before working in this metarepo, so nothing it wrote is lost; or, if the file was edited by hand, put it back as it was committed. Nothing was changed.`;
+}
+function newerThan(a, b) {
+  const split = (v) => {
+    const [core, pre] = v.trim().replace(/^v/, "").split(/-(.*)/s, 2);
+    return { core: (core ?? "").split(".").map((n) => Number(n) || 0), pre: pre ?? "" };
+  };
+  const x = split(a);
+  const y = split(b);
+  for (let i = 0; i < Math.max(x.core.length, y.core.length); i++) {
+    const d = (x.core[i] ?? 0) - (y.core[i] ?? 0);
+    if (d)
+      return d > 0;
+  }
+  if (x.pre === y.pre)
+    return false;
+  if (!x.pre)
+    return true;
+  if (!y.pre)
+    return false;
+  const xp = x.pre.split(".");
+  const yp = y.pre.split(".");
+  for (let i = 0; i < Math.max(xp.length, yp.length); i++) {
+    const p = xp[i];
+    const q = yp[i];
+    if (p === void 0)
+      return false;
+    if (q === void 0)
+      return true;
+    if (p === q)
+      continue;
+    const pn = /^\d+$/.test(p);
+    const qn = /^\d+$/.test(q);
+    if (pn && qn)
+      return Number(p) > Number(q);
+    if (pn !== qn)
+      return !pn;
+    return p > q;
+  }
+  return false;
 }
-var newerThan = (a, b) => !versionAtLeast(b, a.replace(/-.*$/, ""));
 async function upgradeCheck(root, version = VERSION) {
-  const [stamp, found] = await Promise.all([
-    readStamp(root),
-    Promise.all(MIGRATIONS.map(async (m) => ({ m, files: await m.pending(root) })))
+  const [read, found] = await Promise.all([
+    readStampFile(root),
+    Promise.all(MIGRATIONS.map(async (m) => ({
+      m,
+      files: await m.pending(root),
+      problems: m.problems ? await m.problems(root) : []
+    })))
   ]);
+  const { stamp, unread } = read;
   const pending = found.filter((x) => x.files.length).map(({ m, files }) => ({ id: m.id, summary: m.summary, files }));
+  const problems = found.flatMap((x) => x.problems);
   return {
     atticus: version,
     ...stamp ? { stamp } : {},
-    newer: !!stamp && newerThan(stamp.atticus.replace(/-.*$/, ""), version.replace(/-.*$/, "")),
-    pending
+    // Round 49: a stamp that is there but isn't read is a newer or unknown Atticus's: never
+    // taken as no stamp, so this one never writes over it.
+    newer: stamp ? newerThan(stamp.atticus, version) : !!unread,
+    ...unread ? { unreadStamp: unread } : {},
+    pending,
+    ...problems.length ? { problems } : {}
   };
 }
 async function openspecStorePlan(root) {
@@ -404,11 +586,13 @@ function storeLine(s) {
 async function upgradeCommand(root, o, io, version = VERSION) {
   const c = await upgradeCheck(root, version);
   if (c.newer) {
-    io.err(`This metarepo was upgraded by Atticus ${c.stamp.atticus}; this is ${version}. Install ${c.stamp.atticus} or later before working in it, so nothing it wrote is lost.`);
+    io.err(newerWords(c));
     if (o.json)
       io.out(JSON.stringify(c, null, 2));
     return 1;
   }
+  for (const p of c.problems ?? [])
+    io.err(`Left as it is: ${p}`);
   const store = o.openspecStore ? await openspecStorePlan(root) : void 0;
   if (store?.action === "refused") {
     io.err(store.why);
@@ -443,12 +627,25 @@ async function upgradeCommand(root, o, io, version = VERSION) {
   if (c.pending.length) {
     await mkdir(backup, { recursive: true });
     await ensureLocalIgnore(root);
-    for (const p of c.pending)
+    for (const p of c.pending) {
+      const creates = MIGRATIONS.find((x) => x.id === p.id)?.creates === true;
       for (const f of p.files)
-        await cp(join(root, ...f.split("/")), join(backup, ...f.split("/"))).catch(() => void 0);
+        await cp(join(root, ...f.split("/")), join(backup, ...f.split("/")), {
+          recursive: true
+        }).catch((e) => {
+          if (e.code === "ENOENT" && creates)
+            return;
+          throw new Error(e.code === "ENOENT" ? `Couldn't back up ${f} before upgrading: the step ${p.id} would change it, but it isn't there; nothing was changed.` : `Couldn't back up ${f} before upgrading (${e.message}); nothing was changed.`);
+        });
+    }
     for (const p of c.pending) {
       const m = MIGRATIONS.find((x) => x.id === p.id);
-      changed.push(...await m.apply(root));
+      try {
+        changed.push(...await m.apply(root));
+      } catch (e) {
+        const done = c.pending.slice(0, c.pending.indexOf(p)).map((x) => x.id);
+        throw new Error(`${e instanceof Error ? e.message : String(e)} The files as they were before this upgrade are in ${relative(root, backup).split(sep).join("/")}${done.length ? `; these steps had already run: ${done.join(", ")}` : ""}. Run atticus upgrade again once it's fixed.`, { cause: e });
+      }
     }
   }
   const stamp = MetarepoStamp.parse({
@@ -491,6 +688,9 @@ export {
   STAMP_FILE,
   MIGRATIONS,
   readStamp,
+  newerAtticusOf,
+  newerWords,
+  newerThan,
   upgradeCheck,
   upgradeCommand
 };