---
name: "convention-ticket"
type: convention
description: How work is written and run as tickets in Aled's system, independent of the tracker — the standard ticket shape, the capture-then-refine-then-ready discipline, the evidence-first capture format, Pattern A folded validation, the full initiative-to-task cascade and the dependency model, the triage→build→review→gate routing pattern, the rule that every obligation is encoded as structure rather than prose, the execution lanes, and the decision-log entry format. Read whenever creating, refining, routing, or validating a ticket, or designing how work moves. These conventions hold even if the tracker changes; convention-linear maps them onto Linear's teams, states, and labels. Grown as the discipline solidifies.
license: CC BY-NC-SA 4.0
---

# Ticket and work conventions

How work is captured, written, validated, and moved — stated independently of any one tracker, so it survives a change of tool. `convention-linear` is the tool layer: it maps every concept here onto Linear's teams, states, and labels. If those two ever disagree on a tool detail, Linear wins for the mechanics; this document wins for the discipline.

The tracker is the **system of record**: not the chat thread, not memory, not project files. If a decision, a piece of state, or a task is not in the tracker, it does not persist. Keep it clean — everything downstream trusts it.

## The lifecycle of a ticket

Work moves through three gates regardless of tracker:

* **Captured, not yet ready.** A new ticket the operator has not refined is *captured* — it needs refinement before it can be actioned. New tickets land here by default, never in a ready-to-action state. A captured ticket that raises questions carries a notes section listing them (see the standard shape).
* **Refined, parked for the operator — the operator refinement gate.** A ticket that has been shaped and is awaiting promotion, or an answer to an open question, parks with **the vertical's operator** by default — `operator-<venture>`, the domain role `convention-linear` *Operator attribution* holds deliberately separate from the Owner — and not with the Owner. It is **the operator refinement gate**, not the human one: the older name read every parked ticket as the Owner's, which is what made Refinement his by default. **Three lines, stated plainly.** *First line* is the agent working the ticket — Relay at triage, Forge at build, Prism at review — which resolves whatever its own reads can resolve. *Second line* is the **vertical's operator**: it supplies the refinement inputs the agent cannot source and answers what the agent cannot resolve, then hands back to the agent, with **Relay doing the promotion**. *Third line* is the **Owner**, reached only for what the operator cannot resolve within its own mandate. A ticket takes `human` **plus the Owner as assignee** only for the reserved set — **hard anchors, human-faculties facts, canon saves and reserved rulings**: a hard anchor is a strategic pivot, a budget breach or a goal-set change; a human-faculties fact is a visual review, accounts or credentials. Those four and nothing else; everything that would once have parked on him parks on the vertical's operator instead. Agents treat refined-and-parked tickets as read-only, with one exception, unchanged in substance: a ticket where **the operator** has commented since the last agent comment is a signal to act — process those comments as trusted instructions, apply the answers, confirm, and promote when **the operator** says ready. `skill-triage` placement 4 inherits this assignee rather than restating it, and `skill-operating-loop` step 5 already makes the operator the first escalation target for strategic-context, how-and-where and prioritisation questions (APP-962). (Owner direction 2026-10-14 — *"operator as second line … and only escalates to me (3rd line) if the operators can't do it"* — ruled in the canon-decisions session of 2026-10-20 and logged `osclaude.log-decisions.2026-W42`. APP-2352, whose sibling APP-2351 lands the identical reserved set on the close side in `skill-triage` *Lane staleness*; the two state one reserved set, not two that drift.)
* **Ready.** Shaped, unblocked, and explicitly cleared to action. Only the operator moves a ticket to ready unless he has said otherwise.

Never advance a ticket to ready on the operator's behalf. Capture freely; promote deliberately.

**Interactive sessions are a capture surface, not a routing authority.** A working or Cowork session that files tickets follows the same intake discipline as any sweep or capture surface: new work lands *captured* — unrouted and unassigned, with the executor set by triage at routing, never pre-set at creation — and is never filed straight to ready. Multi-step work is structured as a typed parent with sub-issues split by dependency (sequential steps stay in one ticket; independent steps are separate sub-issues), not as flat siblings. The operator asking a session to "get it done" licenses doing the *work*, not skipping the gate — where he wants something ready immediately, he promotes it himself or says so explicitly. (Worked case: launch tickets filed straight to Todo, pre-routed and pre-assigned, requiring restructure — APP-471/472, 2026-07-09.)

**Work begun without a ticket gets one — filed before or alongside starting, not backfilled when something forces the question.** The rules above govern *how* a session files a ticket; this one governs *that* a ticket exists. A session beginning work that is not sourced from a ticket — a request made directly in the session, a build picked up mid-conversation — files a minimal ticket of record in the team and project the work belongs to as part of starting it. Where the work has not started, that ticket follows the same intake discipline as any other capture — captured, unrouted, unassigned. Where the session is already the runner, it does not, for the reason the rule below gives. Minimal is the point: a title, the one-line ask, and the surface it touches is enough, because the ticket's job here is to exist, not to be complete. Ticketless work is invisible to every mechanism built to notice work going wrong — `convention-linear`'s Blocked-versus-In-Review routing, the delivery loop's drive-to-green posture, and `task-health`'s parity passes all key off a ticket existing — so a session left running against no ticket has no state, no assignee and no queue watching it, and simply keeps running. (Owner's ruling, 2026-09-17: *"Seems like we should always file a ticket for work we are doing."* Worked case: a session built a dev-only config panel filed against no ticket, opened a pull request, and then sat in an autonomous re-arm loop for roughly two days waiting on a human sign-off nothing was watching for; the cost surfaced only because the Owner happened to paste a usage report. The retroactive ticket landed In Review, `human`, assigned — exactly the state a ticket-first flow would have produced from the start — APP-1515.)

**A ticket of record for work a session is already doing is filed In Progress under the session's own executor — not captured under `agent:R3-LAY`.** The rule above and the filing invariant compose into a race the moment the work is already running: the ticket-of-record rule says file it *captured, unrouted, unassigned*, and the filing invariant gives a run-filed ticket `agent:R3-LAY` by default so that it enters the triage poll — so the poll refines it, routes it to Todo + `agent:F0-RGE`, and the delivery loop's eligibility scan (phase 1 is `list_issues(label: F0-RGE, state: Todo)`) hands the same work to a second session. Both rules are right for work nobody has started. Neither is right for work that already has a runner. So a ticket of record takes the state and the executor that describe what is true: **In Progress**, carrying a real `agent`-group value for the session doing the work — `human` with the Owner assigned where the piece is his to write — with the title, the one-line ask and the surface it touches, exactly as minimal as before. This does not weaken *Interactive sessions are a capture surface, not a routing authority*: that rule protects the **routing** gate, the act of handing unstarted work to a builder, and there is no routing decision left to protect when the builder is the session filing the ticket. In Progress is not *ready*; it is *claimed*, and claimed is what the board should say. Two properties keep the form honest. An In-Progress ticket carrying no executor is itself a defect (`skill-coordinate` Pass 4, *Started-state ticket carrying no executor*), which is why the executor is set rather than left clear. And the ticket rejoins the ordinary flow when the session ends: the session's closing act moves it to **In Review** with its PR and verdict route, or to **Refinement + `human`** assigned to the Owner where the work was abandoned unfinished, naming in a comment what did land — so nothing rests In Progress under a runner that is gone. (Worked case: A1-522, filed 2026-09-24 as an interactive session's ticket of record on `assoc-one/meirionpritchard-com` carrying a `type:` value, a project and `agent:R3-LAY` per the invariant. The delivery loop triaged it within about 25 minutes and a separate session — `claude/cool-planck-ojp63s` — built it, producing a second pull request beside the session's own: the same change, the same approach, both green, and the Owner left to choose between two PRs for one change. Instance count: 1 — APP-1733.)

**A session-filed ticket of record on the delivery route is born with both headings — minimal governs the prose, not the gates.** The two rules above make a session's ticket of record *minimal* and file it **In Progress**, and together they carry it past the only places the heading invariant is stated: `convention-linear`'s *a ticket in Todo under a delivery executor carries both literal headings* binds at the promoting acts, and *a readiness claim is a checked claim* below binds at the readiness claim — a ticket created straight into In Progress by its own runner passes neither. So the section travels to In Review unwritten, a box check keyed on boxes present passes its half vacuously on a section that is absent, and the merge leg's heading check catches it only at the end (`skill-merge-pr` step 2, APP-1962's rule) — where the documented remedy, return the ticket to Relay to instantiate the section from the `type:*` template, has no addressee, because in an in-session loop the merge leg *is* Relay. The fix belongs at the filing act, not further downstream: a session-filed ticket of record **that will travel the delivery route** — In Progress → In Review → merge — carries `## Acceptance criteria` and `## Definition of done` as literal headings from creation, instantiated from its `type:*` template per *Per-type ticket formats*, boxes unticked. Minimal still governs the prose: a title, the one-line ask, the surface it touches, and those two headings with their boxes. A ticket of record for work that is **not** a delivery change — a capture, a decision, an investigation — takes its own type's shape as before. (Worked case: A1-600, `assoc-one/meirionpritchard-com` PR #224, 2026-10-05, filed in-session with `## Acceptance criteria` only; it passed QA clean and surfaced at the merge heading check, costing about one extra QA round-trip to improvise the section live. Same class as APP-1962, APP-1537, APP-1269 and APP-744 — the check kept firing downstream of the filing act rather than at it. `[pulse-refine]` **where** call under the APP-1099 what/how split; the *what* it sits inside is the Definition-of-Done gate itself, APP-1962. APP-2043.)

**An ambiguous routing instruction resolves toward the gate, never away from it.** "File the build ticket" is ambiguous between *create it routed to the builder* and *create the ticket that will go to the builder* — and only one of those readings is reversible. Read it as the second: file it captured, and let triage route. The asymmetry is the whole argument. Guess low and the operator promotes it in one click; guess high and the loop claims it on the next pass and the guess is already code. This is not a rule against acting on the operator's instruction — it is a rule about which way to fall when the instruction genuinely does not say. Where he wants it routed now, he says so, or he promotes it himself. (Worked case: four tickets filed to ready-and-routed on the reading of "file the forge ticket"; two were claimed and shipped within ~10 minutes, while the operator and the session were still discussing the spec that produced them — A1-211/212/213/214, 2026-07-15, APP-532.)

**A fast loop moves the spec-correctness bar earlier, it does not lower it.** With a ~10-minute turnaround from ready to open PR, there is no window between filing and building in which a loosely-written criterion can be caught and corrected — the review that used to happen after filing has to happen before it. So an acceptance criterion is checked against the project's own canon (its ADRs, its decision log, its tests) **before** the ticket is filed, not after the PR exists. In particular, **do not lift a criterion from another ticket's report at face value**: a report states what a run found, not what the architecture permits. (Worked case: A1-212's criteria told the builder to set a service-owned field on seed rows, taken from A1-196's report without checking the project ADR that made the seed verification-neutral; the operator questioned the premise, the ADR settled it, and by then the PR had been open an hour. What caught it was a pre-existing test encoding the invariant — the backstop was the repo, not the filing discipline, which is the part worth not relying on twice — APP-532.)

**Past the claim, the body is an as-built record — correct in a comment, never in the description.** Once a ticket is claimed and being built, its description is what the change was built against, and rewriting it destroys the only record of that. A correction, a change of mind, or a newly-found constraint goes in a **comment**; where the ticket genuinely needs re-specifying, bounce it back to ready with the correction in the thread and let the loop rebuild against it. This holds hardest on a closed ticket: overwriting a done ticket's description replaces a finished record with an open to-do and there is nothing to restore it from. (Worked case: A1-212's description revised an hour after the PR was built against the original, leaving ticket and PR describing different things; A1-213's description then overwritten while already Done, and restored by hand — APP-532.)

**New scope is never appended to a ticket past its claim — read the ticket's state and its attachments first, then file the scope as a follow-up `blockedBy` it.** The rule above governs *correcting* a claimed ticket's body. This one governs *adding to* it, which is the more damaging half: a correction at least concerns the change being built, where new scope concerns work the open pull request was never asked to do. So before adding an acceptance criterion to an existing ticket, read its **state** and its **attachments**. Where it is **In Review**, or In Progress with a pull request already open, the new scope is filed as its own ticket **`blockedBy`** it, and the claimed ticket is left exactly as the builder claimed it. Appending instead puts the PR in front of criteria it never saw, so review judges a green change against a bar nobody built to — and the undo is worse than the edit, because an appended block with no trailing anchor cannot be removed by patch, so the repair is a **full-description rewrite**, the one thing the as-built rule above exists to prevent. **The pre-hand-off re-fetch is a backstop, not the guard.** `skill-build-ticket`'s re-fetch of the ticket immediately before hand-off does catch this class reliably while the build is still open, but it can only catch drift that arrives before the PR does — so leaning on it leaves precisely the case this rule names uncovered. Read the state before adding the scope; let the re-fetch catch what arrives after. (Worked cases, both 2026-09-24 on `assoc-one/meirionpritchard-com`. A1-412 was already **In Review with a pull request open**, built by a parallel session from a prompt the amending session had itself written earlier; an Owner instruction was appended to it as new criteria, and the repair was to file A1-513 `blockedBy` A1-412 and then rewrite A1-412's whole description, because the appended block had no trailing anchor to patch against. A1-529 is the positive case: the same drift arrived **mid-build** with no PR yet open, the pre-hand-off re-fetch surfaced it, and it was simply implemented — which is exactly where the backstop reaches and where it does not — APP-1723.)

**A ticket that closes green carrying a finding its dependents rest on pushes that finding — closing cleanly is not a reason to escalate nothing.** Every other judgement route in canon fires from a **fail-safe**: a leg that is blocked, bounced, hits an ambiguous spec, or cannot tick a box. A leg that completed cleanly escalates nothing *because* it passed — and a spike, a probe or any investigation whose deliverable partly *is* what it learned can close green having invalidated a sibling's criteria. The pull-side rule cannot catch it, by timing: `skill-triage`'s harvest sweep and `skill-coordinate` Pass 2 both lift a resolved blocker's output into a dependent, but only while that dependent sits in the **refinement gate**. A dependent that already reached Todo is never re-refined, so a finding arriving after that has no path in at all — push and pull miss each other, and the build leg reads criteria that predate the finding and produces a result that is wrong while looking complete. So **at close, read the ticket's own relations** — `blocks`, and any dependent the body or the verdict names — and for each finding that bears on one, take one of exactly two actions: **write the finding into that dependent's acceptance criteria** (a comment where the dependent is already claimed, per the as-built rule above), **or** route the judgement to `operator-<venture>` naming the closing ticket, the dependent and the finding. Never both silently, and never neither. The read is the closing ticket's own relations, not a board-wide `blockedBy` graph — that read does not exist at board scale (APP-976), and scoping the trigger to the ticket already in hand is what makes this authorable at all. The existing *On completion* shape says report the outcome and unblock the dependents; it is silent on the outcome that **changes** what is being unblocked, and this is the push half that pairs with harvest's pull. The judgement itself — does this finding change the dependent's criteria, and how — is a how-and-where call the operator already holds and already makes; what was missing was anything to fire it. (Worked case: APP-1130 closed green on 2026-09-11 carrying two findings that changed what its dependent APP-1131 should measure — a Cowork telemetry record under-reads by ~60% of turns, and `skills_attributed` is empty on that entrypoint. Both lived only in a comment on APP-1130. APP-1131 had been refined and sitting in Todo since 2026-09-07, so its build leg would have produced a baseline that was wrong and complete-looking; caught by hand in an Owner session, and the criteria amended by hand afterwards — APP-1382. The mirror failure, a dependent trusting stale information about its blocker, is APP-422.)

**A correction discharged by splitting, or by a ruling, sweeps the siblings it named — a relation existing is not a relation being read.** The push rule above fires **at close**, which leaves two common discharges uncovered. Both were live on one stand-up, 2026-09-24:

