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

package/dist/{chunk-7JUKDRSZ.js → chunk-7IGKHZ4Z.js}

@@ -7,9 +7,15 @@ import {
   ManualStep,
   changesDirOf,
   external_exports,
-  require_dist,
+  orgPackDirOf,
   toCanonicalYaml
-} from "./chunk-S2A7YC3Q.js";
+} from "./chunk-Q2TECDIT.js";
+import {
+  renameRetrying
+} from "./chunk-TUULXQRW.js";
+import {
+  require_dist
+} from "./chunk-BQGDB6ZL.js";
 import {
   __toESM
 } from "./chunk-TV45EUGM.js";
@@ -116,10 +122,190 @@ function workItemsCsv(stories, o = {}) {
 `).join("");
 }
 
+// packages/adapters/dist/common.js
+var Approval = external_exports.strictObject({
+  /** The person who approved: a handle from the Git host or directory. */
+  by: external_exports.string().min(1),
+  at: external_exports.iso.datetime({ offset: true }),
+  scope: external_exports.enum(["once", "standing"]).default("once"),
+  /** What was approved, e.g. a finding, hand-off PR or artifact path. */
+  ref: external_exports.string().min(1)
+});
+var AdapterError = class extends Error {
+  adapter;
+  code;
+  retryable;
+  constructor(adapter, code, message, retryable = code === "rate-limited" || code === "unavailable") {
+    super(`${adapter}: ${message}`);
+    this.adapter = adapter;
+    this.code = code;
+    this.retryable = retryable;
+    this.name = "AdapterError";
+  }
+};
+function requireApproval(adapter, approval, opts = {}) {
+  const r = Approval.safeParse(approval);
+  if (!r.success) {
+    throw new AdapterError(adapter, "not-approved", "this write needs a person's approval (by, at, ref)");
+  }
+  if (r.data.scope === "standing" && !opts.allowStanding) {
+    throw new AdapterError(adapter, "not-approved", "a standing approval can't cover this write; it needs approval each time");
+  }
+  return r.data;
+}
+var MockBase = class {
+  name;
+  journal = [];
+  failures = [];
+  constructor(name) {
+    this.name = name;
+  }
+  failNext(code, method) {
+    this.failures.push(method === void 0 ? { code } : { code, method });
+  }
+  /** Record a call and raise an injected failure if one is due. */
+  call(method, args, approval) {
+    const i = this.failures.findIndex((f) => f.method === void 0 || f.method === method);
+    if (i !== -1) {
+      const [f] = this.failures.splice(i, 1);
+      throw new AdapterError(this.name, f.code, `injected ${f.code} on ${method}`);
+    }
+    this.journal.push(approval ? { adapter: this.name, method, args, approval } : { adapter: this.name, method, args });
+  }
+  notFound(what) {
+    throw new AdapterError(this.name, "not-found", `${what} not found`);
+  }
+};
+
+// packages/adapters/dist/git-host.js
+function mergeBlockers(pr) {
+  const out = [];
+  if (pr.state === "merged" || pr.state === "closed")
+    out.push(`the PR is ${pr.state}`);
+  if (pr.state === "draft")
+    out.push("the PR is a draft");
+  const latest = /* @__PURE__ */ new Map();
+  for (const r of pr.reviews)
+    if (r.state !== "commented")
+      latest.set(r.by, r.state);
+  if ([...latest.values()].includes("changes-requested"))
+    out.push("changes are requested");
+  const missing = pr.requiredReviewers.filter((r) => latest.get(r) !== "approved");
+  if (pr.requiredReviewers.length > 0 && missing.length === pr.requiredReviewers.length) {
+    out.push(`needs approval from ${pr.requiredReviewers.join(" or ")}`);
+  }
+  if (pr.requiredReviewers.length === 0 && ![...latest.values()].includes("approved"))
+    out.push("needs at least one approval");
+  const failing = pr.checks.filter((c) => c.status !== "passed").map((c) => `${c.name} ${c.status}`);
+  if (failing.length > 0)
+    out.push(`checks not passing: ${failing.join(", ")}`);
+  return out;
+}
+var MockGitHost = class extends MockBase {
+  repos = /* @__PURE__ */ new Map();
+  prs = /* @__PURE__ */ new Map();
+  numbers = /* @__PURE__ */ new Map();
+  constructor(repos = []) {
+    super("git-host");
+    for (const r of repos) {
+      const defaultBranch = r.defaultBranch ?? "main";
+      this.repos.set(r.repo, {
+        repo: r.repo,
+        defaultBranch,
+        protectedBranches: r.protectedBranches ?? [defaultBranch]
+      });
+    }
+  }
+  key = (repo, n) => `${repo}#${n}`;
+  async getRepo(repo) {
+    this.call("getRepo", [repo]);
+    return { ...this.repos.get(repo) ?? this.notFound(`repo ${repo}`) };
+  }
+  async getPullRequest(repo, number) {
+    this.call("getPullRequest", [repo, number]);
+    return structuredClone(this.prs.get(this.key(repo, number)) ?? this.notFound(`PR ${repo}#${number}`));
+  }
+  async listPullRequests(repo, q) {
+    this.call("listPullRequests", [repo, q]);
+    return [...this.prs.values()].filter((p2) => p2.repo === repo && (!q.head || p2.head === q.head) && (!q.state || p2.state === q.state)).map((p2) => structuredClone(p2));
+  }
+  async createPullRequest(input, approval) {
+    const a = requireApproval(this.name, approval);
+    this.call("createPullRequest", [input], a);
+    const info = this.repos.get(input.repo) ?? this.notFound(`repo ${input.repo}`);
+    if (info.protectedBranches.includes(input.head)) {
+      throw new AdapterError(this.name, "invalid", `${input.head} is protected and can't be a PR's source branch`);
+    }
+    if ([...this.prs.values()].some((p2) => p2.repo === input.repo && p2.head === input.head && (p2.state === "open" || p2.state === "draft"))) {
+      throw new AdapterError(this.name, "conflict", `an open PR from ${input.head} already exists`);
+    }
+    const n = (this.numbers.get(input.repo) ?? 0) + 1;
+    this.numbers.set(input.repo, n);
+    const pr = {
+      repo: input.repo,
+      number: n,
+      url: `https://git.example.com/${input.repo}/pull/${n}`,
+      title: input.title,
+      body: input.body,
+      head: input.head,
+      base: input.base,
+      state: input.draft ? "draft" : "open",
+      reviews: [],
+      checks: [],
+      requiredReviewers: []
+    };
+    this.prs.set(this.key(input.repo, n), pr);
+    return structuredClone(pr);
+  }
+  async comment(repo, number, body, approval) {
+    const a = requireApproval(this.name, approval);
+    this.call("comment", [repo, number, body], a);
+    if (!this.prs.has(this.key(repo, number)))
+      this.notFound(`PR ${repo}#${number}`);
+  }
+  async merge(repo, number, approval) {
+    const a = requireApproval(this.name, approval);
+    this.call("merge", [repo, number], a);
+    const pr = this.prs.get(this.key(repo, number)) ?? this.notFound(`PR ${repo}#${number}`);
+    const blockers = mergeBlockers(pr);
+    if (blockers.length > 0)
+      throw new AdapterError(this.name, "conflict", `can't merge: ${blockers.join("; ")}`);
+    pr.state = "merged";
+    return structuredClone(pr);
+  }
+  async closePullRequest(repo, number, approval) {
+    const a = requireApproval(this.name, approval);
+    this.call("closePullRequest", [repo, number], a);
+    const pr = this.prs.get(this.key(repo, number)) ?? this.notFound(`PR ${repo}#${number}`);
+    if (pr.state === "merged")
+      throw new AdapterError(this.name, "conflict", `PR ${number} is merged and can't be closed`);
+    pr.state = "closed";
+    return structuredClone(pr);
+  }
+  /** Test helpers: what reviewers and CI would do on the host. */
+  review(repo, number, by, state) {
+    (this.prs.get(this.key(repo, number)) ?? this.notFound(`PR ${repo}#${number}`)).reviews.push({
+      by,
+      state
+    });
+  }
+  setChecks(repo, number, checks) {
+    (this.prs.get(this.key(repo, number)) ?? this.notFound(`PR ${repo}#${number}`)).checks = checks;
+  }
+  requireReviewers(repo, number, reviewers) {
+    (this.prs.get(this.key(repo, number)) ?? this.notFound(`PR ${repo}#${number}`)).requiredReviewers = reviewers;
+  }
+  markReady(repo, number) {
+    const pr = this.prs.get(this.key(repo, number)) ?? this.notFound(`PR ${repo}#${number}`);
+    if (pr.state === "draft")
+      pr.state = "open";
+  }
+};
+
 // packages/adapters/dist/manual/steps.js
 var import_yaml = __toESM(require_dist(), 1);
 import { createHash } from "node:crypto";
