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

package/dist/{chunk-LU4MQVAL.js → chunk-Q4K5WB2W.js}

@@ -15,16 +15,17 @@ import {
   inAcpSession,
   proposalsSnapshot,
   undoBatch
-} from "./chunk-UYLBRRFK.js";
-import "./chunk-THN26IEF.js";
-import "./chunk-Q46QDDMF.js";
-import "./chunk-TGVVUKTG.js";
-import "./chunk-JYMIB5XY.js";
-import "./chunk-TWQRPM76.js";
-import "./chunk-XOL3GFW2.js";
-import "./chunk-7AB6OWTV.js";
-import "./chunk-PAINMSID.js";
-import "./chunk-ODMBPDDV.js";
+} from "./chunk-DCZWQLYT.js";
+import "./chunk-S7FCV7S5.js";
+import "./chunk-2F4CYZKJ.js";
+import "./chunk-LO6P2VYG.js";
+import "./chunk-CXJ6FUKN.js";
+import "./chunk-CQDGOPGH.js";
+import "./chunk-3NFFJL5D.js";
+import "./chunk-PKBHS4AA.js";
+import "./chunk-Q2TECDIT.js";
+import "./chunk-TUULXQRW.js";
+import "./chunk-BQGDB6ZL.js";
 import "./chunk-TV45EUGM.js";
 export {
   DecideError,

package/dist/{chunk-ECLXZWAG.js → chunk-Q6DFNVRJ.js}

@@ -7,18 +7,20 @@ import {
   diagramLibrary,
   diagramRender,
   loadCatalog
-} from "./chunk-5QUOPNLN.js";
-import "./chunk-4SLBCEPD.js";
-import "./chunk-64AADMTW.js";
-import "./chunk-JYMIB5XY.js";
-import "./chunk-CPK7QSBG.js";
-import "./chunk-YO2PKTXT.js";
-import "./chunk-TWQRPM76.js";
-import "./chunk-XOL3GFW2.js";
-import "./chunk-QHJJMZLX.js";
-import "./chunk-7AB6OWTV.js";
-import "./chunk-PAINMSID.js";
-import "./chunk-ODMBPDDV.js";
+} from "./chunk-OHNCWBKF.js";
+import "./chunk-J2JAKCIW.js";
+import "./chunk-745DAZ4L.js";
+import "./chunk-CXJ6FUKN.js";
+import "./chunk-QKUJMING.js";
+import "./chunk-6ZGLAACW.js";
+import "./chunk-CQDGOPGH.js";
+import "./chunk-3NFFJL5D.js";
+import "./chunk-PKBHS4AA.js";
+import "./chunk-P32RUW3B.js";
+import "./chunk-QA4O2GGC.js";
+import "./chunk-Q2TECDIT.js";
+import "./chunk-TUULXQRW.js";
+import "./chunk-BQGDB6ZL.js";
 import "./chunk-TV45EUGM.js";
 export {
   diagramLibrary,

package/dist/chunk-QA4O2GGC.js

@@ -0,0 +1,265 @@
+import { createRequire as __atticusCreateRequire } from "node:module";
+import { fileURLToPath as __atticusFileURLToPath } from "node:url";
+var require = __atticusCreateRequire(import.meta.url);
+var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
+var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
+
+// packages/ai/dist/cli-options.js
+import { parseArgs } from "node:util";
+var OPTIONS = {
+  help: { type: "boolean", short: "h" },
+  // ADR 0141: what a read took, as the reader reports it (atticus map <repo> --spent).
+  spent: { type: "string" },
+  sessions: { type: "string" },
+  part: { type: "string" },
+  queue: { type: "boolean" },
+  // F10: atticus doctor --counts.
+  counts: { type: "boolean" },
+  version: { type: "boolean", short: "v" },
+  fix: { type: "boolean" },
+  root: { type: "string" },
+  repos: { type: "string" },
+  all: { type: "boolean" },
+  kind: { type: "string" },
+  executor: { type: "string" },
+  fixture: { type: "string" },
+  force: { type: "boolean" },
+  draft: { type: "boolean" },
+  story: { type: "string" },
+  gaps: { type: "boolean" },
+  // ADR 0167: atticus map <repo> --rules, a top-up for reading rules added since a read.
+  rules: { type: "boolean" },
+  // ADR 0169: atticus map <repo> --models reachable|all (ADR 0170: or entries).
+  models: { type: "string" },
+  // ADR 0161: atticus map --all.
+  stale: { type: "boolean" },
+  "max-parts": { type: "string" },
+  "budget-tokens": { type: "string" },
+  idle: { type: "string" },
+  full: { type: "boolean" },
+  "dry-run": { type: "boolean" },
+  json: { type: "boolean" },
+  limit: { type: "string" },
+  filter: { type: "string" },
+  "batch-tokens": { type: "string" },
+  "max-tokens": { type: "string" },
+  // atticus probe (ADR 0124 addendum A-probe).
+  assistant: { type: "string" },
+  pasted: { type: "boolean" },
+  "context-tokens": { type: "string" },
+  "whole-context": { type: "boolean" },
+  search: { type: "boolean" },
+  regex: { type: "boolean" },
+  "ignore-case": { type: "boolean" },
+  paths: { type: "string" },
+  // atticus context (ADR 0107 addendum): the context tools.
+  input: { type: "string" },
+  run: { type: "string" },
+  round: { type: "string" },
+  hops: { type: "string" },
+  line: { type: "string" },
+  around: { type: "string" },
+  depth: { type: "string" },
+  by: { type: "string" },
+  as: { type: "string" },
+  group: { type: "string", multiple: true },
+  channel: { type: "string" },
+  send: { type: "boolean" },
+  site: { type: "string" },
+  reason: { type: "string" },
+  focus: { type: "string" },
+  format: { type: "string" },
+  out: { type: "string" },
+  area: { type: "string" },
+  iteration: { type: "string" },
+  port: { type: "string" },
+  open: { type: "boolean" },
+  "show-token": { type: "boolean" },
+  embed: { type: "string" },
+  parent: { type: "string" },
+  host: { type: "string" },
+  catalog: { type: "string" },
+  "from-catalog": { type: "boolean" },
+  from: { type: "string" },
+  to: { type: "string" },
+  package: { type: "string" },
+  jars: { type: "string", multiple: true },
+  learn: { type: "boolean" },
+  type: { type: "string" },
+  template: { type: "string" },
+  like: { type: "string" },
+  impact: { type: "string" },
+  id: { type: "string" },
+  owner: { type: "string", multiple: true },
+  system: { type: "string", multiple: true },
+  base: { type: "string" },
+  repo: { type: "string" },
+  gate: { type: "string" },
+  lens: { type: "string" },
+  model: { type: "string" },
+  "asked-of": { type: "string" },
+  edit: { type: "string" },
+  description: { type: "string" },
+  title: { type: "string" },
+  name: { type: "string" },
+  badge: { type: "string" },
+  shape: { type: "string" },
+  colour: { type: "string" },
+  attempts: { type: "string" },
+  users: { type: "string" },
+  language: { type: "string" },
+  replace: { type: "boolean" },
+  into: { type: "string" },
+  level: { type: "string" },
+  mode: { type: "string" },
+  approve: { type: "boolean" },
+  pr: { type: "string" },
+  "pr-url": { type: "string" },
+  change: { type: "string" },
+  check: { type: "boolean" },
+  resume: { type: "string" },
+  eval: { type: "string" },
+  epic: { type: "string" },
+  "no-ai": { type: "boolean" },
+  "openspec-store": { type: "boolean" },
+  "no-drift": { type: "boolean" },
+  warnings: { type: "boolean" },
+  "no-rescan": { type: "boolean" },
+  refresh: { type: "string" },
+  export: { type: "string" },
+  result: { type: "string", multiple: true },
+  skip: { type: "boolean" },
+  note: { type: "string" },
+  for: { type: "string" },
+  with: { type: "string" },
+  inputs: { type: "string" },
+  "fill-only": { type: "boolean" },
+  platform: { type: "string" },
+  ref: { type: "string" },
+  task: { type: "string" },
+  latest: { type: "boolean" },
+  org: { type: "string" },
+  framework: { type: "string" },
+  csv: { type: "boolean" },
+  "no-write": { type: "boolean" },
+  junit: { type: "string" },
+  summary: { type: "string" },
+  "json-out": { type: "string" },
+  "warn-only": { type: "boolean" },
+  // A switch (verify --write, verify --all --write); ci snippet --write <dir> takes a folder
+  // (BY_COMMAND below).
+  write: { type: "boolean" },
+  path: { type: "string" },
+  file: { type: "string" },
+  submodule: { type: "boolean" },
+  save: { type: "boolean" },
+  read: { type: "boolean" },
+  only: { type: "string" },
+  "verified-only": { type: "boolean" },
+  unverified: { type: "boolean" },
+  set: { type: "string", multiple: true },
+  find: { type: "string" },
+  drift: { type: "string", multiple: true },
+  journey: { type: "string" },
+  release: { type: "string" },
+  target: { type: "string" },
+  answer: { type: "string" },
+  lesson: { type: "string" },
+  step: { type: "string" },
+  agent: { type: "string", multiple: true },
+  runs: { type: "string" },
+  audience: { type: "string" },
+  value: { type: "string" },
+  bench: { type: "string" },
+  cache: { type: "string" },
+  batch: { type: "string" },
+  specs: { type: "boolean" },
+  estate: { type: "string" },
+  accept: { type: "boolean" },
+  // atticus repo add / repo describe (ADR 0128)
+  reject: { type: "boolean" },
+  cites: { type: "string" },
+  drafted: { type: "string" },
+  "no-description": { type: "boolean" },
+  component: { type: "string" },
+  tag: { type: "string" },
+  source: { type: "string" },
+  "from-figma": { type: "string" },
+  replaces: { type: "string" },
+  promote: { type: "string" },
+  prototype: { type: "string" },
+  off: { type: "boolean" },
+  surface: { type: "string" },
+  session: { type: "string" },
+  command: { type: "string" },
+  markdown: { type: "boolean" },
+  dir: { type: "string" },
+  commit: { type: "string" },
+  confirm: { type: "string" },
+  exclude: { type: "string" },
+  routed: { type: "string" },
+  // atticus map (ADR 0124 §4)
+  estimate: { type: "boolean" },
+  next: { type: "boolean" },
+  copy: { type: "boolean" },
+  facts: { type: "string" },
+  // ADR 0163: atticus repo-type note.
+  add: { type: "string" },
+  "org-wide": { type: "boolean" },
+  // G4 (ADR 0176): atticus rules.
+  key: { type: "string" },
+  rule: { type: "string" },
+  files: { type: "string" },
+  example: { type: "string" },
+  about: { type: "string" },
+  at: { type: "string" },
+  team: { type: "string" },
+  compare: { type: "boolean" },
+  // Review round 47: the flags the questions, decisions and verify commands read, here with their
+  // types, so the command line's first reading never takes their values for command words.
+  handoff: { type: "boolean" },
+  state: { type: "string" },
+  option: { type: "string" },
+  text: { type: "string" },
+  scope: { type: "string" },
+  match: { type: "string" },
+  "add-system": { type: "string" },
+  api: { type: "string" },
+  apply: { type: "string" },
+  mine: { type: "boolean" },
+  none: { type: "boolean" },
+  similar: { type: "boolean" },
+  "no-similar": { type: "boolean" },
+  preview: { type: "boolean" },
+  "accept-proposal": { type: "boolean" },
+  size: { type: "string" },
+  seed: { type: "string" },
+  answers: { type: "string" },
+  right: { type: "string" },
+  wrong: { type: "string" },
+  unsure: { type: "string" },
+  report: { type: "boolean" },
+  verbose: { type: "boolean" },
+  skipped: { type: "boolean" }
+};
+var BY_COMMAND = [
+  { words: ["critic"], options: { resume: { type: "boolean" } } },
+  { words: ["ci", "snippet"], options: { write: { type: "string" } } },
+  { words: ["bench", "stories"], options: { draft: { type: "string" } } }
+];
+var read = (argv, options) => parseArgs({ args: [...argv], allowPositionals: true, options, strict: false });
+function optionsFor(argv) {
+  const words = read(argv, OPTIONS).positionals;
+  const named = words[0] === "legacy" ? words.slice(1) : words;
+  const own = BY_COMMAND.find((c) => c.words.every((w, i) => named[i] === w));
+  return own ? { ...OPTIONS, ...own.options } : OPTIONS;
+}
+function commandWords(argv) {
+  return read(argv, optionsFor(argv)).positionals;
+}
+
+export {
+  OPTIONS,
+  optionsFor,
+  commandWords
+};

package/dist/{chunk-4WXRPQDE.js → chunk-QAXW2N3B.js}

@@ -3,30 +3,27 @@ import { fileURLToPath as __atticusFileURLToPath } from "node:url";
 var require = __atticusCreateRequire(import.meta.url);
 var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
 var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
+import {
+  onboardingView
+} from "./chunk-7JITZFJC.js";
 import {
   onboardingQueue,
   queueWhy,
   reasonOf
-} from "./chunk-HE3HRDNZ.js";
+} from "./chunk-LQJPN536.js";
 import {
-  onboardingView
-} from "./chunk-PNQLCRSS.js";
+  repoIdKey
+} from "./chunk-4U276ICE.js";
 import {
   houseUntaughtOf,
   houseUntaughtWords
-} from "./chunk-3J5I7ZOU.js";
-import {
-  repoIdKey
-} from "./chunk-OMPENNWY.js";
+} from "./chunk-EHA7RMZ3.js";
 import {
   catalogSources
-} from "./chunk-4FOAYLI4.js";
-import {
-  readTaskRun
-} from "./chunk-Y6K3CJBU.js";
+} from "./chunk-OWNCM4ZN.js";
 import {
   rulesLackingAll
-} from "./chunk-GIFMBCTW.js";
+} from "./chunk-WXFLMQSR.js";
 import {
   loadReadPlan,
   partOfWords,
@@ -35,31 +32,34 @@ import {
   readPlanProgress,
   readPlanRelOf,
   tokensWords
-} from "./chunk-MD7KUEJ3.js";
+} from "./chunk-TYQBFTBR.js";
 import {
   checkoutOf,
   conventionsAt
-} from "./chunk-Q46QDDMF.js";
-import {
-  readChangeTasks
-} from "./chunk-YWAKDNMH.js";
+} from "./chunk-2F4CYZKJ.js";
 import {
   isMetarepo,
   notMetarepo
 } from "./chunk-3G4YI4ZU.js";