* **Discharged by a split.** A `RECONCILE:`-type ticket filed to correct a stale premise everywhere it appears is usually discharged by **splitting into legs**, not by closing — so the close-time relation read never runs, and the legs it spawns carry no relation to the sibling the parent named. A split is therefore **complete only when every sibling the correcting ticket's own body or checklist names is either covered by a leg or filed as a leg of its own, by ID, in the split comment**. The same both-halves test the fold-in rule below applies to scope. (Worked case: MBN-297, filed 2026-09-14 specifically to find and correct every place the board asserted Quivo fulfilment, named MBN-280 in its own checklist — "acceptance criterion naming 'UK base, Quivo fulfilment'" — and carried a `blocks` relation to it. Its legs MBN-301 and MBN-302 closed 2026-09-22; MBN-280's acceptance criteria still read "UK base, Quivo fulfilment" verbatim on 2026-09-24, ten days after MBN-297 was filed, and were found only because a stand-up happened to open MBN-280 to check whether it was ready to action. The relation was there the whole time and nothing read it — APP-1715.)
* **Discharged by a ruling.** An Owner ruling that answers a ticket's open question is recorded in the body with its provenance and in the decision log, per the citation rule below — and recording it is not discharging it. A ruled ticket whose **state and lane still say the question is open** goes on reading as an ask on the Owner to every sweep that keys on `human` plus an assignee, for as long as nobody happens to open it. So the ruling write lands **in one act with the state and lane the ruling implies**: off `human` and off the Owner's assignment where the ruling releases the work, or **Blocked** behind the named prerequisite where it defers it. Recording the decision and moving the ticket are two halves of one write. (Worked case: MBN-291, ruled by the Owner on 2026-09-15 — the ruling reached both the ticket body and the decision log — and left in **Todo** on `human`, assigned to him, reading as an open ask on him for over a week until the 2026-09-24 stand-up corrected it. This is APP-1478's own root cause recurring after that note closed with a question asked rather than a rule written, which is the argument for writing it here — APP-1715.)

**A fold-in is complete only when both halves land.** Folding one ticket's scope into another — the duplicate case, where one ticket's scope is absorbed into another — is two edits, not one. (a) The absorbing ticket's scope and acceptance criteria carry the absorbed scope **verbatim**: copy it forward rather than paraphrase, and treat the absorbed ticket's evidence as often the better record. (b) The absorbed ticket is **closed as folded-in with a pointer to the absorber**. Neither half alone suffices: (a) without (b) leaves phantom work in Backlog under a ticket that will never be executed; (b) without (a) silently drops the scope, which lived only on the now-closed ticket. This is the same decision-vs-executed-artefact joint as the as-built rule above — the mirror is a body rewritten to assert a ruling that never happened (APP-948). (Worked case: APP-961, a folded-in ticket whose scope lived only on the ticket that will never be executed.)

## The standard ticket shape

A ticket body uses a **fixed section skeleton with exact heading text**, the way `convention-artefact-format` fixes the shape of a canon artefact. A fixed skeleton is what lets a human and a skill read any ticket the same way — find the objective, find the acceptance checklist — regardless of project or type. Loose headings drift (`Done when`, a merged `Body / acceptance criteria`, a bare `Acceptance`), and drift taxes every read and write and breaks the Definition-of-Done gate, which needs the acceptance block in one predictable place.

The canonical sections, in order, with their exact headings:

* **Title** — action-prefixed and specific (e.g. `PROPOSAL: …`, `SCOPE: …`, `FIX: …`, `DRIFT: …`, `CAPTURE: …`). The prefix signals the kind of work at a glance.
* **`## Objective`** — one or two sentences on what the ticket is for.
* **`## Why this matters`** — brief context, especially how it connects to other work.
* **`## Acceptance criteria`** — the specific, testable conditions that make *this* ticket correct, unique to it. For any ticket an agent will execute, a Pattern A checkbox list under exactly this heading, so the DoD gate and skill-review-pr / skill-merge-pr can locate it. Omit only for a ticket that genuinely has no executable acceptance (e.g. a pure decision ticket). Acceptance criteria are **born as `- [ ]` checkboxes**, never plain bullets — a criterion is load-bearing on the Done gate, and a plain bullet cannot be ticked, so writing one as a bullet silently drops it from the gate. Author every criterion as a checkbox from the first draft.
* **`## Definition of done`** — the standing shipping bar for *every* ticket of this type, pasted from the type template (see *Per-type ticket formats* below) at refine. Also a checkbox list. Both this and the acceptance list must be fully ticked (or struck with a one-line waiver) before Done or merge.
* **`## Notes`** — open questions and decisions for the operator, included only when the brief is not fully defined. This is what makes a captured ticket refinable rather than vague.
* **`## On completion`** — usually "refine with the answers above, then move to ready."

Pin the acceptance heading as exactly `## Acceptance criteria`. Retire the drifted variants (`Done when`, the merged `Body / acceptance criteria`, the bare `Acceptance`).

**Filing invariant — a ticket a run files carries a type, an executor value and a project, or it is filed nowhere.** Every sweep in the system keys on an `agent`-group value and enumerates per live project, so a ticket created with an empty label set or no project rests in Backlog looking correctly filed and is triaged by nobody, swept by nobody, and reported by nobody. Any ticket filed by a run — a follow-on from an exec or QA leg, a capture, a decomposition child — carries at minimum: a `type:` value; an `agent` -group value (`agent:R3-LAY` by default, so it enters the triage poll); and a **project inherited from the parent or originating ticket**. Where the homing is genuinely ambiguous (a fix spanning two projects), file it to the originating ticket's project and flag the ambiguity for triage to re-home in the body — **never to a holding project**, which is only a second place for tickets to go quiet, and never to no project at all. The read-side nets (`skill-triage`'s Executor-presence sweep, `skill-coordinate` Pass 3) catch the Owner's hand-filed tickets; this is the write-side rule for every run. (Worked cases: A1-360 and A1-361, filed by the 2026-08-16 delivery-loop legs with `labels: []`, A1-361 with no project; A1-110, Owner-filed, projectless ~6 weeks; A1-337, operator-filed, projectless four days as the sole gate on firmup Phase 0 → 1 — APP-984 / APP-1000.)

**Minimal variant — trivial and auto-captured tickets.** A trivial or machine-captured ticket (e.g. a GTD capture) is not forced into the full skeleton. The permitted minimal shape is `## Summary` plus whatever the capture carries (`## Actions`, `## Notes`, `## Classification`). Defining this variant is what keeps drift from filling the gap: a ticket is either the full skeleton or the named minimal variant, not a free-form third thing.

**Capture format — the evidence-first capture shape (a third named shape).** An editorial or work *capture* — a decision, moment, breakthrough, or opinion recorded while the thread is fresh — uses its own named shape, neither the full skeleton nor the minimal variant. It exists to preserve **what happened**, sourced from the originating thread, before any interpretation is layered on. Naming it here is what keeps the next capture consistent rather than improvised. Title prefix **`CAPTURE:`**.

* **Produced from the thread, not authored from memory.** The capture is *extracted by the capturing task from the source thread or transcript* — sourced, not invented — and written in the subject's first person because it records their work. The operator reviews and corrects; he does not author it. Where the thread does not evidence a section, **name the gap** ("not in the thread") rather than filling it.

* **The evidence spine** — the record of the event, in order:
  * `## What happened` — the moment: the decision, the thing done. **Mandatory. A capture without it is not a capture, it is an untethered opinion.**
  * `## Why it happened` — the trigger and the stakes: what forced it, why it mattered.
  * `## How it happened` — the mechanism: the approach, the actual moves.
  * `## Decisions and trade-offs` — **the judgement layer, and the highest-value section.** The real forks: the options considered *and rejected*, what was traded off against what, and the reasoning behind the call. Naming the road not taken is where taste shows — a chosen path with no visible alternative reads as luck, not judgement. Same discipline as an ADR (`skill-architecture-spike`: options with trade-offs, recommendation, and why), folded into a capture. In an AI age execution is cheap, so the decisions and trade-offs are the differentiator and the readable evidence of taste — and the easiest section to fabricate, so it is the one to flag rather than fill when the thread is thin.
  * `## What it led to` — the outcome: what changed as a result, and any evidence of impact.

* **The interpretation layer** — sits *on top of* the spine, never in place of it:
  * `## The conviction` — the argument it suggests.
  * `## Design lens` — why it belongs in a Guide to Design (where the capture feeds Mr P).
  * `## Evidence status` — is there a `tc.*` yet; gaps named, not filled.
  * `## Format` — piece or note (+ any derivative).

* **Label lifecycle.** A capture carries the `capture` classification label while parked so the monthly aggregation re-reads it; the label is dropped when the capture is promoted (fleshed into a stated position), to keep the aggregation signal clean.

* **A parked capture carries no executor — it is classification-only until it is promoted.** While it is parked, a capture or an idea row carries **only** classification labels (`capture`, `theme:*`, `source:*`, `story`) and **no** `agent`-group value at all. That is deliberate, not a hygiene defect: a capture is not yet work, so there is nothing to route, nobody is waiting on it, and an executor value would put it in a delivery queue it has no business being in. It follows that a parked capture or idea is **exempt from any executor-presence check**, including `skill-triage`'s *Executor-presence sweep* over Todo, for as long as it stays parked. **On promotion it stops being exempt and takes the full filing invariant in one write** — a `type:` value, an `agent`-group value (`human` where the piece is the Owner's to write, a real agent value where it is not) with an assignee wherever that value is `human`, a project, and the `## Acceptance criteria` / `## Definition of done` its type template carries — and the `capture` label is dropped per the lifecycle bullet above. The exemption is the parked state's, never the promoted row's. (Worked case: MRP-57, MRP-58 and roughly 25 further `Defined` rows were read as unjudgeable by the 2026-09-22 triage sweep — about 27 in all — which correctly declined to correct them on a guess, because the convention was real but unwritten. APP-1633.)

The spine maps directly to the Mr P piece shape in `convention-mrp-voice` — why = the stakes, how + decisions/trade-offs = the design move and the judgement, outcome = the proof, conviction = the flag — which is why extracting it at capture (while the thread exists) seeds the fuller `tc.*` later rather than forcing a reconstruction from memory. `task-content-drain` and `convention-mrp-voice` reference this format rather than restating it.

Set priority and classification per the tracker's taxonomy. Assign the operator **only** when the ticket carries a genuine question, decision, or verification that is his to make — never as a blanket parking gate, or "assigned to him" stops meaning anything. Any comment that assigns him must @mention him and lead with the specific action needed. Where such a comment hands him something to *do*, write it as novice-friendly numbered steps — see *Writing an instruction the operator has to action* below.

## Acceptance criteria vs definition of done

Two distinct things, split so responsibility for each is clear:

* **Acceptance criteria (AC) — per ticket.** The specific, testable conditions that make *this* ticket correct. Written fresh for each ticket.
* **Definition of done (DoD) — per type.** The standing shipping bar for *every* ticket of a type (all bugs, all features). Rule of thumb: if it would be true of the next ticket of this type, it is DoD; if it is unique to this one, it is AC.

Both live in the ticket as their own labelled checkbox section — `## Acceptance criteria` (written fresh) and `## Definition of done` (pasted from the type template) — and **both must be fully ticked, or struck with a one-line waiver, before Done or merge**. This is the two-section gate: splitting them stops a per-ticket condition and a standing shipping condition sharing one list where nobody owns which (worked case: A1-111, where "root cause stated" sat in the same checklist as "PR opened" and the whole list fell through to the operator as a manual waiver).

**Responsibility.**

* **AC** — written by the author (the operator or triage at refine, never the builder); ticked by the builder as built; verified by review (ticked *and* genuinely met); gated by the merge leg, then the operator.
* **DoD** — standing per type in this convention, pasted by the author at refine; ticked by the builder; verified by review; gated by the merge leg.
* The builder never authors AC. Review never ticks a box on the builder's behalf — a blank or unmet box is a changes-needed bounce, not a clean pass.

**A readiness claim is a checked claim — grep the saved body for both headings before stamping a ticket ready.** Whoever asserts that a ticket is ready to action — a refine manifest's *Ready to action* line, a triage promotion, the operator's own promote — confirms by reading the **body as saved** that `## Acceptance criteria` and `## Definition of done` are both literally present. The check is a grep, not a recollection of what was authored: a section goes missing between drafting and saving with nothing to signal it, and four sibling tickets written in the same pass carrying both sections is evidence about those four and none at all about this one. **The asymmetry is the point.** The *reading* side tests the property and repairs a deviant heading in passing — five real `- [ ]` criteria under `## What to check` beside a real definition of done is built, not bounced (`skill-build-ticket` step 3b, and its ruling on why the test is the property and not the string). The *authoring* side still owes the literal template heading, because the pinned heading is what every downstream gate locates the block by, and an author does not get to spend the reader's tolerance: a genuine absence is a bounce that costs a cycle, and a deviant heading spends a repair that cost nothing to avoid. A gate that keeps firing is not the same thing as a manifest that no longer needs it. (Worked case: APP-1223 reached the 2026-09-10 triage poll carrying the refine manifest's `## On completion — Ready to action` line and a well-formed `## Acceptance criteria`, with **no** `## Definition of done` heading at all — not malformed, entirely absent — beside four sibling manifest tickets, APP-1224, APP-1226, APP-1227 and APP-1228, all of which carried both. `skill-triage`'s literal-heading gate caught it at the poll, before routing, so no cycle was lost. Same class as APP-1037 / APP-1017, which were `skill-build-ticket` step-3b bounces on tickets that had already reached Forge — the gate keeps catching manifest defects rather than the manifest avoiding them — APP-1269.) **And read the `type:` label in the same breath as the headings, because a ticket with no `type:` label has no template to instantiate from and therefore cannot have had the DoD pasted from one.** The label is already owed at filing (*the filing invariant*, above), so its absence is a second defect rather than a new one — but it is the cheaper read of the two, it is visible without opening the body, and it explains the absent section rather than merely finding it. A readiness claim on a ticket carrying no `type:` value is refused on the label alone, and the ticket returns for its type to be set and its template instantiated, which is one edit rather than two.

**Starting a build leg is itself a readiness claim — and a derived checklist is not a substitute for the sections.** The rule above binds whoever *stamps* a ticket ready, which leaves uncovered the one route that stamps nothing: a leaf dispatched to a build leg straight out of Backlog, where no refine manifest, no triage promotion and no operator promote ever happened, so the grep that would have caught it was owed by nobody. The **dispatch** owes it too. The build leg's first action is the same grep of the **body as saved** for `## Acceptance criteria` and `## Definition of done`, and a genuine absence of either is a **bounce back to refinement** — the leaf returns for its author to write the AC and paste the type DoD — rather than a build that proceeds. **Deriving the PR checklists from a `Suggested fix`, a `Scope note`, or any other prose section is not the repair, even when flagged as derived**, because a derived checklist makes the builder the author of the AC, which *Responsibility* above forbids outright, and it then passes review on the builder's own reading of what the ticket wanted — the two-section gate's whole purpose, fixing who owns which condition, is spent. A derived-and-flagged checklist is the **tell that the bounce was skipped**, not evidence that it was unnecessary, so it is a changes-needed bounce at review rather than a noted caveat on a clean pass. (Worked case: A1-598, a FIX leaf sitting in Backlog under `agent:R3-LAY`, reached a build leg with a "Suggested fix" and a "Scope note" and neither literal section; the PR checklists for assoc-one/meirionpritchard-com#234 were derived from the "Suggested fix" and flagged as derived, and the review leg passed it on that basis. Same defect class as APP-1037 / APP-1017, one gate earlier — those were caught at the leg, this one never met a gate at all. APP-2207.)

**Waiving a box — two waivers, split by what is actually wrong.** A box that cannot be ticked is one of two different things, and collapsing them is what produced a rule with no path through it. The distinction is **unmet** versus **unverifiable-here**:

* **Unmet — the operator's waiver.** The work does not satisfy the criterion, and shipping anyway is a judgement call about whether that matters. That is the operator's, with a recorded one-line waiver. **The vertical's operator (`operator-<venture>`) may also strike a criterion outright, with a recorded one-line waiver, where it holds evidence the criterion was mis-written** — the evidence bar is a live read of the artefact or the source the criterion names, showing the criterion asserts a state that never held or a bar the ticket's own body contradicts, not a preference that the bar is inconvenient. The waiver names the evidence. Until 2026-09-02 this said who *owns* the waiver without saying who may *strike*, and the silence defaulted every mis-written box to the Owner's lane (APP-1064; Owner grant 2026-09-01, generalised 2026-09-02). Striking a criterion is not loosening a gate: a box that was correct and is merely unmet stays unmet.
* **Unverifiable in the loop's environment — the delivery manager's bounded waiver.** The work may well satisfy the criterion; the loop simply has no instrument to confirm it (the sandbox's egress proxy 403s a preview URL before the request leaves; no runner can drive a live deployed surface). **Relay waives this class itself, with a recorded one-line reason**, provided all three hold: the box is environment-unverifiable and **not** in doubt on the evidence; an **independent signal already covers the surface** (green CI that genuinely ran, a passing visual diff, an identical local code path exercised by a test); and the waiver **names the signal it is relying on**. Where any of the three fails — the evidence is genuinely ambiguous, or nothing independent covers it — it is not this class: route it to the operator as an unmet box.

The reason this is Relay's and not the operator's: Relay runs Linear-only. It cannot provision a differently-egressed runner, add a CI workflow, or open a browser, so "re-route it" was never an instruction it could follow — its only lever *was* the operator's waiver, and the ticket landed on him via the exact route the rule forbade. Every party followed the rule and the ticket still ended up where the rule said it must not. A rule nobody can follow is not a stricter rule, it is an unwritten one: the loop's actual practice already diverged, and resolved the same evidence two ways run to run — on A1-209 (PR #8, 2026-07-14) Relay waived the box and merged, noting the repo-level gap was "a separate hygiene item, not a gate on this"; on A1-216/A1-217/A1-208 it routed to the operator. Naming the narrow class makes the working practice the written one and keeps the operator's waiver for what it is actually for. (Decision: Aled, 2026-07-16. Worked cases and the four candidate shapes: APP-568, consolidating APP-555.)

**This waiver routes around a missing instrument; it does not replace one.** A box repeatedly waived in one repo is evidence that repo needs the runner, not that the criterion is decorative — file the repo-lane ticket. And the box only belongs on the ticket at all where something could plausibly verify it: "runtime-verified on the deployment" on a ticket in a repo with no workflow at all is a criterion authored against an environment that does not exist. (`assoc-one/firmup` has no `.github/workflows/` whatsoever — confirmed empty on three separate delivery-loop runs, A1-209, A1-216, A1-217 — and every firmup ticket paid a Blocked round-trip for it: APP-555.)

**Author a runtime criterion against the instrument that can run it, not the operator's desk.** Where an acceptance or definition-of-done item needs runtime verification against a deployed preview — a payload budget, load behaviour, live rendering — write it as a CI assertion (a Playwright request-interception check with a budget, run in the repo where the egress exists), not as a manual "verify on the preview" step. The loop's sandbox is egress-denied to preview URLs and CDNs, so a manual-preview box lands on the operator by construction — not because his judgement is wanted, but because nothing else in the loop can reach the surface. Reserve manual preview items for genuine judgement calls (design feel, copy), which route to him deliberately. This is the authoring-side of the waiver above: the waiver rescues a box already written the wrong way; writing it as a CI assertion means it never needs one. (Worked case: A1-208 sat Blocked three days on "measured on the preview" and "verified at runtime on the preview URL" with the code clean and CI green, until an Owner-side session measured it by hand and A1-223 moved the check into Playwright CI — APP-579, 2026-07-14.)

**Word the criterion as the property, not the instrument: "runtime-verified against a production build of the PR head" by default, and name the hosted URL only where the deployment itself is what is under test.** "Verified on the Vercel preview" names an instrument the loop cannot reach — the sandbox's egress proxy refuses the preview and the estate domains — so as worded the box is unmeetable by construction, however good the build. "Runtime-verified against a production build of the PR head" names the property, and the sandbox can satisfy it: it has Chromium and Playwright, so Prism builds the head, drives it in a real browser against a controllable stub where an upstream is involved, and runs the negative control (`skill-review-pr` *Unverifiable in this environment*) — stronger evidence than a preview click-through, because a stub can be driven into the empty and error states a hosted preview cannot. Reserve a hosted-URL wording for the residue where the **deployment itself** is under test — DNS, auth in front of the app, edge config, real upstream data — and write that box as the operator hand-off it genuinely is, split per the cannot-reach rule in *Obligations belong in structure, not prose*. That set is much smaller than the manual-preview habit implies. (Owner ruling, Aled 2026-09-03, APP-880; the run that showed the sandbox could do it was A1-374 / `assoc-one/firmup-operator` PR #20, 2026-09-02. The egress-allowlist widening the same ruling ordered is an Owner config action and does not change this rule — a criterion names the property whether or not the URL is reachable.)

**A machine-checkable expected value is a property of the run being asked for, not of the upstream source.** Where an acceptance criterion pins a concrete expected value — a first observation date, a row count, a version string, a file's contents — state it against the artefact the run *this ticket commissions* actually produces, after every parameter the same ticket mandates has been applied. Where a run parameter stands between the source and the output, an expectation copied from the source is unreachable by construction: the box can only be ticked by disagreeing with the ticket, and a run that reads it strictly reports a failure that never happened — the surprise the criterion was written to make legible, manufactured by the criterion itself. So read a pinned value against the other boxes on the same ticket before filing; where the source's own property is the thing genuinely worth asserting, write it as its own criterion, against a run that can reach it. This is the same family as the two rules above — writing a criterion so a machine can tick it, APP-555 / APP-579 — one layer in: those name the *instrument* that must be reachable, this names the *value* that must be producible. (Worked case: APP-937, 2026-09-07, bot.Trader. One box pinned `PANEL.md` showing AUD's first rate observation, **expect** `1990-08-31` — the depth of the RBA F1.1 source series — while the first box on the same ticket mandated fetching with `--from 2005-01-01`, and the adapter clips every series to the requested range. `2005-01-01` was the only value the commissioned run could ever produce. The substantive criterion, "first rate observation before 2008", was met and the box ticked with the discrepancy stated, but as written the ticket could not be satisfied — APP-1137.)

**Word a coverage criterion as the property being reachable, never as a count of artefacts.** The rules above keep a criterion machine-tickable; this one keeps it from being tickable by the wrong thing. A criterion that enumerates artefacts — "stories cover desktop, tablet and mobile" — is satisfied by producing three artefacts, so the criterion becomes the **transmission path** for the anti-pattern it was meant to guard against: the builder ticks the box by writing one story per viewport, and the box is honestly ticked. Write the property instead — the component's responsive behaviour is **reachable and verifiable at each breakpoint** from the single story the convention prescribes. The shape the artefact itself must take is `convention-storybook`'s and is not restated here; what belongs here is that the **criterion** names the reachable property, because the criterion is what the builder builds to and what review ticks. The general form: where a criterion could be satisfied either by the property holding or by N artefacts existing, word it so that only the first satisfies it. (Evidence: APP-1626, the acceptance-criteria-wording half; the artefact-shape half is canon in `convention-storybook` and is not duplicated here.)

**A duration criterion names its measure: which span, which run, and an exact bound with no hedging adverb.** "Each leg completes comfortably under 10 minutes" is three ambiguities in one line — the test step or the whole job including setup, one run or a median across several, and "comfortably" as a second qualitative bar sitting on top of the number. Each reading is defensible, so the builder leaves the box, review cannot close it on its own verification, and it reaches the operator as a judgement call nobody authored: not a diff defect and not a disagreement, just a sentence that does not say what it measures. So write the span (the job's wall clock, or a named step), the run or runs the figure is read from, and a bare numeric bound — "the `playwright` job's total wall clock is under 12 minutes on each of the three matrix legs, read from the aggregate check's run on the PR head". Adverbs of margin — comfortably, well under, roughly — are struck at authoring. This is the same family as the three rules above, one axis along: those name the instrument that must be reachable and the value that must be producible, this names the span that must be measured. And where meeting one reading but not the other turns on a cost — more sharding, more billed minutes — that is the author's to settle before filing, not a reading for review to pick (`convention-github`, *Billed minutes are part of standing up or changing a workflow*).

(Worked case: A1-567 / `assoc-one/meirionpritchard-com` PR #211, QA leg at head `8b8058c`, 2026-09-30 — the criterion read "Confirmed in a real CI run: each leg completes comfortably under 10 minutes", against measured legs of 6m30s test step / 7m54s whole job, 8m09s / 9m50s, and 8m30s / 10m09s. Met on every test step, missed on one whole job, with roughly 1m45s of `npm ci` plus Chromium install accounting for the difference. The builder left the box for review, review could not close it, and because meeting the whole-job reading needed more sharding and more billable minutes it went to the operator as operator review — an Owner touch spent on an authoring ambiguity. The CI figures are reported from that run and not observed; that flag covers the per-leg timings. APP-1900.)

**A definition of done names only artefacts the executing session can actually write from where the work happens — and a DoD requiring a write the lane cannot make is a filing defect, not a blocker to work around.** The rules above keep a criterion worded against an instrument that exists and a property a run can measure; this one asks the narrower question about the *destination*: can the lane that will tick this box write the artefact the box names, from the surface the work actually happens on? A content ticket whose **Definition of done** named a copy-record path that the build repo makes **read-only** cannot reach Done at all — the executing session can produce the copy and has nowhere to put it — and nothing catches that at authoring time, because the path exists, resolves, and reads cleanly. So the rule is categorical: **a DoD names only artefacts the executing session can write from where the work happens**, and **a DoD requiring a write the lane cannot make is a filing defect to repair on the ticket** — raised against the ticket and its type template, never a blocker for the executing leg to work around. The leg's obligation is the reporting one. It names the unwritable artefact and the surface it was asked to write it from, and it **does not invent a substitute path**: a record landed somewhere the DoD did not name is an unticked box wearing a tick, and it costs the next reader a hunt for a record that is not where the ticket says it is. This is the destination-side counterpart of the instrument-side rules above, and the repo-lane-ticket response that *This waiver routes around a missing instrument* already prescribes is the right shape for the repair. (Worked case: one instance, **reported** — a content ticket's `## Definition of done` named a copy-record path that the build repo makes read-only, so the box could not be ticked from the lane the ticket was worked on; no repo permission surface and no session transcript is readable from the refine surface, so both the read-only state and the instance count of **1** are the filing note's report. The canon this leans on is **observed**: the two-section gate above and the instrument-side wording rules in this same section were read against the live store this run, and none of them reaches the destination's writability. `APP-2829`.)

## Per-type ticket formats

Every type shares the common spine — `## Objective`, `## Why this matters`, `## Notes`, `## On completion` — and adds the sections below. The `type:` label selects the template (bound in `convention-linear`). At refine the author instantiates the ticket from its type template: paste the type DoD and confirm the AC are present before promoting to ready.

* **`type:epic`** — adds `## Child scope`. No AC. DoD = all children Done and the outcome met. Closed by the operator, never claimed by the builder.
* **`type:feature`** — adds `## Scope`. AC = the capability delivered. DoD = child tasks Done, end-to-end verified on preview, decision log updated.
* **`type:story`** — AC = the user-visible behaviour. DoD = PR opened, CI present/concluded/green, runtime-verified, no secrets, review verdict posted.
* **`type:task`** — AC = the technical conditions. DoD = PR against the right repo, CI present/concluded/green, typegen/build where relevant, no secrets, review verdict posted.
* **`type:bug`** — adds `## Problem` (repro, expected vs actual, evidence) and `## Already ruled out`. AC = root cause stated and fix applied. DoD = regression guard added, verified at runtime not by a green build, root cause recorded, cross-surface impact flagged, PR + CI.
* **`spike`** — a **time-boxed investigation, where the right course of action is unknown before work begins**. Title prefix `SPIKE:`. Adds `## Question to resolve`, `## Scope` (explicitly in and out), `## Expected output`, and an optional `## Time-box`. AC = the question answered, well enough to decide. DoD = findings recorded as a comment on the ticket, the decision or recommendation stated, and the follow-on tickets filed and linked back. Executor: `F0-RGE` for a technical spike (it runs `skill-architecture-spike`); another agent where the spike is strategic or pipeline work. **A spike is never merged as a PR** — its deliverable is the decision record and the follow-on tickets, not a code change, so a spike that opens a PR with code in it has become a build ticket and should have been split. The type exists because the alternative is a build ticket whose real question is "what should we build?", which the loop answers by guessing. (Worked case: APP-419, "what does upgrading both studios to Sanity v6 actually require", filed as a spike with no type defined — Aled added the `spike` label by hand in-session, and nothing told an agent the format, when to reach for it, or how to route it. APP-420, 2026-07-02.)
* **Design variant** (a `work:` on a task or story, routed to the design agent) — adds `## References`. AC = the screens, states, and decisions. DoD = harvest-ready (node-id, reference asset/SVG, all states, interaction/motion spec); verified by design-parity.
* **Design-system component variant** (a task or story on a design-system component, under the DS epic) — adds no section of its own. AC = the component's own behaviour. DoD is **three gates in order**: **(1) Figma** — tokens applied correctly, the design accurate, and the part correct across breakpoints and in both light and dark mode, **in every state the code renders** — the state list enumerated from a code inventory of the component, never from the states the Figma page happens to hold, and each state shown in each mode, because naming the two theme modes and not the states lets the gate be satisfied by a page showing only the resting state. **And the part owns its surface or states host-dependence explicitly**: a variant carrying no fill of its own is rendered inside a representative host, in each mode, rather than only on its own ground where the dependency is invisible — the system-level form of that clause is `standard-design-system`, *The component config*. (Owner's bar, raised at the Meirion DS gate-1 review, with D145 as the local form; the bar here is built to grow by adding gates, which is what this is. Premises reported, not observed: the gate-1 review, D145's local form, and what the Meirion Figma file renders in each state come from the operator-a1 session — no Figma file and no repo is readable from this surface, and that flag covers those three points only. APP-2522, with APP-2576 for the surface-ownership half); **(2) Storybook** — the same component applied there, in the story set the Owner reviews (coverage bar and the DS-only runtime route: `convention-storybook`); **(3) the build** — confirmed the component is used properly where the app renders it, not merely exported. The order is a gate sequence, not a flat checklist: Storybook is not ticked before Figma, nor the build before Storybook. **Findings, open items and audit results are not written into the Figma doc frames** — not the `FINDINGS` block on `doc/config`; they go on the ticket or are raised in the session, and the existing findings blocks are clutter to remove. Deliberately the first and smallest form: the bar grows by adding gates here, not by re-deriving one per component ticket. (Owner's standing bar for every ticket in the design-system epic A1-231, stated 2026-10-05 while filing A1-604, with his findings-block ruling from the same session; the system-level bar these gates test is `standard-design-system`. APP-2067.)

**Gate 1's breakpoint clause is met by an assertion at the boundaries, not by a look across them.** "Correct across breakpoints" is read in practice as a pass over the two or three widths a reviewer happens to open, and the defect it misses is the one that lives at a boundary: a layout property that changes at the breakpoint itself — a cell that collapses, a column that drops, a label that truncates — holds at every width either side of the edge and fails at it. So the criterion names the property as machine-asserted at each breakpoint boundary the system states: the layout property is read at the boundary widths, from the rendered part, and compared against the value the system states for that mode (the breakpoint set is `standard-design-system`'s, *Layout and grid*; the story set that makes one part reachable at every width is `convention-storybook`'s). This is *Word a coverage criterion as the property being reachable, never as a count of artefacts* one step on: that rule stops the box being ticked by three stories existing, this one stops it being ticked by three looks. (Worked case: a b-text cell collapsing at widths at or below 1024px shipped out of A1-468 and was found only by the build-versus-Figma parity check on A1-787 — a gate-3 instrument catching a gate-1 defect, which is the gate sequence working and also the most expensive place in it to catch the defect. The cell, the 1024px boundary, both tickets and the parity finding are **reported** by the operator-a1 session; no Figma file and no repo is readable from this surface, and that flag covers those particulars only. APP-2579.)

* **DS CHECK slice, and its CODE DS feeder** (a check slice on one design-system part, under the DS epic, and the code-side ticket that feeds it) — the two types the enumerated list above has been missing, so their AC and DoD have been re-derived per ticket or left off. **DS CHECK** adds `## Checks` — the numbered per-part check list, each check written as a property and not as an artefact count — and adds `## After merge (Owner, manual — not merge gates)` wherever a check is a hand-operated step on a surface the merge itself produces (*A step that can only happen after merge goes in a post-merge section, not in a gate section*). AC = every check that can be true before the merge, written against the part itself. DoD = the three gates in order from the design-system component variant above — Figma, Storybook, then the build — with the post-merge steps out of both gate sections and in the named post-merge section, and the review verdict posted. **CODE DS** adds `## Feeds`, naming by identifier the DS CHECK slice it unblocks, and otherwise takes the `type:task` shape: AC = the technical conditions on the code side, DoD = `type:task`'s, plus the dependency recorded as a blocking relation rather than named only in prose (*Structure — hierarchy, ordering, dependency*). Both still instantiate at refine the way every other type does — paste the type DoD, confirm the AC are present, then promote — which is the step these two had nothing to paste from. (Worked case: the twelve-check DS CHECK slice template, the A1-638 shape copied into A1-646, A1-656 and roughly twenty stubs in the range A1-647–A1-682, carried an improvised AC/DoD split per copy; the merge gate fired correctly on A1-771 against that split, so what was missing was the format and not the gate. The template's shape, the stub range and the A1-771 merge-leg result are **reported** by the operator-a1 session; no repo and no Figma file is readable from this surface, and that flag covers those particulars only. APP-2569.)

**A step that can only happen after merge goes in a post-merge section, not in a gate section.** Some conditions are genuinely part of a ticket's outcome and genuinely cannot be met before the merge: a Figma library **publish**, which is a manual one-click step in the Figma UI; a Storybook **Connect** link, which needs the published library; any equivalent hand-operated step on a surface the merge itself produces. Written as an ordinary box in `## Acceptance criteria` or `## Definition of done`, such a step makes the ticket unmergeable by construction — the box cannot be ticked until after the merge, and the merge gate counts it (`skill-merge-pr`, step 2) — so every slice carrying one stalls at the merge leg and buys an Owner waiver to get through. **That is a misuse of the waiver**: the bounded waiver routes around a *missing instrument* (*Waiving a box*; `skill-merge-pr`), and nothing is missing here. The step is real, it is the Owner's, and its time has simply not come.

So the recognised shape is a **separate named section**, under this literal heading:

```
## After merge (Owner, manual — not merge gates)

- [ ] Publish the Figma library (manual one-click step)
- [ ] Add the Storybook Connect link for the published component
```

Its boxes are **tracked, not gated**: they are not counted by the merge gate and not counted by the Done gate, so the ticket merges with them open and the steps stay visible on the ticket instead of living in a waiver comment. The two gate sections keep their meaning exactly — `## Acceptance criteria` and `## Definition of done` hold only what can be true *before* the merge — and the post-merge steps keep a named owner and a surface, which a struck-through box does not. **Nothing that could be met before the merge belongs here**: a condition moved into this section to get a merge through is a gate evaded, and the section's whole licence is that its contents are impossible earlier. The Owner's own instance is the template — ruling on A1-656 that "the acceptance criteria need to take into consideration the manual publish", he added exactly this section to that one ticket by hand; this makes it the shape rather than a per-ticket improvisation. (The twelve-check DS CHECK slice template — the A1-638 shape, copied into A1-646, A1-656 and roughly twenty stubs in the range A1-647–A1-682 — put check 12, *Published: the Figma library is published (manual one-click step)*, in `## Definition of done` and the Storybook Connect link inside check 9 of `## Acceptance criteria`. A1-646 took seven Owner waivers; A1-656's merge leg stopped on 2026-10-19 on checks 9, 11, 12 and the checklist flip. APP-2434.)

**A non-code deliverable's definition of done names its reviewer and the surface that can reach it.** The delivery loop selects its next leg by the deliverable, so a definition of done that names no PR has to say three things or the ticket has no exit: **what is produced** (a Linear document, a deck, a spec, a design file), **which skill reviews it** (`skill-design-parity`, `skill-deck-parity`), and **which surface runs that skill** — the agent or lane that holds it, so the review is dispatchable rather than notional. State the consequence plainly: a review box with no named reviewer strands the ticket in whatever state the build leg left it in. Nothing in the loop is conditioned on such a box, so no sweep recovers it and the dwell is unbounded. (Worked case: A1-388, `assoc-one/firmup-operator`, whose deliverable was the Linear document `a1-firmup.spec.operator-console-theme` and whose one open box read "Reviewed by design-parity". It took the code lane's handoff — In Review + `agent:PR-1SM`, unassigned — and sat there ~99 hours across four consecutive fully-starved delivery-loop runs, the sole transitive root blocker of all six `F0-RGE` build leaves under epic A1-377, because that box named a skill no leg in the loop runs — APP-1129, with APP-1108 for the recovery half.) The read side of this is `convention-linear`'s unverifiable-DoD rule, which gains the matching third case in the same drain: where another surface would verify a box, route to the surface that can, via `skill-fleet-dispatch` carrying the reviewing skill — not a waiver, not Blocked.

* **Human / operator variant** — no AC if it is a pure decision. DoD is a **gate, not a nicety**: **the decision is recorded in the project decision log where consequential** — a linked `Dxxx` entry, or an explicit "no log entry needed" note — and the ticket is **not Done until one or the other is present** (the log is the system of record, a ticket comment is not — `convention-decision-log`); and **every open ticket the decision supersedes is reconciled in the same pass** — repointed, re-scoped, or its ACs waived — rather than left to contradict the decision latently. Carries `human` or `operator-<venture>`. (The gaps this closes: a decision that lived only as a ticket comment for 23 days — APP-724; and a logged decision that silently reversed two open tickets' ACs, surfacing only at runtime — APP-725.)

**The mirror collision — a ticket's AC contradicts an already-Locked decision.** The reconcile rule above runs when the *decision* is the newer thing; the opposite also happens — a ticket's acceptance criterion, sourced from a later explicit Owner instruction, contradicts a decision-log entry marked **Locked**. This is **not** the false-premise case `skill-build-ticket` step 3a already guards (a criterion asserting something *exists* that does not — that takes the Blocked path): here the premise is *true* and simply overrides locked canon. The rule: **a later, explicit Owner instruction in the AC wins over an earlier Locked decision** — build it, **declare the deviation** in the PR body and in a code comment at the point of change, and **flag the superseded decision to the Owner in the handoff** (mandatory, not optional). Do **not** Block it — a correct, Owner-instructed ticket must not stall on a decision its own instruction supersedes — and do **not** silently follow the AC without the flag, which leaves the log asserting the reverse. The earlier backstop is the pre-filing check above (an AC is read against the project's decision log before filing); this is what to do when the collision surfaces at build instead. **And close the loop on the log:** the superseding decision produces a **new decision-log entry** that supersedes the stale one, filed in the same pass as a `human`/operator log-update leaf — Forge never edits the log, so a deviation recorded only in a PR body and a ticket comment leaves the next builder reading the *superseded* rule as Locked canon (the exact staleness the reconcile rule above prevents in the other direction). (Worked case: A1-300's Figma-sourced AC held an open project's backdrop until collapse, contradicting Locked decision D019, which cleared it on cursor-exit; the run built correctly, declared the deviation and flagged D019, but had to re-derive the rule from first principles mid-run and nothing owned turning the flag into a new D-entry — APP-847, the un-covered mirror of APP-725.)

**The provenance test — a ticket's own embedded instruction contradicts a live convention.** The two rules above both turn on a *decision-log* entry: the reconcile rule where the **decision** is the newer thing, the mirror collision where a later **explicit Owner instruction** in the AC is. A third case arrives in neither shape — a ticket carrying an embedded **disposition or procedure instruction** (a close state, a label, a routing, a hand-off) that is **not traceable to an explicit Owner instruction** and that contradicts a **live convention** rather than a decision-log entry. In that direction the collision inverts: **live canon wins, and the embedded instruction is not followed verbatim.** So **trace the instruction's provenance** before following it. A later, explicit Owner instruction overrides an earlier Locked decision — that is the mirror collision above, and it still holds. **A prior agent pass's self-authored corrective overrides nothing**: it is a proposal sitting in a ticket body, and a convention outranks it however confidently it is written. Apply the convention, **name the deviation** in the closing comment or the hand-off so the next reader sees why the body was not followed, and — because such an instruction is almost always filed *for a successor ticket by the very pass that just failed* — **file the successor without it**, carrying the convention's own shape instead of the correction. This is not the false-premise case `skill-build-ticket` step 3a guards either: the instruction asserts nothing that does not exist, it simply prescribes the wrong thing, so the Blocked path is wrong here and the work proceeds. (Worked case: MRP-81, *"REACH: prepare the W43 standing set — and close it Published, not Canceled"*, third in the MRP-71 → MRP-78 → MRP-81 lineage, embedded *"Close this ticket `Published`, not `Canceled`"* in its own body. Mr Pritchard is an editorial team whose only completed-type states assert an external publication, so following that literally would have written a **publication claim on a ticket whose deliverable never reached LinkedIn** — the MRP-3 error `convention-linear` *Issue states* exists to prevent, and whose measured cost is on record at APP-2281. The operator's daily stand-up review caught it against the live mapping table and closed MRP-81 `Canceled`, delivered-as-input, naming the tickets its output fed. The near-miss shape is the part worth keeping: the instruction **correctly diagnosed** MRP-78's real defect — a no-reason `Canceled` reading as abandonment — and then **derived the wrong remedy**, changing the state rather than the one canon had already settled, which is to keep the state and state the reason. Second time in one lineage that its embedded "do differently" guidance needed correcting against canon rather than against itself: MRP-71 → APP-2281, MRP-78 → APP-2406, MRP-81 → APP-2479.)
* **Capture variant** — uses the evidence-first *capture format* above rather than the AC/DoD skeleton; it is a record, not executable work, so it carries no acceptance checklist. Its "done" is the operator's review-and-correct and promotion (or parking).
* **A ticket from a design review round** — not a body shape of its own. A Figma or other design-tool comment never becomes a ticket directly: it is captured into the round's document and triaged there first (`skill-design-review-round`; document naming in `convention-linear`), and a ticket is raised only from a row with an agreed approach. The ticket then takes the type template for what the change *is* (bug, task or story), with AC written against the states the change must hold in, lands captured, and goes through capture → refine → ready like any other — never straight to Todo or In Review, and never carrying a routing verdict in its body. It cites the round document and row and carries the comment's permalink; it does not restate the comment as its specification. (The A1-294 round produced 14 leaves this way round — 0 with AC, 0 with DoD, 6 promoted inside ten minutes — APP-743; Owner ruling 2026-09-03.)

## Writing an instruction the operator has to action

When a comment hands the operator something to *do* — a command to run, a setup step, a manual verification — how it is written matters as much as what it asks. These instructions are the one place an agent hands work directly to him, and the audience is a non-developer, so write them for a novice:

* **Numbered steps, one action per line** — never a run of actions jammed into a prose sentence.
* **Spell out every command literally, in a code span** (`` `npm run typegen` ``) — never describe a command in words he then has to translate into what to type.
* **Separate a decision to make from a thing to type.** A "confirm X?" and a "run this" are different asks; don't fold them into one line.
* **Assume no command-line fluency** — say where to run it and what a good result looks like.

Lead with the specific action or decision needed, then lay the steps out this way. This governs *how readably* the ask is written; the "lead with the action" rule governs *what* the ask is. (`convention-linear` and `skill-triage` bind this to Linear comments and point here rather than restating it.) The wider register and format standard for **everything** an agent puts in front of the operator — the scannable Decision / Action needed / Why header, the plain-language escalation that leads with a recommendation, and writing instructions for someone who does not live in the tool — is `convention-comms-owner`; this section is the ticket-instruction specifics that sit inside it.

## Pattern A — folded validation

The core working discipline, non-negotiable:

**Review criteria live inside the build ticket as two literal checkbox sections — `## Acceptance criteria` (per ticket) and `## Definition of done` (per type). There are no separate review tickets.**

The checkboxes are not decorative — they are the **record of completion**, and ticking them is the gate:

* **Definition of Done = every box in *both* the `## Acceptance criteria` and `## Definition of done` sections ticked** (`- [x]`), or struck through with a one-line waiver where a criterion is deliberately not met. A ticket may not reach Done or be merged while any acceptance or definition-of-done box is unticked without a recorded waiver.

When an agent finishes a ticket:

1. It checks its work against each embedded criterion and **ticks every box it satisfies** when opening the change for review. Any box it cannot satisfy is left unticked and called out, not quietly skipped.
2. It moves the ticket to the review state (leaving the assignee per the routing pattern below).
3. It does **not** mark the ticket done. Sign-off is human, always.

Review verifies each box is both ticked and genuinely met, and names any blank or unmet box — "definition of done confirmed" means every box ticked, not a general thumbs-up. The merge gate refuses to ship a ticket with any box still unticked and unwaived, surfacing it as not-ready rather than merging. The operator reviews against the embedded criteria and closes it himself. This keeps the human queue showing only actionable work — review is a state transition, not a separate piece of work. When writing a ticket an agent will execute, embed the acceptance criteria so this works.

**A criterion that asserts something already exists is a claim, not a given — verify it against the thing itself, at every moment it is acted on.** Criteria routinely rest on a stated prior state of the world: "the landing view is built", "the endpoint already returns X", "the component exists, just wire it up". That assertion is the load-bearing part of the brief, and it is written from memory, from a plan, or from another ticket's report — none of which are the artefact. So it is checked against the artefact: the repo's files, branches and PRs for a build premise; the file's actual contents for a repo-edit premise; the live document for a canon premise; and **the live read through the connector for a business-state premise** — inventory, analytics, a live site, an order book — never a prior report, status update or agenda that restated it. **And the package registry — never a repository's own state — for a dependency-health premise.** "This dependency is abandoned", "the plugin is unmaintained", "upstream is dead" are premises in exactly the way "the component exists" is, and they are routinely sourced from a GitHub repository's **archived** banner, which is the wrong artefact: it is evidence about *that repository's* fate and says nothing about the *package*. A repository is archived as often because it **moved** — a monorepo consolidation, an org rename — as because the project died, and the banner usually says which, in text a reader skips on the way to the conclusion. What settles it is the registry: read `registry.npmjs.org/<package>` (or the equivalent index) and take `dist-tags.latest` with `time[<latest>]` for the **actual last-publish date**, independent of any repository's state; then, where the repo is archived, read the banner and README for a redirect before concluding the code is dead. Two `curl`s, and the direction of the error is the expensive one: a false *abandoned* premise does not block, it **redirects** — it turns an upgrade into a migration evaluation, and the ticket reads well the whole way. (Worked case: A1-500, a spike on `sanity-plugin-mux-input` for `assoc-one/meirionpritchard-com`, 2026-09-23 — the ticket's own title and objective asserted "archived/unmaintained" from `sanity-io/sanity-plugin-mux-input` reading *"This repository was archived by the owner on Jun 17, 2026"*, while the same banner said *"This plugin has moved"* to `sanity-io/plugins` and the registry showed `latest` published **2026-08-21**, two months after the archive date, across 163 published versions. The correction flipped the whole recommendation from "evaluate migrating off a dead dependency" to "upgrade the dependency, then mitigate two bugs confirmed still present upstream". Sibling to the A1-338 / APP-971 case above: an asserted figure taken at face value from the nearest available surface rather than the generating one — APP-1674.)

**And the vendor's own reference, at the version installed — never the absence of a thing in the UI you happened to open — for a native-capability premise.** "The tool has no built-in X", "there is no native bulk action", "this needs a custom implementation" are premises in exactly the way "the component exists" is, and they are written from the surface a session reached rather than from the artefact that settles it. The artefact is the vendor's own capability reference for the **installed** major, read together with the installed package's source; a menu that does not show the action is evidence about that menu. The direction of the error is the expensive one, because a false *absent* premise does not block — it commissions a build of something that already ships, and the ticket reads well the whole way. (Worked case: A1-561 for `assoc-one/meirionpritchard-com`, 2026-09-28, asserted "Duplicate has no Studio-native equivalent" flat while Duplicate is a predefined Sanity document action; a custom action and PR were built and closed unmerged, at one build, one preview and one live check. The same ticket's *other* capability premise — native bulk delete — was marked "needs confirming live", and that one was correctly absent, so the discipline was available on the same ticket and applied to one premise of two — APP-1854.)

**And the live Figma read at the node — never a plan, a page index or a frame's own title — for a design-file premise.** "The example frames are on the DS page", "the variants exist in the file", "the states are drawn" are premises in exactly the way "the component exists" is, and they are written from a plan, from a page index, or from what a frame is called, none of which is the file. The artefact is the live read of the file at the node: the frame and its children as the file currently holds them, read through the design surface rather than inferred from a name. A title is evidence about a title, and doc chrome is named like content, so a page's own scaffolding reads as part frames to anyone working from the index. The direction of the error is the quiet one: a false *present* premise here does not block, it sends each build leg to a different target and each leg works the real one out privately, so the cost is paid once per leg and never surfaces as a defect on any of them. (Worked case: A1-677 called checklist header rows — doc chrome on the page, not part frames — "example frames", and three builders each worked out the real target separately. Precedents APP-1720 and APP-2190. The frames, the header rows and the three builders are **reported** by the operator-a1 session; no Figma file is readable from this surface, and that flag covers those particulars only. APP-2578.)

**The rule is symmetric: a stated absence is a claim too.** "Not covered by delivered work", "not yet implemented", "currently shows X" are premises in exactly the way "the component exists" is, written from the same sources that are not the artefact, and they go stale in the same direction — the gap between capture and refinement is precisely when the work most often lands. A well-formed ticket about already-delivered work is the harder case, because it passes every gate the loop has: it carries both checkbox sections, its criteria are testable, and its premise fails only in the direction nothing tests. So a stated absence is checked against the artefact at the same three moments, and by the same read — one grep is the whole cost. **The consequence differs from the positive case and must not be collapsed into it:** a false *presence* premise Blocks, because there is nothing to build on; a false *absence* premise means the ticket is **already satisfied**, which is not a blocker and is never routed as one — the work is done, the ticket is finished, and what is missing is only the verdict saying so. (Worked case: A1-308 stated "Not covered by delivered work"; the behaviour had shipped 2026-06-18 in `43e1173`, six weeks before the ticket was written and eleven before it was routed. It passed through refinement twice, acquired both Pattern A sections cleanly, and gained a settled design decision — and the run that claimed it found all three criteria met on unmodified `main` and opened no PR. The answer was even readable in the paired ticket's own source, which stated the behaviour was already live. The premise was never wrong about the future; it was wrong about the past, and nothing was scoped to test that direction — APP-1183.)

The check binds at **three moments in the ticket's life**, because any one alone leaves the hole open:

* **At authoring** — verify before writing the premise into a criterion, and where the surface cannot be reached, say so in the ticket ("premise unverified — confirm before building") rather than stating it flat. An unmarked false premise reads exactly like a verified one. **The flag's scope is both a stated prior state and a prescribed approach.** A criterion that names a *technique* — a stub, a mock, a snapshot, a fixture, a benchmark, a test runner — asserts the target repo already holds the harness for it just as surely as "the component exists" asserts the component, and it is written from the same three sources that are not the artefact. So where a criterion prescribes an approach, the author confirms the repo has the infrastructure for it, or scopes standing that infrastructure up as its own leaf (the same split as a credential-gated prerequisite in *Obligations belong in structure, not prose*), or marks the approach unverified so the build leg reports its interpretation rather than silently picking one. The transmission path to watch is a drained friction note: speculative wording ("candidate target: …") graduates verbatim into a criterion and carries the speculation's confidence with it. The matching rule one layer up — a canon artefact naming a runtime or data source verifies it at authoring time — is `skill-ops-retro`'s. (Worked case: APP-1122's criterion required `CLAUDE.md` to state "the stub-verify approach for local checks" while `assoc-one` has no test runner at all — no `test` script in `package.json`, no vitest, jest or playwright dependency — so the criterion named a practice with no harness behind it. The premise flag was present on that ticket and fired as designed; it covered the ticket's stated prior state, not its prescribed approach. The build leg did resolve it correctly, writing to what exists with an explicit "don't stand a mocking harness up to satisfy this note" — judgement, not a rule — APP-1155, 2026-09-07.) **The same flag covers a prescribed *fetch*.** A criterion or a spec that instructs a run to install, pull or copy from a **named host** — a component registry, a block library, any index that is not npm — asserts the run can reach that host, which is an assertion about the environment and not about the repo, and is written from the same sources that are not the environment. Where it cannot be reached, "install the named block" and "Blocked on an unreachable dependency" are both honest readings of one instruction, and which one a leaf gets depends on which run picks it up. So an instruction that names a host **states its fallback in the same place as the instruction** — *"where the registry is not reachable from a delivery run, vendor to the component API and note the reason at the top of each file, so a later install overwrites it cleanly"* — rather than leaving each builder to find, decide and justify it. Reachability is a property of the environment a run executes in and not of the estate, so the fallback is written as the standing answer and the reachability is re-probed, never assumed in either direction. (Worked case: A1-381's spec instructed `npx shadcn@latest add <name>` and copy-and-paste from a Tremor block library; both hosts refused CONNECT with a 403 from the delivery sandbox while npm itself installed cleanly, so the block was specific to the two registries the spec named. The run vendored by hand to the upstream component API and shipped, correctly — and five sibling leaves were queued to hit the same wall, each free to reach the other conclusion — APP-1182.)
* **At claim** — the builder confirms the premise before starting, and where it does not hold, stops and surfaces it rather than improvising the missing work into existence. A ticket is evidence about intent, never evidence about the repo.
* **At pick-up** — whenever a ticket is acted on materially later than it was written, the check is *is this still true*, not *was this ever true* — tested against the code and the decision log, not just the artefact. **And where the pick-up check and the driver brief disagree, the brief does not win.** A conflict found at claim time between what the brief instructs and what the board, the code or the decision log already shows goes **back** before anything is written — not through on the strength of the instruction. This is the trigger the check was missing: the rule above is stated and was not run, so the gap is enforcement rather than content. A claim leg that finds the objective already met stops, says so on the ticket, and hands the conflict back; it does not build to the brief and reconcile afterwards. (Worked case: A1-393 was sent to a build session on 2026-09-23 with every part of its scope already resolved — a decision-log entry recorded the route and named it, another ticket's acceptance criteria said the one code change was folded in there, and two `[coordinate]` comments had already recommended closing it. The session saw that the change had already shipped and went ahead **because the brief said to**, costing one PR, one CI run, a decision-log draft that had to be withdrawn, and one Owner correction — APP-1707. Third instance of the class: the two before it, MBN-262 and MBN-274, each stopped at the read-back and cost one claim cycle, which is the intended price; this one wrote, which is not — APP-996, APP-1388. The repo state and PR numbers in those notes are **unverified from the drain surface**, which can read no repo.) A premise verified when the ticket was authored can rot before it is picked up: a deployment moves beneath it, an Owner runtime decision supersedes a criterion, a metric is stated with no counterpart. Two things make this fire rather than sit as prose. First, **a ticket that names its own obsolescence condition carries an obligation to re-read that condition when the condition arrives** — a ticket that says "if A1-109 is still open, re-harvest" is read against A1-109's current state at pick-up, not its state at authoring. Second, **the trigger is the ticket's age against its project's rate of change, not the reader's memory** — a fast-moving repo ages a premise in days, and it is the gap between write and act, not whether the reader happens to recall the original check, that calls for the re-verify. (Worked case: three defects in one day in one venture — APP-824, where a deployment had moved beneath the ticket; APP-787, where an Owner runtime decision had superseded a criterion; APP-679, metrics stated with no Path A counterpart — APP-902.)

  **A completed re-check leaves proof behind, so the next reader can tell a verified premise from a confidently restated one.** A re-verify that leaves no trace is indistinguishable from a rewrite that changed the tone and nothing else, and the next reader re-derives the whole thing. Cheapest form, and the author's obligation: **any ticket asserting a specific defect carries the `file:line` and the commit sha it was verified at**, and a rewrite or revision banner states which the pass actually was — *re-argued*, or *re-verified against source at `<sha>`*. Claim and evidence are pinned together, so the next reader diffs rather than re-derives. (Worked case: APP-824 was rewritten thoroughly and raised to Urgent, and a day later still read as freshly checked while being wrong against `account.ts:91` — the rewrite carried the confidence of a verification without the pin that would have shown it was not one — APP-905.)

  **A premise about the world is written down and datestamped, or nothing can test it.** The pinning rule above assumes the premise is *stated*; the commoner failure is a ticket whose objective rests on a factual claim that is only implicit in its prose — "clear old stock" assumes there is stock. So a ticket whose objective rests on a claim about the world **states that claim as its own line and datestamps the read that verified it** — `Premise (verified 2026-08-10, Shopify inventory): 24 legacy lines and 5 bundles carry stock` — so that refinement, dispatch and the operating loop's decide step have something falsifiable to re-read, rather than having to reconstruct what the ticket assumes. The check then binds at the same three moments as any other premise. And **a ticket derived from an Owner directive inherits the directive's authority, not its verification**: the directive carries priority and mandate, and the operator's remit rightly stops it cancelling the goal, but testing whether the premise still holds is not changing the goal — it is the operator's job, and a void objective reported as on-track is the expensive outcome. (Worked case: MBN-262, "clear old stock before the rebrand", refined with four criteria, High, cycle-committed and named a Phase-1 priority in three status updates — while every legacy line and bundle had been at zero units since before it was written; a live inventory read on 2026-08-17 was the first thing that tested it — APP-996.)

**A "do not re-derive" scoping block is a snapshot with a suppression attached — mark which of its bullets are commit-sensitive, and never let it cover a load-bearing premise.** A ticket cut from a parent routinely carries a *Scoping notes already established — do not re-derive* section: the reads the refine pass already made, confirmed against `origin/main` at a named commit, so the builder does not pay for them twice. It is a good device and this is not an argument against it. The narrow failure is that **it reads as authority while being a snapshot pinned to a commit the block itself names and the reader is being told not to re-check** — the one instruction in a ticket that suppresses the claim-time premise check above. Its bullets are not equally perishable, and the difference is cheap to mark: *"no* `CLAUDE.md` *exists"* is a claim about a tree at a commit, while *"the scripts are* `typecheck` *and* `format:check`*"* or *"there is no Playwright dependency"* survives most commits. So a scoping block (a) states its commit once and **marks the commit-sensitive bullets**, (b) **names any open sibling PR touching the paths it speaks about**, because a repo with publish-shaped siblings in flight ages a snapshot in minutes rather than days, and (c) leaves every commit-sensitive claim **also** written as a premise criterion with both branches stated — *"read the repo root and confirm no* `CLAUDE.md` *exists; if one does, this becomes an edit, not a create"* — so the suppression never reaches a claim the build rests on. The third is the one that actually works, and it costs one sentence at refine. (Worked case: APP-1282, split out of APP-1226 at 10:45 on 2026-09-10, carried a do-not-re-derive block confirmed against `origin/main` at `241d48e` whose first bullet was that no `CLAUDE.md` and no `AGENTS.md` existed anywhere in the repo. By the exec leg's claim at 12:11 — 85 minutes — APP-1227 had merged as `cf4c042` and added a stub `CLAUDE.md`, the exact file the block said was absent. The block did not catch it; the ticket's own first acceptance criterion did, phrased as an instruction to look with both branches named, so the run cost a re-read and a scoping table in the PR body. Second stale premise in one day on the same ticket family, both caught by the same hedge — APP-1283, APP-1291.)

**A leaf that redefines a term a merged sibling already implemented says so, and names the count that must follow.** Where several leaves are cut from one spec into one repo, the same word — a status, an attention type, a state name — is routinely named in more than one of them, and each leaf's criteria are written and reviewed in isolation. Two definitions of one word can then ship green: both legs pass, both tickets read as met on their own terms, and the numbers agree until the first write that separates them, at which point one surface is confidently wrong and stays wrong. So the obligation is the decision log's, applied to leaves: **a criterion that restates a definition an earlier leaf already shipped cites that leaf and states which way the supersession runs** — one line, "this narrows A1-381's *Version needed*; that count must follow" — and the builder's claim-time premise check asks not only whether the stated prior state exists but whether **it means the same thing**. Where it does not, the structural answer is preferred to the reconciling one: **one derivation, with every count a read of it**, because two derivations of a single thing cannot be kept in agreement by review. (Worked case: A1-381 defined *Version needed* as every live row whose method is `manual`; A1-382, cut from the same spec and refined in the same pass, defined it as `manual` with no verified version — the two produced the same number on the preview payload, and A1-382's own acceptance criterion, that clearing an item updates every count, was unsatisfiable against A1-381's definition. Caught only because the A1-382 run read the merged sibling's code closely enough to notice one word meant two things; nothing in the refine, the claim-time premise check or the per-ticket QA leg was scoped to see it — APP-1187.)

**And the converse: a leaf that mounts onto a merged sibling's contract adds no term and no file that contract does not define or admit — or it says so and names the change.** The rule above catches one word defined twice. The opposite gap is a word, or a path, defined **nowhere**. The brief names a measure the sibling's schema has no field or definition for, or places a file where the sibling's validator, glob or build will read it as something else. Both read as complete prose, and both ship a choice nobody made, because the builder picks a reading or patches the sibling's gate in flight. So at authoring, for a leaf cut onto a merged sibling, read that sibling's contract on `origin/main` — its schema, its validator, the paths its scripts walk. For every **new term** and every **new file path** the leaf introduces, either cite where the contract defines or admits it, or write the definition into the criterion and name the sibling change it needs as a criterion of its own. This is the authoring-side twin of `skill-build-ticket` step 3a: that step asks whether what a ticket *assumes* exists, and this asks whether what a ticket *adds* fits. (Worked cases: APP-2425 asked for Owner dwell in "item-weeks", which neither the planning-week schema, APP-2400 nor the repo defined. It also placed its change log at `data/planning/changelog.json`, a path `npm run validate:planning` walks as a planning-week record. The exec leg chose hours ÷ 168 and added a root-file skip to `collectRecordFiles`, both in flight — APP-2431. The drain that assessed it found the same collision on a third sibling: APP-2426's snapshot path `data/planning/owner-queue/YYYY-MM-DD.json` sits under the same walker, which skips only `schema/`, `backfill-source/` and a root `changelog.json`. Read on `origin/main` `dc16455`, 2026-10-19.)

**A ticket that supersedes other tickets carries the supersession in its criteria, not only in its prose — and the ordering in a relation, not in a scan.** A consolidation or rewrite ticket names the notes it replaces in its objective, because that is where a reader looks for scope. But **the criteria are what a build is held to**, so when the two disagree the criteria win and the prose is decoration: a build can satisfy every box, restructure the passage, drop a correction that already merged, and report a clean pass. The failure is invisible from inside any one ticket — each sibling is individually well-formed, and the gap exists only in the relationship between them, which only a queue scan holding all of them at once can see. So two obligations at authoring time, both cheap:

* **Enumerate the supersession in the criteria.** Every note the ticket replaces gets a checkable line, or the ticket carries the general form once — *"every correction already merged from the notes this supersedes is still present after the rewrite, verified as an exact string"* — which makes the regression the build's own problem rather than a driver's. Prose that names five inputs beside criteria covering three is a scope claim the ticket does not hold itself to.
* **Express the ordering as** `blockedBy`**, never** `relatedTo`**.** Where a consolidation must follow its inputs, that is a genuine sequencing dependency and belongs on the dependent as a relation (*Obligations belong in structure, not prose*, and the genuine-blocker rule). `relatedTo` makes the overlap *visible* to a reader who fetches all of them; it constrains nothing, and three tickets claimed on three days by three runs can be taken in any order with nothing to stop them.

(Worked case: APP-1288, APP-1295 and APP-1321 all edited one passage of `assoc-one/claude-ops`' `CLAUDE.md`; APP-1321 was the consolidation and named all five notes it replaced, including the other two, while its criteria covered only three — neither APP-1288's first-sentence rule nor APP-1295's escaped build-id serialisation appeared in them. All three merged correctly, in order, because one run happened to hold all three at scan time, sequenced them corrections-first, and told the consolidation leg explicitly that the landed corrections were not its to undo; both the build and the review leg then verified the carried-through sentences as exact strings. A run picking up APP-1321 alone on a later day would have had no reason to check, and its criteria would not have prompted it — APP-1360.)

**A read narrower than the claim reports its scope, and a write predicated on absence is gated on a read that covers the space.** These are one rule with two sides, and splitting them is what left the system half-covered — many correct read-side cautions already in `convention-linear` (APP-622, APP-685, APP-702, APP-591) and no write-side gate to catch the other direction. The read side: where a read's scope is known to be narrower than the claim being made, the finding is **"not found in `<scope>`", never "does not exist"** — a code search over one repo, a grep on one spelling, a scan of one project cannot see what lies outside it, and a confident "does not exist" from a bounded read is a false negative waiting to be built on. The write side, the gate the read side implies: **any write predicated on absence requires a read that actually covers the space the absence is claimed over, or explicit Owner confirmation** — do not create-because-missing, delete-because-unused, or assert-a-complete-set off a read that never covered the ground. (Worked case: three instances in one session, detection rate 0/3 — every one caught by the Owner, not the loop, which is what a missing write-side gate looks like. APP-890 is the live positive: it cross-checked its enumeration and reported a caveat instead of asserting a complete set. APP-895.)

The blast radius is what makes this worth a rule rather than a habit. `skill-ops-retro` already requires the check for repo-edit tickets, where a false premise costs one zero-diff cycle (APP-484/APP-495). On a **build** ticket it costs more: a builder that trusts an "already built" framing has nothing to build *on*, so it builds from scratch — un-reviewed, un-specified, and shipping under a ticket that reads like a small cutover. (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 zero trace of it — no component, no branch, no PR, and the repo's own `CLAUDE.md` marked the sections "Not started". The exec run checked the repo first, stopped, and surfaced it with the evidence. Had it trusted the ticket, it would have improvised a from-scratch hero system into a production cutover that also deletes the current live site — 2026-07-16, APP-564.)

**A scope that quantifies over a space states its bound at authoring.** An Objective or criterion phrased as "sweep every X" or "every X in the file" is a fan-out whose size nobody has measured, and the executor discovers it only at dispatch, after the budget is spent. So a quantified scope names its bound where it is written: either enumerate the items, or cap it — the pages, sections or paths it covers, the sub-scopes it excludes, and the expected count where one is knowable — and any open question the ticket itself flags about that scope is settled at refine, not left for the executor to meet mid-sweep. This is the authoring-side sibling of *a read narrower than the claim reports its scope* above: that rule bounds what a read may conclude; this one bounds what a write is asked to cover. (Worked case: A1-346's "sweep every text node for `boundVariables.fontSize == null`" turned out to cover 500-plus nodes across 18 pages, including a documentation-chrome type scale outside the ticket's ramp and an unresolved `default`-mode question; the 2026-09-21 dispatch correctly left it In Review but spent most of its budget discovering the scope — APP-1574, 2026-09-22.)

## The routing pattern — triage → build → review → gate

Agent-executable work runs as a loop across four roles. The roles are tool-agnostic; `convention-linear` binds them to label values and states.

* **Triage** — reads the ticket, sets classification and links, decides whether it needs execution. If it does, routes it to the builder and moves it to ready with the acceptance criteria stated. Where a human decision is required, leaves it for the operator. Triage owns the **post-review merge gate**: it ships flagged work only on the operator's explicit approval signal, and unflagged clean-pass work on the loop's own routing-to-merge signal (see Gate).
* **Build** — claims a ready ticket (status is the lock — a ticket in progress is never re-grabbed), implements against the criteria, opens the change for review, and **never ships it itself**. Hands to review.
* **Review** — reads the change against the embedded criteria and writes a plain-language verdict the operator can act on without reading the work: if clean, what was done plus confirmation it meets the definition of done; if not, everything the builder needs. Does not ship or change state; hands the ticket to the operator's queue.
* **Gate** — the operator, on work that needs human judgment. Either raises follow-ups (a bounce back to ready re-triggers the builder on the same ticket) or approves. **The operator gates work needing human judgment; a clean-pass agent ticket auto-merges.** A review verdict that flags a human need — a design/visual side-by-side, product/UX sign-off, or an acceptance criterion review cannot verify — routes to the operator and ships only on his explicit approval (review finishing is not approval). A clean technical pass with no human-gate flag and genuinely green CI is merged by the loop without waiting for him — the routing-to-merge signal *is* the approval for unflagged work. The gate is by work-type, not universal. (Decision 2026-06-30, APP-402; supersedes the earlier "nothing ships without his approval" blanket. The critical safety condition — CI verified to have actually run, not a false green — lives in `skill-merge-pr`.)

One builder per repo at a time (changes would otherwise conflict); tickets run serially in priority order. An epic is never claimed by the builder — only leaf tickets are.

## Structure — hierarchy, ordering, dependency

Three orthogonal axes carry how work is organised. Keep them distinct; conflating them is what makes a board hard to read.

* **Hierarchy = grouping.** An epic is an outcome held as a parent; it is never executed directly and is closed by the operator when its children are done. Features and stories are capability slices under an epic. A task is the executable leaf. The builder only ever claims leaves.
* **Ordering = capabilities, in finish order.** Strategic sequence lives in the milestone spine and in the operator's promotion to ready; every refined leaf gets a milestone where the project has them. **A milestone is one of exactly three kinds, named so a report can tell them apart without reading the tickets:**
  * `Enabling · <name>` — groundwork that **unlocks later work** and has nothing to demo: research, planning, setup, a decision. Reported done / not done. One or two per project; more than that is usually build work misfiled.
  * **Capability** — a plain-language name for **what someone can now do**, written from the user's or the audience's side. Its description opens `Kind: capability` and closes with a literal `Done when (demo):` line describing something a person could watch happen.
  * `Gate · <name>` — an **approval or a verdict**: a binary moment someone else controls (TestFlight, launch day, store submission, a 30-day review). Optional, where a project has no release event.

  **Three properties make this spine readable where a phase spine was not.** *Milestones are created in the order they will finish* — top of the list is done, the first unfinished row is what is next, and the list itself is the running order. *Done means demonstrated, not dated and not merged*: if the demo needs a device or a gate, the capability cannot close until that gate does. And *a capability milestone shows progress because its demo either runs or it does not* — a binary a report can state, where a phase's completeness was only ever inferable from its ticket count. **If a milestone has a demo it is a capability**, even when it reads as groundwork; that test, not the name, decides the kind.

  **This is the setup shape for every new project. Existing projects are unchanged** — they move over only case by case, on the Owner's call per project, and nothing here is licence to re-slice a running project's milestones. (Owner decision, Aled, 2026-09-22, on three projects tested 21–22 September: app.fitness re-sliced from six phase milestones into 1 enabling / 8 capability / 3 gate — *"a lot clearer and gives me a sense of what the thing can do and how far along we are"*; app.fitness · Launch and app.DS-Quality both set up in the format from scratch, the latter by a session working from a written prompt with no help. APP-1658.)

  **Milestone or epic?** A milestone is a kind above; epics group a body of work within one, regardless of when it runs. Reaching for `type:epic` to represent delivery stages forces a create-then-convert cleanup later (worked case: a1.firmup, four delivery phases first modelled as epics then converted to milestones, 2026-06-27). So: capabilities and gates → milestones; bodies of work beneath one → epics.
* **Dependency = genuine blocker only.** A blocked-by relation means the work technically cannot start until the blocker is resolved (shared files that would conflict, an artefact that must exist first, a decision that gates scope). Never use a dependency to express a sequencing *preference* — that is what ordering is for. A spurious block silently delays delivery; the builder skips blocked tickets rather than stalling.

### The full cascade — initiative → project → milestone → epic → feature/story → task

The three axes describe the leaf end well; the layers *above* a project were never written down, only the pieces, so each venture derived them again from scratch. The whole cascade, with the test for when each layer earns its place:

* **Initiative — one per venture, carrying the outcome.** The single container for everything a venture is trying to achieve. A venture gets exactly one. It is never a wrapper around a single project, and never one per mandate — a per-project or per-mandate outcome stub is the "team mirror" that `skill-strategy-cascade` rules out, restated one layer up. Always earns its place: every venture has one.
* **Project — the delivery vehicle beneath the initiative.** One project per mandate where a venture holds more than one, with per-mandate reporting at project level. This is the layer that makes an initiative-per-mandate redundant: the project already does that reporting job. Always earns its place: work is delivered in a project.
* **Milestone — an enabling step, a capability, or a gate** within a project, per the ordering axis above, and **created in the order it will finish**. Earns its place as soon as a project has more than one thing it can do; a new project is set up with this spine, an existing one keeps whatever it has until the Owner moves it. **Done means demonstrated, not dated** — a capability closes when its `Done when (demo):` line can be run, which is why the spine shows progress at all. **Dates are still carried, but as forecasts of when a gate will be met, not as the definition of done**, and work that depends on another project is anchored to *that project's gate* rather than to a calendar date; a missed gate is the moment to re-plan or re-resource, not to restate the date. Due dates flow **milestone → leaf**: a refined leaf inherits its milestone's target date unless it carries an earlier one of its own. A milestone with no date is a gap to flag, never a blank cell. (Applied at engagement setup by `playbook-client-onboard`; APP-625. A target date behind a Hold is not a commitment — `convention-linear`. Milestone kinds and finish-order creation: APP-1658.)
* **Epic — a body of work within a phase**, parent-only, never executed, closed by the operator. Earns its place when a phase's leaf count makes grouping worth the extra layer — added on that test, not by default.
* **Feature / story — a capability slice**, where the leaves beneath deliver one capability together.
* **Task — the executable leaf.** Always present, and the only thing a builder claims.

**Goals sit inside the venture initiative, not beside it.** The goals cascade — goals → objectives → KPIs — is written as structured sections in the venture initiative's description rather than as sibling goal-initiatives. The reasoning: the review surfaces are LLM-driven and read structured prose natively, so "goals must be objects to be readable" is an assumption imported from traditional software; and goal-initiatives that span every project of a venture identically carry no per-goal information in the linkage, because the real differentiation was always the text inside them. What is given up is the per-goal status-update surface and the tracker's auto-progress, which counts ticket completion rather than KPI movement and was a weak proxy for goal health. (The operator's steer, 2026-07-22, APP-654. `skill-strategy-cascade` and `skill-goal-review` own the read/write surfaces and are updated in their own lane, and the goal-initiatives already created are migrated into their venture initiative's description and retired by the same pass — outstanding at the time of writing.)

**Never design a structure that assumes a layer the tracker does not give us.** There is exactly one container layer above a project: nested sub-initiatives require a plan tier we do not hold, so a shape that depends on them cannot be built and the derivation dead-ends. Where a venture feels as though it needs a layer between initiative and project, the answer is a project per mandate. (Worked case: bot.Trader ran to five initiatives over two projects — two redundant per-project outcome stubs plus three goal-initiatives — created across two sessions a month apart, each defensible alone and incoherent together. Resolving it took three rounds of discussion and one dead end into sub-initiative nesting, and the final shape was obvious once stated: one `bot.Trader` initiative, projects for Mandate A and Mandate B beneath it, applied 2026-07-22 — APP-654. BARA and the `a1.*` ventures meet the same question, which is why it is written here rather than settled per venture.)

`convention-linear` holds the tracker mechanics for these layers — how an initiative or project is created, named, and read safely; this is the shape they are created in.

**Holding state for a blocked leaf — sequencing dependency vs harvest dependency.** A refined leaf carrying a dependency is placed by a single discriminator: **is its spec complete, or is its spec determined by the blocker's output?**

* **Sequencing dependency — spec complete, only ordering outstanding.** The leaf is **ready**: it goes to **Todo** carrying a blocked-by relation, never parked in the refinement gate. The builder's skip-blocked behaviour is the auto-flow — the loop skips it while the blocker stands and picks it up automatically when the blocker clears, with no manual re-promotion.
* **Harvest dependency — spec determined by the blocker's output** (the design→build case: the build leaf cannot be specified until the design leaf resolves the node-id, asset, states, and interaction). The leaf is **not ready**, because its brief does not yet exist. It is held in the refinement gate under the **triage marker** (not an agent executor), and triage re-checks it each pass, **harvesting** the blocker's resolved output into the leaf's body when the blocker completes — then promoting it. See *harvest* below.

**Invariant: an agent executor never rests in the refinement gate.** The refinement gate holds only the triage marker (a harvest leaf awaiting its source) or the human-owned marker (a leaf awaiting the operator's input). A leaf carrying a build executor belongs in Todo — ready, or ready-carrying-a-blocked-by — never parked in refinement. An agent-executor leaf sitting in the refinement gate is a **blind spot**: the triage poll scans the triage marker and the builder scans Todo, so neither sees it, and it stalls silently (worked case: four refined build leaves parked in refinement for two weeks, invisible to both, 2026-06-30, APP-400). Treat an agent executor in the refinement gate as an anomaly to correct, the mirror of the triage marker lingering in Todo.

**Harvest — lifting a completed blocker's output into the dependent leaf.** A blocker reaching a done state does not by itself make a harvest-dependent leaf ready: the blocker's *output* must be lifted into the leaf's body so the leaf becomes a self-contained brief the builder can run without reading the closed ticket. For a design→build dependency this means the node-id, the reference asset/SVG, the states, and the interaction/motion spec are written into the build leaf, *then* it promotes. Harvest is an explicit triage step owned by the re-check of the refinement gate, not something that happens automatically on the blocker's state change. Correspondingly, a producing leaf (e.g. a design leaf) is **not done until its output actually exists to harvest** — a definition-of-done that names an artefact by label alone, with no node-id, asset, states, interaction spec, or resolved purpose, is not met, and marking it done leaves nothing to harvest and a misleading closed ticket.

**A reference artefact is named with its location, and a continuation leaf never inherits it.** Where a ticket must be built against an artefact that already exists — a prototype to port from, a spec, a reference asset — the body names **where it lives and how to reach it** (an attachment on which ticket, a path in which repo, which document), not the filename alone. A bare filename reads as a repo path, so the builder searches the repo, finds nothing, and concludes the artefact does not exist rather than that it searched the wrong store — the failure `convention-linear` records as *"the dot is the tell"*, and one a code search over a private repo makes worse by returning a confident false empty instead of an error. The trap is sharpest on a continuation: a port reference is attached to the ticket that *introduced* the port, while the tickets that *continue* it are children raised later — each inherits the obligation to port and none carries the artefact. So at refinement, either attach the artefact to the continuation leaf or name the ticket that holds it, the same self-contained-brief standard harvest applies to a design→build pair. (Worked case: A1-290 asked for a warning "at the severity the taxonomy implies", with the prototype attached to the parent build A1-219 and named in the child by filename alone. The exec leg searched two repos, reported it unreachable, and re-derived the severity from the taxonomy in the file — shipping `warn` where the prototype said `info`, and dropping a third filter condition that produced a false warning on manual rows. Review caught both — APP-733, 2026-07-31.)

**A spec block cites the inputs a value is produced from, not the produced value.** Where a ticket quotes a block of numbers as its specification — a config, a token set, a tuning table, a ladder of thresholds — it states which fields are **inputs** and which are **derived read-outs**, because once pasted the two are indistinguishable. A read-out is the output of a computation over inputs that are not in the block; transcribed as a spec it instructs the builder to *set* the values the system is supposed to *produce*, and the resulting build is wrong in a way that reads as faithful implementation — every box ticks, the numbers match the ticket, and the ticket was never the specification. The cheap test at refine is arithmetic: take the block's own stated inputs and check that each quoted value is reachable from them. Where it is not, the block is a read-out, not a spec, and the ticket names the inputs instead. This extends the rule above rather than repeating it — naming where the reference lives is what makes the mismatch findable; this is what to do once it is found. (Worked case: a ticket's last three ladder rungs were unreachable from any single `fall` value — they would need 0.676, 0.652 and 0.400 in turn — a falsifiable arithmetic test proving transcription slip rather than intent, on A1-408 — APP-1267.)

## Obligations belong in structure, not prose

The sweeps and gates that move work read **structure** — relations, states, the executor axis, the split of the acceptance list across lanes — not the prose of a body. A constraint a careful human reader would catch but a scan would miss is, to the machinery, not there at all. So every gate a ticket carries is encoded at refinement as the structural thing the machinery acts on, never left as a line only a reading agent will honour. The failure is the same each time: a real constraint stated in prose, invisible to the eligibility scan, discovered only at claim after a full clone-and-investigate dispatch has already been paid.

* **A genuine blocker is a `blockedBy` relation on the dependent ticket** — never a free-text "Blocked by X" line, never left inferable from scope prose alone, and never stated on the wrong end (a blocker's own definition-of-done listing what it unblocks does not block the dependent). The scan reads relations; a dependency it cannot see is one it cannot skip, so the leaf reaches Todo and costs an exec dispatch to discover what a relation would have caught for free. At refinement, wherever one leaf's body names another as a prerequisite, add the relation. (Worked case: A1-237 depended on A1-236 and A1-14 with the dependency only in scope prose and stated on A1-14's own DoD; it reached Todo + F0-RGE and cost a full exec dispatch — APP-661, 2026-07-23.)

  **Reconcile the relation at the moment of parking, not later.** Parking a ticket in Blocked is the point where its real blocker becomes known, and it is the point the `blockedBy` graph most often goes false: the run writes the true blocker into a *comment* ("blocked — waiting on the OANDA token") and moves on, leaving the relation showing an old, cleared, or absent blocker. The graph then asserts a dependency that is not the real one while the real one lives only in prose no scan reads. So **clear or reset the `blockedBy` relation as part of the parking action itself** — remove any stale relation that is no longer why the ticket is parked, and add the relation for the blocker that actually holds it, at the same moment the ticket moves to Blocked, never as a deferred follow-up. A ticket in Blocked whose relations do not name its real blocker is the same prose-not-structure failure as an un-related dependency, caught one step later. (APP-868. The continuous-cleanup half — a sweep that removes a blocker's stale relation once the blocker is Done, including auto-clearing a Done blocker's stale relation — is `skill-coordinate`'s write, authored alongside this.)

  **Reconcile the relation at release, too — the twin of the parking rule.** A `blockedBy` goes false as readily when a blocker clears as when one is added, and prose is where the falseness hides on the release side just as on the parking side. Two shapes, one hygiene:

  * **A dependency withdrawn in prose is not withdrawn until the relation is removed, and whoever writes the withdrawal owns both edits in the same pass.** A comment saying "no longer blocked by X" leaves the graph asserting a block that the reasoning has already lifted, and every scan downstream inherits the stale critical path. (Worked case: APP-747's dependency on APP-667 was withdrawn in prose on 2026-08-09 with the relation still standing on 2026-08-14 — five days of a lead workstream held blocked, and two Owner-facing artefacts inheriting the wrong critical path — APP-889.)
  * **A blocker that is open only pending its dependent's own delivery holds no `blockedBy` over that dependent — the relation is inverted.** Where a parent is kept open only to chase residual acceptance boxes that the child itself delivers, **reopening the Done parent to tick them releases every relation to the leaves that will tick them, in the same action as the reopen** — otherwise the child is held out of every eligibility scan by the parent whose own completion depends on it. (Worked case: APP-766 was held out of every eligibility scan by APP-747 since 2026-08-11, because APP-747's fifth acceptance criterion was APP-766's own deliverable — a semantic inversion of the relation, not a graph cycle — APP-879.)

  Where a blocker's own body asserts it no longer blocks, the surfacing home is `skill-coordinate` Pass 2 — raised there as a proposal, never an automatic relation removal.

  **A `blockedBy` states what the blocker must deliver, so coverage can be tested and not only status.** Every reader of a relation tests one thing — the blocker's status — and releases the dependent when it closes. A relation pointed at the wrong ticket, or at one that only partly covers the dependency, is indistinguishable from a correct one under that test: it renders identically, resolves cleanly, and releases work whose real prerequisite is still outstanding. So a `blockedBy` set at refinement carries **one line on the dependent stating what the blocker must deliver for the dependency to clear** — "blocked by MBN-250: needs the *legacy-range* product pages complete" — and a pass that releases on the blocker closing compares that line against the blocker's outcome first. This is the third member of a family `convention-linear` already documents two-thirds of: a guessed forward ID that binds to whatever holds the number (APP-637), a dependency recorded only in prose that no relation check sees, and now a relation that exists, points somewhere real, and is wrong about *what* it covers. (Worked case: MBN-262 was blocked by MBN-250, which covers *ceramic* product pages while MBN-262 was written against the *legacy* range; the relation read as a healthy dependency in every sweep for a week and silently held the ticket — APP-1014.)

  **A blocker whose deliverable was an answer can answer no — a decision's resolution has a polarity, and the polarity is carried as structure, not as prose.** The rule above makes a relation's *coverage* testable; this is the same discipline applied to a blocker whose deliverable was an **answer** rather than an artefact, where the answer can be "not yet". A decision ticket closed because it was answered "no, not yet" satisfies every eligibility scan's done test while meaning the exact reverse: the relation encodes *that* a dependency existed, never *what it decided*, and the tracker's done state is identical for "yes, cleared" and "no, deferred". So on the write side, where a decision is answered "not yet" the dependent does not become eligible, and the hold is **re-expressed as structure in the same pass that closes the decision** — the dependent returns to Backlog carrying a `blockedBy` on the ticket that opens the next phase, or a milestone, or a due date — never left as a sentence in the closing comment. That is the human/operator variant's reconcile obligation above (repointed, re-scoped, or its criteria waived) discharged in the only form a scan can read. And on the read side: **a blocker reaching done is not evidence the dependent is released** — where the blocker is a decision ticket, read its resolution, not only its state, before promoting the work it gated. The rule turns on reading the resolution, so it holds whichever state a deferring decision is closed in. (Worked case: MBN-251, `BUILD: apply lean BARA branding to homepage, PDP, about`, routed Backlog → Todo + `agent:F0-RGE` on 2026-09-07 because both its blockers were Done — MBN-258, the domain and on-store naming decision, and MBN-252, the voice reference. MBN-258's answer was a deferral: "stay on madebyneud.com as Made by — Neud for now… The BARA branding build (MBN-251) is deferred with this." Two further standing records agreed — MBN-251's own `operator-bara` comment holding it out of the delivery loop until relaunch, and the Owner's MBN-252 approval not to deploy BARA-forward copy until relaunch. Had `skill-build-ticket` step 3a not caught it, the run would have rebranded a live storefront against three standing Owner decisions, while MBN-270 waits in Todo to publish a *Made by — Neud* staged theme live and the BARA trademark clearance chain sits untouched in Backlog. It recurs by construction: nothing about the ticket's state changed when the run reset it, so any pass that promotes on blocker done-ness promotes it again. Distinct from APP-741, dead identifiers on the same ticket, and APP-1033, drained notes never re-tested — APP-1152, 2026-09-07.)

  Two tells that a relation is missing even where no body says "blocked by": an **acceptance or definition-of-done item citing an artefact another ticket produces** ("figures verified against a demo run's audit log", where the audit log is another leaf's deliverable), and a **body phrase that defers the sequencing** ("sequence at routing") — a note-to-self that was never actioned, and a leaf carrying it does not belong in Todo until the sequencing is a relation. The cost of prose is paid every run rather than once: a leaf carrying the relation is skipped in one lookup, while three bot.Trader-B leaves whose dependencies sat in `## Notes` cost roughly fifteen tool calls and two repo greps to establish ineligibility, and nothing caches that answer, so the next run repeats all of it and reaches the same conclusion. The sharper cost is the premise rule above: the leaf with no `## Notes` section at all read as self-contained, and a run that trusted its brief would have invented the audit-log schema that was another ticket's deliverable and shipped it as a scoreboard — only a repo read stopped it. (Worked case: APP-676, APP-677 and APP-679 against APP-674, APP-671 and APP-677 respectively, delivery-loop run 2026-07-28 — APP-700.)

* **A build-lane ticket never carries a `blockedBy` into the `PUL-5E` lane.** A Pulse friction note is propose-only intake (`convention-linear`): it drains to a `.skill` the Owner saves, never through the delivery flow, and nothing in the build lane re-tests it. The eligibility scan is a status test blind to lane, so a build ticket blocked by a canon note is parked behind an artefact that closes on a cadence and by a mechanism the build lane cannot see. Where a build genuinely depends on a canon change, express it the other way round — a delivery-lane ticket for the dependency, which the canon note *blocks* — keeping the build lane's dependency graph inside the build lane. A relation crossing into `PUL-5E` is a refinement defect; `skill-coordinate` Pass 2 is where it is surfaced and corrected. (Worked case: APP-679, Urgent and on the bot.Trader-B scored-window critical path, sat ineligible behind `PUL-5E` note APP-919 for nine consecutive delivery-loop runs, 2026-08-19 to 08-23, after the note's substance had already been resolved by a loader grant — APP-1030.)

* **A human prerequisite is a `human` setup leaf that blocks the build leaf** — never a prose "needs credentials / needs X first" note in the build ticket. Credential-gated build work is refined into a feature with a `human` setup leaf and a build leaf joined by a `blockedBy` relation, so the builder never claims a ticket it cannot start and bounce to Blocked. Left in prose, the prerequisite is invisible until claim and the round-trip is wasted. (Long-standing — APP-230, 2026-06-15 — but it lived only in a closed ticket, which is why it lapsed; it belongs here, in the authoring path. Worked case: APP-536 carried its OANDA-token prerequisite as a body note and had to be split by hand into APP-588 blocking APP-536 — APP-589, 2026-07-19.) How the credentials themselves are named, stored, and defaulted is `convention-secrets`.

  **Ticked ≠ provisioned — a human setup leaf must state its own verification, because nothing else checks it.** A build leaf passes through review, CI, and the merge gate; a self-certified `human` setup leaf has none of those, so the operator ticking its acceptance boxes is the *only* check the setup ever receives — and a ticked box can sit above host state that was never actually provisioned. Close the hole at authoring: **every acceptance box on a human setup leaf names the verification command to run and the exact output that confirms it** — not "credentials configured" but "run `X`; a provisioned host prints `Y`". Name the instrument traps, because the wrong probe returns a confident false pass. A **login shell is the wrong probe for a process-scoped credential**: an interactive shell's environment is not the deploy runtime's, so a variable can read as present in one and be absent where the real consumer runs. A **`find` or `grep` on the wrong spelling returns a false-empty**: a clean exit that reads as "not there" when it only searched the wrong name. Choose the verification to run in the same scope the real consumer runs in, and to fail loud rather than exit-zero on a miss. (APP-861.)

  **The trigger is the criterion, not the author's memory.** This rule's defect is not its wording — it is that nothing makes it fire. So bind it to a signal in the text being written: **any acceptance or definition-of-done box naming a token, key, secret, account, login, or an access only the operator can grant.** The test, applied at refine on the criteria as written: *can the assigned executor tick every box on this ticket without a human first minting, granting, deciding, or **observing** something the executor cannot supply or reach?* If not, this is two tickets — a `human` setup leaf and a build leaf, joined by a relation. Run it as a step, not as a rule to remember; restating the prose is the failure mode here, because the prose was already there.

  **The block is not only a credential — widen the test to any decision the executor cannot supply.** The gating thing is often not a token but a *decision*: a transport choice, an architecture call, a design ruling the executor has no standing to make. These are neither a mint nor a grant, so a test worded only around credentials reads clean and lets the ticket through — and it strands at claim exactly as a credential-gated one does, because the executor still cannot tick every box. So the test at refine is the wider one: *minting, granting, or deciding*. Where the block is a decision rather than a credential, the split is the same shape — the parent keeps the gated criteria under a `human`/operator decision leaf, the ungated build criteria go to a build leaf, and a `blockedBy` relation joins them. (Worked case: APP-824 carried six acceptance criteria, one of them a live safety exposure gated on a transport *decision* the builder could not make — neither a mint nor a grant, so the credential-only wording did not fire, and it had to be split by hand in-session into APP-932 setup + APP-933 build — APP-934.)

  **Widen it once more — a criterion met only by *observing* a surface no delivery leg can reach.** Minting, granting and deciding are all things a human has to *do*; the fourth class is something a human has to *see*. Where the only truth-maker for a criterion is a look at a surface none of the delivery legs can open — an unpublished storefront theme, a view behind a login only the Owner holds, a device screen — it is neither a mint, nor a grant, nor a decision, so a test worded around those three reads clean and lets the ticket through. It strands at claim all the same, because the executor still cannot tick every box. So it takes the same shape as the other three: the observation-gated criteria go to their own Owner-verify leaf, the reachable build criteria stay on the build leaf, and a `blockedBy` relation joins them. **And name the missing instrument on the split rather than waiving the box every run.** Where the surface is unreachable because no instrument exists to expose it, that instrument is a ticket — `convention-linear`'s missing-instrument rule, where a waiver routes around a missing instrument and never replaces one. A criterion waived every run is an unticketed instrument. (Worked case, two of two in one run: MBN-273 and MBN-272, both storefront bug tickets in the 2026-09-09 run, hit this independently. The verified obstacles were the absent store credentials and the absence of any per-PR preview — the repo README records that only `main` syncs to the staging theme, so a PR branch sits on no Shopify surface at all. That reframes the box from hard-to-tick to structurally unclosable before merge, and names the instrument to file: a per-PR unpublished preview theme in CI — APP-1229.)

  **Widen it the other way — a step is `human` only where no Claude surface holds the tool, not where this executor lacks it.** The four classes above all widen *into* the human lane. The test fails in the other direction too: a step a person would ordinarily do by hand — create a hosting project, add a domain, flip a project setting, publish a theme — reads as a mint or a grant, is written as a `human` setup leaf, and is done in a handful of calls by a connector the fleet already holds. The leaf is then right in shape and wrong on the facts, and it puts a person in the critical path for work no person needed to do, because the build leaf is `blockedBy` it. So before a `human` setup leaf is minted, name the system the step touches and ask which surface holds a connector for it — Vercel, Linear, Sanity, Shopify, Figma, GitHub, Gmail, Calendar, Chrome — and where one does, route the leaf to the agent that holds it, or do it in session, rather than to the Owner. This is the authoring-path twin of `convention-linear` *Labels*, which states the same test for the `human` value itself: *check the other Claude surfaces before defaulting to the operator*. **The carve-out is unchanged, and it turns on consequence rather than capability.** `convention-linear` reserves `human` for approval or judgement, an account, billing or credential action, anything irreversible or public, and physical-world steps. A connector that *can* do one of those does not thereby authorise it: a production-affecting or publicly visible connector action carries the Owner's explicit consent, recorded on the ticket, and the leaf stays `human` where that consent is the thing actually missing. (Worked case: A1-574, a `human` setup leaf for the client Storybook on Vercel — project, domain, deployment protection — filed assigned to the Owner on 2026-09-30 with A1-575 `blockedBy` it, under this section's split rule. At the Owner's prompt the Vercel connector created the project, applied the build settings, added the domain and shipped the first production deploy. The Owner's reading: "there are things that have been assigned to me and blocking progress but it turns out you were able to do it" — APP-1891. **Observed** 2026-10-01: A1-574 is still Backlog, `human`, assigned to the Owner, so the leaf outlived the work it was blocking.)

  **A stranded ticket is the after-the-fact smell.** A ticket sitting in review whose unticked boxes can only be closed by a human action is mis-shaped by construction, not awaiting judgement — and it arrives on the operator's desk disguised as "approve this" when the real ask is "mint a credential and accept a waiver". Triage and the coordination pass can detect that shape; the operator noticing it is the expensive path. Note what it does to the waiver rules above: **the single-ticket shape manufactures the waiver.** Split properly, the credential is its own leaf with its own done and every box on the build leaf is builder-reachable, so nothing needs waiving — a definition-of-done waiver requested because a credential is missing is evidence of a shape defect, not a judgement call for the operator. (Worked case: APP-747 was authored as one ticket carrying both the build work and the `OANDA_API_TOKEN` / `OANDA_ACCOUNT_ID` setup. Forge built it, review passed it clean twice, and it stranded with four of five acceptance boxes unable to tick — the same failure APP-536 produced three weeks earlier, on the same credential, in the same repo, with the rule already written. That is what makes it a binding problem rather than a missing-canon one — APP-767, 2026-08-10.)

* **A dependency on a party outside the fleet is a blocking gate leaf carrying a review date — never work that simply never gets scheduled.** The prerequisite rules above cover what a human inside the estate must mint, grant, decide or observe. A client, a supplier or any other third party is the same shape with one difference that matters: nobody here can discharge it. An unscheduled ticket and a ticket waiting on a client look identical to every sweep in the system, and they need opposite responses — chase harder, versus leave alone until a date. So the dependency is authored as **one gate leaf** stating the named conditions, holding a `blocks` relation onto every downstream ticket, so no loop proposes, sizes, books or escalates any of them while it is open. The gate carries a **due date read as a review prompt, not a commitment** — the date on which someone asks — so it cannot sit open indefinitely with nothing noticing, which is the failure that produces the escalations. The check on that date is one question with three answers, one move each: the party has done it (close the gate; the chain releases); not yet, with an expected date (move the due date, and say nothing until then); not yet, with no date (the engagement has stalled — revisit the target, not the schedule). The vertical's operator owns asking it, on its daily pass. Whether a chase ticket sits alongside the gate stays a per-engagement call, not a standing rule. (Worked case: the Meirion cutover chain — A1-267, A1-268 and A1-34 — waited four weeks on the client to sign off the build and populate the CMS with nothing on the board saying so. Every ticket read as schedulable, so the loop correctly escalated through two weekly reports, an Urgent escalation, a folded default, a fresh dated proposal and finally the stand-up, all against a missing fact; A1-429 closed it as a gate of exactly this shape — APP-1443.)

* **An operator's per-leaf build-start signal is the fixed body-line marker `Build-start gate:`** — never a free-prose "wait for my go" buried in the body. Where the operator wants a leaf's build held under his own signal rather than routed on its merits, he writes one line — `Build-start gate:` followed by its state — into the body: a **hold value** (`Build-start gate: held`) means the leaf is parked for his go and must not be routed to a builder however clean it otherwise reads; a **clear value** (`Build-start gate: route`), or no marker line at all, means there is no such hold. A fixed line is what lets the signal be read **deterministically** — a scan matches the line exactly — rather than inferred from prose that reads two ways, which is why a hold stated in ordinary sentences goes unread. `skill-triage` reads it as a held-leaf-versus-route-me discriminator, not a judgement call. (Owner-specified form; APP-792.)

* **A ticket that gates its build on a named session uses the marker *and* names where that session's outcome is written back.** The marker above fixes *that* a hold exists and lets a scan read it deterministically; it does not say what clears the hold. Where a leaf's build waits on a synchronous session — a triage, an unblock, a review slot — the body carries the marker line in its hold state and, beside it, the single artefact the agreed outcome will be written to: a comment on this ticket by default, or a named linked document. Without that second half the gate has nothing to clear against: the session happens, the decision is spoken, and the ticket reaches the build queue reading ready with its stated precondition unmet and unmeetable, because no leg can tell an outcome that was never written from one that does not exist. Naming the write-back also makes the check cheap — a promotion sweep reads one place rather than searching calendar entries, transcripts and sibling tickets for a decision that may be in none of them. (Worked case: a fix ticket gated its build on a calendared triage session in free prose — *"the cause is agreed with the Owner... before any build starts"* — and the session took place, but its agreed cause and fix approach were written nowhere a build leg reads: not on the ticket, not on the sibling it reviewed, no transcript, no document. A triage pass promoted the ticket straight to Todo carrying the build label without checking the stated precondition, and the gap was caught only at `skill-build-ticket` step 3a, after the claim, by cross-checking the calendar by hand. A ticket that gated less explicitly would have sailed through unexamined — APP-1504.)

* **An acceptance criterion the assigned executor structurally cannot reach is split to the lane that can, or marked as a non-executor criterion.** A code ticket routed to the builder may carry a co-requisite that lives off the repo — updating a Linear spec doc, a design edit — which the builder can never satisfy and which the review gate would otherwise bounce the PR on. Either split the repo substance and the non-repo criterion into separate leaves in their own lanes, or keep them on one ticket with the non-repo box explicitly marked as owned by another lane, so review verifies the executor's own boxes and does not fail the change on one outside its reach. (Worked case: A1-247 mixed a Sanity schema change Forge could do with a `spec.meirion-work-architecture` doc edit it could not; the handling — flag the doc box so review does not bounce on it — was improvised in a comment — APP-656, 2026-07-23.)

  **Where a non-executor criterion's output is cited by code, its reconciliation is its own leaf — not an assumed follow-through.** Marking a box as owned by another lane stops review bouncing on it, but says nothing about the code that *cites the unreached box's output* — most sharply, a decision-log `Dxxx` the change refers to but that does not exist yet. Forge correctly does not invent the number, so it leaves a placeholder token (`pending`, `TBD`) in the layer the next build reads — and that placeholder is a **live instruction to a future reader that no decision exists**, written on the very commit that created the decision. That is the "unrecorded canon" failure one tier down, in the token layer, which is exactly where the next build looks to find out what a decision was. So the reconciliation — minting the `Dxxx` entry and repointing the placeholder to it — is authored as **its own `human`/operator log-then-repoint leaf**, joined to the build leaf by a relation, not left as an assumed follow-through that no lane owns. A repo-lane shape-check (`pending`/`TBD` where a `Dxxx` is expected) is a cheap companion that catches the *shape* of the gap, but it cannot see the Linear document, so it catches neither the *existence* half nor substitutes for the reconciliation leaf. (Worked case: A1-299 / PR #101, `assoc-one/meirionpritchard-com`, merged 2026-08-13 as `a611f74` with a `pending` token in the token source, corrected pre-merge in `8e8618f` — caught by the Owner reading the token source after the PR was already approved and queued, the most expensive reviewer at the most expensive moment: a post-approval push, a full CI re-run, a new Chromatic build, and an invalidated approval that had to be re-gated — APP-946.)

* **A `## Notes` decision is a genuinely open question, or it is not written as a gate.** Notes holds gaps with no answer yet — what makes a captured ticket refinable. A decision the author has already reached is written as the decision, with its rationale, in the section it belongs to — not dressed as a "confirm before building" imperative while the recommendation sits in the same paragraph. A gate that carries its own answer is not a gate: writing it as one leaves the ticket ambiguous between holding it (a fully-specified ticket parks waiting for the operator to re-confirm what he already wrote) and routing it (on a reading the words seem to forbid). Reserve the imperative for a decision genuinely still open. (Worked case: A1-240 carried six complete ACs and a "Confirm before building" note whose own bullet already stated the recommendation — APP-623, 2026-07-21. How such a ticket is *placed* once written is `skill-triage`'s call; this rule is about not writing the ambiguity in the first place.)

* **A skill named in an Approach is one the owning agent holds.** `skill-dispatch-run` reads an explicit skill hint before anything else, so a hint naming a skill outside the routed agent's Composition sends the runner looking for a capability it does not have. Before naming a skill in a ticket's Approach or as a `skill:<name>` hint, check the profile of the agent the ticket is routed to (`agent-pixel`, `agent-prism`, and so on) and confirm its Composition lists it; where the capability genuinely sits with a different agent, route the ticket there or split the leg, rather than naming the skill on the wrong agent's ticket. (Worked case: A1-295, routed `P1-XEL`, named `skill-design-parity` — Prism's review skill — for its measurement leg, and three passes across twelve days touched the mismatch without resolving it — APP-1043.)

* **A re-route announced in prose is not a re-route until the executor label and assignee carry it — whoever writes the ruling comment makes both writes in the same action.** The executor axis is structure, and every surface that asks "whose is this?" reads it: stand-up agendas, Owner-session agendas and each lane's queue key on the `agent`-group label and the assignee, never on what a comment says the ticket's next lane is. A comment that rules an Owner question and says the remaining work is moving to another lane, with the `human` label and the Owner's assignment left standing, keeps the ticket on the Owner's desk in every one of those surfaces while the prose says it has left. So the comment that re-routes carries its own writes — the executor label swapped to the lane it names, and the assignee cleared or changed to match — in the same action as the comment, never left for a later pass to notice. This is the executor-axis twin of *a dependency withdrawn in prose* above, and the ticket-level sibling of `convention-decision-log`'s *a ruling that changes board state is not recorded until the state carries it*. (Worked case: MBN-254, the BARA email-capture flows, carried `human` and sat assigned to the Owner in Todo from 2026-08-10; a 2026-09-11 comment ruled its one Owner question and said the build and test work was moving to Reach, with no label or assignee write. `bara.owner-session-agenda` (refreshed 2026-09-18) and the stand-up kept listing it as an Owner ask until `task-bara-operator-standup` swapped `human` for `R3-ACH` and cleared the assignee on 2026-09-21 — ten days after the ruling and three past its due date — APP-1575, 2026-09-22.)

* **A report that asserts a hand-off is written from the label and assignee it read — and a ticket correctly at rest needs no hand-off to describe.** The rule above binds the comment that re-routes; the same prose reaches the Owner one tier up, in a stand-up entry or a status update, and there it is a claim *about* a write rather than a substitute for one. "Vetted this run before passing it to you … moving to your lane" reads as a completed routing act. Where no write followed, nothing distinguishes *said and not done, correctly* — the resting state was right and no hand-off was owed — from *said and not done, incorrectly*, except re-reading the executor label and the assignee against the prose. So a line asserting that a ticket has moved lane, or is moving to the Owner's, is written only from a post-write read-back and **names the lane and assignee it read**; and where the re-read shows the ticket correctly at rest, the line states the resting state and the box still open on it, never a hand-off. (Worked case: `bara.standup.2026-W41`, 2026-10-05, reported MBN-320 as "moving to your lane". No label or assignee write ever landed and none was owed — every acceptance and definition-of-done box was met or correctly not-yet-true, and the one open box was the operator's own Friday job. Re-read first-hand 2026-10-07: MBN-320 is In Review carrying `operator-bara`, `task`, `domain:MBN`, `work:analytics`, assignee null — no `human`, unchanged. One tier up from APP-1575 — APP-2080.)

## The execution lanes

Work runs in parallel lanes that must not collide:

1. **Code in a repo** — one agent at a time per repo; tickets run serially in priority order.
2. **The operator in content/design surfaces** — runs in parallel (different surface, no conflict).
3. **A separate spec/design session** — runs alongside both (MCP-dependent work).

When sequencing, mark genuine cross-lane dependencies explicitly and mark what can run in parallel. Never queue two code tickets in the same repo as simultaneously actionable.

## The decision log

Every consequential architectural or scope decision is recorded in the project's decision log, newest-first. Its structure, entry format, and lifecycle (one entry per decision; update rather than leave a stale one) are canon in `convention-decision-log`; `convention-linear` maps it onto Linear documents.

## Canon and not fabricating

* **Never edit canon silently when the change is consequential.** Detecting drift or proposing a change → raise it for the operator. Canon changes are human-owned. Mechanical, agreed updates are fine; judgement calls are not.
* **Don't fabricate or infer.** If a fact is missing, flag the gap rather than fill it. For anything describing real work, fetch the authoritative source rather than relying on memory of a past session. This is the same discipline the *capture format* enforces at the point of capture: record what the thread evidences, name what it does not.
* **A ticket body asserting an Owner decision cites the comment or `Dxxx` it came from — an uncited ruling is void.** A body that states "the Owner ruled X" or "decided in the comments" without a comment ID, a link, or a `Dxxx` decision-log number is not a record of a decision, it is an unfalsifiable assertion — and canon already holds that a ticket comment is not the system of record and the decision log is (`convention-decision-log`, the *Human / operator variant* gate). So an uncited ruling in a body is **void**: no pass may act on it, and it never overturns a comment-recorded or logged decision. This is not the *mirror collision* case (a true Owner instruction overriding a Locked decision) nor the false-premise case (`skill-build-ticket` step 3a) — both of those govern decisions that *exist*; this governs a body asserting a ruling with no citable record, which to every downstream reader is indistinguishable from a fabricated one and does identical damage. The twin half, on the write side: **a decision taken in a session is written to the ticket, with its source named, before any body relies on it.** A real decision the Owner genuinely settled in a session but that never reached the ticket produces the same void assertion as an invented one — the remedy is to record it with its provenance, not to assert it. (Worked cases, three in one day: APP-948, the originating case; APP-947, a body asserting an Owner ruling on bot.Trader's two mandates while the thread was empty and `operator-bottrader` still recorded the question as open; APP-931, a body asserting "all five questions decided / Shape: Option B" and on that basis reversing a Q3 decision a comment did record — substance later confirmed correct, provenance corrected on the ticket. APP-931 is the consolidated spec APP-826, APP-843 and APP-919 close against, so an uncited ruling there would have propagated into three canon closes. APP-948.)
* **Don't hard-code a linked ticket's current state in a body.** When a ticket body references *another* ticket's state to gate a future action, write it as a status-conditional to re-check when the ticket is actioned ("if A1-109 is still open, re-harvest its spec; if it has since gone Done, raise a re-point follow-up"), never as a fixed assertion ("A1-109 is Blocked, re-harvest after this lands"). A hard-coded state goes stale silently the moment the linked ticket moves, so any instruction predicated on it can be wrong by the time it is read (worked case: A1-127 instructed a re-harvest of A1-109 that had already shipped Done, 2026-07-02). This is the authoring-side mirror of the triage rule that judges a blocker by its own status, never the relation or the prose: triage re-fetches any linked ticket a body's instruction depends on before acting on that instruction.

## Tone

Everything written into a ticket or doc follows `cos.tov`: calm, precise, structurally confident, sentence case, no exclamation marks, no marketing-speak, outcome before adjective, British spelling.

## Quick checklist before creating or updating a ticket

- [ ] Captured (not ready) unless the operator has refined it?
- [ ] Fixed section skeleton with exact headings (`## Objective`, `## Why this matters`, `## Acceptance criteria`, `## Notes`, `## On completion`) — or the named minimal variant for trivial/auto-captured tickets, or the evidence-first **capture format** (`CAPTURE:` prefix, `## What happened` mandatory) for a capture?
- [ ] Instantiated from its `type:` template — the per-type section skeleton plus the standing `## Definition of done` pasted in — with the per-ticket `## Acceptance criteria` written fresh (see *Per-type ticket formats*)?
- [ ] For agent tickets: both `## Acceptance criteria` and `## Definition of done` checkbox lists present (Pattern A), acceptance criteria authored as `- [ ]` checkboxes from the first draft (never plain bullets), each box to be ticked as the record of completion?
- [ ] Before stamping a ticket ready to action: the **saved body** grepped and both literal `## Acceptance criteria` and `## Definition of done` headings confirmed present — never inferred from what was authored, or from the siblings written in the same pass?
- [ ] For a capture: evidence spine produced from the source thread (not memory), gaps named not filled, interpretation layer sitting on top of the spine?
- [ ] Definition of Done understood as every box in *both* sections ticked (or struck with a one-line waiver) before Done/merge?
- [ ] Notes section listing open questions, if the brief isn't fully defined?
- [ ] Assignee — operator only where a genuine human action is needed, not as a blanket gate?
- [ ] Hierarchy, ordering, and dependency set correctly and kept distinct? (Phases → milestones, each milestone carrying a target date set at setup with due-date inheritance milestone → leaf; bodies of work → epics; sequencing-blocked → Todo + blocked-by; harvest-blocked → refinement gate under the triage marker; no agent executor resting in the refinement gate.)
- [ ] Cascade layers right, each earning its place? (One venture initiative carrying the outcome and the goals cascade; projects beneath it, one per mandate; milestones = phases; epics only where grouping earns the layer; tasks as leaves — no per-project outcome stub, no structure assuming nested sub-initiatives.)
- [ ] Premise verified against the thing itself at all three moments — authoring, claim, and pick-up (is this *still* true, tested against code and decision log)? A defect claim pinned to its `file:line` and verified sha, with any rewrite banner stating re-argued vs re-verified? A bounded read reported as "not found in `<scope>`" not "does not exist", and any write predicated on absence gated on a covering read or Owner confirmation?
- [ ] For a leaf mounting onto a merged sibling: every new term and new file path it introduces cited to where the sibling's contract defines or admits it, or defined in the criterion with the sibling change named as its own criterion?
- [ ] Any *do not re-derive* scoping block stating its commit once, marking which of its bullets are commit-sensitive, and naming any open sibling PR touching the paths it speaks about — with every commit-sensitive claim also written as a premise criterion with both branches stated, so the suppression never covers a load-bearing premise?
- [ ] Every gate structural, not prose? (Genuine blocker -> `blockedBy` on the dependent ticket; a decision already answered stated as the decision, not a "confirm before building" note. Watch the two missing-relation tells: an acceptance or DoD item citing another ticket's artefact, and a "sequence at routing" deferral. A `blockedBy` relation reconciled to the real blocker at the moment of parking, and at release — a dependency withdrawn in prose is not withdrawn until the relation is removed, both edits in one pass; an inverted blocker held open only pending its dependent's own delivery released to the leaves in the same action as the reopen. An operator build-start hold written as the fixed `Build-start gate:` marker, not free prose.)
- [ ] Split test run on the criteria as written — can the executor tick **every** box without a human minting, granting, deciding, or **observing** something the executor cannot supply or reach (a transport/architecture/design decision; a surface only the Owner can open)? If not, split into a `human` setup, operator-decision, or Owner-verify leaf + build leaf joined by a relation, rather than shipping a ticket that will strand in review — and where the surface is unreachable for want of an instrument, file the instrument rather than waiving the box.
- [ ] For a `human` setup leaf: does every acceptance box name its verification command and the exact confirming output (ticked ≠ provisioned), avoiding the instrument traps — no login shell probing a process-scoped credential, no `find`/grep on the wrong spelling returning a false-empty?
- [ ] Any reference artefact the ticket must be built against named with its **location** (an attachment on which ticket, a path in which repo), not by filename alone — and carried onto a continuation leaf rather than left on the parent?
- [ ] Any quoted block of numbers marked for what it is — inputs the build sets, or derived read-outs the build produces — with the arithmetic test run on the block's own stated inputs before it is written in as a spec?
- [ ] Any acceptance criterion the executor cannot reach split to the right lane, or marked as a non-executor criterion so review does not bounce on it — and where its output is cited by code, its reconciliation authored as its own `human`/operator log-then-repoint leaf, not an assumed follow-through?
- [ ] Any ticket body asserting an Owner decision citing the comment or `Dxxx` it came from (an uncited ruling is void), and any session decision written to the ticket with its source named before a body relies on it?
- [ ] Runtime-verification criteria authored as CI assertions or as "runtime-verified against a production build of the PR head" rather than a manual "verify on the preview" — a hosted URL named only where the deployment itself is under test, and manual preview reserved for judgement calls?
- [ ] Consequential decision made? → decision-log entry added.
- [ ] Tracker mechanics applied per convention-linear?
- [ ] Tone clean per `cos.tov`?