-import { mkdir, readdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
+import { mkdir, readdir, readFile, rm, stat, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 var LEADING = [
   "schemaVersion",
@@ -170,7 +356,7 @@ async function writeAtomic(path, text) {
   const tmp = `${path}.tmp`;
   try {
     await writeFile(tmp, text, "utf8");
-    await rename(tmp, path);
+    await renameRetrying(tmp, path);
   } catch (e) {
     await rm(tmp, { force: true });
     throw e;
@@ -456,186 +642,6 @@ function exportStep(step, format) {
   };
 }
 
-// packages/adapters/dist/common.js
-var Approval = external_exports.strictObject({
-  /** The person who approved: a handle from the Git host or directory. */
-  by: external_exports.string().min(1),
-  at: external_exports.iso.datetime({ offset: true }),
-  scope: external_exports.enum(["once", "standing"]).default("once"),
-  /** What was approved, e.g. a finding, hand-off PR or artifact path. */
-  ref: external_exports.string().min(1)
-});
-var AdapterError = class extends Error {
-  adapter;
-  code;
-  retryable;
-  constructor(adapter, code, message, retryable = code === "rate-limited" || code === "unavailable") {
-    super(`${adapter}: ${message}`);
-    this.adapter = adapter;
-    this.code = code;
-    this.retryable = retryable;
-    this.name = "AdapterError";
-  }
-};
-function requireApproval(adapter, approval, opts = {}) {
-  const r = Approval.safeParse(approval);
-  if (!r.success) {
-    throw new AdapterError(adapter, "not-approved", "this write needs a person's approval (by, at, ref)");
-  }
-  if (r.data.scope === "standing" && !opts.allowStanding) {
-    throw new AdapterError(adapter, "not-approved", "a standing approval can't cover this write; it needs approval each time");
-  }
-  return r.data;
-}
-var MockBase = class {
-  name;
-  journal = [];
-  failures = [];
-  constructor(name) {
-    this.name = name;
-  }
-  failNext(code, method) {
-    this.failures.push(method === void 0 ? { code } : { code, method });
-  }
-  /** Record a call and raise an injected failure if one is due. */
-  call(method, args, approval) {
-    const i = this.failures.findIndex((f) => f.method === void 0 || f.method === method);
-    if (i !== -1) {
-      const [f] = this.failures.splice(i, 1);
-      throw new AdapterError(this.name, f.code, `injected ${f.code} on ${method}`);
-    }
-    this.journal.push(approval ? { adapter: this.name, method, args, approval } : { adapter: this.name, method, args });
-  }
-  notFound(what) {
-    throw new AdapterError(this.name, "not-found", `${what} not found`);
-  }
-};
-
-// packages/adapters/dist/git-host.js
-function mergeBlockers(pr) {
-  const out = [];
-  if (pr.state === "merged" || pr.state === "closed")
-    out.push(`the PR is ${pr.state}`);
-  if (pr.state === "draft")
-    out.push("the PR is a draft");
-  const latest = /* @__PURE__ */ new Map();
-  for (const r of pr.reviews)
-    if (r.state !== "commented")
-      latest.set(r.by, r.state);
-  if ([...latest.values()].includes("changes-requested"))
-    out.push("changes are requested");
-  const missing = pr.requiredReviewers.filter((r) => latest.get(r) !== "approved");
-  if (pr.requiredReviewers.length > 0 && missing.length === pr.requiredReviewers.length) {
-    out.push(`needs approval from ${pr.requiredReviewers.join(" or ")}`);
-  }
-  if (pr.requiredReviewers.length === 0 && ![...latest.values()].includes("approved"))
-    out.push("needs at least one approval");
-  const failing = pr.checks.filter((c) => c.status !== "passed").map((c) => `${c.name} ${c.status}`);
-  if (failing.length > 0)
-    out.push(`checks not passing: ${failing.join(", ")}`);
-  return out;
-}
-var MockGitHost = class extends MockBase {
-  repos = /* @__PURE__ */ new Map();
-  prs = /* @__PURE__ */ new Map();
-  numbers = /* @__PURE__ */ new Map();
-  constructor(repos = []) {
-    super("git-host");
-    for (const r of repos) {
-      const defaultBranch = r.defaultBranch ?? "main";
-      this.repos.set(r.repo, {
-        repo: r.repo,
-        defaultBranch,
-        protectedBranches: r.protectedBranches ?? [defaultBranch]
-      });
-    }
-  }
-  key = (repo, n) => `${repo}#${n}`;
-  async getRepo(repo) {
-    this.call("getRepo", [repo]);
-    return { ...this.repos.get(repo) ?? this.notFound(`repo ${repo}`) };
-  }
-  async getPullRequest(repo, number) {
-    this.call("getPullRequest", [repo, number]);
-    return structuredClone(this.prs.get(this.key(repo, number)) ?? this.notFound(`PR ${repo}#${number}`));
-  }
-  async listPullRequests(repo, q) {
-    this.call("listPullRequests", [repo, q]);
-    return [...this.prs.values()].filter((p2) => p2.repo === repo && (!q.head || p2.head === q.head) && (!q.state || p2.state === q.state)).map((p2) => structuredClone(p2));
-  }
-  async createPullRequest(input, approval) {
-    const a = requireApproval(this.name, approval);
-    this.call("createPullRequest", [input], a);
-    const info = this.repos.get(input.repo) ?? this.notFound(`repo ${input.repo}`);
-    if (info.protectedBranches.includes(input.head)) {
-      throw new AdapterError(this.name, "invalid", `${input.head} is protected and can't be a PR's source branch`);
-    }
-    if ([...this.prs.values()].some((p2) => p2.repo === input.repo && p2.head === input.head && (p2.state === "open" || p2.state === "draft"))) {
-      throw new AdapterError(this.name, "conflict", `an open PR from ${input.head} already exists`);
-    }
-    const n = (this.numbers.get(input.repo) ?? 0) + 1;
-    this.numbers.set(input.repo, n);
-    const pr = {
-      repo: input.repo,
-      number: n,
-      url: `https://git.example.com/${input.repo}/pull/${n}`,
-      title: input.title,
-      body: input.body,
-      head: input.head,
-      base: input.base,
-      state: input.draft ? "draft" : "open",
-      reviews: [],
-      checks: [],
-      requiredReviewers: []
-    };
-    this.prs.set(this.key(input.repo, n), pr);
-    return structuredClone(pr);
-  }
-  async comment(repo, number, body, approval) {
-    const a = requireApproval(this.name, approval);
-    this.call("comment", [repo, number, body], a);
-    if (!this.prs.has(this.key(repo, number)))
-      this.notFound(`PR ${repo}#${number}`);
-  }
-  async merge(repo, number, approval) {
-    const a = requireApproval(this.name, approval);
-    this.call("merge", [repo, number], a);
-    const pr = this.prs.get(this.key(repo, number)) ?? this.notFound(`PR ${repo}#${number}`);
-    const blockers = mergeBlockers(pr);
-    if (blockers.length > 0)
-      throw new AdapterError(this.name, "conflict", `can't merge: ${blockers.join("; ")}`);
-    pr.state = "merged";
-    return structuredClone(pr);
-  }
-  async closePullRequest(repo, number, approval) {
-    const a = requireApproval(this.name, approval);
-    this.call("closePullRequest", [repo, number], a);
-    const pr = this.prs.get(this.key(repo, number)) ?? this.notFound(`PR ${repo}#${number}`);
-    if (pr.state === "merged")
-      throw new AdapterError(this.name, "conflict", `PR ${number} is merged and can't be closed`);
-    pr.state = "closed";
-    return structuredClone(pr);
-  }
-  /** Test helpers: what reviewers and CI would do on the host. */
-  review(repo, number, by, state) {
-    (this.prs.get(this.key(repo, number)) ?? this.notFound(`PR ${repo}#${number}`)).reviews.push({
-      by,
-      state
-    });
-  }
-  setChecks(repo, number, checks) {
-    (this.prs.get(this.key(repo, number)) ?? this.notFound(`PR ${repo}#${number}`)).checks = checks;
-  }
-  requireReviewers(repo, number, reviewers) {
-    (this.prs.get(this.key(repo, number)) ?? this.notFound(`PR ${repo}#${number}`)).requiredReviewers = reviewers;
-  }
-  markReady(repo, number) {
-    const pr = this.prs.get(this.key(repo, number)) ?? this.notFound(`PR ${repo}#${number}`);
-    if (pr.state === "draft")
-      pr.state = "open";
-  }
-};
-
 // packages/adapters/dist/read-only.js
 var MockWiki = class extends MockBase {
   pages = /* @__PURE__ */ new Map();
@@ -845,6 +851,11 @@ var MockWorkTracker = class _MockWorkTracker extends MockBase {
   }
 };
 
+// packages/adapters/dist/manual/git-host.js
+var import_yaml2 = __toESM(require_dist(), 1);
+import { readdir as readdir2, readFile as readFile2 } from "node:fs/promises";
+import { join as join2 } from "node:path";
+
 // packages/adapters/dist/manual/base.js
 var nowIso2 = () => (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
 var PROVISIONAL = "manual:";
@@ -914,38 +925,98 @@ function changeOfBranch(branch) {
   const m = /^(?:handoff|task|change)\/([a-z0-9][a-z0-9._-]*)(?:\/|$)/.exec(branch);
   return m?.[1];
 }
+var localOf = (open) => Number(open.inputs.number);
+function recordedOf(open) {
+  const n = open.state === "done" ? Number(open.recorded?.values.number) : NaN;
+  return Number.isInteger(n) && n > 0 ? n : void 0;
+}
+var prName = (open) => {
+  const n = recordedOf(open);
+  return n ? `PR #${n}` : `the PR from ${String(open.inputs.head)}`;
+};
+var prSlug = (verb, open) => `${verb}-pr-${String(open.inputs.head)}`;
 var ManualGitHost = class extends ManualBase {
   constructor(opts) {
     super("git-host", "git-host", opts);
   }
+  /**
+   * Review round 48: the repo's own default branch, not one for every repo. A per-repo setting
+   * (`defaultBranch.<repo>`) first, then the repo's `defaultBranch` in the repos manifest (ADR
+   * 0123: the baseline the PRs build on), then the adapter's `defaultBranch` setting, else main.
+   * Its protected branches (`protectedBranches.<repo>`, else `protectedBranches`) always include
+   * the default branch.
+   */
   async getRepo(repo) {
     this.journal.push({ method: "getRepo" });
-    const defaultBranch = this.setting("defaultBranch") ?? "main";
+    const defaultBranch = this.setting(`defaultBranch.${repo}`) ?? await this.manifestDefault(repo) ?? this.setting("defaultBranch") ?? "main";
+    const listed = this.settingList(`protectedBranches.${repo}`) ?? this.settingList("protectedBranches") ?? [];
     return {
       repo,
       defaultBranch,
-      protectedBranches: this.settingList("protectedBranches") ?? [defaultBranch]
+      protectedBranches: listed.includes(defaultBranch) ? listed : [...listed, defaultBranch]
     };
   }
+  /** The defaultBranch a repos manifest of the metarepo's org pack gives the repo, when one does. */
+  async manifestDefault(repo) {
+    if (!this.opts.root)
+      return void 0;
+    const profiles = join2(orgPackDirOf(this.opts.root), "profiles");
+    const names = await readdir2(profiles, { withFileTypes: true }).then((d) => d.filter((x) => x.isDirectory()).map((x) => x.name).sort(), () => []);
+    for (const name of names) {
+      const text = await readFile2(join2(profiles, name, "repos.manifest.yaml"), "utf8").catch(() => void 0);
+      if (text === void 0)
+        continue;
+      let doc;
+      try {
+        doc = (0, import_yaml2.parse)(text);
+      } catch {
+        continue;
+      }
+      const repos = doc?.repos;
+      if (!Array.isArray(repos))
+        continue;
+      const entry = repos.find((r) => r?.id === repo);
+      if (!entry)
+        continue;
+      return typeof entry.defaultBranch === "string" && entry.defaultBranch.trim() ? entry.defaultBranch.trim() : void 0;
+    }
+    return void 0;
+  }
   async prSteps(repo) {
     return (await this.opts.store.list({ system: "git-host", action: "open-pull-request" })).filter((s) => !repo || s.inputs.repo === repo);
   }
-  async related(repo, number, action) {
+  /** The steps of one PR, by the number Atticus gave it (which never changes). */
+  async related(open, action) {
+    const repo = String(open.inputs.repo);
+    const number = localOf(open);
     return (await this.opts.store.list({ system: "git-host", action })).filter((s) => s.inputs.repo === repo && s.inputs.number === number);
   }
+  /**
+   * Review round 44: the number the PR goes by. The recorded one, unless it is the number Atticus
+   * gave another PR in the repo, or one recorded for another PR too: then the number Atticus gave
+   * it, so no number a caller holds ever names two PRs (new numbers skip recorded ones).
+   */
+  async numberOf(open) {
+    const local = localOf(open);
+    const rec = recordedOf(open);
+    if (rec === void 0 || rec === local)
+      return local;
+    const others = (await this.prSteps(String(open.inputs.repo))).filter((s) => s.id !== open.id);
+    return others.some((s) => localOf(s) === rec || recordedOf(s) === rec) ? local : rec;
+  }
   async toPr(open) {
     const repo = String(open.inputs.repo);
-    const number = Number(open.inputs.number);
+    const number = localOf(open);
     const rec = open.state === "done" ? open.recorded?.values : void 0;
-    const merged = (await this.related(repo, number, "merge-pull-request")).some((s) => s.state === "done");
-    const reports = (await this.related(repo, number, "report-pull-request")).filter((s) => s.state === "done").sort((a, b) => a.recorded.at < b.recorded.at ? -1 : 1);
+    const reports = (await this.related(open, "report-pull-request")).filter((s) => s.state === "done").sort((a, b) => a.recorded.at < b.recorded.at ? -1 : 1);
+    const merged = (await this.related(open, "merge-pull-request")).some((s) => s.state === "done") || reports.some((s) => s.recorded?.values.merged === true);
     const last = reports.at(-1)?.recorded?.values;
     const list = (v) => Array.isArray(v) ? v.map(String) : [];
     const reviews = [
       ...list(last?.approvers).map((by) => ({ by, state: "approved" })),
       ...list(last?.changesRequestedBy).map((by) => ({ by, state: "changes-requested" }))
     ];
-    const closed = (await this.related(repo, number, "close-pull-request")).some((s) => s.state === "done");
+    const closed = (await this.related(open, "close-pull-request")).some((s) => s.state === "done");
     let state = open.state === "done" ? open.inputs.draft ? "draft" : "open" : "draft";
     if (open.state === "skipped" || closed)
       state = "closed";
@@ -953,7 +1024,7 @@ var ManualGitHost = class extends ManualBase {
       state = "merged";
     return {
       repo,
-      number,
+      number: await this.numberOf(open),
       url: typeof rec?.url === "string" ? rec.url : `manual://git-host/${repo}/pull/${number}`,
       title: String(open.inputs.title ?? ""),
       body: open.fields.find((f) => f.name === "Description")?.value ?? "",
@@ -965,13 +1036,56 @@ var ManualGitHost = class extends ManualBase {
       requiredReviewers: []
     };
   }
+  /**
+   * The PR by the number Atticus gave it (which a caller may have kept from before the person
+   * recorded the real one, and which no other PR in the repo has), else by the recorded number
+   * it goes by (numberOf). Review round 44: a recorded number equal to another PR's own number
+   * finds that other PR, never this one, so a caller can't be handed another change's PR.
+   */
   async find(repo, number) {
-    const s = (await this.prSteps(repo)).find((x) => x.inputs.number === number);
-    return s ?? this.notFound(`PR ${repo}#${number}`, "no manual step opened it");
+    const all = await this.prSteps(repo);
+    const local = all.find((x) => localOf(x) === number);
+    if (local)
+      return local;
+    for (const x of all)
+      if (await this.numberOf(x) === number)
+        return x;
+    if (all.filter((x) => recordedOf(x) === number).length > 1)
+      throw new AdapterError(this.name, "conflict", `#${number} was recorded for more than one pull request in ${repo}: correct the number on the step of the one it isn't (atticus todo), or use the number Atticus gave it`);
+    return this.notFound(`PR ${repo}#${number}`, "no manual step opened it");
   }
   async getPullRequest(repo, number) {
     this.journal.push({ method: "getPullRequest" });
-    return this.toPr(await this.find(repo, number));
+    const open = await this.find(repo, number);
+    const pr = await this.toPr(open);
+    await this.settle(open, pr);
+    return pr;
+  }
+  /**
+   * Keeps a PR's steps in step with what was recorded: a reviews step still open on a PR that
+   * reads merged or closed is skipped, saying why; a task's PR open on the host, with its reviews
+   * recorded but not its merge, gets a step to record that it merged (a task's PR has no gate to
+   * make a Merge step; a hand-off's gets one when it syncs). Steps only: nothing is sent.
+   */
+  async settle(open, pr) {
+    const waiting = (await this.related(open, "report-pull-request")).filter((s) => s.state === "open");
+    if (pr.state === "merged" || pr.state === "closed") {
+      for (const s of waiting)
+        await recordStep(this.opts.store, s.id, {
+          by: "atticus",
+          at: this.now(),
+          skip: true,
+          note: `${prName(open)} is ${pr.state} on the Git host: nothing left to record.`
+        });
+      return;
+    }
+    if (pr.state !== "open" || waiting.length > 0)
+      return;
+    if (!String(open.inputs.head).startsWith("task/"))
+      return;
+    if ((await this.related(open, "merge-pull-request")).some((s) => s.state === "open"))
+      return;
+    await this.askForReviews(open, open.change);
   }
   async listPullRequests(repo, q) {
     this.journal.push({ method: "listPullRequests" });
@@ -986,15 +1100,16 @@ var ManualGitHost = class extends ManualBase {
   /** A report step for the PR's reviews and checks, unless one is still open. */
   async askForReviews(open, change) {
     const repo = String(open.inputs.repo);
-    const number = Number(open.inputs.number);
-    const reports = await this.related(repo, number, "report-pull-request");
+    const number = localOf(open);
+    const reports = await this.related(open, "report-pull-request");
     if (reports.some((s) => s.state === "open"))
       return;
+    const again = reports.some((s) => s.state === "done") && recordedOf(open) !== void 0;
     await this.step("report", {
-      slug: `report-pr-${number}`,
+      slug: prSlug("report", open),
       action: "report-pull-request",
       key: `git-host|report|${repo}|${number}|${reports.length}`,
-      title: `Record the reviews and checks on PR ${number} (${open.inputs.title})`,
+      title: again ? `Record that ${prName(open)} (${open.inputs.title}) merged, or its reviews again` : `Record the reviews and checks on ${prName(open)} (${open.inputs.title}), and whether it merged`,
       where: `Git host: ${repo}, the pull request opened for step ${open.id}`,
       ...change ? { change } : {},
       inputs: { repo, number },
@@ -1004,7 +1119,8 @@ var ManualGitHost = class extends ManualBase {
       ],
       instructions: [
         "Once reviewers have acted, record who approved, who asked for changes and whether the checks pass.",
-        "Name people by their handle on the Git host. Only what is recorded here counts for approval."
+        "Name people by their handle on the Git host. Only what is recorded here counts for approval.",
+        "Once it is merged on the Git host, record Merged on the Git host: yes here, and Atticus reads it as merged."
       ],
       result: [
         { name: "approvers", label: "Approved by", format: "handles", required: false },
@@ -1014,7 +1130,8 @@ var ManualGitHost = class extends ManualBase {
           format: "handles",
           required: false
         },
-        { name: "checksPassing", label: "All checks pass", format: "yes-no", required: true }
+        { name: "checksPassing", label: "All checks pass", format: "yes-no", required: true },
+        { name: "merged", label: "Merged on the Git host", format: "yes-no", required: false }
       ],
       dependsOn: [open.id]
     });
@@ -1032,14 +1149,15 @@ var ManualGitHost = class extends ManualBase {
       if (pr.state === "open" || pr.state === "draft")
         throw new AdapterError(this.name, "conflict", `an open PR from ${input.head} already exists`);
     }
-    const number = existing.reduce((n, s) => Math.max(n, Number(s.inputs.number)), 0) + 1;
+    const number = existing.reduce((n, s) => Math.max(n, localOf(s), recordedOf(s) ?? 0), 0) + 1;
     const change = this.opts.change ?? changeOfBranch(input.head);
     const proc = this.procedureFor("open-pull-request");
     const open = await this.step("createPullRequest", {
       slug: `open-pr-${input.head}`,
       action: "open-pull-request",
       key: `git-host|pr|${input.repo}|${input.head}|${number}`,
-      title: `Open a pull request from ${input.head} into ${input.base}`,
+      // Ninth UX walk: the release PRs of three repos had one title on Home; the repo tells them apart.
+      title: `Open a pull request in ${input.repo} from ${input.head} into ${input.base}`,
       where: `Git host: ${input.repo}, new pull request`,
       ...change ? { change } : {},
       ...proc ?? {},
@@ -1077,13 +1195,13 @@ var ManualGitHost = class extends ManualBase {
     const open = await this.find(repo, number);
     const change = open.change;
     await this.step("comment", {
-      slug: `comment-pr-${number}`,
+      slug: prSlug("comment", open),
       action: "comment-pull-request",
-      key: `git-host|comment|${repo}|${number}|${shortHash(body)}`,
-      title: `Post a comment on PR ${number} (${open.inputs.title})`,
+      key: `git-host|comment|${repo}|${localOf(open)}|${shortHash(body)}`,
+      title: `Post a comment on ${prName(open)} (${open.inputs.title})`,
       where: `Git host: ${repo}, the pull request opened for step ${open.id}`,
       ...change ? { change } : {},
-      inputs: { repo, number },
+      inputs: { repo, number: localOf(open) },
       fields: [{ name: "Comment", value: body }],
       instructions: ["Post the comment below on the pull request."],
       dependsOn: [open.id]
@@ -1104,13 +1222,13 @@ var ManualGitHost = class extends ManualBase {
     if (pr.state === "closed")
       return pr;
     await this.step("closePullRequest", {
-      slug: `close-pr-${number}`,
+      slug: prSlug("close", open),
       action: "close-pull-request",
-      key: `git-host|close|${repo}|${number}`,
-      title: `Close PR ${number} (${open.inputs.title}) without merging`,
+      key: `git-host|close|${repo}|${localOf(open)}`,
+      title: `Close ${prName(open)} (${open.inputs.title}) without merging`,
       where: `Git host: ${repo}, ${pr.url}`,
       ...open.change ? { change: open.change } : {},
-      inputs: { repo, number },
+      inputs: { repo, number: localOf(open) },
       fields: [{ name: "Pull request", value: pr.url }],
       instructions: [
         "The change went back to the product owner: close the pull request on the Git host without merging it, then mark this step done."
@@ -1128,19 +1246,21 @@ var ManualGitHost = class extends ManualBase {
     const blockers = mergeBlockers(pr);
     if (blockers.length > 0)
       throw new AdapterError(this.name, "conflict", `can't merge: ${blockers.join("; ")}`);
+    const recorder = (await this.related(open, "report-pull-request")).filter((s) => s.state === "done" && s.recorded).sort((a2, b) => a2.recorded.at < b.recorded.at ? -1 : 1).at(-1)?.recorded?.by;
+    const approvedBy = pr.reviews.filter((r) => r.state === "approved").map((r) => r.by).join(", ");
     const step = await this.step("merge", {
-      slug: `merge-pr-${number}`,
+      slug: prSlug("merge", open),
       action: "merge-pull-request",
-      key: `git-host|merge|${repo}|${number}`,
-      title: `Merge PR ${number} (${open.inputs.title}) on the Git host`,
+      key: `git-host|merge|${repo}|${localOf(open)}`,
+      title: `Merge ${prName(open)} (${open.inputs.title}) on the Git host`,
       where: `Git host: ${repo}, ${pr.url}`,
       ...open.change ? { change: open.change } : {},
-      inputs: { repo, number },
+      inputs: { repo, number: localOf(open) },
       fields: [
         { name: "Pull request", value: pr.url },
         {
           name: "Approved by",
-          value: pr.reviews.filter((r) => r.state === "approved").map((r) => r.by).join(", ")
+          value: approvedBy && recorder ? `${approvedBy} (recorded by ${recorder})` : approvedBy
         }
       ],
       instructions: [
@@ -1150,16 +1270,16 @@ var ManualGitHost = class extends ManualBase {
       result: [{ name: "mergedBy", label: "Merged by", format: "handles", required: false }],
       dependsOn: [open.id]
     }, a);
-    throw new AdapterError(this.name, "unavailable", `a person merges PR ${number} on the Git host: do step ${step.id} (atticus todo), then sync again`, false);
+    throw new AdapterError(this.name, "unavailable", `a person merges ${prName(open)} on the Git host: do step ${step.id} (atticus todo), then sync again`, false);
   }
 };
 
 // packages/adapters/dist/manual/read-only.js
-import { readdir as readdir2, readFile as readFile2, stat as stat2 } from "node:fs/promises";
-import { isAbsolute, join as join2, relative, sep } from "node:path";
+import { readdir as readdir3, readFile as readFile3, stat as stat2 } from "node:fs/promises";
+import { isAbsolute, join as join3, relative, sep } from "node:path";
 function folder(opts, value, fallback) {
   const v = value ?? fallback;
-  return isAbsolute(v) ? v : join2(opts.root ?? ".", v);
+  return isAbsolute(v) ? v : join3(opts.root ?? ".", v);
 }
 var ManualWiki = class extends ManualBase {
   constructor(opts) {
@@ -1174,19 +1294,19 @@ var ManualWiki = class extends ManualBase {
     const walk = async (d) => {
       let entries;
       try {
-        entries = await readdir2(d, { withFileTypes: true });
+        entries = await readdir3(d, { withFileTypes: true });
       } catch {
         return;
       }
       for (const e of entries.sort((a, b) => a.name < b.name ? -1 : 1)) {
         if (e.name.startsWith("."))
           continue;
-        const full = join2(d, e.name);
+        const full = join3(d, e.name);
         if (e.isDirectory())
           await walk(full);
-        else if (/\.(md|markdown)$/i.test(e.name)) {
+        else if (e.isFile() && /\.(md|markdown)$/i.test(e.name)) {
           const id = relative(root, full).split(sep).join("/");
-          const body = await readFile2(full, "utf8");
+          const body = await readFile3(full, "utf8");
           const title = /^#\s+(.+)$/m.exec(body)?.[1]?.trim() ?? e.name.replace(/\.(md|markdown)$/i, "");
           out.push({
             id,
@@ -1227,7 +1347,7 @@ var ManualDesignTool = class extends ManualBase {
   async getFile(key) {
     this.journal.push({ method: "getFile" });
     try {
-      return JSON.parse(await readFile2(join2(this.dir(), `${key}.json`), "utf8"));
+      return JSON.parse(await readFile3(join3(this.dir(), `${key}.json`), "utf8"));
     } catch {
       return this.notFound(`design file ${key}`, `export it as ${key}.json into ${this.dir()}`);
     }
@@ -1235,7 +1355,7 @@ var ManualDesignTool = class extends ManualBase {
   async renderFrame(key, frameId) {
     this.journal.push({ method: "renderFrame" });
     try {
-      return new Uint8Array(await readFile2(join2(this.dir(), key, `${frameId}.png`)));
+      return new Uint8Array(await readFile3(join3(this.dir(), key, `${frameId}.png`)));
     } catch {
       return this.notFound(`frame ${frameId}`, `export it as ${key}/${frameId}.png into ${this.dir()}`);
     }
@@ -1714,6 +1834,7 @@ export {
   requireApproval,
   workItemsCsv,
   mergeBlockers,
+  MockGitHost,
   fileStepStore,
   checkResult,
   StepError,