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

package/dist/{chunk-IOW6BF3U.js → chunk-HSZMPH5T.js}

@@ -8,20 +8,22 @@ import {
   addStoreReference,
   readStoreMarker,
   readStoreVia
-} from "./chunk-43E6XX67.js";
+} from "./chunk-D2WSW4GU.js";
 import {
   AdapterError,
   mergeBlockers,
   requireApproval
-} from "./chunk-V3UEPUHT.js";
+} from "./chunk-4KNOJC6J.js";
 import {
   outsideProfileSystems,
   readCatalog
-} from "./chunk-EZBAS5BL.js";
+} from "./chunk-4SLBCEPD.js";
 import {
+  baseClonePath,
   createGit,
-  readChangeRepos
-} from "./chunk-ZQC7MNQB.js";
+  readChangeRepos,
+  writeChangeRepos
+} from "./chunk-XOL3GFW2.js";
 import {
   ChangeArtifact,
   ChangeLifecycle,
@@ -31,6 +33,8 @@ import {
   Phase,
   RecordId,
   TestType,
+  askedGapQuestionId,
+  changeBranch,
   changesDirOf,
   changesRelOf,
   external_exports,
@@ -38,18 +42,21 @@ import {
   fastPathOf,
   handoffBranch,
   isAssistantResolution,
+  listQuestions,
   loadOpenSpecSettings,
   loadOrgPack,
   openspecDirOf,
   orgPackDirOf,
+  questionsRelOf,
   readFlow,
+  readQuestion,
   require_dist,
   specFlowFiles,
   toCanonicalYaml
-} from "./chunk-YK6CSODO.js";
+} from "./chunk-PAINMSID.js";
 import {
   writeFileAtomic
-} from "./chunk-MMB2OHUY.js";
+} from "./chunk-ODMBPDDV.js";
 import {
   __toESM
 } from "./chunk-TV45EUGM.js";
@@ -143,8 +150,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([])
 });
@@ -154,7 +164,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: []
   },
   {
@@ -162,7 +172,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"]
   },
   {
@@ -170,10 +180,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"]),
@@ -531,7 +558,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) {
@@ -554,6 +590,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 {
@@ -593,7 +631,7 @@ function changeStore(root) {
     async list() {
       let names;
       try {
-        names = (await readdir2(changesDirOf(root), { withFileTypes: true })).filter((d) => d.isDirectory() && d.name !== "archive").map((d) => d.name).sort();
+        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 [];
       }
@@ -1118,7 +1156,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) {
@@ -1131,7 +1169,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({
@@ -1159,7 +1197,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" : ""})` : ""}`,
@@ -1183,7 +1221,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]));
@@ -1439,7 +1477,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":
@@ -1495,8 +1533,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":
@@ -1505,7 +1550,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;
@@ -1515,7 +1561,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();
@@ -1607,7 +1656,7 @@ async function checkFindings(root, change, gates) {
         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({
@@ -1634,6 +1683,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;
@@ -1753,8 +1812,353 @@ 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)
+  }))
+});
+async function readNothing(root, id) {
+  const text = await readFile8(join9(changeFolder(root, id), RELEASE_PRS_FILE), "utf8").catch(() => void 0);
+  if (text === void 0)
+    return [];
+  try {
+    const r = NothingFile.safeParse((0, import_yaml7.parse)(text));
+    return r.success ? r.data.nothingToRelease : [];
+  } catch {
+    return [];
+  }
+}
+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 dirs = [join9(root, r.worktree)];
+    try {
+      dirs.push(baseClonePath(root, r.id));
+    } catch {
+    }
+    const dir = dirs.find((d) => existsSync(d));
+    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 before = await readNothing(root, id);
+  const nothing = new Map(before.map((x) => [x.repo, x]));
+  for (const r of repos) {
+    if (!live(r.pr))
+      nothing.delete(r.id);
+    if (live(r.pr)) {
+      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 = [];
+    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);
+  if (JSON.stringify(after) !== JSON.stringify(before))
+    await writeFile(join9(changeFolder(root, id), RELEASE_PRS_FILE), toCanonicalYaml(NothingFile.parse({ schemaVersion: 1, nothingToRelease: after })), "utf8");
+  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 }));
+  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;
+    }
+    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 });
+  return { change: id, rows };
+}
+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 out = [];
+  for (const r of cr.repos) {
+    if (!r.pr && nothing.has(r.id))
+      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);
@@ -1795,29 +2199,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);
@@ -1834,9 +2241,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.";
@@ -1850,25 +2263,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;
@@ -1876,7 +2298,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 {
@@ -1889,26 +2311,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,
@@ -1947,13 +2371,23 @@ 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);
@@ -1971,7 +2405,7 @@ function gitHandoffPublisher(opts = {}) {
         "--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);
@@ -1987,17 +2421,18 @@ function gitHandoffPublisher(opts = {}) {
         await rm(index, { force: true });
       }
     }
