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

package/dist/{chunk-XY3P7JW7.js → chunk-IDKCWSM5.js}

@@ -8,19 +8,22 @@ import {
   addStoreReference,
   readStoreMarker,
   readStoreVia
-} from "./chunk-4AK7IBVP.js";
+} from "./chunk-UUU4CLJG.js";
 import {
   AdapterError,
   mergeBlockers,
   requireApproval
-} from "./chunk-7JUKDRSZ.js";
+} from "./chunk-7IGKHZ4Z.js";
 import {
+  outsideProfileSystems,
   readCatalog
-} from "./chunk-27NKUS3X.js";
+} from "./chunk-J2JAKCIW.js";
 import {
+  baseClonePath,
   createGit,
-  readChangeRepos
-} from "./chunk-EFHQ3TWP.js";
+  readChangeRepos,
+  writeChangeRepos
+} from "./chunk-PKBHS4AA.js";
 import {
   ChangeArtifact,
   ChangeLifecycle,
@@ -30,6 +33,8 @@ import {
   Phase,
   RecordId,
   TestType,
+  askedGapQuestionId,
+  changeBranch,
   changesDirOf,
   changesRelOf,
   external_exports,
@@ -37,18 +42,23 @@ import {
   fastPathOf,
   handoffBranch,
   isAssistantResolution,
+  listQuestions,
   loadOpenSpecSettings,
   loadOrgPack,
   openspecDirOf,
   orgPackDirOf,
+  questionsRelOf,
   readFlow,
-  require_dist,
+  readQuestion,
   specFlowFiles,
   toCanonicalYaml
-} from "./chunk-S2A7YC3Q.js";
+} from "./chunk-Q2TECDIT.js";
 import {
   writeFileAtomic
-} from "./chunk-D3PO4DOZ.js";
+} from "./chunk-TUULXQRW.js";
+import {
+  require_dist
+} from "./chunk-BQGDB6ZL.js";
 import {
   __toESM
 } from "./chunk-TV45EUGM.js";
@@ -142,8 +152,11 @@ var StageStep = external_exports.strictObject({
   loop: external_exports.string().min(1),
   /** The command that runs it; `<change>` stands for the change's id. */
   command: external_exports.string().min(1),
-  /** Files it writes, relative to the change folder; a folder ends in "/". They ride with the hand-off. */
-  writes: external_exports.array(external_exports.string().min(1)).default([]),
+  /**
+   * Files it writes, relative to the change folder; a folder ends in "/", and a "*" in the last
+   * part matches any name in that folder ("tasks/*.prompt.md"). They ride with the hand-off.
+   */
+  writes: external_exports.array(external_exports.string().min(1).refine((w) => !/(^|[/\\])\.\.([/\\]|$)/.test(w) && !/^([/\\]|[a-zA-Z]:)/.test(w), "a write stays inside the change folder (no .. and no absolute path)").refine((w) => !w.split("/").slice(0, -1).some((part) => part.includes("*")), 'a "*" may only be in the last part of a write (tasks/*.prompt.md, not tasks/*/notes.md)')).default([]),
   /** The change type's artifacts of the phase that this stage writes: on the stage path, only these are due. */
   artifacts: external_exports.array(ChangeArtifact).default([])
 });
