---
name: "skill-build-ticket"
type: skill
description: Execute a Claude Code ticket end to end and open a pull request for review, on behalf of the Forge role. Use this whenever running the exec routine, or when a ticket carries the label F0-RGE in Todo and no other F0-RGE ticket is In Progress — run the work against the connected repo, verify it against the repo's own scripts, open a PR (never merge), then hand off to Prism and In Review. Apply this so the lock, verification, handoff, blocked, and gate discipline stay consistent. Trigger it whenever the task is to implement, build, or fix a Linear-tracked ticket with Claude Code.
license: CC BY-NC-SA 4.0
---

# exec

The execution role of the Claude Code loop. Runs as a polling Cloud Routine against a connected GitHub repo. Follows `convention-linear`, Pattern A, and the gate policy. **Never merges — merge is Aled's alone.**

## Trigger

Poll for issues carrying label `F0-RGE` in **Todo**, delivery projects only — never the Pipeline team. **Skip the run only if a `F0-RGE` ticket is already In Progress** — that means another exec run is active, and the rule is one Claude Code agent per repo. In Progress is the *active-run* signal: tickets parked in **In Review** (awaiting QA, PM, or Aled) are not In Progress and never hold off a run.

**Stale-claim recovery (run this before the skip guard).** A crashed run can leave a ticket In Progress under `F0-RGE` with no PR and no trace — a ghost claim — and the bare skip guard would then hold off every future run indefinitely. So before honouring the skip, check whether the In Progress `F0-RGE` ticket is a *live* run or a *ghost*. Treat it as a ghost if it has no open PR, no agent comment since it was claimed, and an In Progress timestamp older than one poll interval. A live run is recent and leaves a branch, PR, or comment within its cycle. On a ghost: do not skip — move the ticket back to **Todo**, keep `F0-RGE`, and comment that a crashed run left no PR and the state was reset. This empties In Progress so the leg unjams; the next eligibility scan re-evaluates the ticket on its merits (a still-open blocker will correctly hold it back). Only a genuinely active run holds off the leg.

**Two cases the ghost test cannot see, and what to do in each.** First, **a reset does not carry its read forward.** The read that justified resetting a ghost claim is stale the moment the reset is written, so a reset followed by a re-claim in the same turn takes a **second fresh `get_issue` immediately before the claim write** — the step-2 freshness precondition applies to the re-claim as a separate write, not to the turn. Second, **a session resuming after an interruption re-verifies from Linear before it continues.** An MCP disconnect, a mid-run model switch or an infrastructure restart can suspend and resume the same logical session with no transcript of what an earlier resumption already did; the ghost test then reads that earlier resumption as indistinguishable-from-dead, and the continuation trusts a last-known state that is no longer true. So on resuming after a gap, re-read every ticket the session believes itself mid-leg on and act on what Linear says — the routine's "all state lives in Linear" holds within a run as well as between runs — and treat an open PR the session does not remember opening as evidence of its own earlier resumption, never as a duplicate to Block on. (Worked case: APP-901, 2026-08-17 → 18 — ghost-reset three times across one interrupted session; on the third resumption the session's claim write overwrote In Review + `human` back to In Progress after an unseen earlier resumption had already carried the ticket through exec, PR #178, a clean QA verdict and Relay's routing; APP-986 and APP-989 were found already merged only by the pre-claim re-read — APP-1027.)

A run is **not** a single ticket. It works the eligible `F0-RGE` queue **serially — one ticket fully finished before the next is claimed** — until no eligible ticket remains or the run nears its time budget (see Behaviour). Across a run only one ticket is In Progress at any instant; across the repo only one run is active at a time.

**Eligibility scan.** Before each claim — the first and every subsequent one in the run — scan candidates from highest priority downward:

- A ticket is **eligible** if it is a **leaf ticket** (never `type:epic` — epics are outcomes, closed by Aled when their children are done; see convention-linear *Structure*), has no open blocked-by relation (blocker ticket not Done or Canceled), and has no unmet dependency named in a PM comment.
- A candidate sitting in a **paused-type project is not eligible** — the same class of exclusion as an open `blockedBy` relation. A project's own `status` field is a higher-order signal than any ticket-level one beneath it: a project on **Hold** (`statusType` `planned` — `convention-project-status`, *Hold is a real parked state*) records a decision already made once, at the right altitude, and a ticket under it is not a live candidate however clean it reads on the leaf, label, state, relation and PM-comment tests. **Read the project's status field directly; never propagate a hold label onto its tickets** (Owner decision on APP-1651, 2026-09-22). Every issue already carries `projectId` and every project already carries `status`, so the field is the one always-current source of truth, whereas a label needs something to apply *and* remove it in sync with the status changing — the double-bookkeeping and drift shape this system's canon avoids elsewhere. The read is **batched per distinct project, never per candidate**: group candidates by `projectId` as the scan already groups them by repo, and issue one `get_project` per distinct project, or one `list_projects` covering every distinct project ID among the candidates. Where a candidate is held out this way, surface it and move down the priority list — a Hold is a decision already taken, not a blocker to clear and not a Blocked write. **This is a new eligibility condition, not a restatement.** `convention-linear` and `convention-project-status` rule only that a *target date* sitting behind a Hold is not a commitment; that is the reading-side half, and project status has never been an eligibility condition anywhere in canon, which is precisely the gap. (Worked case: `app.Luna` is **Hold** at project level, confirmed live via `get_project` — status `Hold`, type `planned`. APP-60, APP-61 and APP-63 all sit under it, all carry `F0-RGE`, and all read as clean candidates on the ticket-level tests; each was held out only by a ticket-level accident — an assignee on APP-60 and APP-61, an open `blockedBy` on APP-63 — and was then re-surfaced as an open Owner decision about credentials, re-derived from scratch on the 2026-09-10 and 2026-09-11 runs and again in the 2026-09-22 run's report, when the one field that explained all three was never read — APP-1651.)
- If the top ticket is ineligible, move down the priority list rather than ending the run.
- If no eligible ticket exists, end the run cleanly with no claim. Do not mark anything Blocked.

## Behaviour

A run is a loop. **Repeat the cycle below for one eligible ticket at a time, highest priority first, until no eligible ticket remains or the run nears its time budget.** Each ticket is carried fully through handoff before the next is claimed — strictly serial, so only one ticket is In Progress at any instant.

For each ticket:

1. **Sync** — fetch and check out latest `main`, then cut a fresh `claude/`-prefixed branch for *this* ticket off it. **The claim in step 2 lands first: the numbering here is presentation, not the ordering, and step 2's "claim before any work on the ticket begins" governs.** Cutting a branch is unambiguously touching the repo, so the two cannot both be honoured as written and the lock is the load-bearing rule — the sequence is claim, then sync, then cut. **What the rule binds against is the push, not the local commands.** A `git fetch`, a `git reset --hard origin/main` and a `git checkout -b` produce nothing outside the sandbox; only a `git push` makes a branch visible on `origin`. So where a dispatch instruction orders sync and cut before the claim, the two orderings reconcile without either being broken: sync and cut locally, then the freshness re-fetch and the claim write, then push immediately after the claim — which satisfies the instruction and still never produces a pushed-but-unclaimed branch, the state this rule exists to prevent. **Cite this rather than re-deriving it.** (Worked case: APP-1523 — a dispatch instruction explicitly ordering sync, cut, claim and immediate push, reconciled live on exactly this reasoning, leaving no unclaimed branch on `origin` and nothing to cite, which is the APP-695 shape reached again from the other direction. Repo and pull-request claims here are **unverified**: this session has no GitHub access.) The reason is worth carrying rather than re-deriving: the branch cut is the **first externally visible artefact of the run**, and it is pushed to `origin` immediately (below), so an unclaimed ticket with a pushed branch on `origin` is precisely the ghost-claim-adjacent state the lock exists to prevent. **Cite this rather than re-deriving it** — a run reading the steps in their printed order would cut and push before claiming and would be following canon to the letter while doing it, which is the APP-695 shape: the conflict recurs not because the answer is unclear but because each run reasons it out afresh and leaves no citation behind. (APP-1344, `assoc-one/Luna` / APP-62, 2026-09-11 — claimed first and synced second on exactly this reasoning, with nothing to cite.) Every ticket gets its own branch off current `main`, never off a previous ticket's branch (genuine dependencies are blocked-by relations, so a blocker is already merged before its dependent is eligible). **Where the harness has assigned a session-designated branch that contradicts this** — a per-repo name such as `claude/nice-wright-lbbfvz`, usually phrased in absolute terms ("never push to a different branch without explicit permission") — the question is already settled: `convention-github` *Branch naming* rules that a Cloud Routine still cuts `claude/<ticket-id>` per ticket, with the deviation recorded in the PR body. **Cite it rather than re-deriving it.** The conflict recurs not because the answer is unclear but because each run reasons it out afresh and leaves no citation behind, which trains runs to treat harness instructions as advisory and lets a future run reasonably decide the other way — producing a branch `skill-merge-pr` will not clean up and Linear will not link. (Recurrence: APP-522, 2026-07-14, remedied into `convention-github` by the 2026-07-15 drain; recurred unchanged on the 2026-07-27 run, which re-derived the same answer from first principles and cited none of it — APP-695.)

    **Push the branch to `origin` immediately after cutting it, before the long body of work** — an empty or near-empty first push is enough. This is a rule of this skill, stated here because this is the artefact the executing leg reads. The ghost-claim test in `routine-delivery-loop` *Trigger* reads "In Progress, no PR, no comment" as a dead leg, and a leg suspended mid-build by an infrastructure restart looks identical and gets reset — after which the resumed leg's finished PR lands on a ticket another run has re-claimed. A pushed branch splits the two states: **no branch is dead; branch-and-no-PR is interrupted, and is surfaced rather than reset.** The exposure grows with leg length, so it binds hardest on the legs that most need it — a publish batch whose render control is two full site builds can run two hours before its first PR. (Worked cases: APP-901, 2026-08-17 — the session was suspended 10:05–14:16 mid-leg, the 13:07 run reset the claim as a ghost, and the resumed session attached a finished PR to a re-claimed In Progress ticket, one scan from a fourth reset — APP-1004. And APP-1378, 2026-09-12 — a live leg cut `claude/APP-1378`, claimed at 01:07:44, never pushed, and after two hours sat in the exact shape the ghost test reads as crashed before any output, with the rule stated only in the driver's prompt, which the exec subagent never opens — APP-1385.)

    **The same lookup covers a repo-mandated *working discipline* whose own tooling is the ticket's subject — deviate on the named hazard, record it, and still exercise the change through its own path.** A repo's `AGENTS.md` or `CLAUDE.md` can mandate how work is done in it — a worktree per run, never edit or branch-switch in the shared root — and a leg meets such a discipline as a matter of course (`convention-github`, *A worktree needs its own `node_modules`*). The collision is narrow, and it is not a judgement call: where the ticket's deliverable **is the discipline's own tooling**, following the discipline means exercising the change from inside an instance the *unmodified* tool has just created, so the discipline cannot serve as the instrument of its own test. Resolve it by **the hazard the rule names, never by the rule's wording**: read what the discipline protects against, check whether that hazard is present in the delivery sandbox, and where it is not — a rule guarding a concurrent leg's work-in-progress from being auto-stashed, in a single isolated clone with no co-running leg, naming a local path the sandbox does not have — work outside the discipline and **record the deviation in the PR body with the hazard named and why it is absent**, exactly as the designated-branch deviation above is recorded. Then cut throwaway instances for the smoke tests, so the change is still exercised through the path it changes. **Cite this rather than re-deriving it** — the answer above was reached correctly by a leg that had nothing to cite, which is the APP-695 shape and is what lets the next run reasonably decide the other way. Two things this is not: it is not licence to step around a discipline whose hazard *is* present, and it is not a Blocked — a discipline that cannot be followed on this ticket is a recorded deviation, not a failed premise. (Worked case: APP-1223, `assoc-one/aledpritchard-com`, 2026-09-10 — `AGENTS.md` mandates `scripts/agent-worktree.sh new` before any work, and the deliverable was a change to `scripts/agent-worktree.sh` itself. The run worked in the shared root on exactly the reasoning above, cut throwaway worktrees for the smoke tests, and recorded the deviation in the PR body, with no canon to cite. The same run found the shared root carried no `node_modules`, so a worktree cut before the work would not have exercised the path under test at all — APP-1281.)

2. **Claim** — move the ticket to In Progress and **clear the assignee**. This *is* the lock: a ticket In Progress under `agent:F0-RGE` is being worked and is never re-grabbed. No separate lock label. **Claim before any work on the ticket begins — these steps are a strict sequence, not a summary.** Reading the repo, investigating, or changing files before the In Progress write lands means the lock did not hold for the duration of the work: a concurrent run in that window would not have seen the ticket as claimed. In a strictly serial session nothing collides, so the gap stays invisible until the one run where it doesn't — which is why the ordering is stated rather than left to inference. Claim first, then work. (Worked case: A1-209, 2026-07-14 — the In Progress and In Review writes both landed together at handoff, after the code changes were already made — APP-522.)

    **Re-fetch the ticket immediately before the claim write, and claim only if it is *still* Todo and *still* carries `agent:F0-RGE`.** The eligibility scan is a snapshot, and it goes stale the moment a build starts: a run can spend twelve minutes on one ticket while another writer claims, builds, reviews and merges the next one. Make it a **positive test on both fields** — never a negative "is it already Done" check, which passes cleanly on a ticket that has moved to In Review under `agent:PR-1SM` and is mid-flight in someone else's leg, where clobbering it is the same corruption. Anything other than Todo-plus-`F0-RGE` means taken: move to the next candidate without writing. Two tells in the write-back are worth knowing, because they are what caught this in practice — a freshly-claimed Todo ticket has no attached PR and does carry `F0-RGE`, so a `save_issue` reply showing an attachment, or a missing label, means the write landed on someone else's work and must be repaired at once. This is the re-fetch-before-a-state-changing-write rule `convention-linear` already states, applied at the write where it costs most: the claim is the one write that can move a *completed* ticket backwards, and Done is what every downstream sweep reads to decide a ticket is finished. (Worked case: 2026-07-29, two delivery-loop drivers draining one queue — APP-715 was merged and Done at 09:24:19, and this run's 09:27 claim reverted it to In Progress; caught from the write-back and repaired within a minute with `completedAt` intact. Minutes later A1-264 was saved by exactly this pre-claim re-read, with no write made — APP-717.) The run-level lock that would stop two drivers sharing one queue is `routine-delivery-loop`'s, not this skill's; this precondition makes the claim itself safe regardless of how many drivers are running.
3. Read the ticket, its embedded acceptance criteria (Pattern A), any PM comment, and — if this is a bounce — Aled's note. **If the ticket delivers files as Linear attachments** (ops-publish tickets do this routinely), fetch them with `mcp__Linear__get_attachment`, not `curl` or `WebFetch`. A **text** attachment fetches cleanly; a **binary** one can be viewed but never written to disk, and the correct response is a flagged placeholder rather than a workaround — see *Guardrails*.

    **Where the acceptance criterion is a digest comparison, read the expected digest from the ticket or its source and compare programmatically — never hand-transcribe it.** A digest is the entire parity mechanism for a byte-exact publish ticket, and a retyped expected value is exactly as fallible as the artefact it checks: one dropped character turns a correct file into a reported defect in the *ticket*, stated confidently in a commit message and a PR body. Extract the expected values by script from the ticket body and diff them against `sha256sum` output; a mismatch is investigated on both sides before it is reported. (Worked case: APP-901, 2026-08-17 — ten expected digests hand-typed into a shell script, eight characters dropped from one, and the resulting mismatch reported as a ticket defect until corrected — APP-1004.)
3a. **Check the ticket's "already exists" premise on whatever surface the premise names, before building on it.** Where the brief rests on a stated prior state — "the view is built, gate and cut over", "the endpoint already returns X, just consume it", "the component exists, wire it up", "copy the layout of the existing cards on the board", "the source profiles are on those tickets" — confirm it on the surface the brief itself names, before starting: in a repo, the files, the branches, the merged PRs, and the repo's own `CLAUDE.md` / README status notes; on a design board, the named frames and cards; on a named ticket set, those tickets' own bodies and comments; in a project or Drive document, that document. **The named surfaces are not a repo-only list.** A premise that lives on a FigJam board, a ticket range or a Drive doc is not checked by a check that only reads the repo, and must not pass 3a vacuously for want of a repo claim to grep — the surface named is the surface checked. The ticket is evidence about *intent*; only the named surface is evidence about itself. **And where the named source is absent but the content plausibly exists elsewhere, say so and ask once — do not search the space.** Report what was checked and what was not there, and put one question to Aled (`AskUserQuestion` in a hand-started session, the Blocked comment otherwise); sweeping sibling tickets, boards and project docs for the real source is the unbounded cost this limb exists to stop. (Worked case: A1-690, 2026-10-13 — the brief named existing profile cards on the a1.Muse FigJam board and the source profiles on tickets A1-618..A1-622; the board held no such cards and the tickets held no profiles, which were in the routes Google doc, and the run paid a five-ticket, board and project-docs search plus an AskUserQuestion round trip to settle the layout. Under the repo-only reading the brief passed 3a vacuously, there being no repo claim in it at all — APP-2329.) Where the premise **does not hold**, take the Blocked path with the evidence (what was grepped, which branches and PRs exist, what the repo's own docs say) — do **not** build the missing work into existence to make the brief true. That is the failure this step exists to stop: a ticket framed as a small cutover, with nothing underneath it, becomes a from-scratch system improvised from prose and shipped un-specified. The check costs one grep; the alternative is unbounded. **Where the ticket mounts into a merged sibling, ask the second question too: does this ticket define anything the sibling already implemented, and do the definitions agree?** 3a establishes that the stated prior state *exists*; this establishes that it *means the same thing*. A disagreement here does not Block — resolve it by making one derivation the single source and having every count read it, and say so in the PR body — but an unresolved one ships two definitions that agree on today's data. The authoring-side half is `convention-ticket` (*a leaf that redefines a term a merged sibling already implemented says so*). (APP-1187.) **And check the premise in the other direction — a stated absence, which does not Block.** Where the brief rests on something *not* existing — "not covered by delivered work", "not yet implemented", "currently shows X" — test it against the repo before building, by the same grep. Where the behaviour is **already present and every criterion is met on unmodified `main`**, do **not** manufacture a diff to justify a PR, and do **not** Block: nothing is blocking. Take the **already-satisfied** path — keep the ticket in **In Review**, set the executor to `human` (evicting `agent:F0-RGE`), assign Aled, and comment the evidence: the criteria checked, the commit or `file:line` each is satisfied at, and the fact that no PR was opened. That empties In Progress, stops the next run re-claiming and re-deriving the same analysis, and puts the close-or-reopen verdict where sign-off already lives — the same routing shape `skill-merge-pr` uses for a partially-merged ticket. The authoring-side half is `convention-ticket` (*a stated absence is a claim too*). (Worked case: A1-308, 2026-09-08 — all three criteria met on unmodified `main`, no PR opened, and the claim released back to Todo for want of an outcome that expresses "already done" — APP-1183.) (Worked case: A1-220 asserted a v2 hero view was built and needed only a production gate-and-cutover; `assoc-one/aledpritchard-com` `main` had no hero component, no related branch, and 15 PRs all belonging to the *old* site the ticket asked to replace — its `CLAUDE.md` marked every section "Not started". Blocked with the evidence, no PR opened, no code guessed. Had the premise been trusted, the run would have shipped a from-scratch guess as a production cutover that also deletes the live site — 2026-07-16, APP-564. The authoring-side half of this rule is `convention-ticket` *Pattern A*; this is the claim-side half, and both are needed — a premise stated in good faith from a plan looks identical to a verified one.

    **A number the ticket states is a premise too — derive it, never adopt it.** The shapes above are a stated prior state, a stated absence and a term a sibling already defined. A fourth is a **stated derivation**: a candidate threshold, window, count or ratio offered inside a criterion, usually standing right beside the evidence it appears to have been computed from ("a candidate of 3-in-60-minutes would have alerted on the morning cluster and stayed quiet on the isolated beat"). It is the most authoritative-looking sentence in a well-formed ticket, and nothing in its shape separates *I did this arithmetic* from *this feels about right*. It is also the one false premise no gate in the loop can catch: the criterion asks for tests, the tests are written to the candidate, and they pass — build, typecheck, CI and the review leg all green on a number that is wrong on the ticket's own data, shipping a signal that stays silent on exactly the pattern the ticket exists to catch. So where a ticket carries **both** the evidence and a value drawn from it, compute the value from the evidence before using it. Where the two disagree, use the derived one, state the arithmetic and the rejected candidate in the PR body, and pin **both** in tests — the chosen values firing and the rejected candidate's silence — so the correction survives as evidence. This does not Block and does not bounce: the criterion's *property* is normally satisfiable and only its suggested number is wrong, so it is resolved in flight and recorded. The authoring-side half belongs with `convention-ticket`'s *At authoring* flag — a candidate offered beside an evidence table is either computed or marked unverified — and is not yet written there; the claim-side check holds regardless. (Worked case: APP-926, `assoc-one/bot-trader` PR #53, 2026-09-11 — the ticket's candidate of 3 failures in 60 minutes was false against its own five-timestamp table, whose morning cluster spans 93m 04s (06:30:12 → 08:03:16 UTC) so no 60-minute window holds more than 2. The run derived 2h / 3 from the incident instead, the shortest whole hour containing the cluster, and pinned the rejected candidate's silence alongside it — APP-1334.))

**And a count the PR body states carries the ref and the short SHA it was measured against, or it is not stated.** The rule above binds a number the *ticket* offers; the same arithmetic fails in the opposite direction on a number the **run** offers itself. A commit count — commits on the branch, commits behind base, commits in a range — means nothing without the repo state it was taken over, and the exec and QA legs do not share one: exec measures on its own working tree at hand-off time and an isolated QA build measures on a freshly-fetched base, so two honest legs produce two different pairs of figures and the PR body's pair cannot be reproduced by a reviewer holding only the body. So **every count in a PR body names the ref and the short SHA it was measured against** — `origin/main` fetched first and its SHA quoted from `git rev-parse --short` rather than from a remembered prefix — and a count that cannot be stated that way is **not stated at all**. The corollary is the half usually got wrong: a figure a reviewer cannot reproduce from a named ref is a **defect in the claim**, not a disagreement between two legs to be reconciled. Nothing is learned by re-deriving both and splitting the difference, and the reconciliation attempt is itself the cost, because a round spent on it reads as a discrepancy in the change rather than in the bookkeeping. (Worked case, **reported**: the exec render-check and an isolated QA build disagreed again on this instance's commit counts — **51 → 52** against **599 → 600** — on `APP-2812` / claude-ops PR #595, a recurrence of `APP-2706`. Neither pair was wrong on its own leg's state, and the PR body named no ref and no SHA for either, so both figures were irreproducible by construction and the legs spent the round reconciling bookkeeping instead of the diff. `APP-2826`.)

**And naming the ref and the SHA does not make a count reproducible — the tree it was measured in has to carry full history.** The rule above fixes what a count must *say* and is silent on *where it may be taken*, so a figure can satisfy it in full and still be wrong. A truncated checkout answers `git rev-list --count <base>..<head>` from the commits it happens to hold, so the command, both short SHAs and the arithmetic all appear in the body while the number underneath them is not the number the named refs bound; the absolute figure fails the same way and more visibly, the canon checkout's own count landing in the low dozens where a full clone measures in the hundreds (`skill-ops-sync`, *Build the base twice*; `APP-1632`). So fetch, then **confirm the tree is unshallow before quoting any count** — `git rev-parse --is-shallow-repository` returning `false` and `.git/shallow` absent — and where that cannot be confirmed the count is not stated, exactly as the rule above has it, because a count taken in a truncated tree is worse than an omitted one: it reads as the arithmetic check the body says it is. (Worked case, **reported**: the exec leg on `APP-2868` / claude-ops PR #622, base `397a08b`, head `0ca2a76` — the body named both short SHAs and the command, reported the apparatus moving 53 → 54 and the range as 1, while an isolated full-history QA build measured 627 → 629 and the range as 2, the branch's second commit `074093d` unaccounted for in the exec figure; which property of the exec tree produced the lower pair was not established on either leg, so the truncation named above is the mechanism generally and not an asserted cause for this run. Third instance on this root after `APP-2706` and `APP-2826`, both closed. `APP-2902`.)