+import {
+  readTaskRun
+} from "./chunk-6MUGR4LS.js";
+import {
+  readChangeTasks
+} from "./chunk-UGUP3ZM6.js";
+import {
+  readNeeds,
+  seedCollisions
+} from "./chunk-R7NYHMUU.js";
 import {
   ASSISTANT_FORMATS,
   probedAssistant,
   readProbes,
   whatRunsWhere
-} from "./chunk-3AQ2R5NL.js";
-import {
-  readNeeds,
-  seedCollisions
-} from "./chunk-BEPCKDCP.js";
+} from "./chunk-BEVTIBRH.js";
 import {
   readChangeFiles
-} from "./chunk-K332XW7K.js";
+} from "./chunk-S4PMJU6H.js";
 import {
   assess,
   changeStore,
@@ -69,21 +69,24 @@ import {
   loadChangePolicy,
   releasePrReasons,
   stageCompletion
-} from "./chunk-HSZMPH5T.js";
+} from "./chunk-IDKCWSM5.js";
+import {
+  fileStepStore
+} from "./chunk-7IGKHZ4Z.js";
 import {
   readCatalog
-} from "./chunk-4SLBCEPD.js";
+} from "./chunk-J2JAKCIW.js";
 import {
   readKnowledge,
   snapshotDates,
   workingDays
-} from "./chunk-64AADMTW.js";
+} from "./chunk-745DAZ4L.js";
 import {
   baseClonePath
-} from "./chunk-XOL3GFW2.js";
+} from "./chunk-PKBHS4AA.js";
 import {
   stepClassOfNextStep
-} from "./chunk-QHJJMZLX.js";
+} from "./chunk-P32RUW3B.js";
 import {
   ScanVerifyProposal,
   catalogDirOf,
@@ -103,9 +106,11 @@ import {
   questionWeights,
   readRepoSpec,
   readSpecFindings,
-  require_dist,
   stepModelsOf
-} from "./chunk-PAINMSID.js";
+} from "./chunk-Q2TECDIT.js";
+import {
+  require_dist
+} from "./chunk-BQGDB6ZL.js";
 import {
   __toESM
 } from "./chunk-TV45EUGM.js";