@@ -153,7 +166,7 @@ var DEFAULT_STAGES = [
     phase: "define",
     loop: "stage/feature.yaml",
     command: "atticus change feature <change>",
-    writes: ["feature.yaml", "feature.md", "design/"],
+    writes: ["feature.yaml", "feature.md", "proposal.md", "design/"],
     artifacts: []
   },
   {
@@ -161,7 +174,7 @@ var DEFAULT_STAGES = [
     phase: "design",
     loop: "stage/architecture.yaml",
     command: "atticus change architecture <change>",
-    writes: ["target-flows/"],
+    writes: ["target-flows/", "stage/architecture-deploy.yaml", "stage/architecture-reads.yaml"],
     artifacts: ["design", "data"]
   },
   {
@@ -169,10 +182,27 @@ var DEFAULT_STAGES = [
     phase: "plan",
     loop: "stage/stories.yaml",
     command: "atticus plan stories <change>",
-    writes: ["requests.md", "stage/stories-answer.yaml"],
+    writes: [
+      "requests.md",
+      "proposal.md",
+      "needs.yaml",
+      "needs.md",
+      "specs/",
+      "tasks/*.prompt.md",
+      "stage/stories-answer.yaml"
+    ],
     artifacts: ["stories", "tasks"]
   }
 ];
+var isWritePattern = (w) => w.includes("*");
+function writeMatches(w, path) {
+  if (w.endsWith("/"))
+    return path.startsWith(w);
+  if (!isWritePattern(w))
+    return path === w;
+  const re = new RegExp(`^${w.split("*").map((x) => x.replace(/[.+?^${}()|[\]\\]/g, "\\$&")).join("[^/]*")}$`);
+  return re.test(path);
+}
 var Privacy = external_exports.strictObject({
   role: RecordId.default("privacy-officer"),
   classifications: external_exports.array(external_exports.string().min(1)).default(["personal", "pii", "sensitive-personal", "special-category"]),
@@ -530,7 +560,16 @@ var LEADING = [
   "from",
   "to"
 ];
+var isPathLike = (id) => !id || id === "." || id === ".." || /[\\/]/.test(id) || /^[A-Za-z]:/.test(id) || id.includes("\0");
+var isFolderRef = (id) => {
+  const parts = id.split("/");
+  if (parts.length === 2 && parts[0] === "archive")
+    return !isPathLike(parts[1]);
+  return !isPathLike(id);
+};
 function changeFolder(root, id) {
+  if (!isFolderRef(id))
+    throw new Error(`${id} isn't a change id.`);
   return join3(changesDirOf(root), id);
 }
 function changeFilePath(root, id) {
@@ -553,6 +592,8 @@ function serializeChange(value) {
 }
 function changeStore(root) {
   async function tryRead(id) {
+    if (!RecordId.safeParse(id).success)
+      return void 0;
     const path = changeFilePath(root, id);
     let text;
     try {
@@ -589,22 +630,33 @@ function changeStore(root) {
       await writeFileAtomic(path, serializeChange(value));
       return path;
     },
+    listWithProblems,
     async list() {
-      let names;
+      return (await listWithProblems()).changes;
+    }
+  };
+  async function listWithProblems() {
+    let names;
+    try {
+      names = (await readdir2(changesDirOf(root), { withFileTypes: true })).filter((d) => d.isDirectory() && d.name !== "archive" && RecordId.safeParse(d.name).success).map((d) => d.name).sort();
+    } catch {
+      return { changes: [], problems: [] };
+    }
+    const changes = [];
+    const problems = [];
+    for (const n of names) {
       try {
-        names = (await readdir2(changesDirOf(root), { withFileTypes: true })).filter((d) => d.isDirectory() && d.name !== "archive").map((d) => d.name).sort();
-      } catch {
-        return [];
-      }
-      const out = [];
-      for (const n of names) {
         const c = await tryRead(n);
         if (c)
-          out.push(c);
+          changes.push(c);
+      } catch (e) {
+        if (!(e instanceof ChangeFileError))
+          throw e;
+        problems.push({ file: e.path, message: e.message });
       }
-      return out;
     }
-  };
+    return { changes, problems };
+  }
 }
 
 // packages/changes/dist/codeowners.js
@@ -712,6 +764,21 @@ function changeTypeOf(ctx, type) {
 var import_yaml4 = __toESM(require_dist(), 1);
 import { readdir as readdir3, readFile as readFile5 } from "node:fs/promises";
 import { join as join6 } from "node:path";
+
+// packages/changes/dist/outside.js
+function outsideSystemsOf(op) {
+  return new Map(outsideProfileSystems(op).map((s) => [s.id, s.boundary === "vendor" ? "vendor" : "other-team"]));
+}
+function outsideKindOf(outside, system, catalogBoundary) {
+  if (!system)
+    return void 0;
+  if (catalogBoundary === "vendor")
+    return "vendor";
+  return outside.get(system);
+}
+var outsideWords = (k) => k === "vendor" ? "a vendor" : "another team's system";
+
+// packages/changes/dist/footprint.js
 function personalLevels(ctx) {
   const pack = ctx.orgPack.pack?.classification ?? [
     "public",
@@ -799,6 +866,8 @@ async function changeFootprint(ctx, change) {
   };
   const profileSystems = new Map(ctx.orgPack.profiles.flatMap((p) => p.profile?.systems ?? []).map((s) => [s.id, s]));
   const isSystem = (id) => get("System", id) !== void 0 || profileSystems.has(id);
+  const outsideSystems = outsideSystemsOf(ctx.orgPack);
+  const outsideKind = (id) => outsideKindOf(outsideSystems, id, get("System", id)?.boundary ?? profileSystems.get(id)?.boundary);
   const systems = new Set(change.systems);
   const components = /* @__PURE__ */ new Set();
   const interfaces = /* @__PURE__ */ new Map();
@@ -846,7 +915,7 @@ async function changeFootprint(ctx, change) {
     if (table)
       tables.add(table.includes(".") ? slug(table) : `${store}.${slug(table)}`);
   }
-  const staged = await stageFootprint(ctx, dir, { get, isSystem, profileSystems, ref });
+  const staged = await stageFootprint(ctx, dir, { get, isSystem, outsideKind, ref });
   for (const f of staged.from)
     from.add(f);
   for (const r of staged.repos)
@@ -905,7 +974,8 @@ async function changeFootprint(ctx, change) {
       repos.add(r.id);
   } catch {
   }
-  const vendors = [...systems].filter((s) => (get("System", s)?.boundary ?? profileSystems.get(s)?.boundary) === "vendor");
+  const vendors = [...systems].filter((s) => outsideKind(s) === "vendor");
+  const otherTeams = [...systems].filter((s) => outsideKind(s) === "other-team");
   const personalSet = new Set(personalLevels(ctx).levels.map((c) => c.toLowerCase()));
   const personal = [];
   for (const s of staged.stores) {
@@ -962,6 +1032,7 @@ async function changeFootprint(ctx, change) {
     records: sorted(change.touches.records),
     repos: sorted(repos),
     vendors: vendors.sort(),
+    ...otherTeams.length ? { otherTeams: otherTeams.sort() } : {},
     personal,
     flows,
     entries: sorted(staged.entries),
@@ -995,7 +1066,7 @@ async function stageFootprint(ctx, dir, h) {
   const tasksText = await read(join6(dir, "tasks.md"));
   if (!files.length && !featureText && !tasksText)
     return out;
-  const { get, isSystem, profileSystems, ref } = h;
+  const { get, isSystem, outsideKind, ref } = h;
   const specs = await specIndex(ctx);
   const catalogRepos = /* @__PURE__ */ new Set();
   for (const r of ctx.records)
@@ -1009,9 +1080,9 @@ async function stageFootprint(ctx, dir, h) {
   const outsideOf = async (id) => {
     const c = get("Component", id);
     if (c)
-      return get("System", c.system)?.boundary === "vendor";
+      return outsideKind(c.system) !== void 0;
     if (isSystem(id))
-      return (get("System", id)?.boundary ?? profileSystems.get(id)?.boundary) === "vendor";
+      return outsideKind(id) !== void 0;
     if (catalogRepos.has(id))
       return false;
     return !await specs.hasComponent(id) && !await specs.hasRepo(id);
@@ -1098,7 +1169,7 @@ async function stageFootprint(ctx, dir, h) {
       const was = op !== "add" && n ? today?.flow.steps[n - 1] : void 0;
       const kind = str(s.kind) ?? was?.kind ?? "step";
       const what = str(s.what) ?? was?.what ?? "";
-      const live = op === "add" || op === "change";
+      const live2 = op === "add" || op === "change";
       const store = obj(s.store);
       const table = str(store?.table) ?? was?.store?.table;
       if (table) {
@@ -1111,7 +1182,7 @@ async function stageFootprint(ctx, dir, h) {
           if (typeof v === "string")
             classification[c] = v;
         out.stores.push({ table, columns: cols, classification, kind, cite });
-        if (live) {
+        if (live2) {
           const hit = [...wordsOf(table), ...cols.flatMap(wordsOf)].filter((w) => personalWords.has(w));
           if (hit.length)
             out.signals.push({
@@ -1139,7 +1210,7 @@ async function stageFootprint(ctx, dir, h) {
           if (entry)
             o.entries.add(entry);
           outside.set(target, o);
-          if (live)
+          if (live2)
             out.signals.push({
               factor: "outside-call",
               detail: `${target}${entry ? ` (${entry}${to?.new === true ? ", new" : ""})` : ""}`,
@@ -1163,7 +1234,7 @@ async function stageFootprint(ctx, dir, h) {
             out.calls.add(iface.id);
         }
       }
-      if (!live)
+      if (!live2)
         continue;
       const fields = obj(s.fields) ?? {};
       const names = FIELD_LISTS.flatMap((k) => strs(fields[k]));
@@ -1291,9 +1362,14 @@ function scoreRisk(input, policy) {
     add("systems", `${f.systems.length} systems touched (${f.systems.join(", ")})`, (f.systems.length - 1) * w.extraSystem);
   for (const s of f.dataStores)
     add("data-store", `data store ${s}`, w.dataStore);
-  const crossed = f.vendors.filter((v) => !(f.outside ?? []).some((o) => o.id === v));
-  if (crossed.length > 0)
-    add("vendor", `crosses the vendor boundary (${crossed.join(", ")})`, w.vendor);
+  const notCalled = (v) => !(f.outside ?? []).some((o) => o.id === v);
+  const crossed = f.vendors.filter(notCalled);
+  const teams = (f.otherTeams ?? []).filter(notCalled);
+  if (crossed.length > 0 || teams.length > 0)
+    add("vendor", [
+      ...crossed.length ? [`crosses the vendor boundary (${crossed.join(", ")})`] : [],
+      ...teams.length ? [`calls another team's system (${teams.join(", ")})`] : []
+    ].join("; "), w.vendor);
   for (const i of f.interfaces) {
     if (i.status === "planned-modify")
       add("interface", `interface ${i.id} planned-modify`, w.interfaceModify);
@@ -1414,7 +1490,7 @@ function handoffName(type, phase) {
     case "plan":
       return "Plan ready";
     case "build":
-      return "Raise PR";
+      return "Build ready";
     case "qa":
       return "QA sign-off";
     case "release":
@@ -1470,8 +1546,15 @@ async function checkStage(root, change, step) {
       break;
     case "stopped":
       return reason(`The ${step.stage} stage stopped and isn't done: see what stopped it, then run ${run} again.`);
-    case "questions":
-      return reason(`The ${step.stage} stage waits for a person to answer its questions: answer them (atticus questions), then run ${run} again.`);
+    case "questions": {
+      const asked = Array.isArray(loop?.questions) ? loop.questions.filter((q) => typeof q === "string") : [];
+      if (asked.length) {
+        const open = new Set((await listQuestions(root, { state: "open" }).catch(() => ({ questions: [] }))).questions.map((q) => q.id));
+        if (!asked.some((q) => open.has(q)))
+          return reason(`The ${step.stage} stage's questions are answered: run it again so it reads the answers (${run}).`);
+      }
+      return reason(`The ${step.stage} stage waits for a person to answer its questions: answer them on Questions (or atticus questions), then run the stage again (${run}).`);
+    }
     case "waiting":
       return reason(`The ${step.stage} stage is with your assistant${typeof loop?.run === "string" ? ` (run ${loop.run})` : ""}: finish the hand-off, then run ${run} again.`);
     case "drafting":
@@ -1480,7 +1563,8 @@ async function checkStage(root, change, step) {
       return reason(`${step.loop} doesn't read as a stage's loop state: run ${run} again.`);
   }
   const out = [];
-  for (const w of step.writes.filter((x) => !x.endsWith("/") && !x.startsWith("stage/")))
+  const artifactFile = new Set(Object.values(FILE));
+  for (const w of step.writes.filter((x) => !x.endsWith("/") && !x.startsWith("stage/") && !isWritePattern(x) && !artifactFile.has(x)))
     if (!await readFile6(join7(dir, ...w.split("/"))).then(() => true, () => false))
       out.push(...reason(`${w} is missing, though the ${step.stage} stage is done: run ${run} again.`));
   return out;
@@ -1490,7 +1574,10 @@ async function stageFiles(dir, step) {
   for (const w of [...step.writes, step.loop]) {
     if (w.endsWith("/"))
       out.push(...await walk(dir, w.slice(0, -1)));
-    else if (await readFile6(join7(dir, ...w.split("/"))).then(() => true, () => false))
+    else if (isWritePattern(w)) {
+      const parent = w.split("/").slice(0, -1).join("/");
+      out.push(...(await walk(dir, parent)).filter((p) => writeMatches(w, p)));
+    } else if (await readFile6(join7(dir, ...w.split("/"))).then(() => true, () => false))
       out.push(w);
   }
   return [...new Set(out)].sort();
@@ -1576,13 +1663,24 @@ async function checkFindings(root, change, gates) {
       continue;
     const round2 = Math.max(...rounds);
     const dir = join7(base, String(round2));
+    const files = (await readdir4(dir)).filter((f) => /\.ya?ml$/.test(f)).sort();
+    const unfinished = {
+      code: "round-unfinished",
+      message: `Critic round ${round2} on the ${gate} gate didn't finish: run atticus critic ${change.id} --gate ${gate} again.`
+    };
+    let hasMeta = false;
     try {
       const meta = (0, import_yaml5.parse)(await readFile6(join7(dir, "meta", "round.yaml"), "utf8"));
+      hasMeta = true;
+      if (meta?.state === "in-progress") {
+        reasons.push(unfinished);
+        continue;
+      }
       for (const l of meta?.lenses ?? [])
         if (l.state === "waiting")
           reasons.push({
             code: "lens-waiting",
-            message: `The ${l.lens ?? "AI"} lens on the ${gate} gate (round ${round2}) is waiting for its hand-off answer${l.runId ? ` (atticus handoff done ${l.runId})` : ""}.`
+            message: `The ${l.lens ?? "AI"} lens on the ${gate} gate (round ${round2}) is waiting for its hand-off answer${l.runId ? ` (Done on run ${l.runId} in Model runs, or atticus handoff done ${l.runId})` : ""}.`
           });
         else if (l.state === "failed")
           reasons.push({
@@ -1591,7 +1689,10 @@ async function checkFindings(root, change, gates) {
           });
     } catch {
     }
-    const files = (await readdir4(dir)).filter((f) => /\.ya?ml$/.test(f)).sort();
+    if (!hasMeta && files.length === 0) {
+      reasons.push(unfinished);
+      continue;
+    }
     for (const f of files) {
       const rel = `review/${gate}/${round2}/${f}`;
       let data;
@@ -1609,6 +1710,16 @@ async function checkFindings(root, change, gates) {
         continue;
       }
       const x = r.data;
+      if (x.severity === "gap" && x.state === "asked") {
+        const q = await readQuestion(root, askedGapQuestionId(change.id, x)).catch(() => void 0);
+        if (q?.state === "open")
+          reasons.push({
+            code: "open-gap",
+            finding: x.id,
+            message: `Knowledge gap ${x.id} on the ${gate} gate (round ${round2}) was asked of ${q.askedOf ?? x.resolution?.askedOf ?? "its owner"} and waits for the answer (owner question ${q.id}, in Questions, Owner questions): ${x.summary}`
+          });
+        continue;
+      }
       const byAssistant = x.severity === "blocking" && isAssistantResolution(x.resolution);
       if (x.state !== "open" && !byAssistant)
         continue;
@@ -1728,8 +1839,459 @@ function prApprovers(handoff2, approvers) {
   return [...new Set(approvers.map(strip))].filter((p) => p !== raiser).sort();
 }
 
+// packages/changes/dist/assess.js
+import { readFile as readFile9 } from "node:fs/promises";
+import { join as join10 } from "node:path";
+
+// packages/changes/dist/release-prs.js
+var import_yaml7 = __toESM(require_dist(), 1);
+import { readFile as readFile8, writeFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { join as join9 } from "node:path";
+var RELEASE_PR_STATES = [
+  "qa",
+  "release-ready",
+  "released",
+  "post-release-review"
+];
+var nowIso = () => (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
+var RELEASE_PRS_FILE = "release-prs.yaml";
+var NothingFile = external_exports.strictObject({
+  schemaVersion: external_exports.literal(1),
+  nothingToRelease: external_exports.array(external_exports.strictObject({
+    repo: external_exports.string().min(1),
+    /** The change branch's commit when it was found to hold nothing beyond the default branch. */
+    commit: external_exports.string().regex(/^[0-9a-f]{7,64}$/).optional(),
+    at: external_exports.string().min(1),
+    by: external_exports.string().min(1)
+  })),
+  /**
+   * Review round 48: the change branch's commit when Sync first read each release PR merged, so
+   * a merged PR stands only while the branch is there (work landed since needs a PR of its own).
+   */
+  merged: external_exports.array(external_exports.strictObject({
+    repo: external_exports.string().min(1),
+    number: external_exports.number().int().positive(),
+    commit: external_exports.string().regex(/^[0-9a-f]{7,64}$/),
+    at: external_exports.string().min(1)
+  })).optional()
+});
+async function readReleaseFile(root, id) {
+  const empty = { schemaVersion: 1, nothingToRelease: [] };
+  const text = await readFile8(join9(changeFolder(root, id), RELEASE_PRS_FILE), "utf8").catch(() => void 0);
+  if (text === void 0)
+    return empty;
+  try {
+    const r = NothingFile.safeParse((0, import_yaml7.parse)(text));
+    return r.success ? r.data : empty;
+  } catch {
+    return empty;
+  }
+}
+async function readNothing(root, id) {
+  return (await readReleaseFile(root, id)).nothingToRelease;
+}
+async function writeReleaseFile(root, id, nothing, merged) {
+  const byRepo = (xs) => [...xs].sort((a, b) => a.repo < b.repo ? -1 : a.repo > b.repo ? 1 : 0);
+  await writeFile(join9(changeFolder(root, id), RELEASE_PRS_FILE), toCanonicalYaml(NothingFile.parse({
+    schemaVersion: 1,
+    nothingToRelease: byRepo(nothing),
+    ...merged.length ? { merged: byRepo(merged) } : {}
+  })), "utf8");
+}
+function repoDir(root, r) {
+  const dirs = [join9(root, r.worktree)];
+  try {
+    dirs.push(baseClonePath(root, r.id));
+  } catch {
+  }
+  return dirs.find((d) => existsSync(d));
+}
+async function staleReleasePrs(root, id, o = {}) {
+  const out = /* @__PURE__ */ new Set();
+  const cr = await readChangeRepos(root, id).catch(() => void 0);
+  const merged = (await readReleaseFile(root, id)).merged ?? [];
+  if (!cr || !merged.length)
+    return out;
+  const git = o.git ?? createGit({ timeoutMs: 3e4 });
+  const remote = o.remote ?? "origin";
+  for (const r of cr.repos) {
+    if (r.pr?.state !== "merged")
+      continue;
+    const entry = merged.find((x) => x.repo === r.id && x.number === r.pr.number);
+    if (!entry)
+      continue;
+    const dir = repoDir(root, r);
+    if (!dir)
+      continue;
+    if (await movedPast(git, dir, remote, r.branch, entry.commit))
+      out.add(r.id);
+  }
+  return out;
+}
+async function movedPast(git, dir, remote, branch, commit) {
+  const ref = `refs/heads/${branch}`;
+  const known = (sha) => git(["cat-file", "-e", `${sha}^{commit}`], dir).then(() => true, () => false);
+  const here = await git(["rev-parse", "--verify", "--quiet", `${ref}^{commit}`], dir).then((x) => x.stdout.trim() || void 0, () => void 0);
+  const onHost = await git(["ls-remote", "--heads", remote, ref], dir).then((x) => x.stdout.trim().split(/\s+/)[0] || void 0, () => void 0);
+  if (onHost && !sameSha(onHost, commit) && !await known(onHost))
+    await git(["fetch", "-q", remote, `+${ref}:refs/remotes/${remote}/${branch}`], dir).catch(() => void 0);
+  const ahead = async (sha) => {
+    if (!sha || sameSha(sha, commit))
+      return false;
+    if (!await known(sha) || !await known(commit))
+      return true;
+    return git(["merge-base", "--is-ancestor", sha, commit], dir).then(() => false, () => true);
+  };
+  return await ahead(here) || await ahead(onHost);
+}
+async function nothingToRelease(root, id, o = {}) {
+  const entries = await readNothing(root, id);
+  const out = /* @__PURE__ */ new Set();
+  if (!entries.length)
+    return out;
+  const cr = await readChangeRepos(root, id).catch(() => void 0);
+  const git = o.git ?? createGit({ timeoutMs: 3e4 });
+  const remote = o.remote ?? "origin";
+  for (const x of entries) {
+    const r = cr?.repos.find((y) => y.id === x.repo);
+    if (r && await moved(r, x.commit))
+      continue;
+    out.add(x.repo);
+  }
+  return out;
+  async function moved(r, commit) {
+    const dir = repoDir(root, r);
+    if (!dir)
+      return false;
+    const ref = `refs/heads/${r.branch}`;
+    const here = await git(["rev-parse", "--verify", "--quiet", `${ref}^{commit}`], dir).then((x) => x.stdout.trim() || void 0, () => void 0);
+    const onHost = await git(["ls-remote", "--heads", remote, ref], dir).then((x) => x.stdout.trim().split(/\s+/)[0] || void 0, () => void 0);
+    const at = (sha) => sha !== void 0 && (commit === void 0 || !sameSha(sha, commit));
+    return at(here) || at(onHost);
+  }
+}
+var sameSha = (a, b) => a.startsWith(b) || b.startsWith(a);
+var firstLine = (e) => (e instanceof Error ? e.message : String(e)).split("\n")[0].replace(/\.$/, "");
+var prOf = (pr, now) => ({
+  url: pr.url,
+  number: pr.number,
+  state: pr.state,
+  updatedAt: now
+});
+var live = (pr) => !!pr && (pr.state === "open" || pr.state === "draft" || pr.state === "merged");
+function releaseBody(id, title, branch, base) {
+  return [
+    `Release of change ${id} (${title}): merges ${branch}, with the task PRs merged into it, into ${base}.`,
+    "",
+    "The go/no-go hand-off is decided over this PR. A person reviews and merges it on the Git host; Atticus never pushes to or merges into the default branch, and never deploys."
+  ].join("\n");
+}
+async function raiseReleasePrs(root, id, o) {
+  requireApproval("changes", o.approval);
+  const change = await changeStore(root).read(id);
+  if (!RELEASE_PR_STATES.includes(change.state))
+    throw new ChangeError("refused", `${id} is ${change.state}; the release PRs are raised once the build is done (in QA or at go/no-go), so go/no-go is decided over the PRs that will ship.`);
+  const cr = await readChangeRepos(root, id);
+  if (!cr?.repos.length)
+    throw new ChangeError("refused", `${id} has no code repos (repos.yaml), so there is no release PR to raise: open its workspace first (atticus workspace open ${id} <repo>).`);
+  const now = o.now ?? nowIso();
+  const git = o.git ?? createGit();
+  const remote = o.remote ?? "origin";
+  const expected = changeBranch(id);
+  const rows = [];
+  let changed2 = false;
+  const repos = cr.repos.map((r) => ({ ...r }));
+  const file = await readReleaseFile(root, id);
+  const before = file.nothingToRelease;
+  const nothing = new Map(before.map((x) => [x.repo, x]));
+  const stale = await staleReleasePrs(root, id, { git, remote });
+  for (const r of repos) {
+    const movedOn = r.pr?.state === "merged" && stale.has(r.id) ? `Release PR #${r.pr.number} merged before ${r.branch} moved on; this one carries what landed since.` : void 0;
+    if (!live(r.pr) || movedOn)
+      nothing.delete(r.id);
+    if (live(r.pr) && !movedOn) {
+      rows.push({
+        repo: r.id,
+        outcome: "kept",
+        pr: r.pr,
+        message: `${r.id}: release PR #${r.pr.number} is already ${r.pr.state} (${r.pr.url}).`
+      });
+      continue;
+    }
+    if (r.branch !== expected) {
+      rows.push({
+        repo: r.id,
+        outcome: "refused",
+        message: `${r.id}: its branch is ${r.branch}, not ${expected}; Atticus raises a release PR only from the change branch.`
+      });
+      continue;
+    }
+    let base;
+    try {
+      const info = await o.gitHost.getRepo(r.id);
+      base = info.defaultBranch;
+      if (info.protectedBranches.includes(r.branch)) {
+        rows.push({
+          repo: r.id,
+          outcome: "refused",
+          message: `${r.id}: ${r.branch} is protected; Atticus never pushes to or raises a PR from a protected branch.`
+        });
+        continue;
+      }
+      if (r.branch === base) {
+        rows.push({
+          repo: r.id,
+          outcome: "refused",
+          message: `${r.id}: ${r.branch} is the default branch; a release PR goes from the change branch into it.`
+        });
+        continue;
+      }
+    } catch (e) {
+      if (!(e instanceof AdapterError))
+        throw e;
+      rows.push({
+        repo: r.id,
+        outcome: "failed",
+        message: `${r.id}: the Git host didn't answer (${firstLine(e)}); raise the release PRs again once it does.`
+      });
+      continue;
+    }
+    const notes = movedOn ? [movedOn] : [];
+    const dir = join9(root, r.worktree);
+    if (existsSync(dir)) {
+      const onHost = await git(["ls-remote", "--heads", remote, `refs/heads/${r.branch}`], dir).then((x) => x.stdout.trim() ? "yes" : "no").catch((e) => {
+        notes.push(`Atticus couldn't reach ${remote} (${firstLine(e)}): push ${r.branch} yourself if the host lacks it.`);
+        return "unknown";
+      });
+      if (onHost === "no") {
+        const from = r.baseSha ?? `${remote}/${base}`;
+        const ahead = await git(["rev-list", "--count", `${from}..refs/heads/${r.branch}`], dir).then((x) => Number(x.stdout.trim()) || 0).catch(() => -1);
+        if (ahead === 0) {
+          const head = await git(["rev-parse", `refs/heads/${r.branch}`], dir).then((x) => x.stdout.trim()).catch(() => "");
+          nothing.set(r.id, {
+            repo: r.id,
+            .../^[0-9a-f]{7,64}$/.test(head) ? { commit: head } : {},
+            at: now,
+            by: o.approval.by
+          });
+          rows.push({
+            repo: r.id,
+            outcome: "nothing",
+            message: `${r.id}: ${r.branch} has no commits beyond ${base} and isn't on the Git host: there is nothing to release from it, so go/no-go doesn't wait for a PR.`
+          });
+          continue;
+        }
+        try {
+          await git(["push", "-q", remote, `refs/heads/${r.branch}:refs/heads/${r.branch}`], dir);
+          notes.push(`Pushed ${r.branch}, which the Git host didn't have.`);
+        } catch (e) {
+          rows.push({
+            repo: r.id,
+            outcome: "failed",
+            message: `${r.id}: ${r.branch} isn't on the Git host and couldn't be pushed (${firstLine(e)}): push it yourself, then raise the release PRs again.`
+          });
+          continue;
+        }
+      }
+    }
+    try {
+      const pr = await o.gitHost.createPullRequest({
+        repo: r.id,
+        head: r.branch,
+        base,
+        title: `${change.title} (release of ${id})`,
+        body: releaseBody(id, change.title, r.branch, base)
+      }, o.approval);
+      r.pr = prOf(pr, now);
+      changed2 = true;
+      rows.push({
+        repo: r.id,
+        outcome: "raised",
+        pr: r.pr,
+        message: [
+          pr.url.startsWith("manual:") ? `${r.id}: the release PR is a step for you (Home \u203A Manual steps): open it on the Git host from ${r.branch} into ${base}, then record its link.` : `${r.id}: release PR #${pr.number} from ${r.branch} into ${base} is open: ${pr.url}`,
+          ...notes
+        ].join(" ")
+      });
+    } catch (e) {
+      if (!(e instanceof AdapterError))
+        throw e;
+      if (e.code === "conflict") {
+        const open = (await o.gitHost.listPullRequests(r.id, { head: r.branch }).catch(() => [])).filter((p) => p.base === base && (p.state === "open" || p.state === "draft")).at(0);
+        if (open) {
+          r.pr = prOf(open, now);
+          changed2 = true;
+          rows.push({
+            repo: r.id,
+            outcome: "kept",
+            pr: r.pr,
+            message: `${r.id}: release PR #${open.number} was already open on the Git host; recorded it (${open.url}).`
+          });
+          continue;
+        }
+      }
+      rows.push({
+        repo: r.id,
+        outcome: "failed",
+        message: `${r.id}: the release PR wasn't raised (${firstLine(e)}); fix that and raise the release PRs again.`
+      });
+    }
+  }
+  if (changed2)
+    await writeChangeRepos(root, { ...cr, repos });
+  const after = [...nothing.values()].sort((a, b) => a.repo < b.repo ? -1 : 1);
+  const mergedBefore = file.merged ?? [];
+  const mergedAfter = mergedBefore.filter((x) => repos.some((r) => r.id === x.repo && r.pr?.number === x.number && r.pr.state === "merged"));
+  if (JSON.stringify(after) !== JSON.stringify(before) || mergedAfter.length !== mergedBefore.length)
+    await writeReleaseFile(root, id, after, mergedAfter);
+  return { change: id, rows };
+}
+async function syncReleasePrs(root, id, o) {
+  const cr = await readChangeRepos(root, id);
+  const rows = [];
+  if (!cr)
+    return { change: id, rows };
+  const now = o.now ?? nowIso();
+  let changed2 = false;
+  const repos = cr.repos.map((r) => ({ ...r }));
+  const file = await readReleaseFile(root, id);
+  const merged = [...file.merged ?? []];
+  let mergedChanged = false;
+  for (const r of repos) {
+    if (!r.pr)
+      continue;
+    let pr;
+    try {
+      pr = await o.gitHost.getPullRequest(r.id, r.pr.number);
+      if (pr.head !== r.branch) {
+        const mine = await o.gitHost.listPullRequests(r.id, { head: r.branch });
+        const own = mine.find((x) => x.url === r.pr.url) ?? (mine.length === 1 ? mine[0] : void 0);
+        if (!own) {
+          rows.push({
+            repo: r.id,
+            outcome: "failed",
+            pr: r.pr,
+            message: `${r.id}: PR #${r.pr.number} on the Git host is from ${pr.head}, not ${r.branch}: check the release PR's number on the Git host (on a manual host, on its step), then sync again.`
+          });
+          continue;
+        }
+        pr = own;
+      }
+    } catch (e) {
+      if (!(e instanceof AdapterError))
+        throw e;
+      rows.push({
+        repo: r.id,
+        outcome: "failed",
+        pr: r.pr,
+        message: `${r.id}: release PR #${r.pr.number} couldn't be read (${firstLine(e)}).`
+      });
+      continue;
+    }
+    const build = buildOf(pr);
+    if (pr.state !== r.pr.state || pr.url !== r.pr.url || pr.number !== r.pr.number) {
+      r.pr = prOf(pr, now);
+      changed2 = true;
+    }
+    if (build && build !== r.build.status) {
+      r.build = { ...r.build, status: build, at: now };
+      changed2 = true;
+    }
+    if (pr.state === "merged" && !merged.some((x) => x.repo === r.id && x.number === pr.number)) {
+      const commit = await branchTip(root, r, o.git, o.remote ?? "origin");
+      if (commit) {
+        for (let i = merged.length - 1; i >= 0; i--)
+          if (merged[i].repo === r.id)
+            merged.splice(i, 1);
+        merged.push({ repo: r.id, number: pr.number, commit, at: now });
+        mergedChanged = true;
+      }
+    }
+    rows.push({
+      repo: r.id,
+      outcome: "kept",
+      pr: r.pr,
+      message: `${r.id}: release PR #${r.pr.number} is ${r.pr.state}${build ? `, checks ${build}` : ""} (${r.pr.url}).`
+    });
+  }
+  if (changed2)
+    await writeChangeRepos(root, { ...cr, repos });
+  if (mergedChanged)
+    await writeReleaseFile(root, id, file.nothingToRelease, merged);
+  return { change: id, rows };
+}
+async function branchTip(root, r, g, remote) {
+  const dir = repoDir(root, r);
+  if (!dir)
+    return void 0;
+  const git = g ?? createGit({ timeoutMs: 3e4 });
+  const ref = `refs/heads/${r.branch}`;
+  const onHost = await git(["ls-remote", "--heads", remote, ref], dir).then((x) => x.stdout.trim().split(/\s+/)[0] || void 0, () => void 0);
+  if (onHost) {
+    await git(["fetch", "-q", remote, `+${ref}:refs/remotes/${remote}/${r.branch}`], dir).catch(() => void 0);
+    if (/^[0-9a-f]{7,64}$/.test(onHost))
+      return onHost;
+  }
+  const here = await git(["rev-parse", "--verify", "--quiet", `${ref}^{commit}`], dir).then((x) => x.stdout.trim(), () => "");
+  return /^[0-9a-f]{7,64}$/.test(here) ? here : void 0;
+}
+function buildOf(pr) {
+  if (!pr.checks.length)
+    return void 0;
+  if (pr.checks.some((c) => c.status === "failed"))
+    return "failed";
+  if (pr.checks.some((c) => c.status === "pending"))
+    return "running";
+  return "passed";
+}
+async function requireMergedPrs(root) {
+  const text = await readFile8(join9(orgPackDirOf(root), "process", "ci.yaml"), "utf8").catch(() => void 0);
+  if (text === void 0)
+    return true;
+  try {
+    const v = (0, import_yaml7.parse)(text)?.archive?.requireMergedPrs;
+    return v !== false;
+  } catch {
+    return true;
+  }
+}
+async function releasePrReasons(root, id, o = {}) {
+  const cr = await readChangeRepos(root, id).catch(() => void 0);
+  if (!cr?.repos.length)
+    return [];
+  const merged = await requireMergedPrs(root);
+  const nothing = await nothingToRelease(root, id, o);
+  const stale = await staleReleasePrs(root, id, o);
+  const out = [];
+  for (const r of cr.repos) {
+    if (!r.pr && nothing.has(r.id))
+      continue;
+    if (r.pr?.state === "merged" && stale.has(r.id)) {
+      out.push({
+        code: "release-pr-stale",
+        message: `${r.id}: ${r.branch} has commits since release PR #${r.pr.number} merged, so they haven't reached its default branch: raise the release PRs again (Release \u203A Raise the release PRs, or atticus change release-prs ${id} --approve).`
+      });
+      continue;
+    }
+    if (!r.pr || r.pr.state === "closed")
+      out.push({
+        code: "release-pr-missing",
+        message: `${r.id}: no release PR from ${r.branch} into its default branch${r.pr ? ` (PR #${r.pr.number} was closed)` : ""}: raise the release PRs (Release \u203A Raise the release PRs, or atticus change release-prs ${id} --approve).`
+      });
+    else if (merged && r.pr.state !== "merged")
+      out.push({
+        code: "release-pr-not-merged",
+        message: `${r.id}: release PR #${r.pr.number} is ${r.pr.state}: a person merges it on the Git host (${r.pr.url}), then Sync records it.`
+      });
+  }
+  return out;
+}
+
 // packages/changes/dist/assess.js
 var liveHandoff = (c) => c.handoffs.find((h) => h.state === "open" || h.state === "changes-requested");
+var isManualPrUrl = (url) => /^manual:\/\//i.test(url.trim());
+var manualHandoffWords = (phase) => `The ${phase} hand-off's PR isn't open yet: your Git host is manual, so opening it is a step waiting on you (atticus todo, or Home \u203A Manual steps in the app). Open it on the Git host as its step says, record its link, then sync; merging it approves the gate.`;
 async function assess(ctx, change) {
   const type = changeTypeOf(ctx, change.type);
   const footprint = await changeFootprint(ctx, change);
@@ -1770,29 +2332,32 @@ async function assess(ctx, change) {
     ...stageReasons,
     ...await checkArtifacts(ctx.root, change, due),
     ...await checkFindings(ctx.root, change, phaseFindingGates(ctx, phase)),
-    ...stageReasons.length ? [] : await checkMandatoryRounds(ctx.root, change, phaseGates(ctx, phase).filter((g) => mandatoryGates(ctx).includes(g)))
+    ...stageReasons.length ? [] : await checkMandatoryRounds(ctx.root, change, phaseGates(ctx, phase).filter((g) => mandatoryGates(ctx).includes(g))),
+    // ADR 0184: go/no-go is decided over the release PRs, each repo's change branch into its
+    // default branch, merged (unless the org pack's ci.yaml says archive.requireMergedPrs: false).
+    ...phase === "release" ? await releasePrReasons(ctx.root, change.id) : []
   ];
   const next = change.state === "returned" ? phaseState(phase) : nextState(type, phase);
-  const live = change.state === "returned" ? void 0 : liveHandoff(change);
+  const live2 = change.state === "returned" ? void 0 : liveHandoff(change);
   const reasons = [...blockers];
-  if (!live) {
+  if (!live2) {
     reasons.push({
       code: "no-handoff",
       message: `No hand-off PR yet: raise "${handoffName(type, phase)}" when the ${phase} work is done.`
     });
-  } else if (live.state === "changes-requested") {
+  } else if (live2.state === "changes-requested") {
     reasons.push({
       code: "changes-requested",
-      message: `Changes were requested on PR #${live.pr.number}; update the artifacts and hand off again.`
+      message: `Changes were requested on PR #${live2.pr.number}; update the artifacts and hand off again.`
     });
   } else {
-    const approved = prApprovers(live, live.approvals.map((a) => a.by));
+    const approved = prApprovers(live2, live2.approvals.map((a) => a.by));
     reasons.push({
       code: "pr-not-merged",
-      message: approved.length ? `PR #${live.pr.number} is approved (${approved.join(", ")}) but not merged yet: ${live.pr.url}` : `Waiting for PR #${live.pr.number} to be approved and merged on the Git host: ${live.pr.url}`
+      message: isManualPrUrl(live2.pr.url) ? manualHandoffWords(phase) : approved.length ? `PR #${live2.pr.number} is approved (${approved.join(", ")}) but not merged yet: ${live2.pr.url}` : `Waiting for PR #${live2.pr.number} to be approved and merged on the Git host: ${live2.pr.url}`
     });
   }
-  return { ...base, phase, next, ...live ? { handoff: live } : {}, blockers, reasons };
+  return { ...base, phase, next, ...live2 ? { handoff: live2 } : {}, blockers, reasons };
 }
 async function canAdvance(change, root) {
   const ctx = await loadChangeContext(root);
@@ -1809,9 +2374,15 @@ async function canAdvance(change, root) {
 async function changeReport(root, id) {
   const ctx = await loadChangeContext(root);
   const a = await assess(ctx, await changeStore(root).read(id));
-  return { ...a, nextStep: nextStep(a), problems: ctx.problems };
+  const tasks = a.phase === "build" ? await taskTicks(root, id) : void 0;
+  return { ...a, nextStep: nextStep(a, tasks), problems: ctx.problems };
+}
+async function taskTicks(root, id) {
+  const text = await readFile9(join10(changeFolder(root, id), "tasks.md"), "utf8").catch(() => "");
+  const boxes = [...text.matchAll(/^\s*[-*]\s+\[([ xX])\]/gm)].map((m) => m[1] !== " ");
+  return boxes.length ? { done: boxes.filter(Boolean).length, total: boxes.length } : void 0;
 }
-function nextStep(a) {
+function nextStep(a, tasks) {
   switch (a.state) {
     case "draft":
       return "Create the change with atticus change new.";
@@ -1825,25 +2396,34 @@ function nextStep(a) {
       return `Revise the work, then hand off ${a.phase} again.`;
   }
   const name = handoffName(a.type, a.phase);
-  if (!a.handoff)
+  if (!a.handoff) {
+    if (!a.blockers.length && tasks && tasks.done < tasks.total)
+      return `Finish the ${a.phase} work (${tasks.done} of ${tasks.total} tasks ticked in tasks.md), then raise "${name}".`;
     return a.blockers.length ? `Finish the ${a.phase} work, then raise "${name}".` : `Ready to raise "${name}".`;
+  }
   if (a.handoff.state === "changes-requested")
     return `Update the artifacts and hand off again on PR #${a.handoff.pr.number}.`;
+  if (isManualPrUrl(a.handoff.pr.url))
+    return manualHandoffWords(a.handoff.phase);
   return `Merge PR #${a.handoff.pr.number} once it is approved (${a.handoff.pr.url}); syncing then moves the change on.`;
 }
 
 // packages/changes/dist/new-change.js
-var import_yaml7 = __toESM(require_dist(), 1);
-import { mkdir, readFile as readFile8, writeFile } from "node:fs/promises";
-import { join as join9 } from "node:path";
-var nowIso = () => (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
+var import_yaml8 = __toESM(require_dist(), 1);
+import { mkdir, readFile as readFile10, writeFile as writeFile2 } from "node:fs/promises";
+import { join as join11 } from "node:path";
+var nowIso2 = () => (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
 var strip2 = (h) => h.startsWith("@") ? h.slice(1) : h;
+function windowsUnsafeName(id) {
+  return /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(\.|$)/i.test(id) || /[. ]$/.test(id);
+}
 function slugify(title) {
-  return title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80).replace(/-+$/, "");
+  const id = title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80).replace(/-+$/, "");
+  return windowsUnsafeName(id) ? `${id}-change` : id;
 }
 async function exists(path) {
   try {
-    await readFile8(path);
+    await readFile10(path);
     return true;
   } catch {
     return false;
@@ -1851,7 +2431,7 @@ async function exists(path) {
 }
 async function defaultSchema(root) {
   try {
-    const cfg = (0, import_yaml7.parse)(await readFile8(join9(openspecDirOf(root), "config.yaml"), "utf8"));
+    const cfg = (0, import_yaml8.parse)(await readFile10(join11(openspecDirOf(root), "config.yaml"), "utf8"));
     if (cfg && typeof cfg.schema === "string")
       return cfg.schema;
   } catch {
@@ -1864,26 +2444,28 @@ async function newChange(root, opts) {
   const id = opts.id ?? slugify(opts.title);
   if (!RecordId.safeParse(id).success)
     throw new ChangeError("invalid", `"${id}" can't be a change id; use a lowercase slug such as add-transfer-limit.`);
+  if (windowsUnsafeName(id))
+    throw new ChangeError("invalid", `"${id}" can't be a change id: Windows can't open a folder named that (con, nul, com1 and the like, or a name ending in a dot). Pick another, such as ${id.replace(/[. ]+$/, "").replace(/^([^.]+)/, "$1-change")}.`);
   const template = pickTemplate(ctx.templates, type.id, opts.template);
   if (!template)
     throw new ChangeError("invalid", `Unknown change template ${opts.template}. Use one of: ${ctx.templates.map((t) => t.id).join(", ")}.`);
   const store = changeStore(root);
   if (await store.tryRead(id).catch(() => true))
     throw new ChangeError("conflict", `Change ${id} already exists.`);
-  const now = opts.now ?? nowIso();
+  const now = opts.now ?? nowIso2();
   const by = strip2(opts.by);
   const dir = changeFolder(root, id);
-  if (opts.openspec && !await exists(join9(dir, ".openspec.yaml"))) {
+  if (opts.openspec && !await exists(join11(dir, ".openspec.yaml"))) {
     await opts.openspec.newChange(id, { description: opts.title });
   } else {
     await mkdir(dir, { recursive: true });
-    if (!await exists(join9(dir, ".openspec.yaml")))
-      await writeFile(join9(dir, ".openspec.yaml"), `schema: ${await defaultSchema(root)}
+    if (!await exists(join11(dir, ".openspec.yaml")))
+      await writeFile2(join11(dir, ".openspec.yaml"), `schema: ${await defaultSchema(root)}
 created: ${now.slice(0, 10)}
 `, "utf8");
   }
-  if (!await exists(join9(dir, "brief.md")))
-    await writeFileAtomic(join9(dir, "brief.md"), renderTemplate(template, {
+  if (!await exists(join11(dir, "brief.md")))
+    await writeFileAtomic(join11(dir, "brief.md"), renderTemplate(template, {
       title: opts.title,
       id,
       type: type.id,
@@ -1922,31 +2504,42 @@ created: ${now.slice(0, 10)}
 
 // packages/changes/dist/publish.js
 import { rm } from "node:fs/promises";
-import { join as join10 } from "node:path";
+import { randomUUID } from "node:crypto";
+import { join as join12, resolve } from "node:path";
 function gitHandoffPublisher(opts = {}) {
   const remote = opts.remote ?? "origin";
   const env = opts.env ?? process.env;
   return {
-    async publish({ root, branch, base, files, message, approval }) {
-      requireApproval("git", approval);
+    async publish(input) {
+      requireApproval("git", input.approval);
+      const key = resolve(input.root);
+      const before = queue.get(key) ?? Promise.resolve();
+      const mine = before.catch(() => void 0).then(() => publishOne(input));
+      queue.set(key, mine.catch(() => void 0));
+      return mine;
+    }
+  };
+  async function publishOne({ root, branch, base, files, message }) {
+    {
       const git = createGit({ env });
       const out = async (args) => (await git(args, root)).stdout.trim();
       const tryOut = (args) => out(args).catch(() => void 0);
       const gitDir = await out(["rev-parse", "--absolute-git-dir"]);
       await tryOut(["fetch", "--quiet", remote, base]);
       await tryOut(["fetch", "--quiet", remote, branch]);
-      const start = await tryOut([
+      const onRemote = await tryOut([
         "rev-parse",
         "--verify",
         "--quiet",
         `refs/remotes/${remote}/${branch}^{commit}`
-      ]) ?? await tryOut([
+      ]);
+      const start = onRemote ?? await tryOut([
         "rev-parse",
         "--verify",
         "--quiet",
         `refs/remotes/${remote}/${base}^{commit}`
       ]) ?? await out(["rev-parse", "--verify", `refs/heads/${base}^{commit}`]);
-      const index = join10(gitDir, "atticus-handoff-index");
+      const index = join12(gitDir, `atticus-handoff-index-${process.pid}-${randomUUID()}`);
       const staged = createGit({ env: { ...env, GIT_INDEX_FILE: index } });
       try {
         await staged(["read-tree", start], root);
@@ -1955,24 +2548,42 @@ function gitHandoffPublisher(opts = {}) {
         const tree = (await staged(["write-tree"], root)).stdout.trim();
         const startTree = await out(["rev-parse", `${start}^{tree}`]);
         const commit = tree === startTree ? start : await out(["commit-tree", tree, "-p", start, "-m", message]);
-        await out(["update-ref", `refs/heads/${branch}`, commit]);
         await out(["push", "--quiet", remote, `${commit}:refs/heads/${branch}`]);
-        return { commit };
+        await keepLocalBranch(out, tryOut, branch, start, commit);
+        return { commit, changed: commit !== onRemote };
       } finally {
         await rm(index, { force: true });
       }
     }
-  };
+  }
+}
+var queue = /* @__PURE__ */ new Map();
+async function keepLocalBranch(out, tryOut, branch, start, commit) {
+  const ref = `refs/heads/${branch}`;
+  const local = await tryOut(["rev-parse", "--verify", "--quiet", `${ref}^{commit}`]);
+  if (local === commit)
+    return;
+  const list = await tryOut(["worktree", "list", "--porcelain"]) ?? "";
+  if (list.split(/\r?\n/).includes(`branch ${ref}`))
+    return;
+  if (!local) {
+    await tryOut(["update-ref", ref, commit, ""]);
+    return;
+  }
+  const own = await tryOut(["rev-list", "--count", `${start}..${local}`]);
+  if (own === void 0 || own !== "0")
+    return;
+  await out(["update-ref", ref, commit, local]).catch(() => void 0);
 }
 
 // packages/changes/dist/handoff.js
-import { readdir as readdir6, readFile as readFile10 } from "node:fs/promises";
-import { join as join12 } from "node:path";
+import { readdir as readdir6, readFile as readFile12 } from "node:fs/promises";
+import { join as join14 } from "node:path";
 
 // packages/changes/dist/drafted.js
-var import_yaml8 = __toESM(require_dist(), 1);
-import { mkdir as mkdir2, readdir as readdir5, readFile as readFile9, rm as rm2 } from "node:fs/promises";
-import { dirname, join as join11, relative, sep } from "node:path";
+var import_yaml9 = __toESM(require_dist(), 1);
+import { mkdir as mkdir2, readdir as readdir5, readFile as readFile11, rm as rm2 } from "node:fs/promises";
+import { dirname, join as join13, relative, sep } from "node:path";
 var CAPTURE_SCHEMA_VERSION = 1;
 var DraftCapture = external_exports.object({
   schemaVersion: external_exports.literal(CAPTURE_SCHEMA_VERSION),
@@ -2026,7 +2637,7 @@ function draftedPath(path, step, artifacts) {
     return false;
   if (step) {
     for (const w of step.writes)
-      if (w.endsWith("/") ? path.startsWith(w) : path === w)
+      if (writeMatches(w, path))
         return !machinery(path);
     return step.artifacts.some((a) => artifactMatch(path, a));
   }
@@ -2047,7 +2658,7 @@ var sameText = (text, recorded) => sha256(text) === recorded || sha256(text.repl
 async function walk2(dir, rel = "") {
   let entries;
   try {
-    entries = await readdir5(join11(dir, rel), { withFileTypes: true });
+    entries = await readdir5(join13(dir, rel), { withFileTypes: true });
   } catch {
     return [];
   }
@@ -2192,7 +2803,7 @@ async function captureHandoff(input) {
   } else {
     const texts = await Promise.all(recorded.map(async (r) => [
       r,
-      await readFile9(join11(folder, ...r.path.split("/")), "utf8").catch(() => void 0)
+      await readFile11(join13(folder, ...r.path.split("/")), "utf8").catch(() => void 0)
     ]));
     if (texts.every(([r, t]) => t !== void 0 && sameText(t, r.sha256))) {
       from = "working-tree";
@@ -2256,10 +2867,10 @@ async function captureHandoff(input) {
     } : {}
   };
   const p = capturePaths(name);
-  await rm2(join11(folder, ...p.drafted.split("/")), { recursive: true, force: true });
-  await rm2(join11(folder, ...p.merged.split("/")), { recursive: true, force: true });
+  await rm2(join13(folder, ...p.drafted.split("/")), { recursive: true, force: true });
+  await rm2(join13(folder, ...p.merged.split("/")), { recursive: true, force: true });
   const put = async (base, rel, text) => {
-    const f = join11(folder, ...base.split("/"), ...rel.split("/"));
+    const f = join13(folder, ...base.split("/"), ...rel.split("/"));
     await mkdir2(dirname(f), { recursive: true });
     await writeFileAtomic(f, text);
   };
@@ -2268,37 +2879,37 @@ async function captureHandoff(input) {
   if (state === "captured")
     for (const [rel, t] of mergedFiles)
       await put(p.merged, rel, t);
-  await mkdir2(join11(folder, "stage"), { recursive: true });
-  await writeFileAtomic(join11(folder, ...p.capture.split("/")), HEADER + (0, import_yaml8.stringify)(capture, { lineWidth: 0 }));
+  await mkdir2(join13(folder, "stage"), { recursive: true });
+  await writeFileAtomic(join13(folder, ...p.capture.split("/")), HEADER + (0, import_yaml9.stringify)(capture, { lineWidth: 0 }));
   return { capture, file: p.capture };
 }
 async function readFolderFiles(dir) {
   const out = /* @__PURE__ */ new Map();
   for (const f of await walk2(dir))
-    out.set(f, (await readFile9(join11(dir, ...f.split("/")), "utf8")).replace(/\r\n/g, "\n"));
+    out.set(f, (await readFile11(join13(dir, ...f.split("/")), "utf8")).replace(/\r\n/g, "\n"));
   return out;
 }
 async function changeFolders(root) {
-  const base = join11(root, ...changesRelOf(root).split("/"));
+  const base = join13(root, ...changesRelOf(root).split("/"));
   const out = [];
   const list = async (dir) => (await readdir5(dir, { withFileTypes: true }).catch(() => [])).filter((e) => e.isDirectory()).map((e) => e.name).sort();
   for (const name of await list(base)) {
     if (name === "archive")
-      for (const a of await list(join11(base, "archive")))
-        out.push(join11(base, "archive", a));
+      for (const a of await list(join13(base, "archive")))
+        out.push(join13(base, "archive", a));
     else
-      out.push(join11(base, name));
+      out.push(join13(base, name));
   }
   return out;
 }
 async function readDraftPairs(root) {
   const out = [];
   for (const folder of await changeFolders(root)) {
-    const names = (await readdir5(join11(folder, "stage")).catch(() => [])).filter((f) => f.endsWith(".capture.yaml")).sort();
+    const names = (await readdir5(join13(folder, "stage")).catch(() => [])).filter((f) => f.endsWith(".capture.yaml")).sort();
     for (const f of names) {
       let capture;
       try {
-        capture = DraftCapture.parse((0, import_yaml8.parse)(await readFile9(join11(folder, "stage", f), "utf8")));
+        capture = DraftCapture.parse((0, import_yaml9.parse)(await readFile11(join13(folder, "stage", f), "utf8")));
       } catch {
         continue;
       }
@@ -2306,8 +2917,8 @@ async function readDraftPairs(root) {
       out.push({
         capture,
         folder: relative(root, folder).split(sep).join("/"),
-        drafted: await readFolderFiles(join11(folder, ...p.drafted.split("/"))),
-        merged: await readFolderFiles(join11(folder, ...p.merged.split("/")))
+        drafted: await readFolderFiles(join13(folder, ...p.drafted.split("/"))),
+        merged: await readFolderFiles(join13(folder, ...p.merged.split("/")))
       });
     }
   }
@@ -2327,8 +2938,8 @@ async function completeCaptures(root, ctx, o) {
       continue;
     for (const h of change.handoffs.filter((x) => x.state === "merged")) {
       const { name } = await captureStageOf(ctx, change, h.phase);
-      const file = join11(changeFolder(root, change.id), ...capturePaths(name).capture.split("/"));
-      const prior = await readFile9(file, "utf8").then((t) => DraftCapture.safeParse((0, import_yaml8.parse)(t)), () => void 0);
+      const file = join13(changeFolder(root, change.id), ...capturePaths(name).capture.split("/"));
+      const prior = await readFile11(file, "utf8").then((t) => DraftCapture.safeParse((0, import_yaml9.parse)(t)), () => void 0);
       if (prior?.success && prior.data.pr.number === h.pr.number && prior.data.state !== "waiting-for-merge")
         continue;
       const base = prior?.success ? prior.data.base : o.defaultBase ?? "main";
@@ -2350,7 +2961,7 @@ async function completeCaptures(root, ctx, o) {
 }
 
 // packages/changes/dist/handoff.js
-var nowIso2 = () => (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
+var nowIso3 = () => (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
 var strip3 = (h) => h.startsWith("@") ? h.slice(1) : h;
 function metarepo(ctx, repo) {
   const fromRuntime = ctx.orgPack.runtime.adapters.gitHost?.settings.metarepo;
@@ -2368,7 +2979,7 @@ async function load(root, id) {
 }
 async function walkReview(dir, gate) {
   const out = [];
-  const base = join12(dir, "review", gate);
+  const base = join14(dir, "review", gate);
   let rounds;
   try {
     rounds = (await readdir6(base)).filter((r) => /^\d+$/.test(r)).sort((a, b) => Number(a) - Number(b));
@@ -2377,7 +2988,7 @@ async function walkReview(dir, gate) {
   }
   for (const r of rounds) {
     try {
-      for (const f of (await readdir6(join12(base, r))).filter((x) => /\.ya?ml$/.test(x)).sort())
+      for (const f of (await readdir6(join14(base, r))).filter((x) => /\.ya?ml$/.test(x)).sort())
         out.push(`review/${gate}/${r}/${f}`);
     } catch {
     }
@@ -2388,12 +2999,12 @@ async function keptPairFiles(dir) {
   const out = [];
   let entries;
   try {
-    entries = await readdir6(join12(dir, "stage"), { withFileTypes: true });
+    entries = await readdir6(join14(dir, "stage"), { withFileTypes: true });
   } catch {
     return out;
   }
   const walk3 = async (rel) => {
-    for (const e of await readdir6(join12(dir, ...rel.split("/")), { withFileTypes: true }).catch(() => [])) {
+    for (const e of await readdir6(join14(dir, ...rel.split("/")), { withFileTypes: true }).catch(() => [])) {
       const p = `${rel}/${e.name}`;
       if (e.isDirectory())
         await walk3(p);
@@ -2421,18 +3032,23 @@ async function handoffFiles(ctx, a, phase) {
     for (const x of f)
       files.add(x);
   }
-  const stage = await phaseStage(ctx, a.change, phase);
-  if (stage)
-    for (const f of await stageFiles(dir, stage))
-      files.add(f);
+  const at = PHASES.indexOf(phase);
+  for (const step of ctx.policy.stages.filter((s) => PHASES.indexOf(s.phase) <= at)) {
+    if (await phaseStage(ctx, a.change, step.phase))
+      for (const f of await stageFiles(dir, step))
+        files.add(f);
+  }
+  const present = async (f) => readFile12(join14(dir, ...f.split("/"))).then(() => true, () => false);
+  for (const own of ["stage/corrections.yaml", "stage/drafted.yaml"])
+    if (await present(own))
+      files.add(own);
   if (phase === "build") {
-    for (const extra of ["tasks.md", "repos.yaml"]) {
-      try {
-        await readFile10(join12(dir, extra));
+    for (const extra of ["tasks.md", "repos.yaml"])
+      if (await present(extra))
         files.add(extra);
-      } catch {
-      }
-    }
+    for (const t of await readdir6(join14(dir, "tasks"), { withFileTypes: true }).catch(() => []))
+      if (t.isDirectory() && await present(`tasks/${t.name}/report.md`))
+        files.add(`tasks/${t.name}/report.md`);
   }
   for (const gate of phaseGates(ctx, phase))
     for (const f of await walkReview(dir, gate))
@@ -2441,6 +3057,18 @@ async function handoffFiles(ctx, a, phase) {
     files.add(f);
   return { files: [...files].sort(), artifacts };
 }
+function namesChange(command, id) {
+  const w = (command ?? "").trim().split(/\s+/);
+  if (w[0] !== "atticus")
+    return false;
+  const changeStep = w[1] === "change" || w[1] === "plan" || w[1] === "critic";
+  return changeStep && w.slice(2).includes(id);
+}
+async function changeQuestionFiles(root, id) {
+  const { questions } = await listQuestions(root, { state: "answered" });
+  const rel = questionsRelOf(root);
+  return questions.filter((q) => namesChange(q.askedBy.command, id) || namesChange(q.rerun, id)).map((q) => `${rel}/${q.id}.yaml`).sort();
+}
 function prBody(a, phase, next, paths, reviewers, review) {
   const c = a.change;
   const lines2 = [
@@ -2475,7 +3103,7 @@ async function handoff(root, id, opts) {
   requireApproval("changes", opts.approval);
   const { ctx, change } = await load(root, id);
   const repo = metarepo(ctx, opts.repo);
-  const now = opts.now ?? nowIso2();
+  const now = opts.now ?? nowIso3();
   const by = strip3(opts.by);
   const a = await assess(ctx, change);
   const phase = a.phase;
@@ -2487,7 +3115,7 @@ async function handoff(root, id, opts) {
     await requireValid(opts.openspec, id);
   const { files, artifacts } = await handoffFiles(ctx, a, phase);
   const dir = changeFolder(root, id);
-  const hashed = await Promise.all(files.map(async (path) => ({ path, sha256: sha256(await readFile10(join12(dir, path))) })));
+  const hashed = await Promise.all(files.map(async (path) => ({ path, sha256: sha256(await readFile12(join14(dir, path))) })));
   const authors = { ...change.authors };
   for (const art of artifacts) {
     const people = (opts.authors?.[art] ?? [by]).map(strip3);
@@ -2495,15 +3123,20 @@ async function handoff(root, id, opts) {
   }
   const branch = handoffBranch(id, phase);
   const rel = changesRelOf(root);
-  const metaFiles = [...files.map((f) => `${rel}/${id}/${f}`), `${rel}/${id}/change.yaml`];
+  const questionFiles = await changeQuestionFiles(root, id);
+  const metaFiles = [
+    ...files.map((f) => `${rel}/${id}/${f}`),
+    `${rel}/${id}/change.yaml`,
+    ...questionFiles
+  ];
   const reviewers = [
     ...new Set(files.flatMap((f) => ownersFor(ctx.codeowners, `${rel}/${id}/${f}`)))
   ].filter((p) => p !== by).sort();
-  const live = change.state === "returned" ? void 0 : liveHandoff(change);
-  if (live && live.phase === phase) {
-    const pr2 = await opts.gitHost.getPullRequest(repo, live.pr.number);
+  const live2 = change.state === "returned" ? void 0 : liveHandoff(change);
+  if (live2 && live2.phase === phase) {
+    const pr2 = await handoffPr(opts.gitHost, repo, id, live2);
     if (pr2.state === "open" || pr2.state === "draft") {
-      await opts.publisher?.publish({
+      const published = await opts.publisher?.publish({
         root,
         branch,
         base: pr2.base,
@@ -2511,9 +3144,11 @@ async function handoff(root, id, opts) {
         message: `${handoffName(a.type, phase)}: update`,
         approval: opts.approval
       });
-      await opts.gitHost.comment(repo, live.pr.number, `${by} updated the hand-off for another review.`, opts.approval);
+      const unchanged = published ? published.changed === false : sameArtifacts(hashed, live2.artifacts);
+      if (!unchanged)
+        await opts.gitHost.comment(repo, pr2.number, `${by} updated the hand-off for another review.`, opts.approval);
       const updated = {
-        ...live,
+        ...live2,
         state: "open",
         updatedAt: now,
         reviewers,
@@ -2523,14 +3158,21 @@ async function handoff(root, id, opts) {
       await changeStore(root).write({
         ...change,
         authors,
-        handoffs: change.handoffs.map((h2) => h2 === live ? updated : h2)
+        handoffs: change.handoffs.map((h2) => h2 === live2 ? updated : h2)
       });
       return updated;
     }
     if (pr2.state === "merged")
       throw new ChangeError("refused", `PR #${pr2.number} is already merged on the Git host; sync the change instead.`);
-    live.state = "closed";
-    live.updatedAt = now;
+    live2.state = "closed";
+    live2.updatedAt = now;
+  }
+  if (change.state === "returned") {
+    const open = (await opts.gitHost.listPullRequests(repo, { head: branch })).find((p) => p.state === "open" || p.state === "draft");
+    if (open) {
+      const message = `PR #${open.number} from ${branch} is still open on the Git host (${open.url}): close it there first (the return asked for that), then resubmit the change.`;
+      throw new ChangeError("refused", message, [{ code: "host-refused", message }]);
+    }
   }
   const base = opts.base ?? (await opts.gitHost.getRepo(repo)).defaultBranch;
   const next = a.next;
@@ -2542,13 +3184,23 @@ async function handoff(root, id, opts) {
     message: `${handoffName(a.type, phase)}: ${change.title}`,
     approval: opts.approval
   });
-  const pr = await opts.gitHost.createPullRequest({
-    repo,
-    head: branch,
-    base,
-    title: `${change.title}: ${handoffName(a.type, phase)}`,
-    body: prBody(a, phase, change.state === "returned" ? nextAfterResubmit(a, phase) : next, files.map((f) => `${rel}/${id}/${f}`), reviewers, opts.review)
-  }, opts.approval);
+  let pr;
+  try {
+    pr = await opts.gitHost.createPullRequest({
+      repo,
+      head: branch,
+      base,
+      title: `${change.title}: ${handoffName(a.type, phase)}`,
+      body: prBody(a, phase, change.state === "returned" ? nextAfterResubmit(a, phase) : next, [...files.map((f) => `${rel}/${id}/${f}`), ...questionFiles], reviewers, opts.review)
+    }, opts.approval);
+  } catch (e) {
+    if (!(e instanceof AdapterError) || e.code !== "conflict")
+      throw e;
+    const open = (await opts.gitHost.listPullRequests(repo, { head: branch }).catch(() => [])).filter((p) => p.base === base && (p.state === "open" || p.state === "draft")).at(0);
+    if (!open)
+      throw e;
+    pr = open;
+  }
   const h = {
     phase,
     branch,
@@ -2575,28 +3227,44 @@ async function handoff(root, id, opts) {
   });
   return h;
 }
+function sameArtifacts(a, b) {
+  const key = (xs) => JSON.stringify([...xs].map((x) => `${x.path} ${x.sha256}`).sort());
+  return key(a) === key(b);
+}
 function nextAfterResubmit(a, phase) {
   const next = a.type.phases[a.type.phases.indexOf(phase) + 1];
   return next ? phaseState(next) : "released";
 }
+async function handoffPr(gitHost, repo, id, live2) {
+  const branch = handoffBranch(id, live2.phase);
+  const pr = await gitHost.getPullRequest(repo, live2.pr.number);
+  if (pr.head === branch)
+    return pr;
+  const mine = await gitHost.listPullRequests(repo, { head: branch });
+  const own = mine.find((x) => x.url === live2.pr.url) ?? (mine.length === 1 ? mine[0] : void 0);
+  if (own)
+    return own;
+  const message = `PR #${live2.pr.number} on the Git host is from ${pr.head}, not ${branch}, and no PR from ${branch} was found: Atticus uses only the hand-off's own PR. Check the PR's number on the Git host (on a manual host, on its step: atticus todo), then sync again.`;
+  throw new ChangeError("refused", message, [{ code: "host-refused", message }]);
+}
 async function syncHandoff(root, id, opts) {
   const { ctx, change } = await load(root, id);
   const repo = metarepo(ctx, opts.repo);
-  const now = opts.now ?? nowIso2();
-  const live = liveHandoff(change);
-  if (!live)
+  const now = opts.now ?? nowIso3();
+  const live2 = liveHandoff(change);
+  if (!live2)
     throw new ChangeError("refused", `${id} has no open hand-off PR to sync.`, [
       { code: "no-handoff", message: `${id} has no open hand-off PR.` }
     ]);
   const a = await assess(ctx, change);
-  const pr = await opts.gitHost.getPullRequest(repo, live.pr.number);
-  const current = pr.url !== live.pr.url || pr.number !== live.pr.number ? { ...live, pr: { number: pr.number, url: pr.url } } : live;
+  const pr = await handoffPr(opts.gitHost, repo, id, live2);
+  const current = pr.url !== live2.pr.url || pr.number !== live2.pr.number ? { ...live2, pr: { number: pr.number, url: pr.url } } : live2;
   const store = changeStore(root);
   const save = async (h2, extra = {}) => {
     const updated = {
       ...change,
       ...extra,
-      handoffs: change.handoffs.map((x) => x === live ? h2 : x)
+      handoffs: change.handoffs.map((x) => x === live2 ? h2 : x)
     };
     await store.write(updated);
     return updated;
@@ -2618,7 +3286,7 @@ async function syncHandoff(root, id, opts) {
       latest.set(strip3(r.by), r.state);
   const approvers = [...latest].filter(([, s]) => s === "approved").map(([p]) => p);
   const requested = [...latest].filter(([, s]) => s === "changes-requested").map(([p]) => p).sort();
-  const counted = prApprovers(live, approvers);
+  const counted = prApprovers(live2, approvers);
   const approvals = counted.map((by) => ({ by, at: now }));
   const advance = async (by) => {
     const h2 = { ...current, state: "merged", updatedAt: now, approvals };
@@ -2631,7 +3299,7 @@ async function syncHandoff(root, id, opts) {
         at: now,
         by,
         pr: pr.number,
-        reason: `${handoffName(a.type, live.phase)} merged`
+        reason: `${handoffName(a.type, live2.phase)} merged`
       }
     ];
     let state = next;
@@ -2666,7 +3334,7 @@ async function syncHandoff(root, id, opts) {
     };
   };
   if (pr.state === "merged")
-    return advance(strip3(opts.approval?.by ?? live.by));
+    return advance(strip3(opts.approval?.by ?? live2.by));
   if (requested.length > 0) {
     const h2 = { ...current, state: "changes-requested", updatedAt: now, approvals };
     await save(h2);
@@ -2687,8 +3355,8 @@ async function syncHandoff(root, id, opts) {
   if (counted.length === 0)
     reasons.push(approvers.length > 0 ? {
       code: "self-approval",
-      person: strip3(live.by),
-      message: `PR #${pr.number} is approved only by ${strip3(live.by)}, who raised it; it needs someone else's approval.`
+      person: strip3(live2.by),
+      message: `PR #${pr.number} is approved only by ${strip3(live2.by)}, who raised it; it needs someone else's approval.`
     } : {
       code: "approval-missing",
       message: `PR #${pr.number} isn't approved yet: ask a reviewer on the Git host (${pr.url}).`
@@ -2727,19 +3395,19 @@ async function syncHandoff(root, id, opts) {
 }
 async function returnToPo(root, id, opts) {
   const { ctx, change } = await load(root, id);
-  const live = liveHandoff(change);
-  if (!live)
+  const live2 = liveHandoff(change);
+  if (!live2)
     throw new ChangeError("refused", `${id} has no open hand-off PR to return.`, [
       { code: "no-handoff", message: `${id} has no open hand-off PR.` }
     ]);
   requireApproval("changes", opts.approval);
   const repo = metarepo(ctx, opts.repo);
-  const now = opts.now ?? nowIso2();
+  const now = opts.now ?? nowIso3();
   const by = strip3(opts.by);
   const host = opts.gitHost;
-  await host.comment(repo, live.pr.number, `Returned to the product owner by ${by}: ${opts.reason}`, opts.approval);
-  const closedOnHost = host.closePullRequest ? (await host.closePullRequest(repo, live.pr.number, opts.approval)).state === "closed" : false;
-  const h = { ...live, state: "closed", updatedAt: now };
+  await host.comment(repo, live2.pr.number, `Returned to the product owner by ${by}: ${opts.reason}`, opts.approval);
+  const closedOnHost = host.closePullRequest ? (await host.closePullRequest(repo, live2.pr.number, opts.approval)).state === "closed" : false;
+  const h = { ...live2, state: "closed", updatedAt: now };
   await changeStore(root).write({
     ...change,
     state: "returned",
@@ -2750,11 +3418,11 @@ async function returnToPo(root, id, opts) {
         to: "returned",
         at: now,
         by,
-        pr: live.pr.number,
+        pr: live2.pr.number,
         reason: `Returned to the product owner (${opts.reason})`
       }
     ],
-    handoffs: change.handoffs.map((x) => x === live ? h : x)
+    handoffs: change.handoffs.map((x) => x === live2 ? h : x)
   });
   return { state: "returned", closedOnHost, handoff: h };
 }
@@ -2774,7 +3442,7 @@ async function archiveChange(root, id, opts) {
     throw new ChangeError("refused", `${id} can't be archived yet.`, a.reasons);
   if (opts.openspec)
     await requireValid(opts.openspec, id);
-  const now = opts.now ?? nowIso2();
+  const now = opts.now ?? nowIso3();
   const updated = {
     ...change,
     state: "archived",
@@ -2790,9 +3458,9 @@ async function archiveChange(root, id, opts) {
 }
 
 // packages/changes/dist/learn.js
-var import_yaml9 = __toESM(require_dist(), 1);
-import { readFile as readFile11 } from "node:fs/promises";
-import { join as join13 } from "node:path";
+var import_yaml10 = __toESM(require_dist(), 1);
+import { readFile as readFile13 } from "node:fs/promises";
+import { join as join15 } from "node:path";
 var LEARN_SCHEMA_VERSION = 1;
 var MAX_CELLS = 4e6;
 var lines = (text) => {
@@ -3139,7 +3807,7 @@ async function pairTouches(root, p) {
   let entry;
   const yaml = (t) => {
     try {
-      const v = (0, import_yaml9.parse)(t);
+      const v = (0, import_yaml10.parse)(t);
       return v && typeof v === "object" ? v : void 0;
     } catch {
       return void 0;
@@ -3181,7 +3849,7 @@ async function pairTouches(root, p) {
         flows.push(m[1]);
     }
   }
-  const change = yaml(await readFile11(join13(root, ...p.folder.split("/"), "change.yaml"), "utf8").catch(() => ""));
+  const change = yaml(await readFile13(join15(root, ...p.folder.split("/"), "change.yaml"), "utf8").catch(() => ""));
   const touches = change?.touches ?? {};
   for (const r of Array.isArray(touches.repos) ? touches.repos : [])
     if (typeof r === "string")
@@ -3274,8 +3942,8 @@ async function detectConflicts(root) {
 }
 
 // packages/changes/dist/size.js
-import { readFile as readFile12 } from "node:fs/promises";
-import { join as join14 } from "node:path";
+import { readFile as readFile14 } from "node:fs/promises";
+import { join as join16 } from "node:path";
 async function changeSize(ctx, change) {
   const type = ctx.orgPack.changeTypes.types.find((t) => t.id === change.type);
   if (!type)
@@ -3284,7 +3952,7 @@ async function changeSize(ctx, change) {
       why: "standard",
       words: `${change.type} isn't a change type in change-types.yaml, so ${change.id} takes the full path.`
     };
-  const brief = await readFile12(join14(changeFolder(ctx.root, change.id), "brief.md"), "utf8").catch(() => "");
+  const brief = await readFile14(join16(changeFolder(ctx.root, change.id), "brief.md"), "utf8").catch(() => "");
   const f = fastPathOf(type, brief);
   const gate = f.fast ? fastGateOf(type, ctx.orgPack.gates) : void 0;
   const words = {
@@ -3298,14 +3966,14 @@ async function changeSize(ctx, change) {
 }
 
 // packages/changes/dist/openspec-stores.js
-import { existsSync } from "node:fs";
-import { readFile as readFile13, writeFile as writeFile2 } from "node:fs/promises";
+import { existsSync as existsSync2 } from "node:fs";
+import { readFile as readFile15, writeFile as writeFile3 } from "node:fs/promises";
 import { homedir } from "node:os";
-import { basename, isAbsolute, join as join15, relative as relative2, resolve, sep as sep2 } from "node:path";
+import { basename, isAbsolute, join as join17, relative as relative2, resolve as resolve2, sep as sep2 } from "node:path";
 function storeDirOf(root, path) {
   if (path === "~" || path.startsWith("~/") || path.startsWith("~\\"))
-    return join15(homedir(), path.slice(2));
-  return isAbsolute(path) ? resolve(path) : resolve(root, path);
+    return join17(homedir(), path.slice(2));
+  return isAbsolute(path) ? resolve2(path) : resolve2(root, path);
 }
 function packRel(root) {
   return relative2(root, orgPackDirOf(root)).split(sep2).join("/");
@@ -3334,7 +4002,7 @@ async function storeSpecLookup(root, capability) {
 var REMOTE = /^[a-z][a-z0-9+.-]*:\/\//i;
 var SCP = /^[^/\\]+@[^:/\\]+:/;
 async function metarepoOrigin(root, git = createGit()) {
-  if (!existsSync(join15(root, ".git")))
+  if (!existsSync2(join17(root, ".git")))
     return void 0;
   try {
     const url = (await git(["remote", "get-url", "origin"], root)).stdout.trim();
@@ -3345,7 +4013,7 @@ async function metarepoOrigin(root, git = createGit()) {
     return void 0;
   }
 }
-async function referenceMetarepoIn(root, repoDir, o = {}) {
+async function referenceMetarepoIn(root, repoDir2, o = {}) {
   const { settings } = await loadOpenSpecSettings(orgPackDirOf(root));
   if (!settings.referenceInRepos)
     return { action: "off" };
@@ -3357,8 +4025,8 @@ async function referenceMetarepoIn(root, repoDir, o = {}) {
       file,
       why: marker.missing ? `this metarepo isn't an OpenSpec store yet (no ${STORE_MARKER}): run atticus upgrade --openspec-store, commit the file, then hand down again` : `this metarepo's ${STORE_MARKER} can't be read (${marker.notes.join("; ")})`
     };
-  const path = join15(repoDir, "openspec", "config.yaml");
-  const text = await readFile13(path, "utf8").catch(() => void 0);
+  const path = join17(repoDir2, "openspec", "config.yaml");
+  const text = await readFile15(path, "utf8").catch(() => void 0);
   if (text === void 0)
     return {
       action: "skipped",
@@ -3370,10 +4038,180 @@ async function referenceMetarepoIn(root, repoDir, o = {}) {
   if ("problem" in r)
     return { action: "skipped", file, why: r.problem };
   if (r.action === "added")
-    await writeFile2(path, r.text, "utf8");
+    await writeFile3(path, r.text, "utf8");
   return { action: r.action, file };
 }
 
+// packages/changes/dist/merge-record.js
+var import_yaml11 = __toESM(require_dist(), 1);
+import { isDeepStrictEqual } from "node:util";
+var HANDOFF_RANK = {
+  open: 0,
+  "changes-requested": 1,
+  closed: 2,
+  merged: 3
+};
+var Clash = class extends Error {
+  field;
+  constructor(field) {
+    super(field);
+    this.field = field;
+  }
+};
+function three(field, base, ours, theirs) {
+  if (isDeepStrictEqual(ours, theirs))
+    return ours;
+  if (base.has) {
+    if (isDeepStrictEqual(ours, base.value))
+      return theirs;
+    if (isDeepStrictEqual(theirs, base.value))
+      return ours;
+  }
+  throw new Clash(field);
+}
+function union(ours, theirs, key, pick) {
+  const out = /* @__PURE__ */ new Map();
+  for (const x of ours)
+    if (!out.has(key(x)))
+      out.set(key(x), x);
+  for (const x of theirs) {
+    const k = key(x);
+    const had = out.get(k);
+    out.set(k, had === void 0 ? x : pick ? pick(had, x) : had);
+  }
+  return [...out.values()];
+}
+var startsWith = (a, b) => b.length <= a.length && b.every((x, i) => isDeepStrictEqual(x, a[i]));
+function mergeHistory(ours, theirs) {
+  if (startsWith(ours, theirs))
+    return ours;
+  if (startsWith(theirs, ours))
+    return theirs;
+  const all = union(ours, theirs, (h) => `${h.from}>${h.to}@${h.at}`);
+  const merged = all.map((h, i) => ({ h, i })).sort((a, b) => a.h.at < b.h.at ? -1 : a.h.at > b.h.at ? 1 : a.i - b.i).map((x) => x.h);
+  let at = "draft";
+  for (const h of merged) {
+    if (h.from !== at)
+      throw new Clash("history");
+    at = h.to;
+  }
+  return merged;
+}
+function mergeHandoff(a, b) {
+  if (isDeepStrictEqual(a, b))
+    return a;
+  const when = (h) => h.updatedAt ?? h.openedAt;
+  const ra = HANDOFF_RANK[a.state];
+  const rb = HANDOFF_RANK[b.state];
+  const top = rb > ra || rb === ra && when(b) > when(a) ? b : a;
+  return { ...top, reviewers: [.../* @__PURE__ */ new Set([...a.reviewers, ...b.reviewers])] };
+}
+function mergeHandoffs(ours, theirs) {
+  const all = union(ours, theirs, (h) => `${h.phase}#${h.pr.number}`, mergeHandoff);
+  return all.map((h, i) => ({ h, i })).sort((a, b) => a.h.openedAt < b.h.openedAt ? -1 : a.h.openedAt > b.h.openedAt ? 1 : a.i - b.i).map((x) => x.h);
+}
+function byKey(field, base, ours, theirs) {
+  const out = {};
+  for (const k of [.../* @__PURE__ */ new Set([...Object.keys(ours), ...Object.keys(theirs)])]) {
+    const v = three(`${field}.${k}`, { has: base !== void 0, value: base?.[k] }, ours[k], theirs[k]);
+    if (v !== void 0)
+      out[k] = v;
+  }
+  return out;
+}
+function mergeChangeRecords(base, ours, theirs) {
+  const b = base === void 0 ? void 0 : ChangeLifecycle.parse(base);
+  const o = ChangeLifecycle.parse(ours);
+  const t = ChangeLifecycle.parse(theirs);
+  const has = b !== void 0;
+  const at = (k) => ({ has, value: b?.[k] });
+  try {
+    const history = mergeHistory(o.history, t.history);
+    const authors = {};
+    for (const k of [.../* @__PURE__ */ new Set([...Object.keys(o.authors), ...Object.keys(t.authors)])]) {
+      const key = k;
+      authors[key] = [.../* @__PURE__ */ new Set([...o.authors[key] ?? [], ...t.authors[key] ?? []])];
+    }
+    const template = three("template", at("template"), o.template, t.template);
+    const value = {
+      schemaVersion: o.schemaVersion,
+      id: three("id", at("id"), o.id, t.id),
+      title: three("title", at("title"), o.title, t.title),
+      type: three("type", at("type"), o.type, t.type),
+      ...template !== void 0 ? { template } : {},
+      state: history.length ? history.at(-1).to : three("state", at("state"), o.state, t.state),
+      owners: byKey("owners", b?.owners, o.owners, t.owners),
+      systems: three("systems", at("systems"), o.systems, t.systems),
+      touches: byKey("touches", b?.touches, o.touches, t.touches),
+      authors,
+      createdAt: three("createdAt", at("createdAt"), o.createdAt, t.createdAt),
+      createdBy: three("createdBy", at("createdBy"), o.createdBy, t.createdBy),
+      history,
+      handoffs: mergeHandoffs(o.handoffs, t.handoffs)
+    };
+    const r = ChangeLifecycle.safeParse(value);
+    if (!r.success)
+      return { ok: false, field: r.error.issues[0]?.path.map(String).join(".") || "record" };
+    return { ok: true, value: r.data };
+  } catch (e) {
+    if (e instanceof Clash)
+      return { ok: false, field: e.field };
+    throw e;
+  }
+}
+function readRecord(text) {
+  try {
+    const r = ChangeLifecycle.safeParse((0, import_yaml11.parse)(text));
+    return r.success ? r.data : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function mergeChangeText(baseText, oursText, theirsText) {
+  const ours = readRecord(oursText);
+  const theirs = readRecord(theirsText);
+  const base = baseText.trim() ? readRecord(baseText) : void 0;
+  if (!ours || !theirs || baseText.trim() && !base)
+    return void 0;
+  const r = mergeChangeRecords(base, ours, theirs);
+  return r.ok ? { ok: true, text: serializeChange(r.value) } : r;
+}
+
+// packages/changes/dist/owners.js
+var OWNER_ROLE_KEYS = [
+  "product-owner",
+  "architect",
+  "business-analyst",
+  "team-lead"
+];
+var ChangeOwnersError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ChangeOwnersError";
+  }
+};
+var strip4 = (h) => h.trim().replace(/^@/, "");
+async function setChangeOwners(root, id, owners) {
+  const store = changeStore(root);
+  const c = await store.read(id);
+  const next = { ...c.owners };
+  for (const [key, people] of Object.entries(owners)) {
+    if (!OWNER_ROLE_KEYS.includes(key))
+      throw new ChangeOwnersError(`The change page names owners for ${OWNER_ROLE_KEYS.join(", ")}, not ${key}: edit change.yaml for other roles.`);
+    const list = [...new Set(people.map(strip4).filter(Boolean))];
+    if (list.length)
+      next[key] = list;
+    else
+      delete next[key];
+  }
+  const sorted2 = Object.fromEntries(Object.entries(next).sort(([a], [b]) => a.localeCompare(b)));
+  const r = ChangeLifecycle.safeParse({ ...c, owners: sorted2 });
+  if (!r.success)
+    throw new ChangeOwnersError(`Those owners can't be written: ${r.error.issues.map((i) => i.message).join("; ")}.`);
+  await store.write(r.data);
+  return r.data;
+}
+
 export {
   ChangeError,
   readTables,
@@ -3381,6 +4219,8 @@ export {
   isFilled,
   CHANGE_POLICY_FILE,
   StageStep,
+  isWritePattern,
+  writeMatches,
   SIGNAL_FACTORS,
   ChangePolicy,
   DEFAULT_CHANGE_POLICY,
@@ -3405,6 +4245,9 @@ export {
   readCodeowners,
   loadChangeContext,
   changeTypeOf,
+  outsideSystemsOf,
+  outsideKindOf,
+  outsideWords,
   personalLevels,
   wordsOf,
   changeFootprint,
@@ -3435,10 +4278,21 @@ export {
   workProgress,
   privacyImpact,
   prApprovers,
+  RELEASE_PR_STATES,
+  RELEASE_PRS_FILE,
+  staleReleasePrs,
+  nothingToRelease,
+  raiseReleasePrs,
+  syncReleasePrs,
+  requireMergedPrs,
+  releasePrReasons,
   liveHandoff,
+  isManualPrUrl,
+  manualHandoffWords,
   assess,
   canAdvance,
   changeReport,
+  windowsUnsafeName,
   slugify,
   newChange,
   gitHandoffPublisher,
@@ -3450,6 +4304,7 @@ export {
   captureHandoff,
   readDraftPairs,
   completeCaptures,
+  namesChange,
   handoff,
   syncHandoff,
   returnToPo,
@@ -3475,5 +4330,10 @@ export {
   openspecStores,
   storeSpecLookup,
   metarepoOrigin,
-  referenceMetarepoIn
+  referenceMetarepoIn,
+  mergeChangeRecords,
+  mergeChangeText,
+  OWNER_ROLE_KEYS,
+  ChangeOwnersError,
+  setChangeOwners
 };