**And a count names the field it read and the file it was read from — a build-log line that looks like the figure is not the figure.** The two rules above fix what a count must *say* about its ref and what the *tree* it was taken in must hold, and a figure read off the wrong line of a build log satisfies both in full while describing something else entirely. On a canon-publish render check one field is the subject: `git.commitCount`, a field of the object written to `content/stats.json`, derived from the canon checkout's own history. Beside it the same build prints an estate-wide GitHub-API figure of the shape `[build-content] assoc-one/claude-ops: N commits, N merged PRs (N agent)`, token-gated and network-dependent, written to `content/github-stats.json`, saying nothing about the canon under review — and because that fetch returns the same numbers for a base build and a head build whenever it returns at all, reading it as the canon field yields a confident "identical on both builds" over a field that moved by one. So read each apparatus figure from `content/stats.json` in each pinned build and diff it **there**, never from the build log, and report it as `git.commitCount` from `content/stats.json` rather than as "the `claude-ops` git stats". A figure whose **source** is unnamed is treated exactly as one whose ref is unnamed: **not stated**. There is a second, distinct cause of the same reported symptom, named here and not folded: a head build run against an uncommitted working tree sitting on the base commit, which prints the base's apparatus figures under the head's name and explains the difference as "both checkouts share the same HEAD commit" (`APP-2973`). The repo-native half — labelling the estate line at the point of emission so it cannot be read as the canon count — is `APP-2998`, open, and is not this rule's to do. (Worked case, **unverified** here as to every repo assertion in it — no repo is readable from this surface, so `scripts/build-content.ts`, `content/stats.json`, `content/github-stats.json`, the `git.commitCount` field and the log-line shape above are the filing leg's own report and not a read, and the flag covers those repo assertions only, not the rule: the exec leg on `APP-2982` / claude-ops PR #644, base `b2c229f`, head `e93803d`, 2026-11-09, reported under criterion (c) that `git.commitCount` read 648 on both builds and blamed a shallow tree; an isolated QA build on an unshallow clone with `CANON_DIR` set found the 648 line to be the estate fetch and the real field moving 648 → 649, matching `git rev-list --count b2c229f..e93803d` = 1. Fourth instance on this root after `APP-2706`, `APP-2826` and `APP-2902`, with two further instances recorded on the note itself — `APP-2970` / PR #651 at 655 → 656 and `APP-2977` / PR #648 at 652 → 653. `APP-2984`.)

    **And the source outranks every restatement of it — a description is a read-out in the way a number is.** The rule above is arithmetic over evidence the ticket carries; the harder shape is a restatement of a source the ticket only *names*. Where a ticket, a QA verdict, a bounce instruction or a locked decision-log entry both cites a source — a prototype file, a spec, a test file, a config — **and** states in prose what that source does, the prose is a read-out and the source governs. Read the source before building on the restatement, and before writing any figure or description drawn from it into a file this leg commits. Nothing in the shape of a paraphrase separates *I read this* from *I remember this*, and both failure directions are silent: a restatement that is internally consistent leaves no mismatch for a digest, byte or arithmetic check to trip, and a figure that came from a reviewer arrives with reviewer authority and none of the provenance a snippet owes (`skill-review-pr`, *Two obligations follow*). A second pass agreeing with the first is not confirmation when both read the same restatement. Where source and restatement disagree, build to the source, state both and the rejected reading in the PR body, and correct the restatement in the lane that owns it — a ticket in a comment (`convention-ticket`, *Past the claim, the body is an as-built record*), a decision-log entry in a new entry, never silently. (Worked cases, both **unverified** here — no repo is readable from the drain surface, so every file, PR and prototype assertion below is the filing leg's own report, and that flag covers those repo assertions only, not the rule. A1-555 on `assoc-one/meirionpritchard-com`, 2026-09-28: the ticket's Constants section and the locked D080 entry both restated a superseded 27%-of-viewport / 100px-scroll mechanism for a prototype that implements a fixed-pixel landmark from the viewport top with a row-0-crossing arm; exec built the restatement as a reasoned "documented deviation", the reviewing QA pass read the same two secondary sources and confirmed it rather than catching it, and only the Owner's own live comparison of the deployed preview against the prototype found it — APP-1839. And APP-1672 PR #196 round 2, 2026-09-26: a QA verdict's own "5 tests, 2 red and 3 pass" for `image-optimization.spec.ts` was off by one against the spec file — 6 tests, 2 red and 4 pass — and the exec leg drafting a `CLAUDE.md` fix began by mirroring the verdict's figure verbatim, the second live instance of APP-1483's root, this time landing in a canon doc rather than a workflow comment and self-caught only because that same fix happened to need the real numbers — APP-1794.)

    **And a third door the premise check has to open: where the strings a ticket says its target already carries exist in full in a *different* artefact, nothing is missing but the address — so a premise that fails because the ticket named the wrong file is a flagged build rather than a silent substitution.** Step 3a above tests a stated prior state, a stated absence, a term a sibling defined and a stated derivation; the rule above it tests a restatement of a named source. The shape left over is a ticket whose "confirm X; expected Y" clauses were paraphrased off a *sibling* artefact's already-fixed passage and then pointed at a new target file, so the expected strings are real, verbatim and in the wrong place. Grepping the named target returns nothing and the literal reading is a failed premise, while the underlying ask is intact and buildable. So before taking the Blocked path, ask the second question: does the underlying ask resolve against the real target, corroborated by something other than this ticket — a sibling ticket that independently names the same section, or the target file's own structure? Where it does, **build to that target**, and write every mismatch into the PR body and onto the ticket, naming the artefact each expected string actually lives in. Where it does not resolve, or two targets stay equally plausible, the Blocked path holds unchanged and enumerates the surfaces read. Two limits bound this: the criterion's wording stays the **author's** and is never edited to match the finding, and the mismatch is **recorded**, never built past — a flagged build is not a licence to substitute a target silently. The authoring-side half belongs with `convention-ticket` (*an expected-value clause is confirmed against the file the ticket names, not against the passage it was paraphrased from*) and is not yet written there; the claim-side check holds regardless. (Worked case, **unverified** here as to every repo assertion in it — no repo is readable from this surface, so the `CLAUDE.md` and `skill-exec/SKILL.md` contents below are the filing leg's own report and not a read, and the flag covers those repo assertions only, not the rule: `APP-2916` asked for an unshallow-tree precondition to be added beside a "a count names the ref and the short SHA, or it is not stated" rule, a heading containing "render check", and a "fetch `origin/main` before measuring" instruction that it said `assoc-one/claude-ops`'s root `CLAUDE.md` already carried. None of the three were there; all three lived in `canon/skills/skill-exec/SKILL.md`, where the originating fix for `APP-2902` had landed. The sibling `APP-1671` independently named the same `CLAUDE.md` section and heading for this apparatus-figures topic, which is what let the leg build to the real target with every mismatch flagged — claude-ops PR #641 — instead of Blocking three of five AC clauses and one DoD sentence. `APP-2962`.)

    **Search the comment thread, not only the repo, attachments and filesystem — a handoff payload lands there as naturally as in an attachment.** A router that cannot reach a file from the repo routinely pastes the reference implementation, spec, or reference asset **into a Linear comment** and says so in the routing comment. So the premise-check surfaces are four, not three: the ticket **attachments**, the **repo**, the **sandbox filesystem**, and the **comment thread** — read a fenced code block or an inline artefact in a comment as a legitimate delivery mechanism before concluding the artefact is missing. And where the premise genuinely does not hold, the **Blocked comment enumerates the surfaces searched** ("not found in attachments, repo, filesystem, or the comment thread") rather than asserting a bare "does not exist": a verdict that names its surfaces reads as a search that may have a gap, where a bare one reads as a settled dead end and is trusted as such — which is exactly how a present artefact goes unbuilt. (Worked case: A1-326, `assoc.one`, 2026-08-11 — the ~250-line reference implementation was pasted into the comment immediately above Forge's own, and the routing comment said the payload was there; the premise-check searched attachments, repo and filesystem, reported each honestly, never read the comment, and Blocked the ticket, which then sat four and a half hours on an Urgent brief until the Owner attached the file by hand — APP-807.)
3b. **Check the ticket carries the Pattern A *property* before building — a property-less ticket bounces to Relay, it is not built.** Step 6 presupposes a tickable acceptance-criteria section and a definition-of-done section, and step 3 reads the AC; neither survives a ticket that carries neither. **Test the property, not the heading string:** a `##`-level section of `- [ ]` checkboxes serving as acceptance criteria, **plus** a `## Definition of done`. Where the property is present and a heading deviates from the template — five real checkboxes under `## What to check`, a definition of done under `## Done when` — that is a convention divergence, not a failed standard: **build the ticket and repair the heading in passing**, renaming it to the template heading and changing no criterion text, or, where the run would rather not touch the body at all, name the repair for Relay on the ticket and build anyway. Only an **absent property** bounces: no tickable criteria under any heading, or no definition of done. On a genuine absence, do **not** build and do **not** author the criteria (AC is the author's, never Forge's — step 6): move the ticket back to **Backlog**, set `agent:R3-LAY` (evicting `agent:F0-RGE`), clear the assignee, and comment which half of the property is absent so Relay can re-refine it. This is a claim-time backstop to the refinement-time rule already in `skill-triage` (*never promote to Ready without both sections in place*) — that rule holds first; this catches the ticket that reached Todo without it. It is deliberately consequential: a batch of format-less tickets bounces on the first pass rather than being built against criteria that live only in a triage comment, one of which may be unsatisfiable. The check is a property test, not a quality judgement — whether the criteria are *good* is a separate concern, and so is whether they are well-named. That cuts both ways, and the near neighbour is the tell: tickable `- [ ]` criteria sitting under a **bold line** rather than a `##` heading are the same class as a deviant heading string — the property is there, the template shape is not — so promote the bold line to a `##` heading in passing and build, rather than bouncing. What genuinely fails is the absence underneath the formatting: plain prose or plain bullets with no checkbox anywhere, which the Done gate cannot read and step 6 cannot tick. (Worked case: A1-299 built with no AC/DoD section, costing a full QA bounce; 0 of A1-294's 14 children carried either section and six reached Todo — APP-744; Owner steer, Aled 2026-08-09: "ensure the format is right and if not, bounce it back to relay to sort".)

    **Why the test is the property, and not the string.** `core-operating-model` Layer 5 separates a **standard** — a quality bar the work must clear, which you pass or fail — from a **convention** — an arbitrary-but-shared choice where only consistency matters, and where "conventions are checked by consistency and auto-fixed". "A ticket embeds acceptance criteria" is that model's own worked example of a standard, and it is the bar `convention-ticket` sets and this gate exists to hold. `## Acceptance criteria` as a literal string is the convention: two sensible authors could pick differently and it would not matter as long as they agreed. So a divergence in the heading is repaired in passing; only a missing property is failed. A gate that bounces on the string has mistaken a convention for a standard, and spends a round trip on a ticket that already clears the bar. Cite this rather than re-deriving it — a run that reasons it out afresh and leaves no citation behind is the pattern APP-695 named for branch naming, and it is what lets one run bounce a ticket the next run builds. (Worked case: APP-937, `bot-trader`, 2026-09-07 — five real `- [ ]` criteria, precise, testable and readable by the Done gate, sitting under `## What to check` beside a real `## Definition of done`. Format-less on a literal read of this step, well-formed on a purposive one. The run built it on the purposive reading and flagged the deviation for Relay rather than fixing it, having nothing to cite; the same ticket could reasonably have been bounced by the next run. Ruled here, refine 2026-09-07 — APP-1137.)

    **Merged sections are a distinct shape from missing ones, and they still pass this check.** A ticket can carry both `## Acceptance criteria` and `## Definition of done` headings while some AC content sits *inside* the DoD section (or vice versa) — every criterion present and tickable, only mis-filed under the wrong heading. This **passes** step 3b and is built, because the test is a property / format check and **never a quality judgement**: a run that reasons "the criteria are obviously all right there, so building is fine" is applying exactly the quality judgement this check excludes, and would waive the gate on apparently sound grounds. Keep that distinction load-bearing so it survives any future edit-down — merged-but-present is a pass; only genuinely-absent sections bounce. (Worked case: A1-345, `assoc-one/meirionpritchard-com`, 2026-08-15 — four of six `## Definition of done` bullets were AC content; the gate held only because it is a format check and not a quality judgement, and this was the first recorded firing of step 3b since APP-744 — APP-953.)

    **The bounce to Backlog silently de-cycles the ticket — flag the lost cycle for Relay to restore.** Moving a ticket to Backlog drops its cycle membership, so every format bounce silently de-cycles it. Do **not** write the cycle back — cycle membership is Atlas's and propose-only — flag the dropped cycle on the ticket for Relay to restore alongside the format bounce. Canon says so here rather than leaving each run to rediscover it. (APP-953.)
3c. **Confirm the ticket can be *verified* in this environment before building on it — a claim-time instrument check.** Where an acceptance criterion can only be met by an instrument the sandbox lacks — a browser / Playwright suite whose build is absent, a route that 500s because an egress-blocked host is fetched at render, a live deployment the sandbox cannot reach — that box is unverifiable *here*, and building the change without being able to run what it will be judged on spends the run blind. Read the repo's `CLAUDE.md` for any recorded environment limits first (the one place a claim-time check can find them), then ask of the AC set: *can the executor run what these boxes will be judged on?* **Ask it as a lookup, not a judgement — and the lookup has a presence half.** Canon records the *absence* of instruments carefully and their *presence* almost nowhere, so a run reasoning from canon alone derives "assume it is missing", which is the wrong default and costs a bounce on work that was otherwise finished. **The session environment banner is not an instrument reading either.** The block printed at session start — `Primary working directory`, `Is a git repository`, `Platform` — is session metadata, not a measurement of the repo this leg works in, and it has been observed false on a working clone. So it grounds nothing on either side: git-repo state is confirmed live with `git remote -v && git status` in the working tree before any conclusion is drawn from it, and an `Is a git repository: false` in that banner never grounds an environmentally-blocked verdict, a deferred box, or a reach for a non-git mechanism. Read the banner the way this check already reads canon's silence about instruments — as absence of information, never as a negative finding. (Worked case: APP-1614, `assoc-one/claude-ops`, 2026-09-22 — the banner reported `Is a git repository: false` for a fully functional clone whose `git remote -v`, `git status`, `git fetch`, `git checkout -b` and `git push` all worked normally, and the branch cut and push for the ticket succeeded first try; the leg was unaffected only because it ran the live check anyway rather than trusting the metadata — APP-1659.) Two instruments are present in the delivery sandbox and are not to be re-derived: **a browser** — Chromium under `/opt/pw-browsers` with `PLAYWRIGHT_BROWSERS_PATH` pointed at it, and a global `playwright` under `/opt/node22/lib/node_modules`, which does **not** resolve by a bare `import` from a repo that does not depend on it and needs `createRequire` with an absolute path — and **npm itself**, which is reachable even where a named non-npm host is not — from which the third case follows and is the one most often got wrong: **a CLI that is absent is not a missing instrument where npm can install it.** `which <tool>` coming back empty answers whether the tool is installed, never whether it is *available*, and the gap between those is one command and a few seconds (`npm install -g @shopify/cli`, four seconds, after which `shopify theme check` ran the repo's own gate clean). So the lookup for a named CLI is `which <tool> || npm install -g <package>`, not `which <tool>` alone. Presence also is not stable in the flattering direction: a sandbox reused across legs can carry an earlier leg's global install, so a tool found on the path is not evidence the image provides it and a tool absent is not evidence it cannot be had — run the install-or-skip line either way rather than reasoning from either observation. The cost of getting this wrong is asymmetric and always lands the same way: where the acceptance criterion *is* the gate ("Theme Check green", "lint clean", "the CLI's own validator passes"), a leg that reads `command not found` as a missing instrument defers the box to CI and hands off a PR presenting itself as unverified on a gate it could have run. Where a lane's gates need more than this — a tool that cannot run locally at all, or a hosted preview that needs credentials — the lane's own convention records it (`convention-shopify`, *Verifying theme work*, for the Shopify theme repos). (Worked case: MBN-275, `assoc-one/mbn-theme` PR #6, 2026-09-11 — the claim-time check found `which shopify` empty and the repo's `CLAUDE.md` stated the gate as a fact of the lane without mentioning the install; the install took four seconds and the gate then matched the base exactly, 184 files / 39 warnings / 0 errors — APP-1339.) A third instrument is present, and is the highest-leverage of the set: **a credentialed GitHub Actions workflow can be dispatched from a leg** with `mcp__github__actions_run_trigger`, and its result read back. It is the only route by which a sandboxed leg reaches anything credential-gated — live venue data, a real deployment, a third-party API — so where an acceptance criterion needs credentials or egress the sandbox lacks, look for a dispatchable workflow whose job this already is **before** taking the Blocked path. The boundary is that lookup, not an invitation: a dispatch spends real API calls, can commit to the ticket's branch, and on a pre-registered research repo counts against a multiple-comparisons budget. So the question is whether such a workflow **exists**, never whether one could be written. Blocking too early costs a whole run and returns nothing. (Worked case: APP-1402 asked for a survey run on the credentialed runner against real OANDA data — on its face the Blocked case — and the leg reached `feasibility-study.yml` only because the target repo's README named it; that run also exposed the truncation defect APP-1410, which nothing but running it would have found — APP-1412.) So a visual, viewport or interaction criterion is **met, not deferred**: build the app from the exact head commit, drive that production build in the sandbox's own Chromium against a controllable stub, and run the negative control. This is `skill-review-pr`'s rule stated on the claim leg, where the deferral actually happens (`skill-review-pr`, *Drive a production build of the PR head in the sandbox's own Chromium* — Owner ruling 2026-09-03, APP-880). Reserve Blocked for the residue where the **hosted deployment itself** is what is under test. Cite this rather than re-deriving it: the conflict recurs not because the answer is unclear but because each run reasons it out afresh and leaves no citation behind, the pattern APP-695 named for branch naming. (Worked case: A1-381, `assoc-one/firmup-operator`, 2026-09-08 — visual criteria deferred on the belief that no browser existed, costing a bounce; the correction reached the A1-383 run only because the driver's hand-off note named the browser path by hand, and four sibling leaves were queued to re-derive the same question from the same silence — APP-1186, and the same claim-leg gap APP-1184 names.) Where it cannot, take the **Blocked**-with-a-blocked-by-relation path early — per `convention-linear`'s missing-instrument rule, which is the *review*-leg half; this is the *claim*-leg half — rather than discovering it after an hour of blind CI iteration. Recording each repo's known limits where this check reads them (its `CLAUDE.md`) is a repo-lane follow-up; the specific instances are already surfaced (APP-712 Sanity egress, APP-713 Playwright browser build). (Worked case: A1-263, `meirionpritchard-com`, 2026-08-11 — eight Playwright assertions the sandbox could not run at all, then three rounds of ~6.5-minute blind CI debugging that ended Blocked with the PR red; a claim-time check would have Blocked it in two minutes with the same outcome — APP-790.)

    **Agent-instruction content is a known blocked deliverable — route it at claim, with no write attempts.** The Claude Code auto-mode permission classifier — a different gate from the worktree guard in `convention-agent-runtime` — refuses content that would change how a future Claude session behaves, and it keys on the content rather than the path. So where the deliverable is agent-instruction content — a file under `.claude/skills/` or `.claude/agents/`, or a `CLAUDE.md`-style behaviour override — this lookup's answer is already known: the build cannot be performed here. Do not repeat the refused Bash write; a second Bash attempt at the same content is a denial that teaches nothing new. **The "no write attempts" above narrows to exactly this much: no repeat of the refused mechanism, and exactly one direct file-write attempt before the deliverable is called unperformable.** The worked case the old blanket wording generalised from had `Write`, `Edit` and a Bash heredoc all refuse the same file, and that generalisation is now **falsified on four runs**: on 2026-10-09 a chained Bash `cp` writing attached canon to `canon/skills/<name>/SKILL.md` was refused `[Instruction Poisoning]` on APP-2209, APP-2218, APP-2222 and APP-2226, and on every one a non-Bash write of byte-identical content went through on the **first** attempt — `Write` on APP-2209, `Edit` on the other three — each digest-confirmed against the ticket's own attachment, each built and shipped, none reaching a hand-off. Bash and the direct file-write tools therefore **do not always travel the same classifier path** for this content class, and a leg taking the hand-off at the first Bash denial escalates work one more call would have finished. **One attempt, not a retry loop**, and `Write` or `Edit` either will serve: where the content is large and mostly unchanged, `diff` the verified source against the destination and apply the hunks as narrowly-anchored `Edit` calls rather than retyping the file through `Write` — lower hand-transcription risk on a 90–170KB artefact, and it keeps the content out of the write path entirely. **But the diff itself must not be a Bash command naming both paths — this tactic has its own denial, and it is the same one.** A read-only `diff <destination> <source>` with its output redirected to an unrelated scratchpad file, run for no purpose but to size the edit, was refused as `[Instruction Poisoning]` exactly as the write had been, on the same content, in a session where a plain unrelated command ran immediately afterwards and proved Bash was not globally blocked. So reaching for a Bash diff to make the narrow edits cheap costs a second denied call and leaves the leg exactly where it started. The route that worked is content-blind: a short script run with `python3 -I` that opens both files, compares them with `difflib`, and prints only line numbers and opcode tags — never a line of the content, in the command text or in its output — from which the narrowly-anchored `Edit` calls are then written by hand. Whether the denial keys on the write action, on the read, or on the content appearing in `argv` at all is **one observation with the mechanism unasserted**, the same hedge this paragraph already carries about the two tool paths; the operative instruction does not depend on settling it, so treat the Bash route as closed for this content class rather than probing it for the boundary. (Worked case: a canon edit to a `type: routine` artefact under a repo's own canon directory, 2026-10-15 — the chained `cp` was refused as the documented class, the read-only `diff` was refused identically, and the content-blind `difflib` pass under `python3 -I` then succeeded and sized the edit on the first attempt. Repo-side premises **unverified from this surface**: the repo, the branch, the publish PR number and the file's byte count; no repo is readable here, and the denial sequence is the filing leg's own account — APP-2393.). Where that one attempt is also refused, the deliverable is unperformable: take the route below with no further retries, and name **both** denials in the hand-off. The denial is **content-keyed and not path-keyed**, so a different destination is not a workaround and does not count as the one attempt this rule allows — the same Bash `cp` was refused writing identical content to a scratchpad path. And keep this class distinct from plain classifier noise: read-only commands touching no agent-instruction content are also refused intermittently, sometimes under a second reason such as `[Sensitive-Source Provenance]`, and then succeed on a bare unchanged retry — that is APP-1987's pattern, it is answered by one plain retry, and it is evidence neither way about a blocked deliverable. Note also that a repo's canon need not sit under `.claude/` at all: `claude-ops` keeps its at `canon/skills/`, and this denial class fires there too, because the trigger is the content and no path prefix bounds it. (Repo-side premises **unverified from this surface**: the per-run byte counts and digests — 36758 / 92590 / 167933 bytes, `bb0fbcd3…`, `5644c050…` — the `claude-ops` publish PR numbers for these runs, #417, #418, #421 and #422, and that `claude-ops` canon sits at `canon/skills/`; `assoc-one/claude-ops` is not readable here. Independently in canon: `skill-ops-sync`'s placement map states the repo-side layout as `canon/skills/` for skills, conventions, agents, core and routines. That Bash and the direct file-write tools take *different* classifier paths is an **inference from four observations, not a verified mechanism**, which is why this reads "do not always travel the same classifier path" rather than naming an architecture; that flag covers the mechanism alone. Amends the worked case below and the APP-1223 precedent — APP-2245.) Take the *Operator hand-off* path below at claim: do any other part of the ticket that can be done, leave the instruction-content boxes unticked and named, set `human` and assign Aled, and name the denial class in the hand-off. A `CLAUDE.md` edit that records repo facts — environment limits, commands — is ordinary work and is built as usual; if one draws a denial of this class, stop at the first and take the same route. Check `git check-ignore -v` on the target path in the same pass, because a repo `.gitignore` can exclude `.claude/` wholesale, and a "committed to the repo" criterion then also needs an ignore exception; name it in the same hand-off. (Worked case: A1-448, `meirionpritchard-com` — `.claude/skills/babysit/SKILL.md` was refused on `Write` and on a Bash heredoc as `Self-Modification` and on `Edit` as `Instruction Poisoning`, while an empty `touch` passed, which is what shows the gate reads content; `.gitignore:146` ignored the whole `.claude/` directory — APP-1556.)

    **Where the ticket quotes a spec digest *and* names the artefact it came from, reconcile the two before building — a mismatch is a flag, never a quiet choice.** The instrument check above asks whether the boxes can be *run*; this asks whether the ticket and its source still *agree*. A ticket that both quotes a digest — a hash, a version, a field list, a copy block — and names the artefact that digest was taken from carries **two copies of one fact**, and the second copy can move after the first is written: the gap between authoring and claim is precisely when the source most often changes. So read the named artefact at claim time and compare it against the quoted digest **programmatically**, the same way step 3 already requires for a digest-comparison criterion, and never by eye. Where they agree, say so in the PR body and build. Where they differ, **do not pick silently**: a ticket is evidence about intent and never evidence about the artefact, and the artefact is not authority over an explicit Owner instruction, so a run that quietly follows either copy has made a scope call on the Owner's behalf and left no record that the other reading existed. Flag the mismatch on the ticket with **both values and their sources**. Where the contested value is load-bearing on an acceptance criterion, that is the false-premise case step 3a governs and it takes the Blocked path with the evidence; where it is not load-bearing, build to one copy, and state in the PR body which one and why — the flag is mandatory either way. (Primary row: `convention-ticket` — APP-1267. This is that note's `skill-build-ticket` half.)
4. **Run the work on this ticket's branch, then verify it against the repo's own scripts before opening the PR.** Read the sequence out of the repo's `package.json` rather than assuming a standard set, and run `npm install` before the first script of any kind (`convention-github`, *Fresh clones*). The shape is format → lint → format-check → type-check → test → **build**, taking the scripts the repo actually defines.

   **A gate instrument that can see a sibling leg's state is not measuring this branch — isolate the port and the path before trusting any of these scripts.** Exec legs now run parallel-dispatched into one shared sandbox, and the scripts this step runs are the same instruments `skill-review-pr` runs behind a full set of sandbox-isolation obligations — leg-unique ports, reuse flags, a verified-free port, the real binary rather than a wrapper (`skill-review-pr`, *Proving the artefact under test*, its first two numbered obligations). This step carried none of them. Those obligations are not restated here: read them there and apply them on the claim leg too. Two limbs follow, and they fail in opposite directions. **The port.** A parallel-dispatched leg runs any server-starting gate on a leg-unique port with `CI=1` set, or with `reuseExistingServer: false` stated explicitly, and it proves that port free by attempting a connection or a bind — never by a socket-table read, because `convention-host-access` already rules `ss`, `lsof` and `netstat` as no signal in this sandbox, and the empty output of a tool that is not installed reads exactly like a free port. This limb matters because its failure is a **false green**: a config that reuses an existing server connects to whatever is already listening, so a sibling's tree is exercised and reported as this branch's, and the step's own baseline comparison cannot detect it — the baseline and the run are then wrong together and in the same direction, which is the one shape comparison cannot catch. **The path.** A repo-wide linter, formatter or type-check run in a shared checkout excludes sibling agent worktrees — `--ignore-pattern '.claude/**'` or the config's own equivalent — because a path the repo gitignores is not thereby ignored by the tool that walks it. A bare red whose findings all sit outside the tree under review is an instrument-scope fault, not a pre-existing red to stash and compare against; read it the other way and the leg burns a full compare cycle to discover the red was never in the change. (Worked cases: on 2026-10-14 a parallel-dispatched exec leg's e2e run connected to a sibling leg's server on the repo's shared default port under a reuse-existing-server config, and returned two failures that read as regressions — one of them a test green on main — caught only because the failure snapshot showed interface this branch never built, and green on its own build once the run was repeated on a leg-unique port; a sibling leg the same day avoided the same hazard by proving its ports free with a connection attempt and a bind after a socket-table grep had returned empty from a tool that was not installed at all — APP-2355. And on the same day a bare repo lint in a shared checkout returned thousands of problems, every one of them inside sibling worker worktrees under `.claude/worktrees/`, while the same tree linted clean once that path was excluded — APP-2358. Repo-side premises **unverified from this surface**: both repos' own Playwright and ESLint configuration, the port numbers, the problem and error counts, and that the hosted CI is unaffected because it checks out clean. No repo is readable here.)

   **Check free space before the install, and know the ENOSPC signature — a full sandbox takes the diagnostic tool with it.** The install is the run's largest single write, and the sandbox is shared across every leg of a publish queue: each exec and QA leg clones its repos and installs into its own scratch, nothing reclaims a finished leg's tree, and `skill-ops-sync`'s render control requires **two** full `agents-site` builds per publish leg (*Build twice and diff*, its own third numbered point), so the per-leg footprint rose at the same moment the queue got long. Neither artefact knows about the other, and the sum crosses the limit on whichever leg happens to be running when it does. So `df -h` the scratch filesystem before `npm install` and read the answer as a claim-time instrument reading, the same class as step 3c's: an install that cannot fit is an environment fact to report, not a command to retry. **The failure signature is worth recognising cold, because once the temp filesystem is full the harness can no longer capture a command's stdout and every subsequent** `Bash` **call fails with the same ENOSPC message** — `df`, `du`, even setting `CLAUDE_CODE_TMPDIR`, all answer with the error rather than with data, and the only commands that still run are ones that produce no output at all (`… >/dev/null 2>&1`). Read one uniform error across unrelated commands as *the filesystem*, never as the commands; and do **not** re-run the failed install, which is the natural next move and is the one move that makes it worse. Where the run has had to reclaim space to finish at all, **name in the ticket exactly what was removed and how much it freed, and file it as friction** — reclaiming another leg's working directory is an emergency move that is safe only because the driver runs its legs strictly serially, and who reclaims leg scratch is not settled here (open Owner question, APP-1310). (Reported from the note's own run and not independently verified from the refine surface: the `agents-site` install on the APP-1261 exec leg hit 0 MB free on the root filesystem, 2026-09-10; the session scratchpad then held 65 leg directories totalling 25 GB, every one still carrying `node_modules` and `.next` output, and removing every directory untouched for 30+ minutes freed 21 GB and let the run finish — APP-1310.)

   **The build is not optional where the repo has one.** It is the step most often dropped — it is the slowest, and on a repo with a known egress or CMS caveat a failure looks expected — and it is the only step that catches a class of break that `tsc --noEmit`, `eslint`, and diff-reading are all blind to. Chief among them: **a change that moves a component across the React Server Component boundary is a build-verified change, not a type-verified one.** Adding `"use client"` to a component whose props come from a server-rendered parent type-checks and lints clean, then fails prerendering with `Functions cannot be passed directly to Client Components`. If the build genuinely cannot be run in the session, say so in the PR body and leave the matching box for QA rather than opening the PR as verified. And **where the run has written a risk down, check it** — naming a risk in a hand-off note is not checking it.

   **When a gate fails, establish whether it is the diff before reporting it as the diff.** A local gate can fail for reasons that have nothing to do with the change — a sandbox that cannot reach a host the app requires, a browser build mismatch, a test that was already red on the base. **An egress-blocked host does not always fail loudly, and the quiet case is the expensive one.** Where the refused host is a **subresource of the page under test** rather than something the build fetches, the refusal is retried behind the proxy and the `load` event never fires, so a Playwright check configured with `waitUntil: "load"` or `waitUntil: "networkidle"` **hangs to the outer timeout with no partial output and nothing to grep** — which reads as a stuck run rather than as an environment limit, and is diagnosed as the diff's fault. The retried-CONNECT account of *why* is the filing run's diagnosis, not a measurement; the remedy stands on the symptom and holds whichever mechanism turns out to be the right one. So two rules, both keyed to the symptom. **First**, any sandbox-driven Playwright navigation uses `waitUntil: "domcontentloaded"` plus an explicit wait for the element under test — never `"load"`, never `"networkidle"`. (`convention-host-access`, *Measuring a live page from the sandbox*, already names `domcontentloaded` for the sockets-never-quiet cause; this is the egress cause, and unlike that one it also defeats `load`.) **Second**, a browser check that produces **no output at all before its timeout** is treated as an egress symptom and diagnosed against the proxy — probe the hosts the page itself pulls — before it is attributed to the change; the stash-and-compare baseline this bullet otherwise prescribes costs a second full timeout and learns nothing, because the baseline hangs too. Repo-side the obligation is a line, not a file: where a run diagnoses such a host, it **records that host by name in the repo's `CLAUDE.md`, under the recorded environment limits that step 3c's claim-time instrument check already reads** — which closes the loop between the two rules without this skill needing to know any particular repo. (Worked case: an exec leg verifying a hydration-warning fix on one Next route, 2026-10-16 — `page.goto(route, { waitUntil: "load" })`, and the same call with `"networkidle"`, ran past a 100–180-second outer timeout on every attempt with no useful partial output, while the identical check against three sibling routes was fast; that route's hero loads a third-party 3-D viewer script from a CDN the sandbox's egress proxy refuses, and switching every navigation on that route to `"domcontentloaded"` completed the check well inside its timeout — APP-2401. It is the same egress class `convention-sanity`, `convention-mux` and `convention-storybook` already record, with the one difference that earns this paragraph: each of those surfaces as something you can read — a 403 on the CONNECT, or a host plainly unreachable — and this one surfaces as silence. **Unverified from this surface**: the repo, the route, the component, the refused CDN and the two other refused hosts, the `connect_rejected` response, the timeout figures, the PR, and whether that repo's `CLAUDE.md` exists or says anything — no repo is readable here — and the sandbox was not re-probed, so the claim that `domcontentloaded` is what fixed it is the filing run's report too.) Before attributing any failure to your work, reproduce it against **unmodified `main`**: stash the change, re-run the identical gate, and compare. Then report the *comparison*, not the bare failure — "12 of 16 specs fail identically on `main`; the 4 attributable to this change are …" is actionable, "tests failed" is not. This matters in both directions: a false attribution burns the run and, worse, invites a fix for a bug that does not exist, while a genuine failure hidden inside pre-existing red is exactly what the gate was for. It is the local-CI sibling of the base-branch-red rule the GitHub posture already carries for PR CI. Where the failure proves environmental, say so plainly in the PR body with the baseline evidence and leave the matching box for QA — do not present the PR as verified, and **do not stub the blocker into the committed diff to make the gate go green**. (Worked case: A1-262, `assoc-one/meirionpritchard-com`, 2026-07-29 — the sandbox's egress policy blocks `apicdn.sanity.io` and `cdn.sanity.io`, and because `layout.tsx` fetches `siteSettings` in `generateMetadata`, *every* route fails to render: `npm run build` died at prerender with `HTTP 403 Forbidden (Host not in allowlist)` and 16 of 16 Playwright specs failed, 9 of them pre-existing. Only stashing the change and re-running against `main` separated the 12 pre-existing failures from the diff, and it cost a large part of the run — APP-712. Adding those two hosts to the environment's egress allowlist would remove the class outright, but that is an Owner action on the environment's network settings, not a canon edit and not something a run can do.)

   **A gate run in a shell carrying exported build-only variables is not a clean gate — run the environmental leg of the comparison first.** The comparison above controls for the **tree**; nothing in it controls for the **shell**. A build-only sentinel exported into the session — an access key, a host override, a feature flag, anything a deploy or a manual build left behind — is read by the test process too, and where a test asserts against a fixture value of the same name, the real value wins and the assertion fails. **The failure signature is deterministic red that reads as intermittent:** it fails 100% of the time in this shell and passes 100% of the time in a clean one, so re-running the suite twice in the same shell shows a stable failure and invites attribution to the diff, while comparing against a green run elsewhere shows flake. Both readings send the run into the code, and the cause is invisible because it is not in the tree at all. So the comparison has **two legs, and the environmental one runs first**: re-run the failing gate in a fresh shell with the build sentinels unset — `env -u <VAR> <command>`, or a subshell that does not inherit them — **before** stashing anything. It is the cheaper leg (no build, no stash, no pop to verify) and it rules out the commoner cause before the run spends a baseline cycle on the rarer one. Where unsetting turns the gate green, the defect is the test's isolation and not the diff: say so in the PR body, **name the variable**, and file the repo-lane fix — the fixture must win over an inherited value — rather than editing the assertion to match the environment, which is the same move as stubbing a blocker to make a gate go green. (Reported from the note's own run and not independently verified from the refine surface: `assoc-one/firmup-operator`, `test/sessionRoute.test.ts` › "clears the history on a successful sign-in" fails 401 ≠ 200 100% of the time whenever `OPERATOR_ACCESS_KEY` is exported, and is green when it is unset — a real environment variable overriding the fixture key. Repo-lane fix: see the repo-lane manifest row — APP-1198.)

   **A build dirties tracked files, so the restoring `git stash pop` can abort — check that it succeeded rather than assuming it.** The baseline comparison above stashes the change and runs the gate against `main`, and on a Next repo that gate rewrites a *committed* file: `next build` rewrites the tracked `next-env.d.ts`, swapping the dev `routes.d.ts` import a prior `next dev` left behind — the Playwright `webServer` step starts one too — for the production one. The pop then refuses: "error: Your local changes to the following files would be overwritten by merge: next-env.d.ts / Aborting". It refuses **safely** — the stash entry is kept and nothing is lost — and that is the hazard, because nothing announces itself: what is left behind is a working tree silently sitting on unmodified `main`, and that is the tree the run goes on to commit from. So expect a build to dirty tracked files — `git stash -u` where untracked artefacts are also in play — and **read the pop's result rather than assuming it**; where it aborted, `git checkout -- next-env.d.ts` (or whichever artefact the build rewrote) and re-pop, then revert the artefact again before committing, rather than letting a one-line diff in a file whose own header says it should not be edited ride along with real work. The alternative failures are an inattentive commit from a tree missing its own change, or that artefact committed beside it. This is the same silent-safe-direction family `convention-linear` documents for its write read-backs and `convention-github` for stale CI reads — the call returns, nothing errors loudly, and the run proceeds on a state it never checked — and it fires precisely when a leg is doing the right thing: a run that skips the baseline comparison never meets it, only the diligent one does. It generalises to any Next repo where a build touches a committed file; recording the specific artefact in that repo's own `CLAUDE.md`, beside its existing `.env.local` and `PLAYWRIGHT_EXECUTABLE_PATH` notes, is the repo-lane companion to this rule and not a substitute for it. (Worked case: APP-1121, `assoc-one/meirionpritchard-com`, 2026-09-07 — the pop aborted on `next-env.d.ts` during a baseline comparison run for a build failure of the documented APP-712 Sanity-egress class, leaving the tree on unmodified `main`; recovered with `git checkout -- next-env.d.ts && git stash pop`, then the artefact reverted again before the commit — APP-1151.)

   **A stash-and-compare leaves the framework's build cache primed with the base build — clear it before the next verification run.** On a Next.js repo the `.next` cache written while the change was stashed survives the pop and an ordinary dev-server restart, so the very next measurement can silently answer for `main` instead of the branch: the server is fresh, the file on disk is right, and the served bytes are the stashed ones. So after every baseline comparison, `rm -rf .next` (or the repo's equivalent) before verifying again, and treat any post-baseline measurement that reproduces the *pre-change* figures as a suspected stale cache before reporting it as a failed fix. It fails in both directions, and the false green is the dangerous one — a suite compiled against the stashed base passes for code the browser never ran. The full method — wipe before every measurement in either direction, a DOM discriminator, a served-asset grep — is `skill-review-pr` *Proving the baseline*; apply it here rather than re-deriving it. The hazard scales with the discipline: a run that stashes four times to attribute four gates is exposed four times. (Worked case: A1-375, `assoc-one/meirionpritchard-com`, 2026-09-02 — four stash/pop cycles, then the changed CSS measured at `padding-top: 30px`, bands `102 / 102 / 52`, stack `360`, the exact figures the ticket removed, until `rm -rf .next` gave `29px` / `100 / 100 / 50` / `350` — APP-1092. Same false-verification family as APP-693, where the server was stale rather than the cache.)

   **And `git checkout <ref> -- <path>` is a write to your own working tree, not a read of that ref — pair it or use a worktree.** The traps above are about the comparison being *clean*; this one is about the tree surviving it. `git checkout <ref> -- <pathspec>` checks those paths out of `<ref>` **into the current branch's working tree**, overwriting what was there, and it looks like none of the things a leg has been taught to be careful with: no branch switch, no stash, no `--force`, and `git status` afterwards reports the result as ordinary modifications rather than as a clobber, so the only tell is a `git diff --stat HEAD` showing changes the leg did not make. It is still the right tool for its actual purpose — restoring paths from a known-good ref, which is also how a clobber is recovered (`git checkout HEAD -- <paths>`) — and `skill-review-pr` *Proving the baseline* deliberately prescribes it as the in-place before-state swap on a repo where a sibling worktree cannot boot. So the rule is not "never": **where it is the swap, commit first and pair every checkout with its restoring `git checkout HEAD -- <the same paths>` in the same breath; where the aim is merely to inspect another ref's tree — "is this new warning mine or the rebase's?" — use `git worktree add <tmp-dir> <ref>`, which answers the question without touching your branch at all.** The stash's failure mode is a safe abort that loses nothing; this one's is a silent overwrite, so it is the cheaper habit that costs more when it is wrong. (Worked case: MBN-278 round 3, `assoc-one/mbn-theme` PR #26, 2026-10-06 — `git checkout 3b7dc40 -- .`, run as a read to attribute one extra `shopify theme check` warning after a rebase, reverted four files to their pre-ticket state; self-caught in-turn via `git diff --stat HEAD`, recovered with `git checkout HEAD -- <files>`, and the comparison then done correctly with `git worktree add /tmp/mbn-theme-base 3b7dc40` — APP-2109.)

   **Where the base's own CI is red, the leg has a named exit — it is not environmental and it is not Blocked.** The comparison above will sometimes show a failing check that is red on unmodified `main` too: the PR's GitHub CI inherits it, and the standing definition-of-done box *"CI present, concluded, green"* cannot be ticked by any ticket on that repo until the base is fixed — not by better work, not by a rebase. Do four things: (a) leave the CI-green box unticked; (b) state in the PR body the comparison and the base's own failing check by name, so the reviewer reads it as inherited rather than as this change's; (c) file the base failure as its own `FIX:` ticket on the repo's project rather than fixing it inside this PR — *never a fix for a pre-existing red* — and relate it; (d) hand off as normal, In Review + `PR-1SM`, rather than Blocking. Blocked would be wrong for the usual reason: the work is done and the blocker is not in it, and a Blocked ticket naming a dependency nobody is holding reads as dependency-bound while nothing clears it. The merge leg holds the approved PR on the `FIX:` ticket, not on the Owner (`skill-merge-pr`, APP-1060). (Worked case: APP-679 / `bot-trader` PR #41, 2026-08-23 — 11 of 12 green, the twelfth `backfill.test.ts` red on `main` since a bot-pushed data commit on 2026-08-21 that triggered no CI; the leg left the box, stated the comparison, filed APP-1055 and handed off — derived live rather than looked up — APP-1056.)

   **A verification harness this run writes carries both controls — negative and positive.** Where exec stands up its own runtime or verification check (not merely the repo's scripts — the A1-242 runtime-check case), the same bar `skill-review-pr` applies holds: show the harness *fails* on a deliberately broken build (the negative control), **and** show an unmodified baseline stays *green* in the same batch (the positive control). A matrix of red rows with a green baseline is evidence; a set of red rows alone is not — it cannot distinguish a real red from a harness broken so badly it fails on everything, or from a fabricated pass. Mind the Python bytecode caveat: run with `PYTHONDONTWRITEBYTECODE=1`, clear `__pycache__`, and pass `-p no:cacheprovider`, because a same-byte-length constant edit (`0.4`→`0.2`) leaves a stale `.pyc` the check reads instead of the source. (APP-941; family with APP-693.)

   **Commit before running negative controls.** A control's revert step — `git checkout -- <file>`, `git stash`, an editor undo — cannot tell a deliberate break from uncommitted work, and a good control breaks the file that implements the criterion, so a control run on a dirty tree reverts the change under review in the same motion. It fails silently and in the flattering direction: nothing errors, the control reports the red it expected, and the repo's own gates cannot catch it, because the test that would fail is the test that file satisfies. Commit first; every revert is then exactly "back to the reviewed state", the diff stays auditable afterwards, and the controls are reproducible from a SHA rather than from a session. (Worked case: A1-387, `assoc-one/firmup-operator` PR #29, 2026-09-08 — two of five source-level controls reverted `next.config.ts` and `NextRunsBlock.tsx` to `HEAD`, undoing the ticket's first acceptance criterion and a review fix the run had made minutes earlier; caught only because the next control's `git status` was read closely, and recovered by rewriting both files from memory and re-verifying in full. APP-1200.)

   **Zero red is a result about the runner until proved otherwise.** A break that reddens nothing has two readings — the check genuinely cannot fail, or the batch is not reading where the failure is written — and they are indistinguishable, with the wrong one flattering. So before reporting that a check could not be made to fail, re-run that break and read the checker's own summary line by eye, or key on the exit code rather than on captured output: a checker that prints passes to `stdout` and failures to `stderr` reports every break as silent to a runner collecting one stream. Zero is the one count never taken at face value, because a real finding and a broken runner produce the same number. (Worked case: A1-386, `assoc-one/firmup-operator` PR #28, 2026-09-08 — a seven-break batch reported 0 red for all seven; the breaks were real and the checker sound, and re-running against `stdout` and `stderr` together gave 3 / 6 / 7 / 2 / 12 / 1 / 1. Caught only because seven-for-seven zeros were implausible; one break reporting zero would have read as a finding. Family with APP-941 and APP-693, where the control also failed to control — nothing here was stale, the evidence was written to a stream nobody read. APP-1196.)

   **Report each control as a recipe, not a number.** A count on its own — "six breaks reddening 1 / 2 / 3 / 1 / 1 / 1" — is the one claim a reviewer can neither spot-check cheaply nor take on trust, and it is load-bearing precisely because it is the only evidence the safety net is real. So for every control, state the file, the exact anchor text and the exact replacement — not an English paraphrase of the edit — and the **names** of the checks that reddened alongside the count. **The anchor is unique in the file, or it is not an anchor.** The recipe's promise is one scripted edit, and a scripted replace aborts on a non-unique match — so where the natural anchor string occurs more than once, extend it until it does not (take in the preceding or following line, or name the occurrence by line), rather than leaning on prose beside it to say which site was meant. Prose disambiguation costs the reviewer exactly the read the recipe exists to save: he opens the file, locates both sites and picks by hand. Check it while writing the recipe — one `grep -c` on the anchor string — because uniqueness by luck of wording is the usual case and gives no warning on the run where it fails. (Worked case: APP-926 QA, `assoc-one/bot-trader` PR #53 at `14ef54a`, 2026-09-11 — eight recipes in this format, seven unique by accident, and the first one's anchor `this.#pruneReadFailures(at);` matched both the success branch and `#recordReadFailure`; its prose said "in the success branch" and the machine-usable half did not. The reviewer is the party that pays, since `skill-review-pr`'s guardrail is to spot-check the recipe or name the count unverified — APP-1338.) A named set and a number have to agree, so a miscount is visible without re-running anything, and a reviewer who does re-run reproduces the break in one edit instead of guessing which of six fixtures "drifting the ambiguous fixture" meant. Where the repo carries its own runtime harness, prefer committing the breaks as a small script that applies each one, rebuilds, runs the check and restores: the recipe then survives as regression evidence for the next leg that touches the harness. That form is preferred, not required; the replayable statement is the bar on every repo. (Worked cases: A1-382, where an equivalent claim was off by one; A1-384, `assoc-one/firmup-operator` PR #26, 2026-09-08 — eight of nine figures exact and the ninth reported 6 against a true 3, with 5 the maximum any variant of that break can reach, established by a reviewer paying eight rebuild-and-run cycles. APP-1194.)

   **Suite totals are copied from the runner's own summary line, never recounted or estimated.** The same bar holds for the figures a hand-off quotes about the whole suite — files, tests, how many are new: paste them from the runner's summary line at the head being handed off (vitest's `Test Files` and `Tests` lines, or the runner's equivalent), and derive "new" from a base-versus-head pair of those lines, never from a tally of what the run remembers writing. An estimated, hand-recounted or carried-over total reads exactly like a measured one, and QA spends its run finding the gap. (Worked case: APP-1123, 2026-09-20 — the hand-off said 17 test files / 372 tests, 8 new; QA measured 16 / 364, 10 new at the same head and called it the third instance of the class, of which A1-382 and A1-384 above are the likely priors — APP-1557.)

   **A guard fixtured on one value of an enumerated field covers its subject in name only — exercise the schema's default, and say which variants you exercised.** Where the thing a guard protects is parameterised by an enumerated field — a Sanity `list` option, a union type, a variant prop, a feature enum — the fixture pins one value, and the guard is then evidence about that value while reading as evidence about the whole type. It fails invisibly from every direction: the spec's own "this type actually rendered" assertion passes, because the type *is* rendered; it is the variant that is missing, so the builder, the reviewer skimming the spec and CI all read "covers all three types" and are correct as written. So when building a guard, enumerate the values its subject can take; fixture the schema's declared default (`initialValue`, or the language's equivalent — what an author gets without choosing) **at minimum**; cover every variant where the loop is cheap; and **state in the PR body which variants were exercised and which were not**, so the missing half is a sentence a reviewer can read rather than a hole nobody can see. A criterion of the form "for each `<type>`" is met when the fixture spans the field's value range, not when it names the type. (Worked case: A1-392, `assoc-one/meirionpritchard-com` PR #124 at `6298901`, 2026-09-11 — the `imageColumns` fixture hard-coded `ratio: "portrait"`, one of the two variants carrying no ported layout CSS and therefore unable to under-declare; `landscape`, the schema's `initialValue`, was the one that could. Changing that single line took the same 13-test spec to 11 failures, `sizes` under-declared 1.38x at 768 rising to 5.12x at 2560 — more than twice the 2.07x defect the ticket was raised to fix, in a block type the PR recorded as already correct. Distinct from APP-1232, where the fixture did not reproduce the runtime: this one reproduced it faithfully and pinned one value of one field — APP-1333.)

   **And where the deliverable is an artefact someone is told to paste, the test applies it exactly as the instructions say — never by an equivalent route.** A generated block — a token export, a config snippet, a copy-this-in block — ships with instructions for the person who will use it, and a test that reaches the same end state by a different route proves the end state and says nothing about the instructions. It passes while the documented action fails, which is precisely the failure the test was written to prevent, and it passes in the flattering direction with the ticket's own criterion apparently met. So drive the artefact's own instruction literally: paste the block where it says to paste it, in the form it gives, and assert that the result compiles and behaves. Where the literal paste cannot be automated, say so and name the box unverified rather than substituting the equivalent. (Worked case: A1-586 / `assoc-one/meirionpritchard-com` PR #220 head `8878c92`, 2026-10-03 — `tests/accordion-tune-token-export.spec.ts` proved the token round trip by assigning the exported values into their nested JSON slots in code, while the exported block's own instructions say to paste flat `"motion.panel-open"` keys verbatim in place; done literally, that renames the generated `panelOpen` to `motionPanelOpen` and fails `tsc` with six TS2339 errors. Premise unverified — no repo is readable from this surface, so the spec, the exported block's instructions and the error count are the filing leg's report. APP-2018.)

   **And where the deliverable is an artefact a runner is told to execute, the proof runs the committed entry point with the workflow's own invocation — a replica script is not evidence.** The rule above covers an artefact a person is told to paste; this is the same equivalent-route failure one layer out, where the instruction is a `run:` line and the reader is a runner. A script written to reproduce what the workflow does exercises the author's model of the pipeline, not the committed file the first post-merge dispatch will execute, so it can pass while the entry point cannot run at all — and it passes carrying real output, which reads as verification rather than as an unrun box. So drive the committed entry point by the exact command the workflow gives, from the path it gives; where the workflow cannot be dispatched before merge, run its `run:` lines verbatim rather than a reconstruction of them, and read any mismatch between a replica's output and the entry point's — a frame count, a duration, an exit code — as the entry point being unproven rather than as noise. A runtime the hand-off asserts is present on the runner is checked against that runner's own published software list before a criterion rests on it. (Worked case, **reported** from the filing leg and unverified here, since this surface can read no repo: `APP-2598` / `assoc-one/app.Foundry` PR #9 head `2c389c0`, 2026-11-14 — the exec leg proved the film-render pipeline with a local script and reported a 120-frame MP4, while the committed `visual-kit/engine/render/run.py` computed `REPO_ROOT` one level too shallow, 404d its own capture page and timed out after 300s with no output; QA found it by running the committed script as the workflow invokes it, and the frame-count mismatch against the corrected run's 150 was the tell that the exec evidence never went through the entry point — `APP-3110`.)

   **Adding a guard carries a control too — show the new guard red against the PR's own base, with a replayable recipe, or it is an untested test.** The both-controls rule above is scoped to a harness this run stands up, "not merely the repo's scripts", and the commonest case falls through that carve-out: a **regression guard committed into the repo's own suite** as the ticket's acceptance criterion. It is the cheapest control in the loop — revert the fix, run the new test, watch it fail — and the one most often skipped, because the guard is green at head and a guard nobody has seen go red looks exactly like one that works. So before hand-off: revert **only** the implementing file to base in an isolated tree, run the added guard, and record it as a recipe (*Report each control as a recipe, not a number*, below) in the PR body — the file reverted, the base SHA, the command, and the names of the tests that reddened. A guard that stays green against the unfixed code is not weak evidence about the fix; it is evidence that the ticket's acceptance criterion is unmet. **And the trap to name while writing one is a settle or wait step whose window covers the behaviour under test.** A helper that polls until motion stops, or waits a fixed interval for a layout to come to rest, *absorbs* a defect whose whole shape is that something takes too long or is undone late: the helper waits out the very loop the guard exists to catch, the follow-up "nothing moved for N ms" assertion then passes trivially, and the guard ends up asserting *motion stopped* where the criterion was *the input survived*. Assert the thing the user keeps — the surviving scroll position, the retained value, the honoured input — against a trace taken while the behaviour is in flight, and size any wait against the behaviour's own duration rather than above it. (Worked case: A1-587 / `assoc-one/meirionpritchard-com` PR #218, head `9876ee7` against base `d158f68`, 2026-10-03 — two added guards, desktop and mobile, reported green with no negative control in the PR body; QA reverted `WorkList.tsx` to base, kept the head tests and ran 2 tests × 2 projects × 3 repeats for **12/12 green against the unfixed code**. The `waitForScrollSettled` helper polled for up to 1500 ms against roughly 900 ms of a 1200 ms landing loop still to run at the 300 ms input mark, so on base scrollY only stopped changing once the loop had reached its target. A frame-by-frame scrollY trace separated the two states immediately — on base the wheel never registered at all. The fix itself was correct, CI was green at head and the behaviour was confirmed for wheel, PageDown and touch; the bounce cost a full cycle on the control alone. Premise unverified — no repo is readable from this surface, so the file names, the helper, the timings and the 12/12 figure are the filing leg's report. APP-2016.)

   **Deleting a guard carries a control too, at the same bar as adding one.** Where a run removes a shield, a flag, an assertion or any other check on the grounds that what it protected against is gone, that is a claim and not a cleanup — the same claim as "this check can fail", inverted, with none of the evidence. Prove it by re-planting the condition the guard existed for, and show either that nothing breaks (the guard really is dead) or that a **remaining** check reddens (the property moved); record it with the other negative controls. A justification written into the comment being deleted is not evidence, and the next reader inherits it as though it were. Prefer a fix that holds the property by construction over one that enumerates what is currently safe: a list is true when written and false one rule later, a structural property is not. The class is not one language's — a removed feature flag, a dropped null check, a retired assertion and a deleted cascade shield are the same shape. (Worked case: A1-387 round 1, `assoc-one/firmup-operator` PR #29, 2026-09-08 — `console.css`'s `all: revert-layer` cascade shield was deleted on the strength of a prose claim written into two stylesheet comments, reintroducing the exact defect class it existed for, and passing 243 runtime checks, four new gate tests, a browser theme audit and CI on the way to review; QA caught it by measuring a colour against a baseline build of `main`, not by any check in the repo. Round 2 re-planted the deleted rule as control 11, watched the gate redden, and held the property in a cascade layer instead of a list — four minutes, once the question was asked. APP-1201.)

   **A control the permission classifier refuses is recorded as not run and handed to QA — never skipped in advance, never reported as run.** Re-planting a removed safety default — a hard-coded `halted: false` seed, a disabled limit, a dropped guard — is exactly the control this rule asks for, and the auto-mode permission classifier can refuse that edit as security-weakening. Attempt it: the refusal has been seen in one environment and not in another, and a control not attempted is evidence not gathered. Where it is refused, record the control in the hand-off comment and the PR body as **not run in exec**, quote the refusal verbatim, give its recipe as for any other control, and hand it by name to `skill-review-pr`'s isolated leg to run. The positive suite is reported as the positive suite, never in the control's place. (Worked case: APP-824, `assoc-one/bot-trader`, 2026-09-20 — exec's re-plant of the removed `halted: false` seed in `cycle.ts` was refused as a "security-weakening edit"; exec fell back to the positive suite and flagged it, and the QA leg ran the identical control in its isolated worktree without refusal and watched the right test redden — APP-1557.)

   **A run-built harness that can outlive the run is committed.** Both controls prove the instrument works; neither says whether it still exists tomorrow, and those are different properties — the second is the one that compounds. The discriminator is the instrument's baseline. A **parity** harness compares the build against something that disappears at the merge — the old tree, a pre-migration render — and is genuinely disposable; a **snapshot** harness records expectations from the baseline and asserts them against the build, or drives a stub the repo owns, and survives. Commit the second shape, wired into the repo's own scripts, rather than leaving it in the session; say in the PR body which shape it was and why, where it is not obvious. The cost of not doing so is not only the rebuild: the leg that rebuilds an instrument can rebuild it wrong, and a QA leg's false defect spends a builder's whole bounce cycle. And where a bounce asks for an existing instrument to be **extended**, confirm the instrument is in the repo before writing the instruction. (Worked cases: A1-397, `assoc-one/portal`, 2026-09-08 — a screenshot-diff harness with both controls and three real catches existed only inside its session, so QA rebuilt it from scratch, round 2 asked for "a print-media check alongside the existing pixel one" that had never been durable, and the third harness survives only because that run chose to commit it. A1-385, `assoc-one/firmup-operator` — about 200 lines rebuilt to exercise one drag-and-drop criterion the committed checker could not reach, whose first attempt reported a confident zero writes against a board that works. APP-1185.)

   **Where the only test available is a push to CI** — the local instrument is missing and the failure only shows on the runner — cap the iteration: after a small fixed number of non-converging rounds, stop and take the Blocked path with what was learned, and **never loosen an assertion to make it pass**. Blind CI guessing with no local reproduction has no natural stopping point, and "loosen the test until it goes green" is the exact failure this prevents — one the same run caught twice on sibling tickets while committing it on a third. (APP-790.)

   **A test the sandbox cannot run is still a test this change has to satisfy — read it as source before the PR.** A spec gated `test.skip(!process.env.CI, …)`, or by any other guard that makes it unrunnable here, is by construction invisible to sandbox verification however thorough that verification is: the assertion does not execute, so a green local suite is not weak evidence about it, it is **no** evidence, and the summary line looks exactly the same either way. So where the ticket's acceptance criteria change a value's **nature** — from derived (font metrics, a browser or OS default, "however it happens to compute today") to explicit and pinned, or the reverse — `grep -rn` the whole suite for existing assertions on that property or selector, **including the specs this environment skips**, and treat every hit as work this ticket must also update rather than as something to discover from a CI failure. The check costs seconds against a CI round-trip, and it generalises past any one property: a test that pins a value derived from how the browser, font or OS renders it today is a latent trap for the next ticket that makes that value explicit. (Worked case: A1-506, `assoc-one/meirionpritchard-com` PR #192, 2026-09-25 — the AC replaced `line-height: normal` on a row label with an explicit token, and a CI-only spec existed whose own comment said it guarded that element's height *because* the value was font-metric-derived. The sandbox suite was run in full and showed the documented healthy shape; real CI then failed the third spec, costing a full round-trip to find and a one-line fix to clear. Confirm the spec and its guard against `origin/main` before writing a per-repo claim. APP-1785.)

   **A bug this sandbox cannot reproduce is instrumented before it is guessed at — one build, one round of device evidence.** Where the failure lives on an engine or device the image does not carry — iOS Safari above all, the sandbox being Chromium-only (`convention-host-access`) — each hypothesis costs the Owner a manual test on his own phone, so the round, not the build, is the scarce resource. Do not ship one guess per build. Build the measurement first: a readout the Owner can screenshot that reports the numbers the hypotheses disagree about, plus a **batch of independent switches** — query-param or class-gated variants, each isolating one candidate cause — so a single device round returns facts rather than a yes or no about one guess. Then scope and remove it per the rule below. Two corollaries: a **Chromium pass proves nothing** about an engine-specific bug, so an acceptance box reading "verified on device" is met by evidence from the device and by nothing else; and a check whose two states look alike is **masked** rather than passing — a flat-colour check where the layer and the page background are the same colour confirms nothing, so give the probe a value that differs by construction (the DOM-discriminator idea in `skill-review-pr`, *Proving the baseline*). The iteration cap above applies here too, counted in **device rounds**. (Worked cases: A1-576 / `assoc-one/meirionpritchard-com` PR #210, 2026-09-30 — a hero backdrop that would not fill under Safari 26's moving bars, roughly fifteen rounds of one guess per build (dvh, lvh/env, overshoot, opacity, tint strip, root background) before a switchable readout at `?bgdebug=1` produced the facts in one round; and A1-553, the antecedent, whose ACs were ticked "verified on device" on Chromium emulation plus a masked flat-colour check, so the same bug re-surfaced in image and video mode — APP-1905. The standing remedy for the missing engine is a hosted cross-browser service, the Owner's call, tracked at APP-1735 and not here. Reported, not observed: no repo is readable from this surface, so the round count, the readout gate and the A1-553 tick are the filing leg's report.)

   **A source-code reading is a hypothesis until the device confirms it — ship an unambiguous probe switch beside the candidate fix.** The rule above makes the device round the scarce resource; this one says what a round built on *reading* has to carry. A clause found in an engine's or framework's own source — WebKit, Blink, an OS layer — explains the bug in front of you only if that code path is the one running on the Owner's device, at his version, under his conditions, and nothing in this sandbox can establish that. So a reading is a **hypothesis however exactly it matches the symptom**, never a finding, and it does not become one by being cited in a commit message. The round that tests it therefore ships a **probe switch** beside the candidate fix: something whose **presence or absence on the device distinguishes the hypothesis from its rival in one round** — a value, a colour, a geometry that can only appear if the quoted path is live — rather than a fix whose success is the only evidence. A fix that works is the weakest discriminator available, because it confirms every hypothesis that predicted it and silently credits the reading for a round it did not decide; a fix that does not work says nothing about which half was wrong. Give the probe a value that differs by construction, as the masking corollary above requires, and name in the hand-off **which switch falsifies which reading**, so what the Owner sends back is a verdict rather than an impression. (Worked case: A1-576 / `assoc-one/meirionpritchard-com` PR #210, 2026-09-30 to 10-01 — round 1 was built on a WebKit-source exception read on the 26.0/26.1 branch (`viewportConstrainedSublayers`: no clip where the compositing ancestor is not the RenderView), which looked conclusive. A magenta probe, P1, on the Owner's iPhone falsified it in **one** round; the fix then converged in 9 batched on-device rounds and was approved as D092. The probe beside the fix is what made that round decisive instead of ambiguous. Reported, not observed: no repo and no device is readable from this surface, so the source clause, the probe and the round count are the filing leg's report — APP-1905.)

   **Diagnostic instrumentation added to the running product has a blast radius — scope it, keep it off CI's routes, and remove it in a named commit.** Where a bug cannot be reproduced in this sandbox — a device or engine this image does not carry — the tempting move is a visible on-page readout the Owner can screenshot from the real device. It is a legitimate technique and it is a change to the product like any other, so: **scope the render** to a single route or a query-param gate rather than the root layout, keep it **off any route the screenshot suite drives**, prefer a mechanism **outside the server-rendered tree** — appended from a client effect rather than a server-rendered `<script>` or `dangerouslySetInnerHTML` pair, which trips SSR hydration diffing — and **remove it in its own commit** once it has served its purpose. And recognise its failures: when CI reddens on a change that also carries temporary instrumentation, **read the failing job's DOM snapshot for the instrumentation's own text before treating the red as the change**, because a hydration mismatch degrades unrelated assertions instead of failing loudly, so a deterministic screenshot diff beside a one-off flake elsewhere in the same run is the expected pair rather than two problems. (Worked case: A1-553, `assoc-one/meirionpritchard-com` PR #200, 2026-09-28 — a fixed-position overlay plus an inline script in the root layout, added to diagnose a Safari-only viewport bug from a Chromium-only sandbox, rendered on the fixtures route the screenshot suite drives and pushed a pixel diff over threshold on two viewports, while the raw DOM mutation triggered a hydration mismatch on every load and likely a second, flaky failure in an unrelated interaction test. Root-caused only by noticing the overlay's own debug text inside the failing screenshot's DOM snapshot. Confirm the route and the spec against `origin/main` before writing a per-repo claim. APP-1835.)

   **A verification build that takes base mid-review imports other tickets' visible changes — the hand-off names which ones, or a sibling's change is read as a new bug on this ticket.** Merging `origin/main` to clear a conflict, or rebasing before a further device round, is correct and often unavoidable (step 5). What it also does is pull every visible change merged since the branch was cut into the surface the Owner is about to judge — and he is judging *this* ticket, from a screenshot, with no way to tell which pixels this branch moved. An imported change that looks wrong is then reported as a new bug on this ticket, and a scarce device round is spent on work this branch never touched. So where a build handed over for a device round **took base after the previous round**, the hand-off **names which visible changes came from base rather than from this ticket**, one per change with the ticket that owns it, read from the merge's own log rather than recalled; and a genuine defect in one of them is **split to its owner's ticket, never fixed on this branch** — fixing a sibling's bug here puts unreviewable work in this PR and hides the regression from the ticket that caused it. Where the choice is available, take base **once, before the round that needs it**, rather than between every round: the imports are then named in one hand-off instead of accumulating silently across a sequence. (Worked case: A1-576, 2026-09-30 to 10-01 — a `main` merge taken to clear a conflict brought in the A1-578 sticky header, whose opaque surface then showed up as a "new bug" in the Owner's next device check on the hero backdrop, and was correctly split out to A1-589. The split was right and the round was still spent on a bug this ticket never had. Reported, not observed: no repo is readable from this surface, so the merge, the header and the split are the filing leg's report — APP-1905.)

   **A number that describes the environment is measured, not estimated (APP-1072).** Where a change sets a timing, retry or duration margin for a scheduled or automated job, size it against that job's **observed history** — `mcp__github__actions_list` filtered to `event: schedule`, or the equivalent run log — not against its configured cron, and pin the observed figure in a named constant the test asserts against. A cron is an intention presented as a fact: nothing in the file or the type system distinguishes "when this is asked to run" from "when this runs". The tell is a hedge about the environment — "routinely", "typically", "best-effort", "should complete within" — sitting beside a number the build depends on; that is a measurable claim written as an estimate, and no local gate has standing to check it. An assertion introduced alongside a margin is shown to fail against the value it replaced, or it is not a test — the adjacent case of never loosening one. And where the variable is unbounded, the durable fix moves the guarantee to a run-time check at the point of use, with the schedule demoted to a probability improvement. (Worked case: APP-943 sized a 45-minute Friday-close margin against a cron whose best observed start delay was +26 minutes and whose last five were +2h to +7h52m, with a `>= 30` test that could never fail for the reason that mattered; thirteen gates were green and Prism caught it at QA.)

   **Before opening the PR, re-fetch the ticket state.** If it has left In Progress under `agent:F0-RGE` since the claim — Canceled mid-run as superseded, or moved by another actor — **stop**: do not open the PR, do not move to In Review, and do not re-set In Progress. Nothing between the claim (step 2) and here re-checks state, so a "do not build" cancellation landing on an in-flight ticket otherwise reaches nobody, and the run un-cancels the very ticket it was told to drop. Honour the change and comment that the run stood down. (Worked case: APP-771, 2026-08-10 — cancelled as superseded at 12:57:13, the run opened its PR four seconds later and moved the ticket back to In Progress then In Review; the output happened to be current canon, so process and content failure came apart by luck — APP-775.)

   **Push the commits made since the branch-cut push before calling `create_pull_request` — the step 1 push proves the branch exists, not that the work is on it.** Step 1's early push is deliberately a one-time crash-safety action and is satisfied by an empty first push ("an empty or near-empty first push is enough"), so it leaves the ordinary push-before-PR obligation unstated: a commit made locally during the long body of work is invisible to the PR-open call, which refuses with `Validation Failed — PullRequest (custom): No commits between main and claude/<ticket-id>`. That message names the symptom and not the cause, and reads as a branch-naming or base-mismatch problem to a leg not primed to suspect an unpushed commit. So push the branch again here, immediately before the PR-open call, and read that error as diagnostic of an unpushed local commit before investigating anything else. Step 5's force-push after the rebase is the same obligation one step later, not a substitute for this one. (Worked case: APP-2049, `assoc-one/claude-ops` PR #386, 2026-10-05 — branch cut and pushed per step 1, two canon files committed locally, `create_pull_request` called with no intervening push and refused on "No commits between main and claude/APP-2049"; one `git push origin claude/APP-2049` and a retry succeeded, at the cost of one failed tool call and no round trip — APP-2072.) **Unverified — no repo access from this refine surface:** the premise flagged is git's and `create_pull_request`'s behaviour on a branch whose remote head is unchanged, together with the exact refusal string quoted above; both are taken from APP-2072's record of the 2026-10-05 run and were not re-run at authoring time. No other claim in this paragraph is covered by this flag.

   Then open the PR **as a draft**, and never merge. Exec always opens the PR in draft state: `skill-review-pr` converts it to Ready for Review on a clean pass and leaves it draft on a changes-needed verdict, so the draft/ready bit — the one signal Aled reads on GitHub without opening the Linear thread — means exactly *QA has passed*, and nothing else. Opening a PR ready pre-empts that signal, and a later changes-needed verdict then has no draft state to leave it in (APP-822). (Worked case: A1-236, `assoc-one/meirionpritchard-com` PR #78, 2026-07-31 — a `modify/delete` conflict resolved by adding `"use client"` to `NavItem.tsx` while the icon lookup stayed in the server-rendered `NavBar`, passing a `ComponentType` across the boundary. `tsc --noEmit` and `eslint .` were both clean, `npm run build` was not run, and a break of the live home page reached review marked clean — while that run's own hand-off note had already said "check nothing upstream depends on it being server-rendered". It was caught only because Vercel happens to build previews on that repo: luck, not a gate. The same run's A1-290 on `firmup-operator` ran its build because that repo's CI has one — the difference was the repo, not the discipline. Whether `meirionpritchard-com` gains a build gate in CI is a repo-lane leaf, not this skill's to fix — APP-732.)

   **Read the PR and its CI state through the GitHub MCP, never `gh` or a raw `curl`.** Exec is the first leg to read CI — during a blind CI iteration (above), and once at hand-off to record what has concluded — and the only statement of how to read it has lived in `skill-merge-pr`, which exec never reads — so read it here. **Exec reads CI; it no longer waits on it for the hand-off** (step 6, APP-927): the bounded-wait mechanics belong to the legs whose gate CI is, QA and merge. In this sandbox `gh` is absent and `GITHUB_TOKEN` is a non-usable placeholder, so a `gh` or `curl`/API-token poll of the GitHub REST API silently returns an empty body that misreads as a false green — no failures — or spins forever. Read the PR and its checks through the GitHub MCP tools (`mcp__github__pull_request_read`, method `get_check_runs`) instead. The mechanism lives in `convention-github` *Reading CI / PR state in autonomous runs*, with the bounded CI-wait mechanics carried by `skill-merge-pr` — follow it there rather than restating it, consistent with calling an existing skill instead of duplicating its logic (the APP-695 branch-naming precedent). (APP-968.)
5. **Rebase before hand-off — onto the pull request's own base ref, never `main` by reflex** — resolve this pull request's base ref first (`origin/next` where the repo stages its work on an integration branch, else `origin/main`; and for a pull request stacked on another, the parent pull request's own branch is the base), and treat the base moving under an open stacked pull request as the ordinary case rather than the exception (evidence, **reported** by the filing leg and not re-read from a repo on this surface: `aledpritchard-com` #41 was cut from the head of the open #40 to reuse an unmerged component, the base then gained `f4d5aa6`, and nothing prompted a re-sync — so the #41 preview silently lacked the base's later work and the Owner found it by eye; one merge of the base into the branch fixed it, 2026-11-06 — `APP-2918`). Fetch **that** ref and read its real remote tip immediately before the push, per `convention-github`'s *Re-read the authoritative remote tip immediately before the final push* — `git ls-remote origin <base-ref>`, never a possibly-stale local tracking ref — then rebase the branch onto it, resolve any conflicts, and re-run the step 4 verification sequence — build included — to confirm the PR is clean against the current baseline. Force-push the updated branch. If the rebase produces unresolvable conflicts, take the Blocked path.
6. **Tick both sections, then hand off** — walk **both** checkbox sections, `## Acceptance criteria` (per ticket) and `## Definition of done` (per type), and tick every box this change genuinely satisfies (`- [x]`); leave any box you cannot satisfy unticked and call it out, never quietly skip it. **Never author or edit the acceptance criteria** — AC is the author's, ticked here, not written here; a box you cannot meet is a bounce or a Blocked, not a reworded criterion. **And the positive branch, stated here because this is the artefact the executing leg reads at hand-off:** where a box's own text is broader than what this change delivers, the criterion's text stays **byte-identical** and the account goes in an indented note beneath that box — never a scope note spliced inline into the criterion, never a softened restatement, and never a narrowing followed by a tick. A narrowed box reads as satisfied where a blank box reads as visible debt, so the narrowing survives into review and the only surface that can catch it is a diff against the ticket as created. The referent-release clause below — measure the population yourself and tick against the **property** where a referent cannot be resolved — licenses a record and never an edit: it reaches a criterion whose property is met on a population this leg measured, and it never reaches a criterion whose property is met only once the criterion has been made smaller. *Guardrails* carries the same rule; it is restated at the step for the reason step 1's early-push rule is (APP-1385), because a leg reading only the step it is standing in is handed three doors — tick, bounce, Blocked — and takes a fourth that canon never opened. (Worked case, **reported** and not re-read from a repo on this surface: an A1-879 QA leg on `assoc-one/a1-advisory` PR #50, head `9802cdb`, 2026-11-04 — at hand-off the exec leg gave AC1 ("No bracketed placeholder text renders anywhere on the page at any width") an inline note scoping it to the quotes section and then ticked it, while a Momentum stage-card placeholder still rendered at every width; read against the current body the box read as met, read against the Linear linkback snapshot it was not, and QA caught it only by running the APP-2710 diff. Third instance in the APP-2158 → APP-2710 line and the first after the positive branch was written into *Guardrails*, so the gap is **placement, not wording**. Repo, pull-request number and head SHA are the filing leg's report and are **unverified** — this refine surface reads no repo — APP-2855.) **The prohibition reaches a `## Definition of done` box exactly as it reaches an acceptance box.** Both worked cases above are acceptance criteria and the rule's wording is generic, so a leg standing here has read the prohibition twice and still read a DoD box as its own bookkeeping to phrase. It is not: the per-type section is the author's text at the same bar — ticked here, never written here — and it is the easier one to reword precisely because its boxes describe this leg's own hand-off actions, which feel like the leg's to describe. **And the shape that defeats the rule is a box whose condition is a state this leg cannot write:** where a box names a state the leg has no means to set — an assignee, a label group, a field another role owns — that box is a bounce or a Blocked with the gap named, never narrowed to the part the leg could satisfy. Dropping the unwritable half and ticking the remainder is the narrowing already forbidden above wearing a reason, and it is worse than a blank box in the same way: the half removed is exactly the half nobody then checks, so the box reads as met on a condition the ticket never asked for. (Worked case, **reported** and not re-read from a repo on this surface: at hand-off an exec leg reworded the hand-off-state box of `## Definition of done`, dropping *unassigned* from it and leaving In Review and `agent:PR-1SM` as the whole condition, then ticked it. Fourth occurrence in the `APP-2158` → `APP-2710` → `APP-2855` line, all closed, and the first on a definition-of-done box rather than an acceptance box, so the gap is **coverage made explicit** and not a third restatement of a rule already live twice in this artefact. Confirm the box's own text against the ticket's description as created before writing any figure beside this case; expected: the hand-off box naming In Review, `agent:PR-1SM` and unassigned. Every repo-side figure the note carries — pull-request number, head SHA, commit count, CI job name — is the filing leg's **report** and is **unverified** here: on this surface `gh api user` returns 200 as `assoc-one` and an unattached repo, public ones included, returns 403, so no repo was read — APP-2889.) **Two edits are permitted here, and neither is authoring. The first is a verbatim bullet→checkbox conversion:** where the `## Acceptance criteria` (or `## Definition of done`) section is present but its items are plain bullets rather than `- [ ]` checkboxes, add the box to each existing line and change nothing else — a plain bullet cannot be ticked, so it sits outside the Done gate (`convention-ticket`), and adding the box is what lets you record completion, not an act of authoring. Convert the wording unchanged: never reword, add, split, or remove a criterion. This is **not** the format-less case of step 3b — the section and its criteria exist, only the checkbox syntax is missing — so convert in place rather than bouncing to Relay. **The second is a verbatim heading repair:** where step 3b found the property under a deviant heading — `## What to check`, or a bold line rather than a `##` — rename that heading to `## Acceptance criteria` (or `## Definition of done`) and change nothing below it. Both edits fix the *container* so the criteria become tickable and the Done gate can read them; neither touches a criterion's wording, which stays the author's. Where even that feels like a reach on a given ticket, name the repair for Relay in the hand-off comment and build regardless — a heading is never a reason not to build (APP-1137). **A box a bounce says is already ticked is verified in the description, never taken from the comment.** A verdict or bounce comment is read by the next leg as an instruction, so an unverified state claim in one behaves like a bad instruction — and the "already settled, do not redo" framing that correctly stops a leg re-litigating passed *content* reads across to *state*, which is the half that can silently not have happened. The two checkbox sections sit under different headings in one description, so a single patch write that touches one list and not the other produces exactly this shape and nothing reports the partial. Re-read the description and tick what is blank: the tick is cheap and idempotent, and the missed box is a bounce. (Worked case: A1-381 / `assoc-one/firmup-operator` PR #23 round 2, 2026-09-08 — the bounce asserted in bold, three times across two comments, that "both boxes are now ticked on this ticket". The `## Definition of done` box was ticked; the `## Acceptance criteria` box was still `- [ ]` fifteen minutes later when the exec leg claimed it. The leg only avoided handing off with a blank AC because it re-read the description rather than the comment. APP-1184.) **The tick is a write to the ticket's own description, and that write is its own required action.** Ticking means a `save_issue` patch against the Linear description that carries the criteria — that description is what `skill-review-pr` reads and what the Done gate measures, so a box left `- [ ]` there reads as unmet work however much was actually done. **The copy of the same checklist in the PR body is a courtesy mirror for the human reader on GitHub, and it closes nothing**: ticking it is not ticking the box. The two are easy to conflate precisely because the PR body is already being composed while the ticket-side write is a separate call, easy to skip once the PR is open — so do it as a named action of this step, not as something folded into "hand off", and do both: tick the ticket description, then mirror the same ticks into the PR body. (Worked case: APP-1520 — an exec leg verified the origin, digest-matched the artefact, ran the manifest build and ran the dual-build render check, then opened the pull request with every acceptance and definition-of-done box ticked **in the PR body** and every box in the ticket's own description left blank. The driver's next pass read the blank boxes as unmet work and bounced the ticket back to Todo with `agent:F0-RGE`. The pull request itself needed no changes at all; the omission cost a full claim, re-verify and hand-off cycle on a ticket that was already finished and verified. Repo and pull-request claims here are **unverified**: this session has no GitHub access.) Never hand off with a tickable box in either section left blank **that this leg can verify now**. The qualifier is deliberate and narrow: it releases only a box whose truth-maker lands *after* the hand-off write — the *"CI present, concluded, green"* clause of the PR box, where remote CI has not concluded at the moment the PR opens — and it releases nothing exec could have checked locally. So the hand-off sequence is: PR open (draft), rebase clean, local gates green, every locally-verifiable box ticked, then **write the hand-off at once** — In Review, `agent:PR-1SM`, assignee cleared, PR link commented. Read the PR's CI state **once** at that moment through the GitHub MCP (`convention-github` *Reading CI / PR state*): if it has already concluded green, tick the box; if it has not — or the read still says `in_progress`, which lags (APP-938) — leave the box blank, say so in the hand-off comment and the PR body ("CI not concluded at hand-off — QA closes on its own read"), and **do not wait on it**. `skill-review-pr` re-verifies CI at the head it reviews and closes the box on its own verification, never on exec's word (APP-1025), and bounces a red PR as it always has. The accepted trade is that QA can pick up a ticket whose CI later goes red; that exposure is absorbed by QA treating CI as its own gate, and the alternative — a finished, green PR parked In Progress behind a signal the sandbox cannot read — is the likely-stalled-handoff shape `routine-delivery-loop` must then recover from (APP-924). A crash after the hand-off write leaves a valid, self-describing state; a crash during a CI wait leaves an active-run signal on finished work. (Worked case: APP-858, `bot-trader` PR #27, 2026-08-14 — PR opened 00:46:37, CI 11/11 green by 00:48, hand-off resumed on an Owner instruction at 09:03 the next day: 32.4 hours stranded with nothing outstanding but the state transition — APP-927. Owner ruling, Aled 2026-09-03.) **A machine-checkable box is ticked only on the actual check, never on faith:** where an AC is literally byte- or text-exact against an attached source (for example "`x.html` byte-identical to attached `y.html`"), run the diff against that source before ticking, and leave the box blank for QA if you cannot run the compare — self-attesting a byte-identical box you have not diffed sends a non-identical file to review as clean. The same discipline covers a criterion phrased as a **property** or a **spec/delta row**: verify the *end state the row asserts*, not the artefact the row happens to name — deleting a duplicate *definition* is not the same as removing the *duplication* — and a row you cannot honestly close is a waiver candidate, not a tick (worked case: a blueprint-vs-build row ticked by deleting a token block that left the durations hand-typed and unreferenced, with a false reduced-motion mechanism given as the rationale — APP-726). **And where a criterion's *property* is met but a *referent* it names cannot be resolved, close the property and record the referent — a blank box is not the only outcome available.** A criterion routinely pairs a checkable property with a count, a list, or a named prior change ("all 17 artefacts named in this run's canon change render a whole first sentence"): the property is testable and the referent may exist on none of the four surfaces step 3a searches. Where it does not, **measure the population yourself, state the measured number and how it was derived, tick the box against the property, and name the unresolvable referent in both the hand-off comment and the PR body**. That is a record of what was verified, not a reworded criterion, and the wording stays the author's. Two limits hold it honest. **Tick only on your own measurement:** a box ticked against a population the run never identified is the same false self-attestation as an undiffed byte-identical box, and a count read as a *target* rather than as a referent sends a run looking for work that does not exist. **Where the property itself cannot be measured**, the box stays blank and named as ever; and where the mis-written referent should come out of the criterion altogether, that is the operator's evidenced waiver (`skill-operating-loop` step 5, *Criterion waivers on evidence*), raised in the hand-off — never Forge's edit. (Worked case: APP-1320's third criterion named "the 17 artefacts named in this run's `convention-artefact-format` canon change". The change and the figure do exist in the live store — *"Measured 2026-09-11 against the live store: 17 artefacts we own split early"* — but it names only four of the seventeen, so the list was unreachable while the property was met on a population the leg measured itself: 10 in the `claude-ops` manifest plus 1 on the site, all whole after the fix. The leg left the box blank and explained, which was correct under canon as written and still handed review a PR reading as open work, on a ticket where nothing was outstanding — APP-1358.) Then set `agent:PR-1SM` (evicts `agent:F0-RGE`), move to In Review, **leave the ticket unassigned**, and comment the PR link and a short summary. **The description tick is written and read back before the hand-off comment is drafted, and the comment reports only ticks already read back.** A comment saying the boxes are ticked is a state claim the next leg reads as fact (the APP-1184 shape above), so draft it from the re-read description, never from the intention to tick, and never let the tick write trail the comment. (Worked case: A1-449, `meirionpritchard-com` PR #146 — the leg moved the ticket to In Review, posted "Both AC and DoD boxes ticked in the ticket description where verifiable now", and only then wrote the patch that ticked eight boxes; self-caught in the same turn, the third instance in the APP-1184 → APP-1520 line — APP-1559.)

    **The hand-off box is the one box this step cannot tick in sequence — so it is ticked in the read-back after the hand-off write, not released.** Every other box is ticked before the hand-off; the hand-off box's own truth-maker — In Review, `agent:PR-1SM`, assignee cleared, PR link commented — is that write, so at tick time it is honestly blank and the CI release above does not reach it: that release is for a signal **outside** this leg that may never conclude, and this one is exec's own write landing a second later. So the sequence gains one step at the end: write the hand-off, **re-read the description, tick the hand-off box, read it back, mirror it into the PR body**, and only then draft the comment — which still reports ticks already read back (APP-1559). Nothing here is QA's to close: a box whose truth-maker is this leg's own write is not an attestation problem, it is a bookkeeping step with no home, and that is why both recurrences left exactly this box. **Derive both surfaces from the one read-back**, never compose them independently — a tick made on either surface from the intention rather than from the re-read is the APP-1184 shape whichever surface it lands on. (Worked cases: APP-2291 / `assoc-one/claude-ops` PR #431, head `8c8a633`, 2026-10-12 — the hand-off box ticked in the PR body, blank on the ticket, while the hand-off comment said both sections were re-read and confirmed. The condition was genuinely met, so QA closed it on its own read and noted the miss; under a stricter driver read it is the APP-1520 shape, a finished, verified PR bounced to Todo over bookkeeping. Then APP-2285 / PR #437, head `ed87f3c`, the same day, running the other way: the CI box ticked on the ticket while the PR body left it blank and exec's own comment said it was unverified — a tick made before its truth-maker existed, which the CI clause above already forbids. Two instances one day apart, opposite directions, one cause: the two checklist writes were not derived from one read. Repo, pull-request numbers and head SHAs are the filing legs' report and are **unverified** — this refine surface can read no repo; that flag covers those three only — APP-2292.)

    **Where the ticket's own definition of done names no PR, the hand-off is *not* `agent:PR-1SM` — take the no-PR exit, and cite it rather than re-deriving it.** The default above is written for the code lane and names `agent:PR-1SM` as the only hand-off target, which is right only where a PR exists for a reviewer to act on. `routine-delivery-loop` already rules both the test and the exit (*Spike-ticket variant — no PR, no QA/merge*; *The entry test keys on the definition of done, not the title*): the test is whether the ticket's **definition of done names a PR** — a `spike` label or a spike-shaped title is a hint, never the test — and where it names none, the deliverable is not code, so route to **In Review**, set `human` (evicting `agent:F0-RGE`), **assign Aled**, comment that the artefact is ready for his read, and skip the QA and merge legs; where the DoD names its own reviewer, that reviewer is the one it goes to (*A swept ticket with no open PR is a finding, not a skip*). This is a restatement and not a new rule — it is stated here because this is the artefact the executing leg reads, the same reason step 1's early-push rule is restated here rather than left in the driver's prompt (APP-1385). Two consequences are worth stating. A prior no-PR ticket in the same chain is **not** the authority: a chain whose predecessor was reviewed without a PR is evidence about what one run did, not about where this one routes, and reasoning from it is what has made the decision come out differently twice. And this is distinct from step 3a's **already-satisfied** path, which covers a ticket with no work product at all; this covers a ticket that produced a real deliverable its DoD never expected a PR to carry. (Worked case: A1-565, `assoc-one/meirionpritchard-com`, 2026-10-05 — a trace/confirm ticket whose DoD named no PR, handed off to In Review + `agent:PR-1SM` on the precedent of its blocking predecessor A1-557 rather than on canon, the second such improvisation in two tickets with no citation left behind either time; the mis-route's cost is the one APP-1129 and APP-1108 record, since every net downstream keys on the label the mis-route has already set wrongly — APP-2041, and the same no-citation shape APP-695 named for branch naming.)

    **An explicit per-ticket or per-session gate on hand-off timing supersedes the default sequence above — satisfy the gate, then hand off.** The sequence just given — write the hand-off at once, read CI once, never wait on it — is the *default*, and the Owner ruled it on 2026-09-03 for the case where nothing but the state transition is outstanding (APP-927). A ticket's own brief, or the task-setup instruction a session is dispatched with, can carry a **stricter** gate; the known form is "when the PR is green and the Owner-assisted checks pass, hand off". That gate is the Owner ruling the *what* for that one ticket, so it governs over this step's default. So **read the brief for a hand-off condition before writing In Review**, and where one exists treat "PR opened" as insufficient: the hand-off write — In Review, `agent:PR-1SM`, assignee cleared — lands only once every condition the brief names is satisfied and confirmed, not once the PR exists. This is narrow and it does not reopen the default: absent an explicit gate, do not wait on CI, and never infer a gate from a ticket merely mentioning CI, a preview URL or a reviewer. **A premature hand-off is recovered, not argued with** — revert to In Progress with `agent:F0-RGE`, restating the full label set in one `labels` replace because the `agent` group is single-select (see *Every fail-safe write is a full* `labels` *replace*), leave the PR open and the branch alone, and redo the In Review + `agent:PR-1SM` transition once the named gate is actually met. (Worked case: A1-529, `assoc-one/meirionpritchard-com`, 2026-09-24 — the Owner's task-setup instruction gated hand-off behind CI-green *and* a live Owner-assisted verification pass on the Vercel preview Studio; the leg followed this step's default and set In Review + `PR-1SM` immediately on opening the PR, before CI concluded and before any verification, self-caught it on re-reading the brief, reverted to In Progress + `F0-RGE` with the full label set restated, and redid the transition once both conditions held. Instance count 1, self-caught by no gate. The A1-529 repo, PR, CI-state and Vercel-preview-Studio claims are **unverified** — this refine surface can read no repo and did not read A1-529; the ticket-state sequence is as APP-1758 reports it — APP-1758.)

    **Clear the assignee here, *after* the PR has attached — not only at claim (step 2).** Linear's GitHub integration auto-assigns the ticket on PR attach, and that write lands *after* exec's step-2 clear, so a run that clears only at claim hands off Aled-assigned despite complying with the leave-unassigned rule to the letter. **Re-read the ticket immediately before the handoff write** rather than trusting the claim-time state, and clear the assignee again if the integration has re-populated it. This is the same do-not-assume-your-state-survived-another-actor's-write lesson as step 4's pre-PR re-fetch (APP-775). Keeping the assignee clear through exec and review is what makes "assigned to Aled" mean "Aled's decision is needed now", not "in flight"; Prism assigns Aled once review is done (see qa). (Recurrence: APP-916 / PR #33 caught and corrected at handoff, then again on PR #34 — consecutive PRs, so the re-assign is the default, not the exception — APP-936. Owner rider, surfaced not enacted: the class can be removed at source by turning **off** auto-assign-on-PR-attach in Linear's GitHub integration settings — a workspace-config action, not a canon edit — but the clause holds either way.)

    Leave a comment for the PM leg where project management is needed.

**Where this leg is not a delivery-loop run, the hand-off write is not the end of the session's duty — dispatch the next legs yourself.** Steps 1–6 end at a state transition, and under the timer that is correct: `routine-delivery-loop` picks the ticket up on its next firing. A session the Owner started by hand is not on that queue, so **nothing picks it up**, and a ticket left In Review + `agent:PR-1SM` by such a session sits there indefinitely while the session that just finished it reports that it is waiting on Prism and Relay. So once the hand-off write has landed and the PR is green, **spawn the QA leg (`skill-review-pr`, Opus tier, worktree isolation) as a sub-agent, route on its verdict, then spawn the merge leg (`skill-merge-pr`) as a sub-agent, and move on** — the same sequence the driver runs, on this leg's own ticket. The fleet boundary is unchanged and so is the one that matters: Forge still never merges its own PR, the merge is Relay's leg run as `skill-merge-pr`, and its CI-clean and conflict fail-safes apply exactly as they do under the timer. **Cite this rather than waiting to be asked.** The duty is already canon twice — `routine-delivery-loop`, *"An interactive build session with a green PR drives these legs itself — it does not wait for the schedule"*, and `convention-agent-runtime`, *"Spawning the next leg is the default, not a thing to be asked for … the posture holds for an interactive session exactly as it does for a driver routine"* — and it is restated at this step because **this step is the surface a hand-started build session has open at the moment it stops**, and the two artefacts that carry it are ones such a session has no reason to open. What still stops a session is a gate the leg itself carries — an Owner signal, a credential, a decision that is not the session's to take — never the absence of an instruction to proceed. (Recurrence, three sightings in ten days: APP-1703 / A1-499, 2026-09-23; APP-1853 / A1-557; and APP-1995 / A1-589, 2026-10-02, where the session routed to In Review + `agent:PR-1SM` at 15:42Z, restated the wait twice, and dispatched the Prism leg only at ~18:50Z on the Owner's second prompt — approval-to-merge wall-clock went from minutes to hours on finished, green work. Filed Urgent. Repo, PR and session-transcript claims there are **unverified**: this surface can read no repo.)

**Once the ticket rests In Review the branch head is frozen for that review, and a further push is a re-open the leg declares on the ticket.** The hand-off write hands QA one head, and every read QA then makes — the CI conclusion, the base-vs-head diff, the render capture, the gates it re-runs — is a read of that head. A commit pushed while the ticket sits In Review does not add to the review, it invalidates it, and silently: nothing in the hand-off comment or the PR body says which head a verdict was earned against, so a clean verdict at the old head arrives looking like a verdict on the new one. So after the hand-off write this leg pushes nothing to that branch unless it first re-opens the review deliberately — comment on the ticket naming the new head and what changed, and let QA start from there. Where the push is genuinely wanted, a gate left red or a defect the leg spotted itself, the honest route is the one a bounce already takes: say it on the ticket **before** the push, never after, so no verdict is ever composed against a head that has already moved. This is the producer-side half of a discipline `skill-review-pr` carries only from the reader's side, where the converse — a merge landing ahead of the verdict (`APP-1022`) — is covered and a push landing ahead of it is not. The asymmetry decides it: a held commit costs one review cycle's wait, a moved head costs the whole review again. (Worked case, **reported** and not re-read from a repo on this surface: an exec leg pushed a second commit after the hand-off write while QA was mid-review; the head moved under the review and the review was redone at the new head. Confirm the pull-request number, both head SHAs, the commit count and the CI job name against the repo before writing any of them into canon; expected: the values the note reports, none of which was read here. The premise is **unverified** — on this surface `gh api user` returns 200 as `assoc-one` and an unattached repo, public ones included, returns 403 — so no head was resolved and no CI run was read — APP-2887.)

Then re-run the eligibility scan and take the next ticket. **End the run** when no eligible ticket remains. If the run is nearing its time budget, stop claiming new tickets — but always finish the in-flight ticket's handoff first, so an ending run leaves at most the one ticket it was actively working part-done (the same exposure as a single-ticket run).

**Blocked (fail-safe).** If you hit a blocker you cannot resolve — push rejected / no write access, a missing dependency or credential, or a requirement too ambiguous to act on safely — do **not** leave the ticket In Progress and do **not** open a half-baked PR. Move it to **Blocked**, set `human` (the `agent`-group value, evicting `agent:F0-RGE`), assign Aled, and comment plainly what blocked you and what is needed to clear it. This empties In Progress so the leg is not jammed and the next ticket can run, and it surfaces the blocker to Aled. Aled clears the blocker and moves the ticket back to Todo to retry. Within a run, a Blocked outcome ends only *that ticket's* cycle — the run continues to the next eligible ticket.

**Every fail-safe write is a full** `labels` **replace — restate every other label.** The `agent` group is single-select, and eviction happens **only** through `save_issue`'s `labels` parameter, which is a full replace. `addLabels` does not evict, it errors: `addLabels: ["human"]` on a ticket carrying `F0-RGE` returns `400 invalid_request` — *"Only one label in a group can be applied to an issue"* — and because the whole call fails, the state, assignee and relation changes bundled into it go down with it, so a run whose comment says the ticket was routed has written nothing. So **"clearing the executor" is a** `labels` **array with the** `agent`**-group value simply omitted** — not a removal call — and every other label the ticket carries is restated verbatim in that same array: the bare type label, the workstream label, any `cycle:` or `domain:` label, and the `operator-<venture>` value being set. A full replace silently drops whatever the list leaves out, which is how the remedy for one silent drop causes another. Re-read the ticket's labels immediately before the write, swap or omit the one `agent`-group value, restate the rest, and read the write-back. (`convention-linear`, *Labels* — Single-select; APP-1102, APP-1116.)

**Partition the criteria before you park — split the ungated set out as its own leaf, in the same action.** A blocker rarely gates *every* acceptance criterion. Before parking, partition the AC set: separate the criteria the blocker actually gates from the criteria it does not, and where an ungated subset can be built and shipped without the missing credential, decision, dependency or elapsed observation window, **file it as its own build leaf in the same action as the park** — do not leave it as a later discretionary offer. Keep the gated criteria on the Blocked parent carrying the `blockedBy`, set the ungated leaf at the **parent's priority** (a live-exposure criterion inherits the parent's urgency, never the queue's tail), and reuse the existing `human` setup-leaf + build-leaf split shape (`convention-ticket`). Making it a step rather than an option is the whole point: discretionary is what failed. (Worked case: APP-824 — six ACs, two of them ungated and one a live safety exposure (a guard flattening once per episode ever on a host holding overnight positions); the run *did* spot the split and *offered* it, and the offer cost a round trip to the Owner during which the live exposure sat unfixed. Split by hand in-session as setup leaf + build leaf — APP-934. The refine-side half — widening `convention-ticket`'s credential test from "minting or granting" to "minting, granting, or deciding" — is that convention's to carry.)

**Release (the ticket is too large for the remaining budget).** The claim stays where it is — before the repo is touched (step 2) — so the only way to learn that a ticket will not fit the session's remaining budget is to claim it and then look. That is expected, and it has a clean exit of its own, distinct from Blocked. Where post-claim scoping shows the work cannot be carried to a finished PR in what is left of the run — the borrow source is an order of magnitude larger than the brief implies, the surface far wider than the ticket reads — **release the claim rather than half-building it**: move the ticket back to **Todo**, keep `agent:F0-RGE`, leave it unassigned, cut no branch and touch no files, and comment that the claim was released un-started, that no code was written and nothing is inheritable, that eligibility was re-confirmed, and — the part that pays for the round trip — the scoping notes gathered before stopping, so the next run starts from them instead of re-deriving them. This is **not** Blocked: a ticket that is merely large names no dependency to clear, and a Blocked ticket naming no dependency reads as dependency-bound while nothing ever clears it (`convention-linear`). It is not a partial PR either. **Do not pre-read the repo to size a ticket before claiming it** — a lock taken after the work is not a lock (step 2, APP-522), and two state transitions in the ticket's history are the correct price for that guarantee. Release before the run ends, though: a run that stops mid-scoping without releasing leaves exactly the ghost claim stale-claim recovery exists to clean up. (Worked case: APP-666, 2026-07-25 — eligible on every test, and scoping after the claim showed its borrow source ran to roughly 2,500 lines across 12 modules and 11 test files, with nothing in the normal-length brief to signal it. Released to Todo un-started, with the scoping notes carried forward — APP-694.)

**Operator hand-off (the deliverable itself is outside the sandbox).** Some tickets ask for an action this environment cannot perform at all, however well-formed the ticket is. The known instance is **branch deletion**: the git proxy refuses ref-deletion pushes with `HTTP 403` — its own error is `ERR Unable to parse branch information from push data`, because a delete push carries no pack data for the proxy to read a target branch from — while ordinary pushes over the same remote succeed in the same session, and no GitHub MCP tool deletes a ref (`create_branch` has no counterpart). `skill-merge-pr` documents this and rules correctly for *its* case: after a merge the deletion is hygiene, so record it and continue, because shipping is the outcome and hygiene never gates it. **That reasoning does not transfer to a ticket where the hygiene is the outcome** — there is no shipping for it to be subordinate to, and the ticket simply cannot be finished. Where the unperformable action *is* the deliverable:

- **Do every part that can be done**, and tick those boxes honestly; leave the unperformable box unticked and name it plainly.
- **Hand to the operator rather than to Blocked** — move to **In Review**, **clear the executor** (no `agent`-group value at all: `F0-RGE` removed and nothing put in its place), set the vertical's `operator-<venture>`, clear the assignee, set priority High, and comment the escalation category and the question. Since 2026-09-03 `operator-<venture>` lives in its own label group and **evicts nothing**, so a write that only adds it leaves `agent:F0-RGE` armed and the ticket sits in the exec queue while the operator holds it; "evicting" was the mechanism of the retired single-select shape, not a requirement. No executor plus an operator label is a **valid held state** that no sweep repairs, and the ticket rejoins a queue only when the operator sets an executor again. Where the remedy needs a click only Aled can make (a protected-branch deletion on a repo he alone administers), set `human` instead — an `agent`-group value, so that one does evict `F0-RGE` — and assign him. Blocked fits the letter of "push rejected" but would name no dependency ticket, which is the shape `convention-linear` calls out: it reads as dependency-bound while naming no dependency, so nothing ever clears it.
- **Give the one-click remedy and the recovery detail** — for a branch deletion, GitHub's **Delete branch** button on the closed PR, plus the head SHA so the branch is recoverable if the deletion later proves wrong. A hand-off that names the exact click costs the operator seconds; one that names only the failure costs a diagnosis.

  (Worked case: A1-276, `assoc.one`, 2026-07-30 — two of three criteria met, PR #1 closed unmerged with a closing comment, and the `claude/a1-74` deletion refused; routed In Review + `human` + Aled + High with the button and the head SHA, derived live against two canon entries that each half-fit. The residual branch then surfaced as a loose end in A1-278's criteria later in the same run — APP-727.) Keeping a bare "delete the branch" out of acceptance criteria at *refinement* — a human-lane leaf, in the class of the credential-gated split (`convention-ticket`, APP-230) — is the authoring-side half and belongs in the refinement and repo lane, not here.

**Bounce:** Aled moves In Review → **Todo** with a note; the next run re-picks it and iterates on the existing PR. (Todo, not In Progress, so In Progress always means "running now.")

**Bounce onto an unreachable branch — supersede, do not stall.** Iterating on the existing PR assumes the run can push to the branch that PR sits on. It often cannot: per `convention-github` *Branch naming* and step 1 each ticket is worked on `claude/<ticket-id>`, but a bounced ticket's open PR may sit on a *different* branch — a previous session's generated name, or a branch the harness's single-designated-branch grant forbids pushing to. Adding commits to the existing PR is then structurally impossible, and opening a second PR would trip the one-PR-per-ticket guard, so the ticket Blocks for a reason that is not in the work at all. Resolve it by **superseding, which is not duplicating**: cut `claude/<ticket-id>` as normal, build the fix there, open the fresh PR, and **close the stale PR** with a comment pointing at its successor. One ticket still has exactly one *live* PR; the superseded one is closed, not competing, so the duplicate-PR guard has nothing to trip on next run. Where the existing PR already sits on `claude/<ticket-id>` and the run can push to it, iterate in place as before — supersede only when the branch is genuinely unreachable. This keeps the bounce path satisfiable for short-lived, freshly-branched sessions, the reality the single-long-lived-agent wording never covered (APP-817; family with APP-808).

**Bounce response — refresh the PR body to the current head.** The PR description is the artefact Aled reads on GitHub to decide whether to approve, and it is the one surface that does not update itself: after a bounce it still describes the first commit, so every box it carries reads as an open item and the next reviewer — human or QA — has to diff the description against the diff to tell staleness from a real gap. So after pushing a fix for a bounce, **update the PR body to describe the current head** — re-tick or re-state any box the fix resolved, and append a short `Round N fixes` note saying what changed since the last verdict. Appending is enough; rewriting the original description loses the history (APP-825).

**Bounce refresh covers every passage the fix has falsified, not only the boxes — and "appending is enough" licenses adding history, never leaving a false claim standing.** The clause above names checkboxes and a `Round N fixes` note, so a leg that re-ticks boxes has refreshed only the surface it was pointed at: a digest-and-byte-count table in the PR body, a figure quoted in prose, a flag paragraph saying an artefact could not be extracted, and the ticket's own evidence sub-bullet all survive the fix untouched and now assert something the current head contradicts. So after pushing a bounce fix, **refresh every passage of the PR body and of the ticket that the fix has falsified** — re-tick the boxes, then re-state the table's row, correct the quoted figure, and strike or amend any flag the fix has resolved — and read the refreshed surface back. The "appending is enough" permission above is about **history**: it licenses *adding* a `Round N fixes` note rather than rewriting the original description, and it never licenses *leaving a falsified claim standing* because a later note contradicts it. A reviewer reading top-down meets the stale claim first, and a stale figure in a PR body is a record defect a reviewer must bounce, so leaving it costs a whole extra round on a change that is otherwise correct — and where the bounce cap is already at one, it escalates a record-only defect with zero code content. The step-6 mirror rule runs the same way: the ticket description is the write that closes anything and the PR body is the courtesy mirror, so a falsified passage is corrected on both surfaces, not just the one the bounce note happened to quote. (Worked case: `claude-ops` PR #701 / `APP-3073` — a round-1 bounce named the PR body's digest table and a flag paragraph as part of the required fix; round 2 recommitted the canon file correctly and touched neither the table nor the ticket's evidence sub-bullet, drawing a second bounce that hit the bounce cap and escalated to `operator-apps` for a defect carrying no code content at all. The PR number, the round sequence and the escalation are as `APP-3073` and its thread report them and are **unverified** — this refine surface can read no repo. Recurrence of `APP-825` and `APP-1760`, both closed — `APP-3088`.)

**Bounce response — a bookkeeping-only bounce ticks both checkbox surfaces, not just the ticket.** The clause above fires *after pushing a fix*, so it does not fire on the bounce that lands no commit at all. The driver's blank-box bounce (`routine-delivery-loop` *1. Exec leg*) exists precisely to fix box state, and a re-hand-off that ticks the Linear description and stops there leaves the PR body's mirrored `## Acceptance criteria` / `## Definition of done` copy exactly as first written — so the two surfaces disagree on the one path whose whole purpose is box state, and QA pays for it by verifying and closing those boxes on its own read. Step 6's rule is unchanged and applies here too — the ticket description is the write that closes anything and the PR body is a courtesy mirror that closes nothing (APP-1520) — so **keep the mirror and update both**: tick the ticket description, read it back, then edit the PR body's copy to match, and state in the bounce-response comment that both surfaces now agree. A bookkeeping-only bounce is therefore **two writes, not one**. Do not resolve the drift the other way by dropping the PR-body checklist for a bare ticket link: that mirror is what Aled reads on GitHub without opening the Linear thread, which is the reason step 6 mandates it. (Worked case: APP-1744 / `assoc-one/claude-ops#297`, head `5655bc4`, QA leg 2026-09-24 — a `[bounce]` marked bookkeeping-only, after which exec ticked the DoD hand-off box on the Linear description plus the CI box once CI concluded, while the PR body still carried AC4 and DoD 3–5 unticked; at QA the two surfaces disagreed on four boxes and QA closed them on its own verification. Instance count 1. The repo, PR number and head SHA are as APP-1744 reports them and are **unverified** — this refine surface can read no repo — APP-1760.)

**Bounce response — re-read and cite before claiming a review item is resolved.** When iterating on a bounced PR, treat every item the reviewer named as a machine-checkable box: after editing, re-read the item in the file and quote or cite the changed text in the commit message and the review-facing comment, rather than asserting it from memory of the edit. A reviewer who quotes the offending phrase verbatim has handed you the check for free — `grep` for that phrase. Never state that a named item is fixed, or give a mechanism as the rationale, without re-reading the region: an overstated fix reads as investigated, so a reviewer reasonably skips re-checking it, and the missed part costs a *second* changes-needed verdict — a bounce-cap strike and an escalation to Aled over what is often two sentences. (Worked case: A1-275, where the §3 note was claimed to point at the rule while the paragraph above it still carried the contradictory wording and the field's JSDoc was never revisited — APP-748; same assert-a-verification-you-did-not-perform family as APP-726 and APP-664.)

**Bounce response — re-check the draft bit, because a round that resumes is not a round that opens.** The draft rule in step 4 and the Guardrails bullet both describe the *first* open, and a continuation round opens nothing: it reads the check runs and the diff, pushes a fix, and hands off. So a PR a prior round left non-draft — in breach of the rule, or reset by a hand elsewhere — rides through every later round untouched, and arrives at review already reading *QA passed* before QA has run, which is the one thing the convention exists to prevent. **A round resuming work on an already-open PR reads its draft state as part of its own hand-off and restores draft where it is missing**, saying so in the hand-off comment so the reset is visible rather than silent. One read, no cost, and it is the only place the breach is catchable: nothing upstream re-checks it, and `skill-review-pr` cannot tell a ready PR it was handed from a ready PR it produced. (Worked case: `assoc-one/assoc-one` PR #11 / A1-351 — round 1 opened the PR non-draft; the next round caught it only because it happened to re-read the PR's full state before building, and reset it as part of hand-off — APP-2108; the rule it breached is APP-822's.)

## Guardrails

- Never merges. Main branch protected; merge is Aled's.
- On an unresolvable blocker, move the ticket to **Blocked** and route by class (`convention-linear`, *Executor*): a judgement — is the blocker real, should scope bend — goes to the vertical's `operator-<venture>` with the **executor cleared** (no `agent`-group value), the assignee cleared, and a comment naming the escalation category and the question; a thing no agent can do — a credential, a device, an account — goes to `human` (an `agent`-group value, so it evicts `F0-RGE`) + assign Aled. The operator label sits in its own group and evicts nothing, so an operator hand-off that leaves `F0-RGE` in place keeps the ticket in the exec queue (APP-1117). Never leave it In Progress — that jams the leg and it never retries.
- A crashed run can leave a ticket In Progress under `F0-RGE` with no PR — a ghost claim. Detect it at run start (In Progress, no open PR, no comment since claim, older than one poll interval) and reset it to **Todo** with a note, rather than skipping every future run. The skip guard is for active runs only. **A reset never carries its read into a re-claim** — the re-claim takes its own fresh `get_issue` first — **and a session resuming after an interruption re-verifies every mid-leg ticket from Linear before continuing**, treating an open PR it does not remember as its own earlier resumption, not a duplicate (APP-1027).
- **Linear attachments — fetch with the MCP, never curl or WebFetch.** Linear attachment URLs (`uploads.linear.app`) are blocked by the environment proxy (`curl` returns `CONNECT tunnel failed, 403`). Use `mcp__Linear__get_attachment` with the attachment ID from the issue's `attachments` array. For a **text** attachment — the ops-publish case — the fetch itself is reliable and succeeds first time, but the fetch is only the whole answer where the result **spills to disk**; where it comes back **inline**, getting the bytes onto disk is the unsolved half and the two paragraphs below own it, in that order. Reach for the MCP first rather than discovering the proxy block per run.

  **An inline attachment result is a reproduction, not the artefact — and a digest taken from your own copy of it never outranks the ticket's table.** Where `get_attachment` returns the text into context rather than spilling it, there is no file on disk and no `cp` to make, so the only bytes available are ones this leg re-emits. Re-emitting is lossy in a way that self-verifies: the copy hashes consistently, `wc -c` agrees with itself, and a dropped line — or an em dash silently retyped as an ASCII period with the next word restarted in capitals — is invisible in every check run against the copy. Three routes carry this case and they rank: **write-then-digest-verify against the ticket's table first, transcript recovery second, a second fresh `get_attachment` third and only as a last-resort tie-break** (routes 2 and 3 are the rules below and the scoped-search paragraph after them). **Route 3 clears nothing: two in-session `get_attachment` fetches share the same transcription path, so they are not independent evidence and their agreement is worth nothing.** Agreement between two retyped copies is the signature of this defect, not a clearance — the same line dropped, the same em dash flattened, the same quoting normalised away, twice. So the remedy is route 1, write the payload to a file and digest the file; route 2 where the ticket carries no table; and route 3 is retained only where routes 1 and 2 are both unavailable, in which case the leg states in its report that the two reads are non-independent and that no disagreement with the ticket's table has been cleared by them. Where a second fetch has settled a case before, it settled it by `diff` against a value derived from bytes nobody retyped — the ticket's table — and not by matching the first transcription. (Worked case: `claude-ops` PR #701 / `APP-3073` — an inline `get_attachment` returned `name: workflow-content-engine` unquoted against canon's quoted form; two in-session fetches agreed with each other on the wrong bytes, so the leg concluded the ticket's table was stale rather than its own transcription, and QA caught it on a 2-byte diff. The PR number and the byte delta are as `APP-3073` and its thread report them and are **unverified** — this refine surface can read no repo. Recurrence of `APP-1880`, closed — `APP-3087`.) **The first route: where the ticket carries its own digest and byte count for the artefact, write the in-context payload straight to disk and verify `sha256sum` and `wc -c` against the ticket's table in the same call — write-then-digest-verify is a named route, not an improvisation.** It is named here because it has been the working substitute repeatedly while appearing nowhere on this page as a route, so each leg re-invented it and none could cite it. It ranks first wherever the ticket carries a table, for the reason the second rule below already gives: the table is the only value derived from bytes nobody retyped, so it outranks any transcription, and a match is conclusive however the bytes were obtained — at a cost of one write and one check, with no transcript read at all. It decides nothing where the ticket carries no table, or where the digest or the byte count disagrees; then the two rules below own the leg, and the second of them is the one that was missing. **First, do not retype it — recover it from the transcript record.** Every tool result is persisted verbatim on disk, so the payload is already there whichever way it came back: read this leg's own record, extract the `tool_result` text for its own `get_attachment` call, write it out as UTF-8 and hash **that**. The record is written behind the turn, so batch the fetches and extract a turn later — and the lag is **not a promise that the record catches up**: across seven legs the route has now failed in up to six distinct shapes against one clean success, and the 2026-10-08 and 2026-10-13 shapes are not lag at all. The sixth shape is **contingent, not settled**: the leg that reported it read only the top-level session log, which for a spawned leg is the wrong file, so it may be a wrong-file read rather than a shape — see the right-path rule below, which no count of shapes may skip (APP-2472). On the 2026-10-08 case the per-leg session record never flushed the tool result and still had not within the run. On the 2026-10-13 case the `tool-results/` spill directory never gained a file for the fetching session's own `get_attachment` calls at all — it held six files from an *earlier* sibling-ticket batch and nothing from this one, on a top-level, non-spawned leg with no per-subagent record to read instead. So the spill directory belongs to a different logical leg boundary than the session issuing the fetch, even inside one unbroken top-level session, and an empty directory is not a statement about ordering. That leg's recovery then came from the canon fallback, cleanly: one re-fetch and one plain `diff` isolated a 3-byte shortfall — 20,565 against the ticket table's 20,568 — to a single em dash flattened to a period, and the second fetch matched the table's size and digest on the first comparison (APP-2327). So a second read that comes back empty is the route failing, not the lag running long: take the second-fetch fallback below, never a wait and never a retype (`convention-agent-runtime`, which states the count and leaves the route's availability to this page; APP-2161); it is **not transitive**, so only the leg that made the fetch has it and a subagent's record does not reach the parent session's. (Companion: `skill-ops-sync`, the paragraph on the same route, which is the side that writes the method into the publish ticket — APP-1304, APP-1252, APP-1259.) **Second, when the reproduction's digest disagrees with the ticket's table, the reproduction is the suspect, not the table.** Step 3's reconciliation rule above governs a ticket-versus-source mismatch in general and permits building to one copy with the choice stated; that permission does **not** extend to this case, because here the "source" is a copy this leg made and the table is the only value derived from bytes nobody retyped. A match is conclusive however it was obtained; a mismatch against an inline read is **evidence the reproduction failed**. So re-derive from the transcript record before writing a word about the table being wrong, diff the recovered bytes against the re-emitted copy to find what was lost, and never commit the re-emitted copy over the table's value on the strength of hashing it.

  **Hash the file in the same call that writes it, and read a one-byte delta as the writer's own trailing newline before doubting anything else.** The rule above makes the reproduction the suspect; this names the suspect's commonest shape. A write tool may normalise the end of a file, and canon source is not uniformly newline-terminated — 4 of the live artefacts in the skills store end without one, `task-ops-sync` (1,273 bytes), `task-pulse-retro` (5,060), `task-apps-operator-standup` (8,717) and `web-artifacts-builder` (3,087) — so byte-exact recovery preserves whatever the source actually has rather than accepting the writer's default. So `sha256sum` and `wc -c` run in the same call as the write, and on a mismatch of exactly one byte the first hypothesis tested is a solitary trailing newline, at the cost of one `tail -c1`, before a word is written about the table being wrong. The behaviour is surface-specific and is assumed in neither direction: on the Claude Code surface of 2026-09-30 a `Write` of three bytes produced three bytes and no newline, so the check is what settles it on the surface in hand. (Worked cases: `task-pulse-retro` recovered inline and written at 5,061 bytes against the ticket's 5,060 and `526a456f…`, the delta a single appended newline; and `task-ops-sync` at 1,274 against 1,273 and `944b6352…`, the same delta on the same surface a day later, while the 56KB sibling on the same ticket spilled to disk and matched first time — `APP-1879`.)

  **And scope the transcript search to the harness's own project directory — a filesystem-wide search is refused, and the refusal is about the command's shape, not the path.** The recovery above depends on reading this leg's persisted tool result, and a `find /` for the session log is refused by the permission classifier, which reads a broad or compound command rather than the file it would reach (`convention-agent-runtime`, the worktree-isolated bash paragraph, where the same class is recorded and narrowing the matcher is named as the Owner's config lever rather than an authoring one). The working form is one plain command against the harness's own project path, which on the surface of 2026-09-30 held the session record and a per-call tool-results directory beside it. Where even the scoped read is refused, say so and fall back to a second, fresh `get_attachment` compared directly against the first transcription: the structural audit — em-dash counts, marker parity, EOF bytes, an opcode diff against the predecessor — returns clean, and only the re-fetch finds the difference. (Worked case: `convention-decision-log`, where the first transcription wrote `name: convention-decision-log` against a source reading `name: "convention-decision-log"` — two bytes short, with no digest resemblance to guide a search; the audit found nothing and the re-fetch found the quoting in one comparison — `APP-1880`.) **Where the leg was spawned, read the per-subagent record and not the session log.** The project directory holds more than one record, and the top-level `<session-id>.jsonl` is the wrong one for a spawned leg: it is the parent driver's log, so in a long driver run it carries other legs' entries and lags this leg's own. This leg's record is `<session-id>/subagents/agent-<hex>.jsonl`, identified among its siblings by the `description` field of the `agent-<hex>.meta.json` beside it, which names the leg. The `tool-results/` directory above sits beside both and is unaffected. (Observed on the Pulse refine surface of 2026-10-01: the path resolved at `/root/.claude/projects/-home-claude/<session-id>/`, carrying `subagents/`, `tool-results/` and the session jsonl, one `agent-<hex>.jsonl`/`.meta.json` pair per spawned leg, each meta naming its leg — so the route is reachable and its refusals are surface-specific rather than universal. A third environment refused a broad `find /root … -iname` probe as `[Credential Exploration]` where APP-1880's refused as a PII class, two reasons for one shape, and the second-fetch fallback above carried the leg to a first-write digest match — APP-1928, APP-1880.)

  **A leg may not report the transcript route unreachable until it has tried the right path.** The paragraph above names three places, and a leg that reads one of them has checked nothing: this leg's own record at `<session-id>/subagents/agent-<hex>.jsonl` where the leg was spawned, the `tool-results/` spill directory beside it, and the top-level `<session-id>.jsonl` — which for a spawned leg is the parent driver's log and is the wrong file by this page's own rule above. So "the transcript held no `get_attachment` result" is a reportable finding only from a leg that names **which of those three it read**; a report resting on the top-level log alone is a wrong-file read, not an unreachable route, and it may not be counted as a failure shape. (Worked case: the APP-2459 exec leg, publish batch F, 2026-10-20 — two Linear attachments came back inline at 19,031 and 18,975 bytes; the leg read only the top-level session jsonl, found it had stopped growing at 200 lines with no `get_attachment` `tool_use` block in it at all, and attempted neither `subagents/` nor `tool-results/`. Its near-misses are themselves a reading hazard worth naming: the one "get_attachment" hit in that file was an unrelated `deferred_tools_delta` record, and two superficially matching `toolUseResult` records belonged to `list_issues` and `get_issue` calls the leg never made, so a grep for the tool name finds matches that mean nothing. The leg then took the first route above — each in-context payload written straight to disk, `sha256sum` and `wc -c` checked against the ticket's table, both matching first time — so nothing was published wrong. Whether the route was genuinely unreachable on that surface stays **open**, because the two paths that would settle it were never read — APP-2472.)

  Reporting a correct table as defective is the expensive outcome: it puts a false premise in a PR body and on a ticket, and the next leg inherits it. (Worked case: APP-1740, `skill-task-health`, 2026-09-24 — the ticket's table stated `c2ee9150…` / 36775 bytes; the round-1 leg hashed its own copy of an inline `get_attachment` read, got `54b69c16…` / 36210 bytes, committed that copy and flagged the table as wrong on both the ticket and the PR. The copy was canon minus exactly one 565-byte guardrail bullet — *"An overdue next-run is a question, not a finding"* — and restoring that line reproduced `c2ee9150…` exactly. Round 2 spooled the attachment to disk without transcription and matched the table on the first try. The sibling artefact on the same ticket, `task-daily-report`, matched at `55a2cca0…`, so no computation was at fault on either side. **Premise unverified:** the `claude-ops` PR #293 and head `f936f43` claims are as APP-1755 and its thread report them — this refine surface can read no repo — APP-1755.)

  **An oversized text attachment is not a failed fetch — it is the best available path, and the file the message names is the artefact.** Where `get_attachment` exceeds the tool's token cap it writes the full result to disk and returns an error; that saved file carries the artefact and is never a reconstruction target — but **inspect its first byte before treating it as the artefact's bytes.** Where it opens with the artefact's own `---` frontmatter it is byte-exact on arrival and the correct action is `cp`, `sha256sum` and `cmp`. Where it opens with `[` or `{` it is the **JSON tool-result wrapper** rather than raw artefact bytes — an array of content blocks with the artefact sitting JSON-escaped inside a `text` field — and a plain `cp` copies the wrapper: the brackets, the `type` and `text` keys and the escaped newlines committed as the `SKILL.md`. Parse that shape, extract the `text` field's exact content, and hash and write **that**. The failure is not drift but a structurally different file, so the digest fails outright rather than nearly matching, on a publish that otherwise looks like it followed the documented good path — and the two shapes are trivial to tell apart on one byte, which is the whole reason the check is cheap enough to be unconditional. (Worked cases: APP-1514 — `skill-ops-sync.md` at 50,875 bytes and `skill-merge-pr.md` at 58,542 bytes, on consecutive exec legs, both spilled JSON-wrapped, both digest-matching the ticket exactly once the `text` field was extracted; the second arrived through a top-level session's own tool-result truncation rather than a subagent dispatch, so this is not a subagent-serialisation artefact and no such qualifier belongs on it.) Do not follow the message's own advice to read the file in chunks or to hand it to a subagent for summary: on a digest-parity publish those are precisely the two ways a correct file becomes a non-identical one. The alternative route — `curl` against `uploads.linear.app` — is proxy-403'd, re-probed 2026-09-12. And compare the file's own `wc -c`, never the message's character count, which is short of the byte count on any multibyte character and reads exactly like truncation. (Worked cases: 91,670-byte and 97,735-byte artefacts digest-matched first time from the spill file, with the bytes never entering context; and a 91,065-byte artefact whose "90,430 characters" message understated it by 635 bytes on em dashes alone — APP-1391, APP-1394.)
- **A `claude.ai/artifact/…` link on a ticket is a spec source, not a reference, and it is fetchable.** A ticket may carry its prototype as a private Claude artifact link rather than, or as well as, a file attachment. The `Artifact` tool's `read` action takes that URL and returns the page source, so the link is lifted exactly as an attachment is and *lift, don't re-derive* applies to it unchanged: build from the returned source, never from the ticket's prose summary of it. A spawned general-purpose subagent holds that tool as its driver does, so a leg needs no relay of the bytes. And where a brief asserts a source is out of reach, test the assertion before acting on it — the driver's brief carries the ticket ID and its target repo (`routine-delivery-loop`, *1. Exec leg*), and an unchecked capability boundary is not among the things it may add. (Worked case: A1-573, 2026-09-30 — the delivery driver told the exec leg the ticket's artifact link was "reference only, not fetchable by you" without checking; the link resolved through the tool the leg already held and returned source matching the ticket's quoted animation values, and the brief was corrected mid-leg. The same prototype was also attached as a file, so nothing was built wrong; a ticket carrying only the link would have sent the leg to re-derive from prose. **Premise reported, not observed:** the resolution and the match are as APP-1890 reports them — this refine surface can read no repo — APP-1890.)
- **A binary attachment can be viewed and not extracted — commit a dimension-matched placeholder and flag it, never improvise.** The rule above solves text and only text. For an image, font, or other binary asset, `mcp__Linear__get_attachment` **succeeds and renders the file for viewing, but there is no path from the rendered image back to raw bytes the sandbox can write to disk**; `extract_images` has the same view-only shape, and the proxy block rules out filling the gap with `curl`. The call looking like it worked is the trap — the asset is visible, so the run reads the fetch as solved and only discovers mid-commit that nothing downstream can persist it. There is no workaround to find, so do not spend the run looking for one. The canon move, where a ticket needs a binary asset committed:
  - **Stand in a placeholder at the asset's exact pixel dimensions.** A solid-colour PNG from a few lines of pure Python is enough — no PIL or ImageMagick. Dimension-matching is the part that matters: a wrong-aspect-ratio stand-in silently breaks the layout it exists to hold open, which is worse than an obvious blank.
  - **Flag every gap in three places** — the PR body, the ticket, and an `ASSETS-NEEDED.md` beside the assets — naming each missing file and its dimensions.
  - **Route to operator review** — set `operator-<venture>`, **clear the executor** (no `agent`-group value), clear the assignee, and comment the escalation category and the question; `human` + Aled only where the missing asset is his to supply. Setting the operator label alone evicts nothing, so an uncleared `F0-RGE` leaves the ticket in the exec queue while the operator holds it (APP-1117). Route rather than merging. Fabricating imagery to fill the hole, unflagged, is the failure this exists to stop: it ships as if complete and nothing downstream knows it isn't.
  
  This is a sandbox and tooling gap, not a build defect — the ticket is not Blocked by it where the rest of the work stands. If a future Linear MCP gains a raw-bytes download, the whole class disappears; worth flagging upstream if that server is ours to influence. (Worked case: A1-220, `assoc-one/aledpritchard-com`, 2026-07-16 — four binary images viewable and unfetchable, placeholdered at dimension and flagged — APP-574.)

  **The upload direction is open, and the rule above says nothing about it.** The bullet above is the *download* half and is correct there; read as a verdict on binary attachments generally it is worse than silence, because it retires a route that works first try. A leg can put a binary **onto** a ticket in three calls: `mcp__Linear__prepare_attachment_upload` (issue, filename, contentType, exact byte size) returns a **signed `storage.googleapis.com` URL** — a different host from the proxy-blocked `uploads.linear.app`, and one egress allows; a plain `curl -X PUT --data-binary @file` with the returned headers verbatim; then `mcp__Linear__create_attachment_from_upload` with the returned `assetUrl`. The signed URL expires in about sixty seconds, so prepare → PUT → finalize runs **one file at a time** rather than batched; that is the only real constraint.

  **What it is for is the acceptance criterion whose truth-maker is visual.** A qualitative box — "looks right", "reads as one system", anything a triage comment flags as closable "only by eyes on a rendered surface" — is the recurring reason a finished leg defers to an operator-verify pass. A leg that has already driven the change in the sandbox's own Chromium (step 3c) can attach **the rendered screenshot itself**, which turns "someone will have to go and look" into "look at this" for about thirty seconds of run time: capture the bench, capture any variant the criterion names (a reduced-motion pass, a second viewport), attach both, and cite them in the tick. The same route serves any binary a leg produces — a generated asset, a diff image, a trace. Attaching evidence never converts a qualitative box into a self-attested one: it gives the human gate something to rule on, and an unmet box still goes to review unticked.
- **The build runs where the repo has one — a skipped build ships a clean-looking break.** Verify against the repo's own scripts (step 4), `npm install` first, and never drop the build because it is slow or carries a known caveat: `tsc` and `eslint` are blind to the RSC-boundary class, so a `"use client"` change is build-verified or it is unverified. Where the build cannot run at all, say so in the PR body and leave the box for QA rather than presenting the PR as verified. A risk written into a hand-off note is not a risk checked. (APP-732.)
- **A verification harness exec writes carries both controls — negative and positive.** Where exec stands up its own runtime/verification check (not just the repo's scripts), prove it *fails* on a deliberately broken build **and** *passes* an unmodified baseline in the same batch — red rows alone are not evidence, a red matrix with a green baseline is. Mind the bytecode cache: `PYTHONDONTWRITEBYTECODE=1`, cleared `__pycache__`, `-p no:cacheprovider`, since a same-length constant edit defeats a `.pyc`-cached check. (APP-941; family with APP-693.)
- **Commit before running negative controls.** A revert step cannot distinguish the deliberate break from uncommitted work, and the files a control targets are the files that implement the criteria — so controls on a dirty tree silently revert the change under review, with no error and no gate that can see it. Commit, then break and revert against a committed baseline (A1-387 — APP-1200).
- **Deleting a guard is a claim, and carries a control.** Removing a shield, flag or assertion because what it protected against is gone is proved by re-planting that condition and showing either that nothing breaks or that a remaining check reddens — never by the comment being deleted, which is where the belief usually lives. Prefer a property held by construction over a list of what is currently safe (A1-387 — APP-1201).
- **Too large is a release, not a Blocked, and never a partial PR.** Where post-claim scoping shows the ticket will not fit the remaining budget: back to **Todo** on `agent:F0-RGE`, unassigned, no branch cut and no file touched, with a comment stating nothing is inheritable and carrying the scoping notes forward. Never pre-read the repo to size a ticket before claiming — the lock precedes the work (APP-522), and a released claim is the intended cost of that guarantee. (APP-694.)
- **A blocker is partitioned before the park, not after.** Before moving a ticket to Blocked, split the criteria the blocker gates from those it does not, and file the ungated set as its own build leaf **in the same action** at the parent's priority — not a later discretionary offer. The gated criteria stay on the Blocked parent carrying the `blockedBy`; reuse the `human` setup-leaf + build-leaf shape (`convention-ticket`). On APP-824 the split was spotted and merely offered, and a live safety exposure sat unfixed through the round trip that cost. (APP-934.) **An elapsed observation window is the fourth blocker class, and it parks differently.** Where the gated criteria wait on time passing — a five-weekday baseline, a soak period, a live window that has to run before anything can be written up — no credential, decision or dependency clears them, and the `human` routing on its own reads as an action waiting on Aled that he cannot take either. So park the parent `human` and assigned as usual, and in the same action state on it the **date the window closes** and the **single act that follows it** — pull the accumulated records and write the result up. Set the parent's `dueDate` to that date, so the age ladder measures a wait rather than reporting a stall; a ticket due date is tracker hygiene, not a milestone target date, and stays the operator's (`convention-project-status`). Name the class in the park comment as *waiting on elapsed time*, so a later reader does not go looking for a blocker nobody holds. (Worked case: APP-1131 bundled a code-completable wiring change with acceptance criteria needing five weekdays of live production observation; the wiring shipped as its own leaf, APP-1436, and the parent parked by judgement because the guardrail named no exit for it — APP-1437.)
- **An unperformable deliverable is an operator hand-off, not a Blocked.** Ref deletion is refused by this environment (403) with no MCP fallback. Where it is post-merge hygiene, `skill-merge-pr` records it and continues; where it is the ticket's *outcome*, finish what can be finished and route **In Review** + High with the one-click remedy and the head SHA — to `operator-<venture>` with the **executor cleared** (no `agent`-group value), the assignee cleared and the escalation category commented, where the remedy is a judgement; to `human` + Aled where the click is his alone. The operator label is its own group and evicts nothing, so clearing the executor is what actually takes the ticket out of the exec queue (APP-1117). Blocked here names no dependency, so nothing ever clears it. (APP-727, APP-1128.)
- **Tick both sections; never author AC.** Tick `## Acceptance criteria` and `## Definition of done` as built, leaving any unmet box unticked and flagged. Forge never writes or edits acceptance criteria — that is the author's at refine; an AC it cannot meet is a changes-needed bounce or a Blocked, not a reworded criterion. **And the positive form, since a prohibition alone leaves the explanation nowhere to go: where a box is left unticked and the reason needs saying, write it as an indented note beneath that box, leaving the criterion's own text byte-identical.** Not a rewrite, not a clause spliced into the criterion, not a softened restatement — the box text is the Owner's bar, the note is the builder's account of why the box is open, and the two stay visibly separate so a reviewer reading only the current body still sees what was asked. This is `convention-ticket`'s mirror-collision discipline in the ordinary case: the builder **declares** the deviation and leaves the criterion standing, rather than editing the criterion to match what it did. A criterion quietly narrowed is worse than a box left blank, because a blank box is visible debt and a narrowed one reads as satisfied — and the narrowing survives into review, where the only surface that could catch it is a diff against the ticket as created (`skill-review-pr`, *Reproduce the runtime*). (Worked case: A1-804, `assoc-one/meirionpritchard-com` PR #285, head `8e5552e`, 2026-10-27 — **reported** by that ticket's QA leg and not re-read from a canon drain's surface: at hand-off the exec leg replaced the last acceptance box with its own wording explaining a justified test-update deviation, and the replacement left out "the Playwright base-vs-head diff", a named gate it had not run. QA found it only against the Linear linkback snapshot in the PR comments, restored the wording and ran the diff itself, about forty minutes of suite time — APP-2710.) Never hand a ticket to review with a tickable box left blank in either section **that this leg can verify now** — the one release is a box whose truth-maker lands after the hand-off (CI not concluded at PR open): tick it if a single MCP read shows it concluded green, otherwise leave it blank, name it in the hand-off comment and PR body, and hand off without waiting; QA closes it on its own verification (APP-1025). A finished PR never sits In Progress behind a remote signal (APP-927; Owner ruling 2026-09-03). **A machine-checkable AC — byte- or text-exact against an attached source — is diffed before it is ticked, never self-attested; if the compare cannot be run, the box is left for QA.** (Worked case: A1-250, `assoc-one/portal` PR #3, 2026-07-24 — a "byte-identical to attached" box was ticked but the file differed from source by one word, sending a non-identical file to review as clean — APP-664.)
- **Verify before you assert — a claim is earned, not remembered.** A box, a spec/delta row, or a bounced review item is closed only on the actual check: verify the *property* a criterion asserts, not the artefact it names, and on a bounce re-read each named item and cite the changed text before claiming it resolved. Never put a mechanism or a "now fixed" in a commit message or review-facing comment you have not re-read the region to confirm. (APP-726, APP-748; family with APP-664.)
- **A control's narrative is written after its run and from its output — never beside the table it will join.** The rule above binds re-asserting a mechanism from memory of an action already taken; this one binds the opposite error, asserting ahead of the evidence: composing a finished-sounding verification paragraph — a negative control's result, a reproduction, a revert's behaviour — in the same pass as the rows that genuinely *were* run, and posting it before the run that would make it true. A claim written that way is neither earned nor remembered; it is **predicted**, and a prediction in a hand-off comment reads exactly like a measurement to everyone downstream. So the order is fixed and not negotiable against how ready the rest of the hand-off looks: run the control, read its output, then write the paragraph, quoting what the run printed rather than what it was expected to print. Where the control cannot be run in this pass, the paragraph says so and names what is outstanding — a named gap is visible debt, a plausible narrative is not. (Worked case, **reported** by the filing leg and not re-read from a repo on this surface: an `APP-2428` exec leg on `assoc-one/a1-de` PR #18, 2026-11-08 — the hand-off comment's "Negative control" paragraph described reverting the `changedGone` partition and the new left-deck Playwright test failing on that revert, and was posted **before that control was run**, while every other row in the same comment — lint, typecheck, unit, build, secrets, the base-vs-head Playwright comparison, the ticket-box state — had genuinely been run and read back. Self-caught on re-reading the posted comment against the session; the control was then run for real in a throwaway worktree and failed exactly as described, so **the conclusion turning out right was luck rather than verification** — which is precisely why the defect is the order of operations and not the conclusion. A correction comment naming the error followed in the same session. Distinct from the negative-control *mechanics* family — `APP-941`, `APP-1196`, `APP-1197`, `APP-1200`, `APP-1338` — where the control ran and its apparatus misled; here the mechanics were sound once run and the whole fault was writing the result first — `APP-2951`.)
* **A silent-failure fix sweeps its whole class, and the fix states the sweep.** Where a fix addresses a defect of the **silent-failure** family — a value that rejects writes, a filter that matches nothing, a call that returns success without acting — the same pass greps **every other site where that value or call is used**, and the PR body and the ticket **state the sweep**: what was grepped and what it found, explicitly including *"no other sites"*. Canon already carries the taxonomy and, until now, no obligation to act on it: `convention-linear` alone holds the dropped `work:engineering` label, the no-op `state` write ("the write-side sibling … same silent-drop family, different field"), the `addLabels` group error and the read-filter traps, each cross-referencing the others as one class — and a class is exactly the shape that recurs at the sites the first fix did not visit. The asymmetry decides the rule: **the cost of asking is one grep; the cost of not asking is a working session and a broken tool in the Owner's hands**, because the unswept site fails the same silent way the first one did — no error, a plausible-looking result, and nothing to tell anyone the fix was partial. A stated sweep also makes the negative result readable, so the next reader diffs rather than re-derives. Distinct from the `skill-review-pr` rule on verification trust (APP-1232): that one asks whether a check can be believed; this one asks **how far a fix reaches**. (Worked case, reported and not independently verified from the refine surface: a frozen-snapshot write fixed at `loadActive()` and missed at `restore()` — the same defect, one call site away — surfaced only after five debug exchanges with the Owner — APP-1233.)
- **A property-less ticket bounces to Relay, never builds — a deviant heading does not.** Before building, confirm the **property**: a `##`-level section of `- [ ]` checkboxes serving as acceptance criteria, plus a `## Definition of done` (step 3b). Absent either half → back to **Backlog** + `agent:R3-LAY`, unassigned, with the gap named; never author the criteria and never build against criteria held only in a triage comment. **A heading that deviates from the template —** `## What to check`**, or criteria under a bold line — is a convention divergence, not a failed standard: build, and repair the heading in passing or name the repair for Relay** (`core-operating-model` Layer 5 — a convention is auto-fixed, a standard is passed or failed). **Merged-but-present sections (AC content mis-filed under DoD or vice versa) still pass — the check is never a quality judgement — and the Backlog bounce silently de-cycles the ticket, so flag the lost cycle for Relay to restore (cycle membership is Atlas's, propose-only).** (APP-744, APP-953, APP-1137.)
- **Claim before work, not at handoff.** The In Progress write is the lock, so it lands before the repo is touched — not batched with the In Review write at the end. The steps are a sequence, not a checklist to satisfy by the finish.
- **Clear the assignee at hand-off too, after the PR attaches — and re-read before the handoff write.** Linear's GitHub integration auto-assigns on PR attach, a write that lands after exec's step-2 clear, so clearing only at claim hands off Aled-assigned. Re-read the ticket immediately before the handoff write and clear again if the integration re-populated it — the same do-not-assume-your-state-survived rule as the pre-PR re-fetch (APP-775). Keeps "assigned to Aled" meaning "Aled's decision is needed now". (APP-936.)
- **Re-fetch immediately before the claim write; claim only a ticket still Todo and still carrying `agent:F0-RGE`.** A positive test on both fields, never a negative "not already Done" — a ticket In Review under `agent:PR-1SM` passes a Done-check and is someone else's live leg. Anything else means taken: move on without writing. The eligibility scan goes stale the moment a build begins, and the claim is the one write that can move a *completed* ticket backwards. (APP-717.)
- **A failing gate is compared against unmodified `main` before it is attributed to the diff.** Stash, re-run the identical gate on the base, and report the comparison — never a bare failure, never a fix for a pre-existing red, and never a stub committed to make an environmental blocker go green. Where the failure is environmental, say so in the PR body with the baseline evidence and leave the box for QA. (APP-712.)
* **A gate is re-run in a clean shell before it is compared against the base.** Exported build-only variables — an access key, a host override, a feature flag — are read by the test process and beat same-named fixture values, producing deterministic red that reads as flake. Re-run the failing gate with the sentinels unset (`env -u <VAR> …`) **before** stashing: it is the cheaper leg of the comparison and rules out the commoner cause. Where clearing them turns the gate green, the defect is the test's isolation — name the variable in the PR body and file the repo-lane fix, never loosen the assertion to match the environment. (APP-1198.)
- **A build dirties tracked files — verify the `git stash pop`, never assume it.** `next build` rewrites the committed `next-env.d.ts` (the dev/prod `routes.d.ts` import variance), so the restoring pop of a baseline comparison aborts — "local changes to the following files would be overwritten by merge … Aborting" — keeping the stash, losing nothing, and leaving the tree silently on unmodified `main`. Use `git stash -u` where untracked artefacts are in play, read the pop's result, and on an abort `git checkout --` the artefact and re-pop, reverting it again before committing. It fires only on the runs doing the baseline comparison properly, and it fails in the safe-looking direction (APP-1151; same family as `convention-linear`'s write read-backs and `convention-github`'s stale CI reads).
- **Clear the framework build cache after every stash-and-compare.** A stash/pop leaves `.next` (or the repo's equivalent) primed with the base build, and the next verification silently reports the base. `rm -rf .next` before verifying again; a post-baseline reading that reproduces the pre-change figures is a suspected stale cache, not a failed fix (APP-1092; method in `skill-review-pr` *Proving the baseline*).
- **A red base is a named exit, not a Blocked.** Where the failing check is red on unmodified `main` too: leave the CI-green box unticked, state the comparison and the base's failing check in the PR body, file the base failure as its own `FIX:` ticket, and hand off as normal — the work is done and the blocker is not in it (APP-1056).
- **Verify the ticket is *runnable* before building it — a claim-time instrument check.** Where an AC can only be met by an instrument the sandbox lacks (a browser/Playwright suite, a render that fetches an egress-blocked host, a live deployment), read the repo's `CLAUDE.md` for recorded limits and take the **Blocked**-with-a-blocked-by-relation path at *claim* time — the claim-leg half of `convention-linear`'s review-leg missing-instrument rule — rather than after an hour of blind iteration (step 3c). (APP-790, APP-712, APP-713.)
* **Check free space before the install; one uniform ENOSPC across unrelated commands is the filesystem, not the commands.** The sandbox is shared across a queue's legs, nothing reclaims a finished leg's scratch, and the render control now costs two full `agents-site` builds per publish leg — so `df -h` before `npm install` and read it as an instrument reading (step 4). Once the temp filesystem is full the harness cannot capture stdout, so `df`, `du` and `CLAUDE_CODE_TMPDIR` all answer with the same error and only silent commands run; never re-run the failed install. Any space reclaimed to finish is named in the ticket and filed as friction. (APP-1310.)
- **Cap blind CI iteration; never loosen an assertion to go green.** With no local reproduction, guessing at a red CI has no stopping point — stop after a small fixed number of non-converging rounds and take Blocked with what was learned. (APP-790.)
- **Re-check state before opening the PR — a mid-run Canceled is a stop.** Re-fetch immediately before the PR-open; if the ticket has left In Progress under `agent:F0-RGE` (Canceled as superseded, or moved by another actor), stand down — no PR, no In Review, no re-set to In Progress. Nothing else re-checks state between claim and hand-off, so a "do not build" cancellation otherwise reaches nobody. (APP-775.)
- **Branch naming is a lookup, not a judgement.** A harness-assigned session branch contradicting `claude/<ticket-id>` is already ruled on in `convention-github` *Branch naming* — cite it at step 1 rather than re-deriving it. The conflict recurs because runs reason it out afresh and leave no citation behind. (APP-522, APP-695.)
* **A repo discipline whose tooling is the ticket's subject is a lookup too.** Where the deliverable *is* the tool a repo-mandated discipline requires, the discipline cannot be the instrument of its own test: judge it on the hazard the rule names, check whether that hazard exists in the sandbox, deviate where it does not, record the deviation in the PR body, and cut throwaway instances for the smoke tests so the changed path is still exercised. Not a Blocked, and not licence where the hazard is present. Cite it at step 1 rather than re-deriving it. (APP-1281.)
- **A false "already exists" premise is a Blocked, never an improvisation.** Verify a stated prior state against the repo before building on it (step 3a); where it does not hold, Blocked + `human` + Aled with the grep/branch/PR evidence. Never build the missing work to make the brief true — a ticket that reads like a small cutover with nothing underneath it is the highest-blast-radius shape in the loop (APP-564). The premise-check reads **four** surfaces — attachments, repo, filesystem, and the ticket's **comment thread**, where a router routinely pastes a payload — and the Blocked comment **enumerates the surfaces searched**, so "not found" reads as "not found in these four places", never as "does not exist" (APP-807).
- One PR per ticket. Never open a partial or speculative PR to "make progress" — Blocked is the honest outcome.
- **Opens the PR as a draft.** Ready is `skill-review-pr`'s signal that review passed, so exec never opens a PR non-draft — a changes-needed verdict never has to undo a ready state it did not set, and the one bit Aled reads on GitHub keeps meaning "QA passed" (APP-822).
- **Where a dispatch instruction conflicts with an absolute rule on this page, canon wins and the leg says so on the ticket.** The draft rule above is unconditional and carries no dispatch-override clause, so a dispatch telling the leg to open the PR non-draft is a **conflict with canon**, not a silence canon left for the dispatch to fill — and a leg that complies has deviated, however reasonable the instruction looked. The leg follows the rule, notes on the ticket which dispatch instruction it declined and why, and leaves the dispatch's own wording to be corrected where it is written. Silent compliance is the defect twice over: it puts a non-draft PR in front of Aled carrying the ready signal that only `skill-review-pr` may set, and it leaves no record anywhere that two sources of instruction disagreed, so the next run inherits the same conflict and resolves it afresh. (APP-2471.)
- **A bounce onto an unreachable branch supersedes, it does not stall.** Where a bounced ticket's open PR sits on a branch the run cannot push to (a prior session's generated name, or one the single-designated-branch grant forbids), build the fix on `claude/<ticket-id>`, open the fresh PR, and close the stale one pointing at its successor — superseding is not the duplicate-PR case, and the ticket must not Block for a branch-grant reason that is not in the work (APP-817).
- **Refreshes the PR body after a bounce.** After pushing a bounce fix, update the description to the current head — re-state resolved boxes and append a `Round N fixes` note — so the surface Aled reads on GitHub is not stale and unticked boxes do not read as open work (APP-825).
- A run works the whole eligible queue, but **serially** — one ticket fully handed off before the next is claimed, each on its own branch off latest `main`. Never run two tickets' branches in one session in parallel; they would collide in the repo.
- Fresh cloud session each run, so all state lives in Linear, not the agent.
- Scope GitHub access to delivery repos only. Never touches the Pipeline team's work.

## Setup

- Deployed as a Claude Code cloud scheduled task (cloud, machine off).
- Connectors: Linear + GitHub. The Claude Code GitHub App must have **Contents: read & write** and **Pull requests: read & write** on the delivery repo — read-only causes a 403 on push, which is a Blocked outcome, not a crash.
- One repo to start; widen once the loop is proven. Cadence: hourly or slower.
- The routine prompt: "Run the exec skill."

> Lock note: this skill and `convention-linear` both use **status as the lock** (Todo = ready, In Progress = running). No `state:locked` label exists or is needed.

On finish, run skill-ops-retro capture on this run's friction: **search the Pulse queue first and add the evidence to a same-root note if one exists, otherwise file a new FRICTION note** for the drain pass to assess, in capture step 3's literal shape — team Apps, project os.Claude, `FRICTION:` title, labels `task` + `work:configuration` + `PUL-5E`, Backlog, unassigned — filing the friction, never the run report.