@@ -289,6 +294,7 @@ async function readNextState(root) {
       const questions = [.../* @__PURE__ */ new Set([...changeQuestions[c.id] ?? [], ...asked])];
       const missing = c.state === "define" || c.state === "returned" ? await draftMissing(changeContext, c).catch(() => ({ draft: false, brief: false })) : { draft: false, brief: false };
       const blocking = stageOf(c.state) === "tasks" ? await blockingOf(changeContext, c).catch(() => 0) : 0;
+      const gate = draftingAt(own) >= 0 && !live && (stagesDone.includes(own) || c.state === "returned") ? await gateFindingsOf(changeContext, c).catch(() => []) : [];
       if (busy && stageOf(c.state) !== "done" && (!active || busy > active.at))
         active = { id: c.id, at: busy };
       changes.push({
@@ -301,6 +307,8 @@ async function readNextState(root) {
         feature: existsSync(join(changesDirOf(root), c.id, "feature.yaml")),
         ...missing.draft ? { undrafted: true } : {},
         ...blocking ? { blocking } : {},
+        ...gate.length ? { gate } : {},
+        ...c.state === "released" ? await releasedOf(root, c.id) : {},
         ...stageOf(c.state) === "release" ? await releasePrsOf(root, c.id) : {},
         ...missing.brief ? { brief: `${changesRelOf(root)}/${c.id}/brief.md` } : {},
         ...questions.length ? { questions } : {},
@@ -312,7 +320,8 @@ async function readNextState(root) {
             phase: live.phase,
             number: live.pr.number,
             url: live.pr.url,
-            state: live.state
+            state: live.state,
+            ...isManualPrUrl(live.pr.url) ? await manualPrRecorded(root, c.id, live.branch, orgPack) : {}
           }
         } : {},
         ...clash.length ? { seedCollisions: clash } : {},
@@ -410,9 +419,124 @@ async function blockingOf(ctx, c) {
   const a = await assess(await ctx(), c);
   return a.blockers.filter((b) => b.code === "blocking-finding" || b.code === "open-gap").length;
 }
+async function gateFindingsOf(ctx, c) {
+  const a = await assess(await ctx(), c);
+  return a.blockers.flatMap((b) => b.code === "blocking-finding" || b.code === "open-gap" ? [{ code: b.code, ...b.finding ? { finding: b.finding } : {}, message: b.message }] : []);
+}
+function gateBlockedStep(c, stage, gate) {
+  const first = c.gate?.[0];
+  if (!first)
+    return void 0;
+  const id = c.id;
+  const more = c.gate.length - 1;
+  const head = `${id}'s ${stage} stage is done, but the ${gate} gate is blocked, so its hand-off would be refused: ${first.message.replace(/\.?$/, ".")}`;
+  const tail = more ? `; ${more} more after it.` : ".";
+  const asked = /\(owner question (q-[0-9a-f]+)[,)]/.exec(first.message)?.[1];
+  if (asked)
+    return {
+      step: "answer",
+      command: `atticus questions answer ${asked}`,
+      where: METAREPO,
+      why: `${head} Its owner answers ${asked} (Questions, Owner questions), and the answer closes the gap${tail}`,
+      person: true,
+      change: id
+    };
+  const f = first.finding ?? "<id>";
+  if (first.code === "open-gap")
+    return {
+      step: "finding",
+      command: `atticus finding ${id} ${f} ask`,
+      where: METAREPO,
+      why: `${head} Ask its owner (atticus finding ${id} ${f} ask --asked-of <who>), or fill it in (atticus finding ${id} ${f} edit-and-apply)${tail}`,
+      person: true,
+      change: id
+    };
+  return {
+    step: "finding",
+    command: `atticus finding ${id} ${f} edit-and-apply`,
+    where: METAREPO,
+    why: `${head} Fix it (atticus finding ${id} ${f} edit-and-apply), or record why it doesn't apply (not-relevant --reason, or waive)${tail}`,
+    person: true,
+    change: id
+  };
+}
+async function releasedOf(root, id) {
+  try {
+    const { archiveGate } = await import("./chunk-5BD2KYLE.js");
+    const g = await archiveGate(root, id);
+    return {
+      released: { blockers: g.blockers.map((b) => ({ code: b.code, message: b.message })) }
+    };
+  } catch {
+    return { released: { blockers: [] } };
+  }
+}
+function releasedSteps(c) {
+  const id = c.id;
+  const blockers = c.released?.blockers ?? [];
+  const repoOf = (m) => /^([A-Za-z0-9][\w.-]*): /.exec(m)?.[1];
+  const reads = [];
+  for (const b of blockers) {
+    const repo = repoOf(b.message);
+    if (!repo)
+      continue;
+    if (b.code === "needs-reading")
+      reads.push({
+        step: "reread",
+        command: `atticus map ${repo}`,
+        slash: `/atticus-map ${repo}`,
+        where: METAREPO,
+        why: `${id} is released, and the archive gate needs what shipped read: ${b.message}`,
+        repo,
+        change: id
+      });
+    else if (b.code === "catalog-stale")
+      reads.push({
+        step: "verify",
+        command: `atticus verify ${repo} --write`,
+        where: METAREPO,
+        why: `${id} is released, and the archive gate needs the catalog written from what shipped: ${b.message}`,
+        repo,
+        change: id
+      });
+    else if (b.code === "not-synced")
+      reads.push({
+        step: "sync",
+        command: `atticus workspace sync --repos ${repo}`,
+        where: METAREPO,
+        why: `${id} is released, and the archive gate needs ${repo}'s clone at what merged: ${b.message}`,
+        repo,
+        change: id
+      });
+  }
+  const others = blockers.filter((b) => !repoOf(b.message) || !["needs-reading", "catalog-stale", "not-synced"].includes(b.code));
+  if (others.length)
+    return [
+      ...reads,
+      {
+        step: "archive-gate",
+        command: `atticus ci archive-gate ${id}`,
+        where: METAREPO,
+        why: `${id} is released, but the archive gate doesn't pass yet: ${others.map((b) => b.message).join(" ")}`,
+        change: id,
+        person: true
+      }
+    ];
+  return [
+    ...reads,
+    {
+      step: "archive",
+      command: `atticus change archive ${id}`,
+      where: METAREPO,
+      why: reads.length ? `Then a person archives ${id} (its spec deltas merge into openspec/specs/ and the estate is scanned again).` : `${id} is released and the archive gate passes: a person archives it (its spec deltas merge into openspec/specs/ and the estate is scanned again, so the catalog says what shipped).`,
+      change: id,
+      person: true
+    }
+  ];
+}
 async function releasePrsOf(root, id) {
   const reasons = await releasePrReasons(root, id).catch(() => []);
-  if (reasons.some((r) => r.code === "release-pr-missing"))
+  if (reasons.some((r) => r.code === "release-pr-missing" || r.code === "release-pr-stale"))
     return { releasePrs: "raise" };
   if (reasons.some((r) => r.code === "release-pr-not-merged"))
     return { releasePrs: "merge" };
@@ -439,6 +563,8 @@ function stageOf(state) {
   }
 }
 function changeSteps(c) {
+  if (c.state === "released")
+    return releasedSteps(c);
   const stage = stageSteps(c);
   const id = c.id;
   const done = stageOf(c.state) === "done";
@@ -481,6 +607,15 @@ function changeSteps(c) {
   const ownDone = (c.stagesDone ?? []).includes(stageOf(c.state));
   return ownDone ? [...seeds, ...stage, ...asked, ...find, ...raise] : [...asked, ...seeds, ...stage, ...find, ...raise];
 }
+async function manualPrRecorded(root, change, branch, orgPack) {
+  const steps = await fileStepStore(root).list({ change, system: "git-host" }).catch(() => []);
+  const open = steps.find((x) => x.action === "open-pull-request" && x.inputs.head === branch && x.state !== "open");
+  if (!open)
+    return {};
+  const named = orgPack instanceof Error ? void 0 : orgPack.runtime.adapters.gitHost?.settings.metarepo;
+  const repo = typeof open.inputs.repo === "string" ? open.inputs.repo : void 0;
+  return { recorded: typeof named === "string" || !repo ? {} : { repo } };
+}
 function handoffWait(c) {
   const h = c.handoff;
   if (!h)
@@ -498,6 +633,17 @@ function handoffWait(c) {
         ...isManualPrUrl(h.url) ? {} : { pr: h.url }
       }
     ];
+  if (isManualPrUrl(h.url) && h.recorded)
+    return [
+      {
+        step: "merge",
+        command: `atticus change sync ${id}${h.recorded.repo ? ` --repo ${h.recorded.repo}` : ""}`,
+        where: METAREPO,
+        why: `${id}'s ${h.phase} hand-off PR is recorded on its manual steps: syncing reads what was recorded and moves the change on; once its merge is recorded, that approves the ${h.phase} gate.`,
+        change: id,
+        person: true
+      }
+    ];
   if (isManualPrUrl(h.url))
     return [
       {
@@ -591,6 +737,9 @@ function stageSteps(c) {
           change: id
         }
       ];
+    const blocked = gateBlockedStep(c, stage, gate);
+    if (blocked)
+      return [blocked];
     return [
       {
         step: "handoff",
@@ -955,7 +1104,7 @@ function nextSteps(s) {
       why: `${plural(s.unverifiedNeeds, "open need")} of changes ${s.unverifiedNeeds === 1 ? "comes" : "come"} from knowledge items no person has verified: check each against its page (atticus knowledge verify, correct or reject).`,
       person: true
     });
-  const inFlight = s.changes.filter((c) => stageOf(c.state) !== "done");
+  const inFlight = s.changes.filter((c) => stageOf(c.state) !== "done" || c.state === "released");
   for (const c of inFlight)
     if (c !== inHand)
       out.push(...changeAnswer(c, byChange[c.id] ?? []), ...changeSteps(c));