-  };
+  }
 }
+var queue = /* @__PURE__ */ new Map();
 
 // 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),
@@ -2051,7 +2486,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));
   }
@@ -2072,7 +2507,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 [];
   }
@@ -2217,7 +2652,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";
@@ -2281,10 +2716,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);
   };
@@ -2293,37 +2728,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;
       }
@@ -2331,8 +2766,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("/")))
       });
     }
   }
@@ -2352,8 +2787,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";
@@ -2375,7 +2810,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;
@@ -2393,7 +2828,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));
@@ -2402,7 +2837,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 {
     }
@@ -2413,12 +2848,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);
@@ -2446,18 +2881,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))
@@ -2466,6 +2906,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 = [
@@ -2500,7 +2952,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;
@@ -2512,7 +2964,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);
@@ -2520,13 +2972,18 @@ 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({
         root,
@@ -2536,9 +2993,9 @@ 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);
+      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,
@@ -2548,14 +3005,14 @@ 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;
   }
   const base = opts.base ?? (await opts.gitHost.getRepo(repo)).defaultBranch;
   const next = a.next;
@@ -2572,7 +3029,7 @@ async function handoff(root, id, opts) {
     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)
+    body: prBody(a, phase, change.state === "returned" ? nextAfterResubmit(a, phase) : next, [...files.map((f) => `${rel}/${id}/${f}`), ...questionFiles], reviewers, opts.review)
   }, opts.approval);
   const h = {
     phase,
@@ -2604,24 +3061,36 @@ 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;
@@ -2643,7 +3112,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 };
@@ -2656,7 +3125,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;
@@ -2691,7 +3160,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);
@@ -2712,8 +3181,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}).`
@@ -2752,19 +3221,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",
@@ -2775,11 +3244,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 };
 }
@@ -2799,7 +3268,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",
@@ -2815,9 +3284,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) => {
@@ -3164,7 +3633,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;
@@ -3206,7 +3675,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")
@@ -3299,8 +3768,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)
@@ -3309,7 +3778,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 = {
@@ -3323,14 +3792,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("/");
@@ -3359,7 +3828,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();
@@ -3382,8 +3851,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(repoDir, "openspec", "config.yaml");
+  const text = await readFile15(path, "utf8").catch(() => void 0);
   if (text === void 0)
     return {
       action: "skipped",
@@ -3395,10 +3864,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,
@@ -3406,6 +4045,8 @@ export {
   isFilled,
   CHANGE_POLICY_FILE,
   StageStep,
+  isWritePattern,
+  writeMatches,
   SIGNAL_FACTORS,
   ChangePolicy,
   DEFAULT_CHANGE_POLICY,
@@ -3463,10 +4104,20 @@ export {
   workProgress,
   privacyImpact,
   prApprovers,
+  RELEASE_PR_STATES,
+  RELEASE_PRS_FILE,
+  nothingToRelease,
+  raiseReleasePrs,
+  syncReleasePrs,
+  requireMergedPrs,
+  releasePrReasons,
   liveHandoff,
+  isManualPrUrl,
+  manualHandoffWords,
   assess,
   canAdvance,
   changeReport,
+  windowsUnsafeName,
   slugify,
   newChange,
   gitHandoffPublisher,
@@ -3478,6 +4129,7 @@ export {
   captureHandoff,
   readDraftPairs,
   completeCaptures,
+  namesChange,
   handoff,
   syncHandoff,
   returnToPo,
@@ -3503,5 +4155,10 @@ export {
   openspecStores,
   storeSpecLookup,
   metarepoOrigin,
-  referenceMetarepoIn
+  referenceMetarepoIn,
+  mergeChangeRecords,
+  mergeChangeText,
+  OWNER_ROLE_KEYS,
+  ChangeOwnersError,
+  setChangeOwners
 };