---
name: "skill-triage"
type: skill
description: Triage and project-manage Linear tickets in the operator's delivery projects on behalf of the Claude Code PM role. Use this whenever running the triage routine, or when a ticket carries the agent:R3-LAY label, or a comment @mentions the claude-code label — set status, priority, and links, refine a ticket from its type template, check every Todo ticket carries an executor, and hand off to Forge or to the operator. Apply this rather than triaging ad hoc, so routing, labels, and the Pattern A handoff stay consistent. Trigger it even when the request just says "triage", "tidy the board", or "what needs doing" in a Linear context.
license: CC BY-NC-SA 4.0
---

# triage

The PM / triage role of the Claude Code loop. Runs as a polling Cloud Routine — there is no Linear agent app, so triggering is by label, not agent session. Follows convention-linear throughout.

## Trigger

**Poll every ticket in Backlog, per delivery team, regardless of its** `agent`**-group label — and repair the label as the pass's first action.** Backlog membership is the trigger; `agent:R3-LAY` is no longer the gate. A Backlog ticket with a missing or wrong `agent`-group value was invisible to the one pass that would fix it — the Backlog analogue of the Todo silent hole the *Executor-presence sweep* closes downstream. A mislabelled ticket is itself a reason to triage it, so the **first action on any Backlog candidate is to set or correct its** `agent`**-group value** (`agent:R3-LAY` where triage still owns it, a real executor where the placement is already clear), then triage the ticket on its merits. Label hygiene is a triage output, not a triage precondition. Scope stays **delivery teams only** — never the Pipeline team (Network / Roles / Advisory / Pitches) — and the read stays **per delivery team**, with the compact `fields` set below and a page cap of about 25 rows a page, paged rather than widened. `agent:PUL-5E` **Backlog notes stay out of the delivery-triage path** — and because the label filter cannot express *not this value*, **the team whose Backlog is mostly Pulse notes is read per project instead**: read every project on that team except `os.Claude`, then read `os.Claude` on its own and drop the `PUL-5E` rows. A per-team paged read spends its whole page budget on excluded notes and never reaches the tail, so the rotation team's full poll is impossible by construction rather than by budget. (Worked cases: Apps' non-`PUL-5E` Backlog remainder unpaginated across at least four consecutive fires — `APP-1554`, `APP-1665`, `APP-1710`, `APP-1808`, `APP-1840`.) The `agent:PUL-5E` notes stay out of the delivery-triage path exactly as the *Blocked-state sweep* excludes them: those are canon-improvement intake, propose-only, and reach the Owner by their own route — triage neither triages them nor comments on them. A comment @mentioning the `claude-code` label is a human flag to look; the ticket's presence in Backlog is the routing signal. (Owner request, 2026-09-03 — APP-1109.)

**A repair on one sibling is tested against the whole batch — siblings filed in one sitting are one population.** The label repair above is a per-ticket action on a defect that is rarely per-ticket: a set of children filed under one parent in one sitting shares its author, its template and therefore its missing fields, so the member that surfaced is a sample, not the case. Where the first action sets or corrects an `agent`-group value on a ticket that has siblings — children of the same parent, or tickets created within the same sitting — read the parent's children once and test the same field across all of them; repair as many as the five-per-team bound allows, and **name the unrepaired remainder by ID** in the run's report, so the next fire works a known list instead of rediscovering the batch one ticket at a time. The population test is not the collated-capture rule's alone (*Behaviour*, where it is written against an unrefined member): **any** missing-field defect takes it, and the trigger is the parent, not the intake path. (Worked case: MRP-23's fleet series — MRP-25 through MRP-35, 11 children created 2026-07-20 in one filing pass — carried no `agent`-group value at all, each with a complete, well-formed brief, so each was the silent hole the *Executor-presence sweep* names, one state earlier. The 2026-09-11 pass repaired 5 plus a same-shaped standalone (MRP-40) and left 6 to be found again. Same failure as the A1-294 comment batch reached by a different intake path — a planning session filing an editorial series — APP-1337.)

**Read the poll with a compact `fields` set — that is the first defence against overflow, ahead of any narrowing by state.** `list_issues` takes a `fields` param: pass a compact set (`["title","status","labels","assignee","project","parentId","url"]`) and each row returns those keys only, with the long `description` body omitted, so the whole label-scoped poll returns in one call even on a team the size of Apps. Pull a single ticket's full body with `get_issue` when you actually come to triage it. Setting `fields` first also changes what the open-states rule below is *for*: it becomes a relevance filter rather than a token one — a closed ticket is still never a triage candidate, so still exclude it, but the exclusion is no longer what keeps the read inside the limit. The out-of-band subagent parse earlier runs fell back to is retired as a routine step; it survives only where the full bodies of a large set are genuinely all needed at once (`convention-linear` *Reading Linear safely*). This closes the gap the poll section used to carry between an instruction — "filter to open states" — that no single `list_issues` call could satisfy (there is no open-states-only filter, and a `state` filter for a backlog-type state matches every team's backlog state and overflows) and a fallback the skill never named: a run following the section literally overflowed at 45 tickets / ~70k characters and recovered only out of band (worked case: `task-triage`, 2026-07-27, APP-688; the `fields` finding is APP-742, 2026-08-10).

**Scope the poll to open states only.** `agent:R3-LAY` is a triage marker that is *evicted* when a ticket is routed to a real executor — but tickets that are never routed (epics the operator closes by hand, `FRICTION:`/`OPS:` notes, human-decision tickets) keep it through to close, so the marker accumulates on Done / Canceled / Duplicate work indefinitely. An unscoped `label:R3-LAY` poll therefore re-reads every closed ticket every run — drowning live candidates in closed-ticket noise, and at default fields overflowing the tool's token limit outright (worked case: 66 issues / ~99.8k characters returned, 41 of them closed, 2026-06-30, APP-401). Filter to **open states** (exclude Done / Canceled / Duplicate — e.g. iterate the active states, or drop the completed/canceled state types), since a closed ticket is never a triage candidate regardless of its label. This is the label-scoped-poll companion to the whole-board overflow guidance in `convention-linear` *Reading Linear safely*.

**Every exclusion in this section survives the widening — only the label gate went.** The wider Backlog scope changes what is *read*, not what is *skipped*: closed states are still excluded, non-leaf parents are still excluded, phased-placeholder and un-greenlit-epic leaves are still skipped-not-mutated, and `agent:PUL-5E` notes stay out of the delivery-triage path. Two of them need restating against the wider scope. First, **the open-states rule now carries more weight than it did**: with the label gate gone it is the only thing keeping Done / Canceled / Duplicate tickets out of a whole-team read, so exclude them by **state type** rather than trusting a marker to have been evicted. Second, **check the state name the filter actually returns** — a Backlog-named state filter on these teams also returns **Refinement**, so a nominal `state: Backlog` read hands back the operator's lane as well; that lane is read-only to this leg for ticket content (*Refinement comment sweep*), so partition the result by state name before acting and never treat a Refinement ticket as a Backlog candidate. (APP-1109.)

**Exclude any non-leaf parent from the poll — a parent with children has no routing event, so it can never terminate.** The property that matters is *not a leaf*, not the type name: an epic, or a `type:feature` (or any type) that **has children**, is an outcome the operator closes when its children are done — it is *never* routed to Forge, while `agent:R3-LAY` is a triage marker *evicted at routing*. So a non-leaf parent in Backlog under `R3-LAY` has nothing that ever evicts the marker — it matches the poll every run, is read in full, and offers the pass nothing terminating to do. **Filter out `type:epic` and any parent that has children** (a candidate is a non-leaf if it has any sub-issues — check its children rather than the poll's own result set, since they may sit in Todo / In Progress / Done outside it: `list_issues(parentId: <id>)` non-empty is the test). Excluding them costs nothing: the children are still polled and routed on their merits, and a parent needing the operator (an un-greenlit epic) is surfaced once by the rule below, not by the poll. This is the same unbounded re-surfacing family, each fix for a different population: closed tickets (APP-401), human-owned Refinement leaves (APP-304 / APP-391), correctly-parked leaves under un-greenlit epics (APP-452), `PUL-5E` notes in the Blocked sweep (APP-552), epics (APP-593) — and now non-leaf `type:feature` parents, which an exclusion naming only `type:epic` let fall through. (Worked cases: APP-523, a greenlit epic read for zero action on consecutive runs, 2026-07-20, APP-593; and the bot.Trader-B features APP-671 / APP-672 / APP-673, in Backlog under `R3-LAY` with every build leaf already routed to F0-RGE or Done, re-read in full every poll — APP-701 / APP-731.)

**Skip a scheduled task's own run-report ticket — and surface the batch once.** This is one more population in the unbounded re-surfacing family the exclusions above enumerate, and the only one whose real fix is upstream rather than here: a sibling scheduled task that files its run report as a *ticket* rather than as a run-log comment leaves a row the poll can never terminate. `convention-agent-runtime` line 91 makes a run-log **one comment on a durable surface** — the artefact's own loader ticket, or the vertical's initiative — and `skill-ops-retro` capture step 3 and `skill-coordinate`'s own closing line both say the same thing from the other end: a run's summary of what it swept, wrote and skipped belongs there and nowhere else, never as a ticket in the queue. Such a row is **not delivery work**: it has no `agent`-group value to set and no sensible one to invent, so the poll's own first action — set or correct the `agent`-group value — cannot be taken on it at all, and a literal poll either mislabels it (wrong) or improvises a skip with no canon basis (inconsistent, differently each fire). **Recognise it by its title** — a `<skill> run report — <date>` form, or any body that is a self-contained record of one run's passes rather than a unit of work — then **skip it in the poll, leave it unmutated, and never set an** `agent`**-group value on it.** Then **surface the batch once** to the operator, naming the authoring artefact whose own closing step put it there, exactly as an un-greenlit epic is surfaced once rather than re-read every poll: these rows are a cleanup backlog and a defect in the author's output contract, not a poll population to budget for every rotation. **The existing prohibitions do not reach them, because they are keyed on the wrong set:** "never in the Pulse queue" names a **label**-keyed set — the queue is read on the bare `PUL-5E` value — while this poll's population is keyed on **state**, so a report ticket carrying no label at all satisfies both prohibitions and still lands here every fire. (Worked case: `task-coordinate` filed APP-2165, "coordinate run report — 2026-10-08", read live as an unlabelled Apps / os.Claude Backlog ticket, plus six siblings reported in the same shape but not individually read — APP-2129, APP-2196, APP-2078, APP-2031, APP-1998, APP-2021 — 7 of roughly 96 true-Backlog candidates on Apps in the 2026-10-11 fire. APP-2262, "coordinate run report — 2026-10-11", is a second instance found the next day, reported unlabelled but not re-read; and `pulse-retro` reports such as APP-2086 are reported to follow the same shape. APP-2261.)

**Skip genuinely-not-ready Backlog leaves — the active-siblings / phased-placeholder scope.** Open-state scoping drops closed tickets, and the executor-hygiene relabel (below) drops human-owned Refinement work, but a third class still re-surfaces every poll with **no terminating action**: `agent:R3-LAY` Backlog leaves that are legitimately R3-LAY, open, and genuinely not yet refinable. Two shapes:

  - **Phased-placeholder leaves** — a Backlog leaf whose body is an explicit placeholder ("detail after Phase X surfaces the real …"), correctly parked awaiting an *earlier phase's* output, so not yet refinable.
  - **Un-greenlit-epic children** — R3-LAY Backlog leaves under an epic with **no active siblings** (zero Todo / In Progress / Done anywhere under it) that the operator has not greenlit; refining or routing them would hand an un-greenlit backlog to the delivery loop.

  Apply the **active-siblings test** already used in the F0-RGE dormant-project carve-out (*Resting state*, the invariant): a Backlog leaf in a project or epic with work already in flight is a live triage candidate; a leaf in a dormant / un-greenlit project or epic, or one whose body explicitly defers its spec to a later phase, is **not** — **skip it in the poll** until its gating phase completes or the epic is greenlit. Do not mutate it (it is already correctly `R3-LAY` in Backlog — unlike the human-owned and dormant-`F0-RGE` cases there is no hygiene relabel to make). **Surface the parked epic once** to the operator with the recommendation (greenlight, or leave parked) rather than re-scanning its children every run. This keeps the poll bounded to genuinely-actionable candidates so a single new ticket is not drowned among dozens of correctly-parked leaves (worked case: the only actionable ticket on the whole board sat among ~25 re-surfacing parked leaves — 2026-07-07, APP-452; companion to the closed-ticket overflow APP-401 and the human-owned re-surfacing APP-304 / APP-391, and distinct from the dormant-`F0-RGE` carve-out APP-435, which relabels rather than scopes).

  **What counts as a greenlight — written approval beats the proxy.** The active-siblings test is a **proxy** for "has the Owner greenlit this?", and it is a good one precisely because a greenlight usually isn't written down. When it *is* written down, the direct evidence wins: **an explicit, dated, Owner-attributed approval in the epic's or project's body or comments is a greenlight, even with zero active siblings.** Treat the epic as live and route its leaves on their merits. Zero active siblings then means only "not started yet", which is the normal state of an epic approved this week. The wording must be all three — explicit, dated, and attributed (e.g. *"Approved direction (Aled, 2026-07-14): build a v2 as a genuine alt…"*); a hopeful reading of ordinary prose is not a greenlight, and absent that, the proxy stands. **And the rule runs both ways: a written hold beats the proxy too.** A project whose Linear `status` is **Hold**, **Paused** or **Cancelled** is explicit, dated, Owner-set evidence that its work is not in flight, and it overrides the active-siblings test in the direction that *reduces* mutation: its leaves stay the dormant pre-label case (*Resting state*, case 2) whatever the sibling count, and the correcting move is to surface the project, never to promote anything. Without this limb the proxy reads a held project that still carries Todo leaves as active and routes its whole Refinement population to Todo — the mutation case 2's own worked case exists to prevent. (Measured 2026-10-09: `app.Luna` reads `status: Hold` with 9 Todo `agent:F0-RGE` leaves and 26 in Refinement, so the sibling test returns "in flight" on a project the Owner has held — APP-2164, APP-435.) (Worked case: APP-523's three children, none in flight, under a dated written approval — routed on the reasoning that a written greenlight is better evidence than a proxy for one, but with no rule saying so, another run could have parked all three with equal justification. Same evidence, two defensible answers, 2026-07-15, APP-553. Contrast the same run's bot.Trader call — six fresh leaves, no recorded approval — correctly surfaced, not routed.)

  **"Approved direction" is not "approved to start" — route the first leaf, not the epic.** A written approval of a *direction* does not by itself authorise beginning the build. So on a written greenlight, route only what the approval actually covers: a **discovery, definition, or positioning leaf** — work that sharpens the approved direction and is cheap to unwind — goes to its placement normally. A leaf that **commits build effort** waits: leave it, and name the ambiguity to the operator in the routing comment on the leaf you did route, rather than resolving it silently in either direction. This keeps the cost of a misread proportionate — the downside of routing a positioning ticket against an approved direction is close to nil; the downside of starting a build off your own read of intent is not. (APP-524 was routed to Sonar on exactly this basis, with the ambiguity flagged rather than resolved, 2026-07-15.)

  **The Owner filing work under the epic himself is a greenlight signal too — stronger than the proxy.** Where the Owner has personally created a ticket under an epic (a human-setup leaf, a dependency he has taken on), that is direct evidence of intent to proceed, not an inference from activity. Read it alongside the active-siblings proxy: either is sufficient. It ranks above the proxy because it is an act of the Owner's rather than a side-effect of the board's state, and below a written approval only because it is unstated. (Worked case: bot.Trader's Phase 2a leaves — APP-536/537/538/539 — were correctly *surfaced not routed* on 2026-07-15 with no approval and no active siblings, and correctly routed on 2026-07-20; the thing that actually changed the answer was the Owner filing APP-588, a credential-setup leaf of his own, which neither named rule captured and a run could equally have missed — APP-593.)

  **Named for the operator, not decided here:** a greenlight legible to an agent — a label, a project state, or a fixed line in the epic body — would remove the interpretation step entirely. That is the operator's call to make, not triage's to assume; the rules above are what triage does meanwhile.

  **Exclusion — a decision-gated leaf in an *active/greenlit* epic is not skipped; it goes to placement 4.** The skip scope above is for leaves that are *not yet refinable* because an earlier phase or a greenlight is missing. It must **not** be applied to a leaf that is refinable-but-decision-gated — one whose only outstanding need is an operator decision (an ownership call, a rescope, a scope-vs-fold) — sitting under an epic that **is** greenlit and in flight (has Todo / In Progress / Done siblings). Such a leaf belongs in **placement 4 — Refinement + `human` + assigned to the operator** with the decision named, on his plate, **never skipped-as-parked and never left in Backlog under `agent:R3-LAY`**. The distinguishing test is the **same active-siblings test, applied to the *epic***: active/greenlit epic + leaf-needs-a-decision → placement 4; dormant / un-greenlit epic → skip and surface the epic once. Conflating the two drops decision-gated leaves into a dead zone — not routed, not skipped-cleanly, just sitting under a standing recommendation that never reaches the operator (worked case: five Phase-1 firmup leaves — A1-98/101/102 the app-side ownership decision, A1-100 the stateless rescope, A1-104 the scope-vs-fold — sat in Backlog under `agent:R3-LAY` across two triage passes while their epic A1-110 was greenlit and in flight, "assigned to relay but nothing happened", corrected to Refinement + `human` + assigned, 2026-07-07, APP-459).

**Bound the pass — at most five rows per delivery team per fire, first touches first, remainder named.** The rules above say what is *eligible*; they say nothing about how much of it one run works, and an unbounded pass over a first-touch backlog is the case that breaks. A Backlog ticket never triaged costs a full template instantiation — read the body, paste the type's standing `## Definition of done`, author testable `## Acceptance criteria`, read the description back, then the placement, parent, milestone and label writes — roughly an order of magnitude more than re-checking a ticket already refined once. So **work at most five rows per delivery team per fire**, and order the candidates so that **rows carrying no prior triage comment come first**: a first touch is both the most expensive row and the one that has waited longest, and a run that spends its budget re-checking familiar tickets never reaches it. Five is chosen because it keeps a run inside one context window across all the delivery teams while a few-times-a-day cadence still clears roughly fifteen first touches per team per day — fast enough that a stalled team drains in days rather than weeks. The cap bounds the *work*, never the *scope*: every eligible row stays eligible on the next fire. **Name the remainder** — count the eligible rows not reached, per team, and report them per the *Guardrails* rule below. (Refine ruling, 2026-09-10; the *what* it sits inside is the all-of-Backlog poll instruction above, APP-1109. Worked case: MBN-257, created 2026-06-29 with no bare `type:` label, no `## Definition of done` and no triage comment, eligible on every poll and reached by no run until 2026-09-09 — APP-1207.)

**And rotate one team's full poll per fire — the cap bounds a team's share of a fire, the rotation is what drains a board this size.** Five-per-team was set against a smaller board. At current size four consecutive fires to 2026-09-25 each left named residue on every team and completed a first-touch pass on none: Apps at roughly seventy Backlog rows, A1 at roughly ninety with a second page never fetched, MBN with about twenty beyond the five worked, and Mr Pritchard's small set. Five rows across four teams spends the whole fire on breadth and finishes nothing, so the residue is permanent and the board does not move. So each fire takes **one rotation team, polled in full**, and holds the other three to the five-per-team cap exactly as written above. **The rotation team is determined by the run's own date, never chosen:** take the ISO ordinal day number of the run's UTC date modulo 4 and read it against the fixed order **Apps (0), A1 (1), MBN (2), Mr Pritchard (3)**. That needs no memory of earlier fires and is re-derivable by anyone reading a report against its date, which a "next team along" rule is not; and every team gets a full poll inside any four consecutive days. Where the task fires more than once in a day, **every fire that day takes the same rotation team** — the second full poll is cheap because the first drained it, and advancing within the day would need state this pass deliberately does not keep. **The residue line is mandatory, not optional, and it is mandatory for the rotation team too**: per team, the eligible rows worked, the eligible rows not reached, and the ID of the oldest first-touch row left; and where the rotation team's full poll did not complete inside the fire, the literal words `rotation poll incomplete: <team>`, so a fire that ran out of budget on its own rotation team is distinguishable from one that drained it. The rotation still advances on the next fire and the incomplete team is not re-taken, because re-taking would need the previous report. (Four consecutive fires, each with named residue and no completed poll on any team — APP-1554, APP-1633, APP-1665, APP-1710 — generalised into a standing pattern by APP-1762.)

**Precedence when the budget will not cover everything — a run does not choose its own subset.** The cap above bounds the *poll*; it says nothing about the poll's standing against the four sweeps, so a run short of budget or context selects its own slice and no two runs degrade the same way. Work a fire in this order, and drop from the back:

1. **Executor-presence sweep** over Todo, per delivery team — cheap, deterministic, an invariant violation rather than a judgement, and the only check that can see a ticket sitting in no queue at all.
2. **Harvest sweep**, then **blocked-state sweep** — both must precede comment-idempotency silencing (see that guardrail), both are self-terminating, and each holds a leaf stranded on a blocker that has already cleared.
3. **Refinement comment sweep — its own named pass, not an implied step.** Run it as a pass in its own right over each delivery team's Refinement population (`Defined` on Mr Pritchard): the team-wide check for "the operator has commented since the last pm/agent comment", working exception (1) of *Refinement comment sweep* below. It is third because he has already commented and is the waiting counterparty. **A bounded fire that cannot reach it says so — one line in the run report reading "refinement comment sweep: not run this fire" — and the next run treats it as unreached, never as clean.** The obligation is the load-bearing half. Five consecutive runs to 2026-09-22 folded this sweep into the Backlog poll's incidental reads and none of them was wrong to, because canon named no pass there was anything to skip; but a silent omission recorded as a clean board is indistinguishable from a sweep that ran and found nothing, so the gap re-set to zero every run instead of accumulating. Reporting the skip costs one line and makes it visible. (APP-1564, whose own condition re-test failed inside 2h14m of its close; APP-1633.) **And a pass that can only ever be skipped is not a pass — bound it, carry a cursor, and finish the population across fires rather than within one.** Reporting the skip made the gap visible and did not close it: the obligation as written is the *whole* Refinement population of *every* delivery team, which is on the order of 115 tickets at two reads each, so no bounded fire has ever discharged it and the honest skip line is the only reachable outcome. A sweep whose only terminating state is "not run this fire" is a standing report of its own impossibility. So run it as a **bounded slice with a cursor**: each fire checks up to **ten** Refinement/`Defined` tickets **per delivery team**, taken in `updatedAt` order **oldest-checked first**, and the run report names the last ticket id checked per team as the cursor the next fire resumes from. **Realise "oldest-checked first" from a descending page — the connector exposes no ascending direction.** `list_issues`' `orderBy` takes `createdAt` or `updatedAt` and nothing else: there is no direction parameter at all, so descending is the only direction the connector offers and the ordering above cannot be read off the head of a page. Build it in two reads rather than one. First enumerate each team's Refinement/`Defined` population with an id-and-`updatedAt`-only `fields` set, paging to the last page — that enumeration is cheap precisely because it reads no bodies and no comments — then take the slice from the tail of a descending page, which is the oldest-`updatedAt` end, skipping ids the cursor has already passed. The per-ticket comment read is the whole cost of this sweep and it still falls on ten rows per team; only the cheap enumeration is unbounded, and it is what makes the cursor monotone. A fire that cannot afford even the enumeration writes the slice-not-run line and leaves the cursor where it stands — it does not substitute the head of the page, because a newest-first slice is the form this rule already names as the unbounded one wearing a cap. A team whose population is at or under the slice is swept whole and reported as **complete**, which is the state the unbounded form could never reach. Wrapping past the end of a team's population restarts it, and a ticket whose `updatedAt` has moved since its last check re-enters ahead of the cursor — the operator commenting is exactly the event this sweep exists to catch, so a changed `updatedAt` outranks the cursor's position. The skip line stays, narrowed to what it can now honestly say: a fire that cannot reach even its slice reports **"refinement comment sweep: slice not run this fire"** and the cursor does not advance, so the unreached slice is carried rather than silently re-set. The bound is **per team and per fire**, never a cap on the population — the population is finished across fires, which is the point. (The slice is refine's call, not the note's: APP-2020 proposed "N tickets/team/fire with a cursor" and named no N or ordering. Ten per team is one fire's reach at four teams against the reads the check costs, and oldest-checked-first is what makes the cursor monotone — a newest-first order re-reads the same head of the queue every fire and is the unbounded form wearing a cap. Worked cases: the sweep reported unreached on three consecutive fires — APP-1710 2026-09-24 "not run exhaustively, same as every prior run", APP-1997 2026-10-03 "not spot-checked this run at all", APP-2020 2026-10-04, which pulled the full 115-ticket population across four teams, resolved the one flagged app.Luna anomaly, and still could not make the per-ticket check — APP-2020.)
4. **The Backlog poll**, to the five-per-team cap, in its own existing order: a self-routing dispatch row first (APP-1324), then the committed-Todo `agent:R3-LAY` rows the *Executor-presence sweep* hands it (APP-1581), then the first touches.

The ordering is cost against a waiting counterparty, not importance. The first three are cheap, deterministic and have somebody blocked behind them; a first touch is the most expensive row in the fire and its counterparty is the board itself. This does not relax the cap, and it does not license skipping a step that fits — a run with budget runs all four sweeps and the poll. What it removes is the runner's discretion over *which* work a short fire drops. (Worked case: the 2026-09-15 pilot fire of the cloud-Routine loader worked one to two rows against the five-row bound on Apps, MBN and A1, never reached Mr Pritchard at all, and ran none of the harvest, blocked-state or executor-presence sweeps — a scope it chose for itself, correctly and in good faith, because canon stated none. APP-1469.)

**Drop from the back means from the back — the *Refinement comment sweep* is dropped only after the Backlog poll has been dropped.** The list above is an order, and a short fire has read it as a priority ranking instead: it runs the two cheap sweeps, runs the poll because the poll is what a triage fire is taken to be *for*, and drops item 3 out of the middle because it is the dearest of the three cheap-side steps. That is not dropping from the back — it is the runner's discretion over *which* work a short fire drops, the thing this rule exists to remove, re-entering through the one step whose omission has a sanctioned reporting line. So state the obligation literally: **item 4 goes before item 3 does**. A fire that worked *any* Backlog poll row — a rotation team polled in full, the five-per-team cap worked, a single self-routing dispatch routed — spent the budget the sweep would have been dropped to protect, and had no licence to drop it. **Step 3's skip line is available only to a fire that has also dropped the poll**: item 3's sanctioned "refinement comment sweep: … not run this fire" line may be written only beside the same admission for the poll, and a run report carrying the first without the second is itself the defect to fix — the sweep was not out of budget, it was outranked by the step beneath it. This does not license dropping the poll to reach the sweep either: a fire with budget runs both, and the only ordering this adds is which one goes first when one of them cannot. (Worked case: seven consecutive fires — the seventh through the thirteenth, `APP-1710` 2026-09-24 through `APP-1931` 2026-10-01 — dropped the sweep while working the poll, each saying so plainly and in good faith in the sanctioned line. The thirteenth is the clearest: item 4 reported *"not run this fire. Budget did not reach a per-ticket comment-thread check across the ~90 Refinement/Defined rows this run could see"*, while the same fire polled MBN's rotation Backlog in full at 23 rows, read Mr Pritchard's 7 in full, and took Apps and A1 to a first page each. No run was wrong against the text as written. — APP-1931.)

**A fire that names tickets adds targeted work — it never replaces the order above.** An on-demand fire whose payload lists specific tickets works those tickets first, within the same per-team budget, and then runs the four sweeps and the poll exactly as listed. A hand-curated list is data typed by whoever fired the run, not a query, so it can under-count the condition it describes, and only the standing sweep can find what it left out. Where the payload cites a note as its source, read that note's own ticket list and work the union. (Worked case: the 2026-09-21 on-demand fire named five tickets force-moved into Todo by the W39 cycle commit; the note it came from listed seven, and the executor-presence sweep, run regardless of the payload, caught A1-298 — `human` and unassigned, its stated hold cleared since 2026-09-04. APP-1582, 2026-09-21.)

**Order a self-routing ticket ahead of the first touches — it costs a fraction of one, and it is somebody's dispatch (**APP-1324). "First touches first" is right because a first touch is the most expensive row and has waited longest. One class inverts that arithmetic: a ticket whose **body already names its executor** — a `DISPATCH:` note asking for a named agent (`A1-DE`, `P1-XEL`, `R3-ACH`, `SO-N4R`, `SC-0UT`) or naming `skill-fleet-dispatch` / `skill-dispatch-run` in its ask, carrying its own `## Definition of done` — needs no template instantiation, no AC authoring and no placement judgement. It needs one label swap and one state move. So **rank it first within the pass, ahead of the unrefined first touches**, and route it on what the body says rather than re-deriving the target: set the named `agent`-group value as a full `labels` replace, move to **Todo**, leave the assignee **clear**, and comment one line naming what was set and the body line it was read from. Do not re-litigate the routing decision the raising operator already made — triage is executing a stated route here, not choosing one; where the named value is not a live `agent`-group value, or the body names no runnable agent, it falls back to the ordinary placement rules. Two properties make this worth a rule rather than a judgement. It is **cheap**, so it never displaces a first touch by more than minutes of budget. And a dispatch is the one Backlog shape with a **waiting counterparty** — an operator loop that raised it, a stand-up that will re-flag it, and a fleet pass that cannot see it until the executor label is set — so the cost of leaving it is not a stale row but a stalled chain, and the failure mode of leaving it is a stand-up escalating priority on a ticket whose only problem is a label. (Worked case: A1-406, *"DISPATCH: re-run Aide's cutover-chain hold-window proposal for* A1-362", filed 2026-09-09 07:11Z correctly into Backlog with `agent:R3-LAY` and an Ask naming Aide and both dispatch skills. It sat two days untouched; the 09-10 stand-up escalated it High → Urgent on a launch-date premise that then dissolved, the 09-11 stand-up de-escalated it back to High rather than escalating a fourth time, and it was finally routed by hand at 2026-09-11 10:22Z — `R3-LAY` → `A1-DE`, Backlog → Todo, unassigned — the exact write above. Second occurrence of the APP-1012 shape after that note drained. APP-1324, APP-1012.)

The run also revisits tickets in **Blocked** carrying any `agent:*` label **except `PUL-5E`** (not only R3-LAY), to catch blockers that have since cleared — see *Blocked-state sweep* below — and runs the cheap deterministic *Executor-presence sweep* over Todo. **In Progress** and **In Review** are never touched by the run.

## Behaviour

Read the issue and its comments, then:

- Set state, priority, and links. Apply missing `type:` / `work:` labels per convention-linear. Never move an unrefined ticket out of Backlog; never leave a refined, actionable one stuck in it.
- Decide whether the ticket needs execution (code):
  - **Needs execution** — set `agent:F0-RGE` (single-select evicts `agent:R3-LAY`), move to Todo, **clear the assignee**, and comment what's needed with the acceptance criteria embedded in the body (Pattern A), so the exec leg is self-contained. Only ever route a **leaf ticket** to Forge — never an epic (`type:epic` is an outcome closed by the operator when its children are done; see convention-linear *Structure*). **Gate the route on the literal headings, read from the description at the moment `agent:F0-RGE` is set.** Re-read the description and confirm `## Acceptance criteria` and `## Definition of done` are literally present as `##` headings with checkbox lists beneath. A refinement comment's claim that they were added does not count; a checkbox list under `## Scope` or `## What this is` does not count. `skill-build-ticket` step 3b is the backstop that bounces a format-less ticket back to Backlog — but it catches the defect at the most expensive point, one full delivery-loop pick-up later, and de-cycles the ticket on the way. (Worked cases: APP-966, whose 2026-08-17 refinement comment recorded an AC conversion that never landed in the body, and A1-354, routed on a `## Scope` list with no conversion attempted — both bounced un-built on 2026-08-18 — APP-1037, APP-1017.)
    - **And where the pass has just resolved a decision ticket, the route is a new leaf, not a label swap on the record.** A `SCOPE:` or decision-shaped ticket correctly carries no acceptance criteria while the question is open — that is the shape doing its job — so the heading gate above cannot fire on it and the executable instruction sits in the decision prose, where the resolution is the new build brief. Setting `agent:F0-RGE` on that ticket therefore produces exactly the ticket the gate exists to stop, with the gate silent. So: **file the build as a new leaf** carrying its own `## Acceptance criteria` authored from the resolution and the pasted type DoD, one leaf per repo where the work spans repos (*the execution lanes*), and **leave the original closed as the decision record it always was**. Reshape the original in place only where it carries no record worth preserving — a question nobody else will re-read — and never in the same action as the route, because the reshape is authoring and the route is a label.
  - **Needs a human decision** — leave a clear comment and assign to the operator. The comment must @mention him (`@aledpritchard`) and lead with the specific action or decision needed, phrased so he can reply or act directly. Where it hands him something to *do* — a command, a setup step, a manual verify — write it as numbered, novice-friendly steps, one action per line, commands spelled out literally in a code span, a decision kept separate from a thing to type (`convention-ticket` *Writing an instruction the operator has to action*). Do not guess.
  - **Needs connector-surface work** (design, brand, a design system, marketing / GTM, discovery / service design, pipeline capture, or chief-of-staff scheduling — anything the Cowork-surface fleet runs, not code) — set the **matching connector-fleet executor** (single-select, evicts `agent:R3-LAY`): `agent:P1-XEL` (Pixel — brand, design system, visual production), `agent:R3-ACH` (Reach — marketing, content, GTM), `agent:SO-N4R` (Sonar — discovery, audit, user modelling), `agent:SC-0UT` (Scout — pipeline), or `agent:A1-DE` (Aide — the Owner's time). **Leave it in Todo, unassigned** — `skill-fleet-dispatch` picks it up on the connector surface, the counterpart to routing code to Forge. This is the route the *Executor-presence sweep* and `convention-linear` already assume triage takes — the sweep sets `agent:R3-LAY` expecting the next pass to assign a real connector-fleet executor — so it is named here as a triage output rather than left for each run to infer that setting `P1-XEL` is legitimate. What **refinement bar** a connector-fleet leaf must clear before it may be routed — Forge requires `## Acceptance criteria` + `## Definition of done`; the connector fleet's bar is unstated — is an open question carried in APP-810 and not settled here: where the bar is genuinely unclear on a given leaf, treat it as a decision-gated leaf (placement 4 — Refinement + `human`, assigned, the decision named) rather than routing it on a guess. (Worked cases: APP-122 and APP-508, both connector-surface Figma leaves, routed to `agent:P1-XEL` on 2026-08-12 citing the 2026-08-11 executor-hygiene comments that anticipated the re-route — APP-810.) Where such a leaf's deliverable is a **proposal an Owner sign-off turns on**, it is filed as a Linear document and attached as a native Link rather than left as a comment (`convention-linear` *durable artefacts*, APP-1135) — triage repairs a comment-filed proposal by filing and linking the document, not by escalating the ticket's priority.
  - **Not actionable** — route to the right state (needs info, blocked, canceled) with a one-line reason.

## Refinement: placement, structure, assignee

When refining a Backlog ticket, structure it before polishing its content:

- **Instantiate from the type template (every Backlog ticket).** Set the ticket up from its `type:` template (`convention-ticket` *Per-type ticket formats*): confirm the section skeleton for that type, **paste the standing `## Definition of done`** for the type, and confirm the per-ticket **`## Acceptance criteria`** are present and testable. Don't promote a ticket to Ready without **both** sections in place — AC written and DoD pasted. The author writes AC; never leave it to Forge. **After any structural edit to the description, read it back and confirm each heading the refinement comment claims is present** — the read-the-write-back discipline `convention-linear` applies to every state write, applied to a description write. A comment saying "converted the six bullets to a testable `## Acceptance criteria` checklist" against a body that holds only the DoD half is the tell; so is a bullet count in the comment that does not match the body (six claimed, seven present). Confirm before promoting, not after Forge bounces it (APP-1037, APP-1017).
- **A collated capture is not a refined ticket, however decided it reads.** Feedback lifted in a batch from a design tool, a call, or a client thread arrives as a *capture*: a verbatim source quote, a line of assessment, and often a routing verdict ("outstanding bug — Relay to route to Forge"). The routing verdict is the trap. It presents interpretation as specification, so the ticket reads as already shaped and the promotion to Todo reads as routing rather than as skipping a gate. Test the ticket, not its confidence: **no `## Acceptance criteria` and no `## Definition of done` means not refined**, whatever the body asserts about what should happen next, and whatever state it was created in — a ticket authored straight into Todo or In Review never passed the gate that would have caught it. Refine it from its `type:` template before it goes anywhere. And treat a batch of siblings created in one sitting as **one population**: where one member is unrefined, check the rest rather than only the one that happened to surface. (Worked case: the A1-294 collation turned 18 Figma comments into 14 leaves — 0 of 14 carried acceptance criteria, 0 carried a definition of done, 0 passed through Refinement; six went Backlog → Todo inside ten minutes of creation and four were created directly In Review. All three that reached a builder cost a cycle, 2026-07-31 / 2026-08-09, APP-743.) Which artefact should own a design-tool-comment intake path end to end is an open question with the Owner; this rule is what triage does regardless of where that lands.
- **Write no acceptance criterion you cannot verify — the port-shaped premise check.** An AC of the form *"port from the prototype"*, *"port the motion verbatim"*, *"per the Jul 17 prototype"* asserts a premise: that the named behaviour exists in the named source. Where it does not, the criterion is not merely wrong, it is unsatisfiable — the exec leg is told to lift exact values from a source that holds none, and the likelier outcome under time pressure is not a bounce but an invented-values PR. Triage runs on the Linear connector alone and cannot open a repo or a prototype file, so it is not placed to confirm the premise; that makes this an **authoring** rule rather than a verification one — do not assert a source you have not read. Two checks, both available from the ticket text:
  - **Defect or request? The source's own wording decides.** *"should stick to the top"*, *"could squash down"* is a request for **new behaviour**; *"still present"*, *"used to"*, *"has regressed"* is a **defect** against something that shipped. "Port, don't re-derive" is coherent only for a defect. Where the source reads as a request, shape the ticket as new work needing a spec — a prototype pass, a decision-log entry, or an operator decision on the acceptance bar — and place it accordingly, rather than dressing it as a port.
  - **A named-source criterion carries its own verification.** Where a port is genuinely the right shape but triage cannot confirm the source holds the behaviour, write that into the AC — name the file and the thing to find in it, and make confirming it the executor's first step — rather than stating it as settled fact.

  (Worked cases: A1-301 and A1-302, routed with *"port, don't re-derive"* ACs for behaviours the prototype never contained, Blocked at the claim by `skill-build-ticket` step 3a before a branch was cut, 2026-08-01; and A1-299 a day earlier, where the build target did exist and only the criterion's source did not, so step 3a had no false premise to catch — exec built past the unachievable criterion and shipped a black focus ring on a black fill in dark mode, pinned by a tautological test, costing a full QA bounce. Confirmed as a class defect across the A1-294 batch, 2026-08-09, APP-737.) This is the triage-side mirror of `skill-build-ticket` step 3a's "already exists" premise check (APP-564) and of `convention-ticket` *Pattern A*'s authoring-side rule; step 3a remains the fail-safe, but it catches the defect at the most expensive point, which is why the cheap check sits here.
- **A new-workflow leaf cannot carry a pre-merge-run acceptance criterion — reframe it at refinement.** When a leaf's deliverable is a **new GitHub workflow file** and its `## Acceptance criteria` or DoD asks for a run, dispatch, or evidence link **on the branch or before merge**, that pairing is unsatisfiable by construction: GitHub only dispatches a workflow already on the default branch, so a brand-new workflow has no pre-merge run to link (`convention-github` *Pre-merge evidence for a brand-new workflow*, APP-632). Detect it from the ticket text — new-workflow deliverable + a before-merge run/evidence AC — and reframe to convention-github's path before it reaches Todo: **(a)** add a `pull_request` trigger so the workflow runs on the PR, or **(b)** accept post-merge evidence. Letting the forbidden AC through strands the build and the review and forces an Owner round-trip; this enforces at refinement what convention-github already prescribes when the ticket is authored. (APP-975, APP-632.)
- **A corrected figure sweeps its siblings — check the log at refinement.** When an Owner ruling or a decision-log entry corrects a **numeric figure or a criterion** on one ticket, the correction is rarely local to it: a chain of tickets cut in one sitting from one spec duplicates the same sentence by construction, so the other open tickets citing the same figure are wrong the same way. Sweep those siblings and correct them too, rather than treating the fix as belonging only to the ticket it was raised on. Cheap detection signal: a ticket whose AC states a numeric value **also governed by a decision-log entry** (or a token / spec) warrants a log check at refinement. This is the authoring-side counterpart to `skill-build-ticket` step 3a's repo premise-check, and the authoring-side half of APP-847 (the exec-side case is already canon). (APP-971, APP-847.)
- **Placement check (every Backlog ticket).** Before refining content, ask where the ticket belongs: does it sit under an existing epic or feature, and does it belong to an existing milestone? Set the parent and milestone during refinement. A parent existing is not enough — test that the parent's **home matches the ticket's domain**: a `domain:*` ticket (or one whose subject clearly belongs to one venture) parented under an epic in a different team/project, or under a canon epic whose siblings carry no domain, is mis-homed. Flag it for re-homing in the refinement comment rather than refining it into the wrong place. If no home exists and the work implies one, say so in the refinement comment rather than inventing structure. (Continuous detection of mis-homed children and scope-bled epics across the board is `skill-coordinate` Pass 3; triage applies the same test reactively, one ticket at a time, at refinement.)
- **Harvest linked context.** Read the ticket's linked tickets — blocked-by, blocks, related, and any reference in its body or comments. Where a linked ticket is **Done**, pull its resolved context into this ticket's body (the decision, design, icon, node-id, acceptance detail) so the ticket is self-contained for whoever executes it. A Done ticket's context is a refinement input, not something left stranded on the closed ticket. (Removing satisfied blocker relations stays with `skill-coordinate`; triage only reads and harvests.) **Where the ticket was authored from a source note, go one hop further and read that note's *other* children before leaving this one refined.** The read above covers the ticket's own links, and it stops one relation short of the commonest sibling collision: two delivery tickets cut from one `FRICTION:`/`OPS:` note on different days, each correctly linked to the note and neither linked to the other. Nothing in either ticket's own link set shows the other, so both refine cleanly, both reach Todo, and the queue holds one scope twice. So for a ticket whose body or relations name a source note, fetch **that note's** relation list and check whether a sibling already carries this scope. Where one does and has shipped, mark this ticket a Duplicate candidate **in comment prose** naming the sibling by identifier and route it for sign-off — never by writing `duplicateOf`, which enacts the close rather than proposing it (`convention-linear`, the `duplicateOf` bullet). Where one does and has not shipped, relate the two and note "likely superseded, confirm before build", so the exec leg meets the collision before cutting a branch rather than after. The check costs one `get_issue`; the alternative is paid at claim by a premise check that happened to run first. (Worked case: APP-1270 and APP-1322, both authored from APP-1198 with near-identical Objective/AC/DoD text — APP-1322 reached Todo first and delivered the whole scope across two merged PRs, and APP-1270 was still in the dispatch queue when a `skill-build-ticket` step 3a check found every one of its criteria already satisfied on `main`. Nothing between filing and claim looked at the note's second child. *The repo state, the PR numbers, the commit and the test results are reported from APP-2008 and are unverified here: no repo is readable from this surface.* — APP-2008, 2026-10-03.) **Where the ticket's body or a routing instruction is predicated on a linked ticket's state** ("re-harvest after X lands", "X is still Blocked"), re-fetch that linked ticket's *current* status before acting on the instruction rather than trusting the body's assertion — a hard-coded state goes stale the moment the linked ticket moves (worked case: a re-harvest instruction against a ticket that had already shipped Done, 2026-07-02, APP-422). This is the read-side mirror of the `convention-ticket` authoring rule against hard-coding a linked ticket's state in a body, and the same discipline as judging a blocker by its own status below.
- **A blocker reaching Done is not on its own evidence the dependent is released — read a DECISION blocker's resolution before promoting the work it gated.** A `blockedBy` relation records *that* a decision gated the leaf, never *which way* it went, and Linear's Done state is identical for "yes, cleared" and "no, not yet": a `DECISION:` ticket closed because it was answered as a deferral satisfies every Done test in this file while meaning the exact reverse of what the test reads it as. So where a candidate's blocker is a decision ticket, read its **resolution** — the answering comment, or the decision recorded in its body — and not just its state, before promoting the leaf it gated. Where the answer was a deferral, the dependent **stays in Backlog** and the pass says so in one line naming the deferring decision, rather than routing on the blocker's state alone; the hold is then re-expressed as structure on the dependent — the `Build-start gate: held` line this skill already reads deterministically, a blocked-by on the phase-opening ticket, or a milestone — so the next pass reads a hold rather than a clean board. `convention-ticket` owns the rule and the closing form a deferring decision must take; this is where it is **enforced**, because triage is what promotes Backlog work once its blockers read Done — and the same test applies wherever this skill treats Done as satisfied, including the *Harvest sweep*'s read-the-blocker's-own-status bullet and the *Blocked-state sweep*. This is the promotion-side sibling of the checks triage already carries against a candidate that only *looks* ready — the `agent:R3-LAY`-in-Todo test (does anything ever evict the marker?) and the executor-presence sweep's held-state exception: in each, a field reads correct and means something else, and the fix is to test the thing the field stands for rather than the field. (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, *"DECISION: domain + on-store naming"*, and MBN-252. 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, including MBN-251's own `operator-bara` comment that it *"must not be picked up by the delivery loop yet"* and the Owner's *"do not deploy BARA-forward copy until relaunch"*. Only `skill-build-ticket` step 3a's claim-side premise check stopped the run rebranding a **live storefront** against three standing Owner decisions — one gate later than triage, and the last one before code. APP-1152.)
- **A standing structural-ineligibility flag on the thread gates promotion the way an open blocker does — and it is a *different* test, because it tracks no relation and resolves no Done.** The bullet above tests a blocker's *resolution*; this one tests a hold with no blocker behind it at all. Where a prior pass — a `[coordinate]` comment, an `[exec]` decline, an operator note — has posted a flag naming something **the named executor's surface cannot reach**, that flag is a hold on promotion, and a sweep that reads relations correctly still misses it by construction: `blockedBy` is empty, nothing is Done or not-Done, and every structural eligibility test reads clean. So the promotion does **not** proceed on an executor-presence or refinement-completeness reading alone. Promoting a flagged ticket spends the **claim → discover the missing input → Blocked · Urgent · Aled** cycle that the pre-claim readiness test exists to avoid, and spends it on a gap already named in writing on the thread. The flag is **converted**, never outranked: either re-scope it per the surface-reachability test (`task-cycle-planning` Step 3, APP-2282 — where an agent has already declined an act for want of surface access, *that decline converts the criterion*) into a `human` leaf for the part the lane cannot reach plus a fleet leaf for what the lane can produce; or the ticket **rests held**, with the flag restated in the pass's own one line as the reason it rests. It is never silently outranked by a correct read of a different signal. This is the promotion-side mirror of the *Blocked-state sweep*'s rule that an informal blocker the sweep has identified is one it must stop re-identifying — reached from the side where `blockedBy` does not apply at all, because the blocker is a connector gap, not a ticket. (Worked case: MBN-293, *"TASK: lifecycle flows — welcome, abandoned checkout, post-purchase, review ask"*, `agent:R3-ACH`. A `[coordinate]` comment of 2026-09-23 posted the flag and predicted the outcome in terms — *"Flagging before this is claimed by dispatch: it will get picked up and re-Blocked on the same connector gap unless it's noted or re-routed first."* A `[triage]` comment of 2026-10-05 promoted it Backlog → Todo on a correct read of a *different* signal — fully refined, parent greenlit, executor already present, *"resting in Backlog unrouted was the same class of defect as APP-1791"* — without mentioning the flag standing one comment above it on the same thread. The 2026-10-18 fleet-dispatch run met the flag again and stopped only because it happened to read back through the thread. *Premise flag on the flag itself: it is stated as "no API surface", and the part readable live is narrower — a session's Shopify tool set carries no Email or Flow automation tool, which is read live here, while `graphql_mutation` against the Admin API is an untested route to them, so what is verified is "no dedicated tool surface". APP-1641's wider claim — that marketing automations and Flow are admin-UI-only and the native popup has no Admin API resource — is that note's own read of Shopify's docs and is reported, not re-verified here. MBN-293's comment dates and the 2026-10-18 run's own reads are the filing leg's report.* — APP-2412, APP-1641.)
- **Set the vertical's `operator-<venture>` label at refinement — nothing else in canon ever writes it.** A ticket refined in a vertical's home delivery team carries that vertical's `operator-<venture>` value, read off the team routing table in `convention-linear`. This closes a read with no writer. `skill-operating-loop`'s read recipe reads the vertical's `operator` label **workspace-wide** for both its queue and its scope (Owner ruling, Aled, 2026-09-04, APP-1117), and `convention-linear` *Operator attribution* defines the group and that reading rule — but the only other mention of the label in this file is the *Executor-presence sweep*'s test **for** it as an anomaly exemption, and no artefact obliged setting it. The label is written today only by a delivery-loop hold route, so a vertical's ordinary work never carries it and the operator-routed queue read in each daily stand-up returns empty however busy the board is. **Write it as an `addLabels` add, never as a full `labels` replace.** The `operator` group has no `agent`-group sibling: an operator value evicts nothing and is evicted by nothing, so adding it is safe on its own, where bundling it into a `labels` replace would silently drop the ticket's `type:` or `work:` value. This is routing hygiene, like the `agent`-group repair at the top of the poll — it does not change the ticket's placement, does not gate promotion, and is never a reason to hold a ticket. Backfilling the label on tickets refined before this rule is an operational sweep for the operator, not a triage-pass action. (APP-1217.) **Resolve the vertical from `convention-linear`'s team routing table, which now names an owning operator on every delivery-team row — and note that Apps resolves by project, not by team:** a ticket in the bot.Trader project carries `operator-bottrader`, and everything else in the Apps team carries `operator-apps`. That was the gap the rule shipped with. It cited a table that named an operator on one row of five (MBN), so a refiner working any other team had nothing to read, and the instruction was satisfiable only in the one vertical that least needed it. **The rule works where refinement has since run, and only there.** Workspace-wide reads on 2026-09-11 at 04:23Z: `operator-apps` and `operator-a1` both return rows with `hasNextPage: true`, `operator-bottrader` returns three, and `operator-bara` and `operator-mrp` return **zero** — the two verticals with no ticket through refine since the rule landed. An empty operator read is therefore now evidence about *that vertical's refinement throughput*, not about the mechanism, and the read stays empty until the operational backfill named above runs; the same bare-value call resolving three other labels rules out label or group resolution as the cause. **Do not treat a zero read as a reason to hold, re-triage, or repair a ticket** — it is not an anomaly and there is nothing in the triage pass that answers it. `[pulse-refine]` ruling, 2026-09-11; the *what* it sits inside is the refine-sets-the-label rule this bullet already carries (APP-1217). (APP-1274, APP-1275.)

- **Milestone assignment.** Every refined leaf ticket gets a milestone where the project has them (app.fitness M1–M6, os.Claude M1–M3).
- **Restructure oversized tickets (propose-first).** A Backlog ticket too big for one PR is not refined as-is. Propose an epic + sub-task breakdown in a comment for the operator's approval, and wait — do not create sub-issues in bulk until he approves (the A1-3 pattern, made standard).
- **Where the split is the ticket's own, act and record rather than propose and wait.** The guardrail exists for a restructure that imposes a shape the ticket does not carry; it has no work to do where the proposed breakdown restates verbatim a split the ticket's own Sequencing or Notes section already names, and the only open condition was a named blocker now confirmed Done or Canceled. In that case there is no judgement left to reserve, so create the children, set the relations, and record what was done and which text it came from. Reserve propose-and-wait for a restructure that departs from what the ticket itself specifies. (Owner instruction, 2026-09-12: *"this is exactly the kind of stuff that the operator should pick up and run with — stalling the entire project on something that doesn't really matter."* Worked case: APP-1076's toolkit-build/run-leaf split was proposed verbatim from the ticket's own Sequencing note twice, on 2026-09-04 and 2026-09-07, and sat unanswered in Backlog for five to eight days — APP-1403.)
- **A build leaf demoted into a parent takes an outcome's state, executor and assignee — not its build-leaf ones.** When a decomposition moves a leaf's substance out to new children, the leaf *becomes a parent* — an outcome the operator closes when its children are done, never itself routed to Forge (the poll excludes it as a non-leaf; `convention-linear` *Structure*). So re-dress it as an outcome, not a build item: **strip the build executor** (`agent:F0-RGE`, and any leftover `human` carried from its build-leaf days); **its state tracks its children** — **In Progress** while any child is in flight, **Todo** if none has started — and it is **never left Blocked-with-no-blocker** (removing the now-stale blocked-by that moved to a child would otherwise strand it in a false Blocked that re-surfaces on the Blocked sweep forever); **clear the assignee** unless the parent itself carries a genuine operator decision. (Worked case: A1-281 — Blocked + `human` + assigned, its real blocker moved to child A1-351 — was moved to In Progress with the assignee cleared but left carrying `human` on a guess; this states the demotion explicitly, APP-921.)
- **Read the operator's build-start gate deterministically.** `convention-ticket` defines a fixed body-line marker, `Build-start gate:`, for a leaf whose build the operator wants held under his own signal. Match it as an **exact line, never an inference from surrounding prose**: a `Build-start gate: held` line (any hold value) means the leaf is **held for his go** — do not route it to a builder however clean it otherwise reads, leave it parked, and where it is otherwise ready surface it to him once as awaiting his build-start signal (placement 4). A `Build-start gate: route` line, a cleared value, or no marker at all means there is no such hold and the leaf is placed on its merits per the four placements below. Held-leaf versus route-me-leaf is a deterministic discriminator read off the marker, not a judgement call. (APP-792.)
- **Resting state — the four placements.** A refined leaf rests in exactly one of four states, chosen by the nature of its outstanding gap. This is the canon binding of the placement model in `convention-ticket`.

  **The state names below are the engineering set — translate them per team, don't improvise.** Not every team has `Refinement` or `Blocked`: Mr Pritchard runs an editorial workflow where the equivalents are **`Defined`** (refined-and-parked, i.e. placements 3 and 4) and **`In Review`** (where another team would use Blocked), with `Published` / `Scheduled` for done. The mapping is canon in `convention-linear` *Issue states* — read it rather than picking the closest-looking state, because the same evidence has produced two defensible answers on the same run. **And check the write landed:** `save_issue(state: …)` naming a state a team does not have returns **HTTP success with nothing changed** — no error, no warning — so a run that trusts its own write reports a ticket parked in Refinement while it sits in Backlog re-surfacing on every poll. Read the state back after any placement write. (Worked case: MRP-21, MRP-23, 2026-07-20 — APP-620.) **A ticket in a cycle cannot take placements 3 or 4 as written** — both are backlog-type states, and moving a cycle ticket there drops its cycle; it takes the Todo-resident forms in the *Executor-presence sweep* instead (APP-1581).

  1. **Clean — nothing outstanding.** → **Todo** + executor (`agent:F0-RGE`), assignee cleared. Relay auto-promotes; there is no separate manual Todo gate.
  2. **Sequencing dependency — spec complete, only ordering outstanding.** → **Todo** + executor + blocked-by relation. The builder self-skips while the blocker stands and picks it up when it clears.
  3. **Harvest dependency — spec determined by the blocker's output** (the design→build case). → **Refinement under `agent:R3-LAY`** (the triage marker, never an agent executor). Relay re-checks it each pass and harvests the blocker's output into the leaf's body when the source completes, then promotes it (see *Harvest sweep* below).
  4. **Needs operator input.** → **Refinement under `human`**, assigned to the operator with an @mention leading the specific decision needed. This is where a **decision-gated leaf in an active/greenlit epic** belongs — see the *Skip genuinely-not-ready Backlog leaves* exclusion above: a leaf whose only gap is an operator decision, under an epic already in flight, is refined to here, not skipped and not left in Backlog.


  - **Placements 3 and 4 are unavailable to a ticket that is in a cycle — repair it in place at Todo instead.** Both rest the leaf in a **backlog-type** state, and Linear drops cycle membership in any backlog-type state, so taking either placement silently undoes the Owner's commit rather than parking the leaf. A ticket carrying a cycle therefore takes the **Todo-resident forms** of these two placements, set out in the *Executor-presence sweep* — read them there rather than re-deriving them here, and do not take the ticket out of the cycle to make a placement fit, because amending the commit is not triage's write. (The governing sentence is in this section's preamble above; this is the same rule stated where a reader looking up a placement actually lands. APP-1581.)
  - **A state move that changes no routing is not a disposition — say what it waits on, or take placement 4.** A poll may legitimately move a leaf out of `Backlog` into the team's second backlog-type state (`Refinement`, or `Defined` on Mr Pritchard) while keeping `agent:R3-LAY`: that is placement 3, and it is right where the spec genuinely awaits a named blocker's output. It is **not** right where the outstanding gap is a question for the operator — what a capture becomes, piece or note — which is placement 4 and takes `human` plus an assignee. Either way the move is indistinguishable downstream from a bare poll-and-leave: `updatedAt` advances and a comment lands, so the daily stand-up's carry read and `convention-linear`'s age ladder both read a touch while the substantive question has not moved, and the leaf climbs Low → Urgent with no disposition to show for it. So a state move that does not evict `R3-LAY` carries a **disposition comment naming the condition it waits on and who owns the wait** — the shape the `[pm-triage]` "for harvest / for qualify" comments already take — and a move with no such comment is not counted as having triaged the ticket for the ladder's purposes. (Worked case: MRP-57 and MRP-58, Mr Pritchard captures, climbed Low 25 Sep → Medium 30 Sep → High 2 Oct → Urgent 5 Oct with zero substantive comments on their own question, and a `[pm-triage]` Backlog poll on 2026-10-06 moved them and MRP-59 Backlog → Defined with `R3-LAY` left in place; that day's `mrp.standup` routed MRP-57/58 to `agent:R3-ACH` by hand to break the stall. Same family as APP-593 / APP-452 / APP-701 / APP-731 on a population none of them covered — plain `capture`-type leaves with no epic or feature wrapper — APP-2081.)
  - **Fifth outcome — Relay's own PM work is done here, not placed.** The four placements above all route work to *someone else*. A poll hit whose deliverable is Relay's own PM work — a `DECOMPOSE:` of a landed leg into build leaves, a `RECONCILE:` of a board against a decision or a pause, a relation or parent restructure, a bulk state correction the operator has instructed — has no one to be routed to: Relay is the executor. Nothing else in the scheduled layer runs it (`routine-delivery-loop` scans `F0-RGE` only; `skill-fleet-dispatch` names `R3-LAY`-in-Todo an anomaly and hands it back to triage; `task-coordinate` coordinates other tickets). So triage **executes it in this pass** — does the decomposition, the reconciliation, the relation fixes — then closes the ticket (Done, with the outcome recorded) or moves it to the state its remaining steps warrant (Blocked behind a named prerequisite, or Refinement + `human` where a step needs the operator), in the same run. It is never routed onward and never left resting in Todo under `R3-LAY`, so `convention-linear`'s "not a resting executor" rule holds: the marker is evicted by the work being done. Bound it as the operator's instruction bounds it: reversible state, label and relation writes; never Cancel or delete on Relay's own judgement — **with one carved-out exception, and only on the Owner's grant**: the satisfied-or-superseded close that *Lane staleness* below names, where every open box on a `human` Owner-lane row is fleet-shaped, none of the four human faculties is present, and the residual is already satisfied or wholly superseded. That close is irreversible and it is permitted anyway, because the Owner granted it in the canon-decisions session of 2026-10-20 — so it is **not Relay's own judgement, which is what this bound forbids**. The bound is otherwise untouched: outside that one named test a Cancel, a Duplicate, a delete or any other irreversible disposition still waits for the operator or the Owner (APP-2351). Where a step is explicitly deferred behind another ticket, do the steps that are clear and say which are deferred and behind what. Where `skill-coordinate`'s Pass 1 has already executed an operator-authorised write on the same ticket (its confirmation comment is on the thread), close rather than repeat. (Worked cases: A1-340, Urgent, Todo + `R3-LAY` from 2026-08-14, step 1 unblocked and Owner-input-free from 2026-08-18, unrun for two weeks while a1.Muse reported red; A1-371, High, filed 2026-08-22 by the same route; A1-339, executed on 2026-08-15 by judgement with no rule saying so — APP-1050.)
  - **A fifth-outcome deliverable that exceeds a reversible board-op is surfaced, not executed inline — and never pushed to the Owner for want of a runner.** The rule above bounds inline execution to reversible state, label and relation writes. Where the deliverable is Relay's own by its body but is **substantial or risk-bearing** — a security-sensitive host runbook, a credential-handling procedure, a synthesis of several tickets' host steps into one ordered document — inline execution inside a triage pass is the wrong container; and placement 4 is the wrong answer too, because the work is Relay's rather than the Owner's and routing it to him only stalls it. **File it as a dedicated Relay authoring pass:** a ticket in **Todo routed to** `agent:R3-LAY` with the deliverable named in the title and its `## Acceptance criteria` and `## Definition of done` written, so a Relay run picks it up as its own piece of work rather than as a board-op inside somebody else's triage. Leave one comment on the originating ticket naming what was filed and why it exceeded the inline bound. **The converse also holds: a documentation or record-keeping write to a Linear document *is* a reversible board-op, and triage executes it inline** — a `LOG:`-style write of an already-settled decision has settled content, a named destination and nothing to author, so it needs neither a runner nor the Owner. Do it in the pass and close the ticket. Where the content is **not** already settled it is not a record-keeping write and this does not apply; refine it and place it on its merits. (Worked cases: A1-367, *"LOG: record the D009 outcome in* `log.meirion-decisions`*"*, a fully-drafted Linear-document write pushed to placement 4 for want of a runner; and APP-982, *"sequence the four open host-lane items into one ordered runbook"*, Relay-owned by its own body but security-sensitive per `convention-host-access` / `convention-secrets`, stalled about three and a half weeks at High while blocking Urgent host items — 2026-09-03, APP-1107.)
  - **The line between an inline fifth outcome and an operational sweep is scale, not only reversibility — a named-ticket decision is executed, an open-ended N-ticket mechanical sweep is declined.** The two bounds above are **reversibility** and **risk**, and neither separates the two shapes that actually arrive. Both are `TRIAGE:`-titled asks raised by the same `operator-*` loop, both carry `agent:R3-LAY`, and canon's only worked example on the decline side is one specific case — the `operator-<venture>` label backfill named in *Set the vertical's* `operator-<venture>` *label at refinement*. A bulk label backfill is perfectly reversible and carries no risk, so the reversibility bound on its own reads it as executable, and the decline survives only as an analogy to that one example. The missing test is **scope shape**, and it is **not a ticket count**: a named set of twenty is still one decision, and a shape of three is still a query nobody verified. A deliverable that **names its tickets** and turns on **one judgement** — read these two, decide, label them, raise the mismatch — is Relay's own PM work: execute it in the pass, per the rule above. A deliverable defined by **a shape to match across a board or several verticals** — "every open ticket in Luna, app.fitness, …" — where the count is whatever the query returns and no judgement recurs per ticket, is an **operational sweep for the operator**: comment the decline naming this test, leave the ticket untouched, and do not part-execute it. The reason is accountability rather than effort — a sweep's correctness is a property of its query, and a triage pass has no budget to verify a query it did not write, so a half-run sweep is worse than none. Where an ask is genuinely both, a bounded named set *and* a shape: do the named set, name the residue by ID in the comment, and say plainly that the shape is the operator's. (Worked cases, one run, 2026-09-24: APP-1427, two named cOS.Build tickets to read, decide, label `operator-apps` and raise a Hold-versus-in-flight mismatch on — executed inline and closed Done, the whole four-item ask complete; and APP-1530, a bulk `operator-apps` backfill across four verticals, 20-plus tickets reachable only by shape — declined with a comment and left untouched. Both calls were correct and both were derived from scratch against one analogy, which is the cost this test removes — APP-1710.)
  - **Invariant: an agent executor never rests in Refinement — with a dormant-project carve-out.** Refinement holds only `agent:R3-LAY` (a harvest leaf awaiting its source) or `human` (a leaf awaiting the operator). A leaf carrying `agent:F0-RGE` parked in Refinement is a **blind spot** — the triage poll scans `R3-LAY`, the delivery loop scans Todo, so neither picks it up and it stalls silently (worked case: A1-49/50/51/53, four refined F0-RGE build leaves parked in Refinement for two weeks, invisible to both, 2026-06-30, APP-400). But two different states share this shape, and only one is the blind spot the invariant corrects:
    1. **Stranded ready leaf in an active flow** — a refined, genuinely-ready leaf in a project that is **in flight** (has Todo / In Progress / Done siblings), left in Refinement by oversight. This *is* the blind spot: correct it to placement 1 or 2 (Todo, or Todo + blocked-by) — the mirror of `R3-LAY` lingering in Todo.
    2. **Pre-labelled leaf in a dormant, un-greenlit project** — a leaf whose `agent:F0-RGE` was set at *creation* (the pre-assign anti-pattern in `convention-linear` *Backlog default*, which skips the `R3-LAY` triage gate), sitting in a project with **no active siblings** (zero Todo / In Progress / Done) that the operator has not greenlit. This is **not** ready to build, and correcting it to Todo would hand an entire un-greenlit backlog to the delivery loop — a large, consequential mutation nobody requested. Do **not** auto-promote it. The correcting move is to take it off the delivery-loop's Todo path — relabel it off `F0-RGE` to `agent:R3-LAY` (routing, not content, like the executor-hygiene relabel) so it no longer reads as build-ready — but where this affects a whole dormant backlog (dozens of leaves), **surface the project to the operator** with the recommendation (greenlight, or relabel off `F0-RGE` until greenlit) rather than bulk-relabelling unprompted, since a large mutation across an un-greenlit project is consequential. (Worked case: ~25 Luna MVP leaves plus later-milestone app.fitness and cOS.Build video-iteration-2 leaves, all pre-labelled `F0-RGE` in Refinement with no active siblings, where a literal invariant would have moved ~25 tickets to Todo — 2026-07-04, APP-435.)
    The test that separates the two is **active siblings**: a leaf in a project with work already in flight is a stranded ready leaf (correct to Todo); a leaf in a project with none is a dormant pre-label (relabel off `F0-RGE`, don't promote, surface the project). `agent:R3-LAY` is itself a legitimate resting label in Backlog / Refinement / In Review, not triage-only.
- **Assignee discipline.** Assign the operator at refinement **only** when the ticket rests under `human` (placement 4) with a genuine question or decision for him; placements 1–3 park **unassigned**. When routing a Todo ticket to Forge, clear the assignee. Any comment that assigns the operator must @mention him (`@aledpritchard`) and lead with the specific action or decision needed, and where it hands him steps to run, format them as novice-friendly numbered actions (see `convention-ticket` *Writing an instruction the operator has to action*).

## Refinement comment sweep

Refinement is the operator's lane and is **read-only** to the pm leg for ticket *content* — never re-refine, or rewrite the title or body of, a Refinement ticket — with three narrow exceptions:

1. **Operator comment since the last pm/agent comment.** For tickets where the operator has commented since the last pm/agent comment, process his comments as trusted instructions (steps below). **And test the comment's content, not only its presence — a field-only stamp discharges nothing (APP-2670).** This exception exists because the operator has *said something*, and it is written as though any comment of his were that. A system-authored stamp recording a field write — `"From Aled's Triage session: estimate set to N (Xm) — later, [tag]"`, a priority auto-set, a label note — is authored under his name and in his session, bumps `updatedAt`, and sorts as the latest operator comment, while carrying no instruction, no answer and no decision. Read literally, it satisfies this exception on its face, and nothing in the wording distinguishes it from an accept: a pass can promote a ticket or treat an open question as answered on the strength of a comment that answered nothing. So the test is **decision prose** — the comment must say something a pass could act on: an instruction, a ruling, an accept or reject of a quoted recommendation, a scope change, or an answer to the question the ticket carries. Where the latest operator comment is a field-only stamp, **this exception does not fire**: the ticket is left exactly as it stands, the earlier pm/agent comment remains the last substantive turn, and the ticket stays in the population for a later fire rather than being counted as reacted-to. Report it as a stamp rather than as a processed exception, so the sweep's own counts stay honest and the cursor does not record a row as checked-and-answered when it was checked and found silent. Where the operator both sets a field *and* says something, the prose is the comment and this exception fires on it normally — the test is the absence of decision content, not the presence of a field write. (Worked case: the 2026-10-26 fire found the same `"estimate set to N (Xm) — later, [tag]"` shape on 15+ tickets across Apps, A1, MBN and Mr Pritchard, every one stamped inside the four minutes 18:10–18:14Z on 2026-10-19 — one sizing sitting, not 15 replies. That run told them apart from genuine quoted-recommendation accepts and left the stamp-only rows untouched, which was right and was written down nowhere — APP-2670.)
2. **Executor-hygiene relabel.** A clearly human-owned Refinement ticket still carrying `agent:R3-LAY` — a pre-convention leftover, parked under a standing agent comment for the operator (e.g. a real-device verify, a credential setup, a recruit-testers task) — may have its `agent`-group value set to **`human`** and be assigned to the operator. This changes *routing, not content*, so it is not a re-refinement: it drops the ticket from the `R3-LAY` triage poll, matching convention-linear's rule that refined human-owned work carries `human` precisely so it leaves the poll. Setting `human` here is the documented hygiene action, not a consequential call — no hold and no new operator comment is required. Leave the ticket's title, body, and standing comment untouched, and skip the comment-idempotency re-read on a ticket once it has been migrated (it no longer matches the poll). This is the sanctioned migration path for tickets parked in Refinement under the old label before the `human`-value convention existed.

3. **Human-owned, operator-assigned, zero comments — write the missing placement-4 ask.** A Refinement (or `Defined`) ticket carrying `agent`-group `human`, assigned to the operator, and holding **no comment at all** has no operator comment to process and no stale comment to leave alone: the *Assignee discipline* obligation it should have been parked under — an @mention of him leading the specific decision needed — was never discharged, so there is nothing on the ticket for the daily stand-up or `task-daily-report`'s "your move" read to act on. Exception (1) cannot reach it, because there is nothing to react to, and exception (2) only moves a label, so the population accumulates unrepaired behind a rule written solely for the moment of parking. Write the comment: `@aledpritchard`, the decision needed stated from the ticket's **own title and body** and from any sibling in the same batch that *does* carry the ask, and — where the title will not yield one — the explicit question of what reply would resolve it. This writes a **comment only, never the title or body**, so Refinement's read-only-to-content rule is untouched and no hold is required. **And test the whole batch, not the member that surfaced:** a zero-comment assigned ticket is a batch-creation defect in the same shape as the missing `agent`-group value the *Trigger* section repairs, so read the parent's children (or the tickets filed in the same sitting), test the comment field across all of them, repair as many as the five-per-team bound allows, and **name the unrepaired remainder by ID** in the run's report. (Worked case: five tickets — A1-348 plus MBN-238, MBN-239, MBN-240 and MBN-242 — read by the 2026-10-09 Refinement-comment sweep, all `human`, all assigned to the operator, all with zero comments, while their batch sibling MBN-241 carried its ask from 2026-07-13. Same class as MRP-23's fleet series and the A1-294 collation, on the comment field rather than the label or the AC/DoD sections. APP-2195.)

For exception (1), process his comments as trusted instructions:

- Apply his answers to the ticket — **title and body**. Where the answer resolves a placeholder carried in the title (e.g. `(purpose + icon)`), rename the title to reflect it. Don't echo back a question whose answer is already on the ticket.
- Reply confirming what changed.
- Promote to Todo when he says it is ready (routing to Forge where execution is needed, per the rule above). **Where the refinement comment named more than one distinct open call, promote only when each one has a traceable answer.** A refinement comment routinely lists several — a *definition* call and a *shape/executor* call, say — and an operator decision can close one in full and the other only in part, while the label move that follows (`human` → a build executor) reads identically either way and the ticket's state carries no signal that part of the original ambiguity survived. So before promoting, re-read the refinement comment that named the calls, **enumerate them, and match each to a resolution in the thread**; **a call answered only in part is an unanswered call** — "the query is now a build job" settles the lane and does not name the repo the build job targets, and a half-answer is exactly the shape that survives a skim. Where any call is unanswered, **leave the ticket in Refinement under `human`**, assigned to the operator, and comment naming the open call verbatim rather than restating the set. The check is cheap at this step and expensive nowhere else: the cost of skipping it lands on the next executor, which claims, investigates the ticket, its full comment history, its siblings, `convention-github`'s repo table and the owning project docs from scratch, and then Blocks it straight back. (Worked case: APP-609 — a 2026-09-03 refinement comment named two calls (the clean-pass definition, and "shape/executor — a repo script (Forge), a Cowork Linear-analytics task, or a change to a skill"). The 2026-09-07 decision resolved the first in full and the second only in part, ruling the work a build job without naming a repo, and moved the executor `human` → `R3-LAY`. The ticket re-entered Todo + `F0-RGE` twice — on the 2026-09-07 refinement exit and again on 2026-10-03's pm-triage pass — before an exec leg on 2026-10-03 investigated from scratch, found no repo named anywhere, and Blocked it back to `human`, on an Urgent ticket already stalled since 2026-07-20 — APP-2006.)
- Clear the assignee once the ask is resolved.

Never re-refine a Refinement ticket's content without a new operator comment; the executor-hygiene relabel in exception (2) is the only routing change permitted without one. A **harvest** of a completed blocker's output into a parked harvest-dependent leaf (below) is likewise a permitted content change without a new operator comment — it applies the source ticket's resolved output, not a fresh refinement of the leaf.

## Harvest sweep

Placement 3 (harvest dependency) parks a leaf in Refinement under `agent:R3-LAY` because its spec does not yet exist — it is determined by a blocker's output. Each run, re-check these parked harvest leaves and complete them when their source resolves.

**Run the harvest and blocked sweeps before comment-idempotency silencing** (see the guardrail). A blocker completing since the last comment is a material change, so the sweep must re-evaluate the leaf before any "nothing changed, stay silent" test runs — otherwise a standing Relay comment silences the very run that should harvest and promote (worked case: A1-108 / A1-109 left parked though both blockers — A1-106 Mux env, A1-107 the placement decision — had gone Done minutes earlier, 2026-07-01, APP-408). The harvest is self-terminating — it routes the leaf to Todo + F0-RGE and out of the poll — so there is no re-fire risk in running it first.

For each `agent:R3-LAY` leaf carrying a harvest dependency in **Backlog or Refinement** — both halves, read in the same pass:

- **A leaf found in Backlog with a formal `blockedBy` is mis-parked, and this sweep returns it to Refinement in the same pass.** Placement 3's resting state is Refinement (the four placements below), so a leaf correctly labelled `agent:R3-LAY` and correctly carrying the blocker relation but sitting in bare Backlog is one state short of where its own placement puts it. Move it Backlog → **Refinement** here, with **no content change**, and comment **one line** naming the placement and the move — that line is the trace, and it is what makes the repair readable instead of silent. The scope used to be Refinement alone, which is why this never fired: whatever sets the label and the relation — first refinement, or the Executor-presence sweep's repair bouncing a non-executor leaf out of Todo — does not also set the state, **and no other mechanism re-asserts it.** The Backlog poll is not that mechanism: it is capped per team and rotated by ISO ordinal day (the rotation rule above), so a leaf on an off-rotation team waits for its turn while the same gap goes unseen on the other three teams. Reading both halves here is what closes it, because this sweep is unconditional and self-terminating. **Except a leaf carrying a cycle** (`cycleId` set): a backlog-type state drops cycle membership and Refinement is backlog-type, so the move would silently undo the Owner's commit — such a leaf takes the **Todo-resident form** the Executor-presence sweep already prescribes, left in Todo under `agent:R3-LAY` with one line naming why, and is not moved here. (Four worked instances across two dates and two mechanisms, **reported** by the filing run and not re-derived from the ticket surface here: `MBN-251` and `MBN-271`, both 2026-10-23, fully refined and resting in bare Backlog, each moved to Refinement with no content change and a one-line `[triage]` trace; `MBN-285`, correctly placed with a `blockedBy` on `MBN-308` on 2026-09-26 and promoted to Todo the same day, then pulled out of Todo by an Executor-presence-sweep repair on 2026-10-31 that landed it back in **Backlog, not Refinement** — the repair fixed the wrong half of the state; and `MBN-290`, found in Backlog on 2026-11-06 already carrying `agent:R3-LAY` and a live `blockedBy` on `MBN-321`, moved to Refinement in that run. That run reached them only because MBN drew the full rotation and the other three teams were capped at five rows, which is the capped-and-rotated poll failing as a re-assertion mechanism rather than succeeding as one — `APP-2908`.)

- **Is the source blocker done? Read the blocker's own status, never the relation.** The connector does not expose Linear's derived active/resolved flag: a `blockedBy` array keeps listing a blocker after it completes and auto-resolves (the activity feed's "no longer blocked by …" is derived, not a change to the relation record), and the relation payload carries only `{id, title}` — no `resolved` / `active` field (verified across A1-108, A1-109, COS-236, A1-15, 2026-07-01, APP-408). So for each blocked-by id, fetch that blocker's status and treat **Done / Canceled / Duplicate** as satisfied. Do **not** wait for the relation to disappear — it never does on its own; the record persists until explicitly deleted — and do **not** read block-satisfied off the relation payload, where no flag exists. This costs one `get_issue` per blocker until the connector carries the flag; the connector-side ask is named in `convention-linear` *Reading Linear safely*. If the blocker is not done, leave the leaf parked — a blocker merely reaching a done state is the *cue* to harvest, not the completion itself.
- **Harvest the output into the leaf's body.** Lift the blocker's resolved output into the leaf so it becomes a self-contained Pattern A brief the builder can run headless. For a design→build dependency this means the Figma node-id, the reference asset/SVG, the states, and the interaction/motion spec are written into the build leaf's `## Acceptance criteria` and body — not a bare "matches the locked design" with nothing to build against. (Worked example: a build leaf carrying a "Locked design (harvested from …)" block with the node-id, SVG, and hover spec is buildable; one carrying only an icon *name* is not — unless the icon renders from the CMS, see the DoD note below.)
- **Then route to Todo + executor** (placement 1 or 2), assignee cleared. Harvest-then-promote is a single triage action.

**Design definition-of-done — a producing leaf isn't done until its output exists to harvest, *unless the build renders it from the CMS*.** A design (or other producing) leaf marked done on an artefact *name* alone — no node-id, no asset/SVG, no states, no interaction spec, no resolved purpose/destination — has nothing harvestable, so its dependent build children cannot proceed regardless of state, and the "done" is misleading. When refining or reviewing a producing leaf, require its DoD to name node-id + asset + states + interaction spec + resolved purpose before it can be closed. Two failure modes this guards against: (1) the design goes done but nobody lifts its spec into the build child (harvest never triggered — this sweep is the trigger); (2) the design is closed with no real output (nothing to harvest).

**But distinguish a bespoke-spec build leaf from a CMS-rendered one before bouncing on "only a name".** The DoD above applies to build leaves carrying a *bespoke* design — custom motion, exact states, a hand-drawn asset — where the name without the spec is genuinely un-buildable. It does **not** apply to a build leaf that renders an icon purely from the CMS (`item.icon`) with standard interaction and an established sibling build pattern: there the icon *name* plus the sibling pattern is a complete brief, and no hardcoded node-id/SVG exists to harvest by design (the schema decision made icons CMS SVG uploads). Bouncing such a leaf as "un-harvestable" is a false negative — it forced repeated Todo→Refinement bounces and operator intervention on three CMS-rendered nav-icon builds whose only bespoke sibling carried the motion spec (A1-50 / A1-51 / A1-53 vs the m-wave A1-49, 2026-07-01, APP-406). So before bouncing a build leaf for a name-only design source, ask whether the build needs a bespoke spec at all: if it renders from the CMS with standard interaction and a sibling pattern to follow, it is buildable — route it to Todo, do not bounce it.

## Blocked-state sweep

Blocked is otherwise a silent gap: a blocker that has since cleared (PR merged, dependency Done, relation cancelled) leaves the dependent stranded until the operator notices by hand. Each run sweeps it.

Scope: tickets in **Blocked** carrying **any** `agent:*` label **except `agent:PUL-5E`** (not only R3-LAY). In Progress and In Review are left untouched.

**Bound the sweep — at most five Blocked rows per delivery team per fire, longest-blocked first, remainder named.** The Backlog poll carries an explicit five-per-team cap; this sweep carries none, and at current population a full-depth pass — one `get_issue(includeRelations)` per row, plus a `list_comments` read on every row with no formal blocker to find its stated reason — consumes the large majority of a fire's budget. Under the precedence order in *Trigger* that does not merely run late: it **structurally starves items 3 and 4 every time one team's Blocked list is large**, because both sit behind it. So work at most **five Blocked rows per delivery team per fire**, ordered by how long each has sat in Blocked, and **name the unreached rows by ID** in the run report so the next fire works a known list instead of rediscovering the population. A row the fire opens is finished within that fire — never left half-assessed — so the cap bounds how many rows are opened, not how deeply one is read. (Worked cases: the first migration-pilot fire, 2026-09-15, APP-1526; the fifteenth, 2026-10-04, where the Refinement comment sweep was not run at population scale, APP-2020; and the seventeenth, 2026-10-06, which analysed 21 Blocked candidates end to end across Apps / A1 / MBN for one genuine action and reached neither the Refinement sweep nor three teams' Backlog polls — APP-2077.)

**Why `PUL-5E` is excluded, explicitly.** `PUL-5E` is an `agent`-group value, so an "any `agent:*`" scope silently swallows the entire Pulse friction queue whenever those notes rest in Blocked — which is exactly where `skill-ops-retro`'s drain parks a surfaced one. Those notes are canon-improvement intake: `convention-linear` is explicit that a ticket carrying `agent:PUL-5E` *"is propose-only intake, not a build candidate"*, and this skill's own guardrail is to spot, capture, and stop. So the sweep would read them, be forbidden to act, find no terminating action, and read them again next run — the same unbounded re-surfacing class as the human-owned `R3-LAY` re-reads (APP-304 / APP-391) and the closed-ticket poll overflow (APP-401), each of which got a scope fix. This one is the Blocked sweep's version of that fix. A Pulse note in Blocked is **Aled's signal, not triage's queue**: it reaches him through `task-daily-report`'s os.Claude canon sweep and returns to the next Pulse drain on its own. Triage neither reads it nor comments on it. (Worked case: 6 of 9 live Blocked tickets on Apps were `PUL-5E` notes the sweep could only look at, while the three genuinely actionable ones — A1-199, APP-484, APP-472 — sat among them, 2026-07-15, APP-552.)

For each such ticket, read its blocked-by relations and judge whether each blocker is resolved (Done / merged / Canceled / Duplicate). As in the harvest sweep, judge resolution by the **blocker's own status**, not by the relation's presence or absence — the connector keeps a satisfied block in the `blockedBy` array with no resolved flag, so a live block and an auto-resolved one look identical until you fetch the blocker (APP-408):

- **Stale-relation cleanup (autonomous).** Where a blocker was **Canceled** or marked **Duplicate**, actively remove that blocked-by relation and note the removal in a comment. This is one of the sweep's **two** autonomous mutations, and both are relation-graph writes that leave state, labels, priority and assignee untouched: this one removes a hold that has ended, and the *Informal-blocker check*'s formalisation below records one that has not. Everything else this sweep finds is **surfaced, never executed** — the unblock policy's recommendations, the priority bump and the @mention all wait on the operator. The division is deliberate: a relation write makes the graph agree with a hold the board already shows, where a state write moves work, and only the second needs a human behind it.
- **All blockers cleared → surface, never auto-route.** Do not silently move the ticket onward — auto-routing a cleared ticket straight to Forge + Todo risks an unblock→route→re-block loop. Instead post a comment @mentioning the operator (`@aledpritchard`) with the recommended next move, assign him, and set priority **Urgent**. Only after he agrees does the *next* Relay run execute the move.
- **Still genuinely blocked → leave in place.** Optionally note any stale or invalid blocker relation, but do not move it.

**Informal-blocker check.** The bullets above judge resolution by **formal blocked-by relations**. But a ticket is just as often parked in Blocked by an **informal blocker** — a precondition stated in a comment that no relation tracks (e.g. an `[exec]` note "blocked — canon content not attached", or "waiting on the operator's decision"). These are the silent ones: nothing in the relation graph changes when they clear, so the sweep must read the thread. For each Blocked ticket, alongside its relations:

- **Identify the blocking comment.** Take the most recent agent / exec / Relay comment that explains why the ticket sits in Blocked, and extract its stated precondition(s): a missing attachment or file, body content that must be present before execution, or a decision/answer awaited from the operator.
- **Test against current state, not the state when the comment was written.** Are the named attachments now present? Has the description been edited to include the missing content? Has the operator commented an answer since? A change to `updatedAt` or the attachment count *after* the blocking comment is the cue to re-read.
- **All preconditions satisfied → surface, never auto-route** — same handling as a cleared formal blocker: comment @mentioning the operator (`@aledpritchard`) with the recommended next move, assign him, set priority **Urgent**, hold in Blocked until he confirms.
- **Still outstanding → leave in place**, optionally noting in one line exactly what is still missing so the thread stays current. **And where the outstanding blocker *is* a Linear ticket, write the formal `blockedBy` relation before moving on — an informal blocker the sweep has identified is one it must stop re-identifying.** The bullets above read the thread because nothing in the relation graph changes when an informal blocker clears; the cost nobody named is that nothing in the graph changes when one is *found*, either. So every reader downstream of this sweep that queries relations rather than prose — `routine-delivery-loop`'s phase-2 eligibility scan, `skill-coordinate`'s dependency pass, the harvest sweep's blocker read — walks straight past a hold this sweep has already established, and the next fire pays the same thread-read to reach the same answer. The conversion is bounded and mechanical: it applies **only** where the precondition names, or resolves unambiguously to, **an identified open Linear ticket** — not to an awaited Owner answer, an unattached file, a credential, or a repo state, each of which has no ticket to point at and stays prose. Write the relation, comment one line naming the comment it was read from and the ticket it now points to, and change **nothing else** — not the state, not the labels, not the priority. This is **recording a hold that already exists**, the direction-of-error twin of the stale-relation cleanup above: cleanup removes a hold that has ended, this records one that has not, and both make the graph agree with the board rather than moving work. Where the prose names a blocker that **cannot** be resolved to a ticket, say so in the same one line — "informal blocker, no ticket identified: <precondition>" — so the next fire inherits the attempt rather than repeating it. (Worked cases: `APP-1226`, Blocked since 2026-09-10 with `blockedBy: []` and `operator-a1`/Urgent, and `A1-545`, Blocked since 2026-09-26 with `blockedBy: []` after cycling Todo↔In Progress↔In Review↔Blocked twice — both read by the Blocked sweep on 2026-10-03 and neither formalised; the 2026-10-04 fire then **identified** A1-545's hold as the same 2026-09-29 evening-session uncertainty carried by `A1-564`, a live ticket it had moved to Refinement + `human` in the same pass, and still left the graph empty because no rule permitted the write. Sixteen runs of the same root — APP-976, APP-1712, APP-1943, APP-1997, APP-2020.)

**Lane staleness — a `human` Blocked row whose residual is wholly the fleet's.** The bullets above judge the *blocker*; nothing yet judges the *lane*. A lane is set once at refinement or at routing and nothing re-tests it when the **remaining** work changes shape: a publish or cutover leaf legitimately carries `human` while it awaits a sign-off, and once Forge has committed, pushed and opened the PR the residual is a CI re-run and a review — the label is simply stale, and a stale `human` reads as the Owner's to every pass at once, so the sweeps see the row and none of them owns it. So on each Blocked row this sweep opens that carries `human`, read its unticked acceptance / Definition-of-done boxes — already in hand from the informal-blocker and freshness reads, so no extra fetch — and test them for a human faculty: a credential, eyes on a rendered surface, an irreversible or public act, or money. Where every open box is fleet-shaped and not one of those four is present, report the row as a **lane finding**: one comment @mentioning the operator (`@aledpritchard`) naming the unticked boxes, the fleet value that owns the residual, and how long the row has sat in Blocked, at priority **Urgent**. **The grant now exists: where the residual is already satisfied or wholly superseded, close it.** Until 2026-10-20 this rule stopped at the finding — surface it, do not re-lane it here, whether triage may take it being the Owner's to grant. He has granted it. Where **every** open acceptance / Definition-of-done box on a `human` Owner-lane row is fleet-shaped and **not one** of the four human faculties is present — a credential, eyes on a rendered surface, an irreversible or public act, money — **and** the residual is **already satisfied or wholly superseded**, **triage or the vertical's operator may close the row**, recording the evidence in the closing comment: which boxes stood open, what satisfied or superseded each of them, and the read that established it. **The four-faculty test is the gate and is unchanged** — a row that fails it is surfaced exactly as before, at Urgent, and the surfacing route is not retired. Nor is the satisfied-or-superseded limb optional: a fleet-shaped residual that is still genuinely outstanding is **re-laned or surfaced, never closed**, because the grant is to retire work already done, not to dispose of work nobody has run. A close taken under this test is **not on Relay's own judgement but on the Owner's grant**, which is what carries it past the reversible-writes bound in *Fifth outcome* above; that bound's carve-out names this test and nothing wider. A lane finding remains **its own standing recommendation** for comment idempotency, distinct from any blocker-cleared recommendation already on the thread, so an existing surface comment about a blocker does not silence it. The `human` + Owner lane stays reserved for the same four and nothing else — **hard anchors, human-faculties facts, canon saves and reserved rulings** — the identical set `convention-ticket` *Refined, parked for the operator* states on the refinement side, so the two artefacts carry one reserved set rather than two that drift. (Owner ruling, canon-decisions session 2026-10-20, APP-2351: *"yes — triage or the vertical operator may close a satisfied Owner-lane residual. `human` plus the Owner stays reserved for hard anchors, human-faculties facts, canon saves and reserved rulings."* Its sibling APP-2352 lands the same reserved set in `convention-ticket`. The 2026-10-14 remark the grant was asked against — that it was "too obvious what needs doing" — confirms surfacing **and** grants the close; it had been read as confirming only the first, which is why APP-1378 sat named-but-unclosed across three consecutive runs.) A lane finding is **its own standing recommendation** for comment idempotency, distinct from any blocker-cleared recommendation already on the thread, so an existing surface comment about a blocker does not silence it. (Worked case: APP-1378, *"PUBLISH: operator daily-standup lane, 6 artefacts"* — Blocked, Urgent, `human`, assigned, `blockedBy: []`, created 2026-09-11, seven of nine boxes ticked and the two open ones a CI re-run and a Prism review: no credential, no rendered surface, no irreversible or public act, no money. Three consecutive runs named its stale blocker correctly and none re-laned it, because the label read as the Owner's — APP-2020, APP-2077, APP-2128. APP-531 is the same shape one state over, In Review at 83 days, which this sweep's scope does not reach — APP-2139.)

**Zero-comment, human-assigned Blocked row — write the missing ask.** The three checks above all presuppose something to read: the formal-blocker check needs a relation, and the informal-blocker and lane-staleness checks both read the thread for a stated reason or a standing recommendation. A Blocked ticket carrying `agent`-group `human`, assigned to the operator, `blockedBy: []`, and **no comment at all** satisfies none of them — the sweep can only re-read the body, confirm it is self-consistent, and move on — so the *Assignee discipline* obligation it should have been parked under was never discharged, and there is nothing on the ticket for the daily stand-up or `task-daily-report`'s "your move" read to act on. This is the *Refinement comment sweep*'s exception (3) one state over, and it closes the same gap: write the comment — `@aledpritchard`, the ask restated from the ticket's **own title and body**, and where the body will not yield one, the explicit question of what reply would resolve it. **Comment only** — no state, label, priority or assignee write — which keeps it inside this sweep's surface-never-execute division, and the row stays in Blocked. **And test the batch, not the member that surfaced**, exactly as exception (3) does: read any siblings filed in the same sitting, repair as many as the five-per-team bound allows, and **name the unrepaired remainder by ID** in the run report. (Worked case: `APP-1895`, *"DRIFT: unaccountable design-parity review verdict on A1-557 — provenance unknown"* — Blocked since 2026-09-30, `human`, assigned to Aled, `blockedBy: []`, zero comments since creation, read live by the 2026-10-13 fire, which carried no bullet that could fire on it. Verified live in that run as carrying no `agent:PUL-5E` label, so genuinely inside this sweep's scope — APP-2298.)

**Unblock policy — what to recommend when all blockers have cleared:**

- *Ready to action* (complete brief, just needs execution) → recommend **Todo** with concrete instructions. If it is repo/code work, the *subsequent* routing pass sets `agent:F0-RGE` — never auto-set in the same run.
- *Clearing it needs separate work* → recommend a new unblocking ticket in **Backlog** at High/Urgent, linked as the blocker.
- *Brief now incomplete* → ask the specific question in-thread, refine on the operator's reply, then promote to Todo.

**Freshness check before recommending a move.** When all blockers have cleared (formal or informal) and you are about to recommend **Todo**, sanity-check that the content the ticket *carries* is still current before recommending the move. Scan the ticket's related tickets and recent comments for any note that an attached or referenced artefact has since been superseded. If it has, recommend re-attaching the latest version or narrowing the ticket's scope rather than routing stale content onward. (Worked case: a publish ticket whose two formal blockers had both cleared, but a related ticket recorded that one of its attached canon files had since been advanced in a later session — surfacing that wrinkle rather than auto-routing a stale publish was the correct call, and this check makes it mandatory.)

**The check covers the ticket's own factual premise, not only its attachments, and it reads the repo rather than the thread.** Where the body rests on a stated absence — "not covered by delivered work", "currently shows X" — re-test it against the repo before recommending Todo; the gap between capture and refinement is exactly when the work most often lands, and a refinement pass that adds clean acceptance criteria to a stale claim repairs the ticket's shape while carrying its central factual claim forward unexamined. Where the behaviour has since shipped, recommend closing the ticket as already-satisfied with the evidence rather than routing it to a build run. (`convention-ticket`, *a stated absence is a claim too* — APP-1183.)

## Executor-presence sweep

Every poll in the system keys on an `agent`-group value, so a Todo ticket carrying **none** falls out of all of them at once: not `F0-RGE` for the delivery loop's eligibility scan, not `R3-LAY` for this poll, not `human` for `task-daily-report` and `skill-attention-sweep`, not an `operator-*` value for the operator loops. A *wrong* executor was assumed to be the benign case — it at least keeps a ticket in some queue where a hygiene pass can find and relabel it — and that premise does not hold. Grepped live, `convention-linear` returns **0** for *wrong executor*, *wrong agent* and *mislabel*: **no pass in canon repairs a wrong executor on a ticket past Backlog.** The Backlog poll above repairs the label as its first action and reads **Backlog only**; this sweep reads Todo and flags only the *absent* value. So a Todo ticket carrying the wrong executor sits in a queue that will never select it, and is read by nothing that would move it. **This sweep therefore flags a wrong executor on a Todo leaf as well — on the one signal that needs no re-deriving of the routing judgement: a `[dispatch-run]` or `[fleet-dispatch]` comment in the ticket's own thread that names a different `agent`-group value and the remit ground for it.** The read is already in hand — `list_comments` at `limit: 10`, the thread read this pass already owes before any categorical write (`convention-linear`, *A pass that writes on a rule about a ticket's category reads that ticket's own thread first*) — and the write is the one that comment already specified: set the named value as a **full `labels` replace** restating the rest of the set, **leave the state and the assignee exactly as they stand**, and comment one line naming the value set and the dated comment it was read from. **Never infer a re-route from prose.** Only a `[dispatch-run]` or `[fleet-dispatch]` comment naming a live `agent`-group value may produce this write; where it names none, or names a value that is not live, report the ticket and leave it alone. This is the same not-re-litigating the raising pass already made that *Order a self-routing ticket ahead of the first touches* applies to a `DISPATCH:` body, reaching a comment on a ticket already past Backlog instead of a body in it. (Worked case: MBN-339, *"write the five bundle descriptions and set product type / vendor / gift tags"*, Todo under `SO-N4R` with a 2026-10-24 `[dispatch-run]` comment finding a remit gap rather than a lookup miss — the deliverable is product copy plus Shopify metadata, which sits in Draft's and Reach's Composition, and its own parent MBN-285 already carries `R3-ACH` — and recommending `R3-ACH` to match while deliberately leaving label, state and assignee untouched and naming a downstream sweep as the leg that should re-route it. Eight days and at least one further board-wide fleet-dispatch sweep later the ticket was unchanged: still `SO-N4R`, still Todo, no relabel. The ticket states, the comment and the sweep dates are the filing run's **report** and are unverified here; that `convention-linear` carries no wrong-executor repair is **observed**, grepped live this pass — APP-2801.) **No executor is a silent hole**: the ticket reads as the healthiest kind there is — Todo, prioritised, milestoned, a well-shaped body — and nothing in the system will ever select it.

The mechanism is a ticket authored **straight into Todo**, which bypasses the Backlog triage gate that is the only thing that sets an executor. The check is cheap and deterministic — a true invariant violation rather than a judgement call — so run it each pass: read **Todo per delivery team — not "across the delivery projects" — with a compact `fields` set including `labels`, `assignee`, `projectId` and `cycleId`** (the same `fields` discipline as the poll; a by-team read is the only one that can return a ticket in no project, which a project-scoped read hides by construction — APP-984), and flag every ticket with **no `agent`-group value at all**, plus every ticket carrying `human` but **unassigned** — a weaker instance of the same class, labelled but landing on nobody's surface, since the human-lane sweeps key on items assigned to the operator.

- **No executor *plus* an** `operator-<venture>` **label is a valid held state — never an anomaly.** Owner ruling (Aled, 2026-09-04, APP-1117): *"no* `operator` *value in the* `agent` *group. An operator hold is expressed by clearing the executor (no* `agent`*-group value), setting* `operator-<venture>`*, clearing the assignee, and commenting the escalation category. 'Evict' was the mechanism of the old single-select shape, not a requirement."* The same ruling fixes the two reads: **scope** is every ticket carrying `operator-<venture>`, executor or not; **queue** is the subset carrying `operator-<venture>` **and no executor** — the judgements pending on the operator — and re-routing (setting `F0-RGE`, or `human` + Aled) leaves the queue while staying in scope. Its canon consequence lands here, in the ruling's own words: *"*`skill-triage`*'s executor-presence sweep (and any sweep that repairs an executor-less ticket) treats no executor + an operator label as a valid held state, never an anomaly; no executor and no operator label stays the anomaly it is today."* So **test for an** `operator-<venture>` **label before flagging an executor-less ticket**: where one is present, leave the ticket exactly as it stands — do not set `agent:R3-LAY`, do not assign, do not comment — it is already on the operator's queue by design, and a repair would take it off. The repair below applies only to a ticket with **no executor and no operator label**. **This sweep reads Todo, and a hold does not rest there.** The ruled hold write lands a ticket in **Blocked** or **In Review** (`convention-linear` *Operator attribution*, the hand-off write), so a **leaf** in Todo with an `operator-<venture>` label and no executor is not held: it is an unrouted ticket, usually one authored straight into Todo, and it takes the repair below with the label kept. The one exception is a ticket whose latest comment is an operator hand-off naming its escalation category: the hold is real and only its state write failed, so move it to **Blocked** and leave the executor clear. (Worked case: MBN-302, created straight into Todo at Urgent with no executor on 2026-09-18, now carrying `operator-bara`: the shape the unscoped carve-out told this sweep to leave alone — APP-1537.)
- **A non-leaf parent is never routed, so it never carries an executor — in any state.** The Backlog poll already excludes non-leaf parents (*Trigger*). The same property holds here. Where a Todo row carries `type:epic`, `agent:R3-LAY`, `human`, or an assignee, test it for children (`list_issues(parentId: <id>)` non-empty). On a non-leaf, **no executor plus its `operator-<venture>` label is the correct resting form**: never flag it, and never give it `agent:R3-LAY`. `agent:R3-LAY` on a non-leaf is itself the anomaly to clear, because the marker is evicted only at routing and a parent has no routing event, so nothing else will ever remove it. **`human` plus an assignee on a non-leaf is the same anomaly in the human lane's clothes, and is cleared the same way.** It satisfies this sweep's own test — *either* a real `agent`-group value *or* `human` plus an assignee — so a pass looking only for a bare or Forge-bound executor reads it as correctly-routed human work and walks past it, every run. Clear `human` with the same full `labels` replace that keeps the `operator-<venture>` label, and clear the assignee in a write of its own (`convention-linear`, *Writing Linear safely* — a nullable param is never cleared in a bundled write). The rule names all three values because naming one has not been enough. Clear it with a full `labels` replace that keeps the `operator-<venture>` label (set that label from the team routing table where it is missing), leave the state as it stands, and comment one line. `convention-linear`'s "Epics never carry `agent:F0-RGE`" is the same rule stated for one value. (Worked case: MRP-1, *"SETUP: Stand up the Substack publication"*, a `type:epic` created straight into Todo on 2026-06-08 and carrying `agent:R3-LAY` + `operator-mrp`, with no rule saying what it should carry — APP-1554. The same epic has now surfaced in this family of checks four times without landing, and the reason is the gap this bullet just closed: it read `agent:R3-LAY` + `operator-mrp` + assigned on 2026-09-20 and 2026-09-21, and `human` + `operator-mrp` + assigned on 2026-09-23, so the executor value on one non-leaf moved from the case the rule named to the case it did not. Three of the four runs left it unmutated because the `human` case had to be inferred from the opening sentence; the fourth cleared it and flagged that the inference was not a stated rule — APP-1526, APP-1554, APP-1564, APP-1665.)
- **A classification-only capture or idea carries no executor by design — test for it before flagging.** Mr Pritchard's editorial pipeline files a `CAPTURE:` or `PIECE (idea):` row with content-classification labels only (`capture`, `theme:*`, `source:*`, `story`) and **no** `agent`-group value. The row is not yet work: there is nothing to route, so there is no queue it should be sitting in, and the absent executor is a valid resting form rather than the silent hole this sweep exists to close. So a parked capture or idea is **exempt from this sweep until it is promoted** — leave it exactly as it stands: do not set `agent:R3-LAY`, do not assign, do not comment. `convention-ticket` *The standard ticket shape* → *Capture format* owns the rule and states what the row must take on promotion; read it there rather than re-deriving it here. (Worked case: the 2026-09-22 sweep found MRP-57, MRP-58 and roughly 25 further `Defined` rows — about 27 in all — that it could neither pass nor flag, and correctly declined to correct them on a guess because no artefact stated whether MRP captures need an `agent`-group value at all. APP-1633.)
- **No `agent`-group value → set `agent:R3-LAY`** and comment one line saying what was set and why. This is executor hygiene, not refinement: do not route it to Forge in the same pass and do not move it out of Todo. It deliberately produces the R3-LAY-in-Todo anomaly `convention-linear` names, because that anomaly is *visible and self-terminating* — this sweep's committed-Todo rule below hands the ticket to the pass, which sets a real executor (the Backlog poll never reads Todo, so the poll alone would never reach it; APP-1581) — where an empty field is neither. Resolve it in the same pass where the ticket is already refinable. Where the flagged leaf also lacks the literal `## Acceptance criteria` or `## Definition of done` heading (read the description of the flagged row only), it is not refinable in place: it breaks the Todo-boundary invariant (`convention-linear` *Issue states*), so move it to **Backlog** under `agent:R3-LAY`, where the poll will refine it, and comment one line naming the missing heading. (APP-1537: MBN-301, MBN-302 and MBN-299.) **Except a ticket in a cycle** (`cycleId` set): a backlog-type state drops its cycle membership (`convention-linear` *Issue states*), so the move silently undoes the Owner's commit. Leave it in Todo under `agent:R3-LAY` and refine it in place under the committed-Todo rule below — author the missing heading from its `type:` template — and comment one line naming the heading added. (APP-1581, 2026-09-21; worked case: MBN-301, brought back into Todo heading-less by the W39 commit and fixed in place rather than returned to Backlog — APP-1583.)
- `agent:R3-LAY` **in Todo is triage's own queue — work it in place, and never out of Todo while it is in a cycle.** The Backlog poll reads Backlog only (*Trigger*), so a Todo leaf under `agent:R3-LAY` — set by the repair above, or carried in when committing a Backlog or Refinement ticket to a cycle force-moved it to Todo (`convention-linear` *Issue states*) — is reached by no poll unless this sweep hands it on. Owner direction (Aled, 2026-09-21): *"we do not want tickets in Todo that have not been triaged."* So this sweep flags every Todo leaf carrying `agent:R3-LAY`, and the pass works it to the full refinement bar (*Refinement: placement, structure, assignee*) inside the poll's budget (*Precedence*, item 4). Where the ticket carries a cycle, place it with **Todo-safe placements only**: placements 1 and 2 as written; placement 3 becomes **Todo +** `agent:R3-LAY` **+ a blocked-by relation to the source**, which this rule re-checks each pass and harvests as the *Harvest sweep* does; placement 4 becomes **Todo +** `human` **+ assigned to the operator**, the @mention leading the decision. Never move a cycle ticket to Backlog or Refinement (`Defined` on Mr Pritchard): each is backlog-type on every delivery team, and the move drops the cycle. Taking a ticket out of the cycle amends the Owner's commit and is not triage's write — where the honest answer is "not this cycle", say so in the placement-4 comment and leave membership to him. A Todo `agent:R3-LAY` leaf that is a filed Relay authoring pass (*fifth outcome*, headings present, deliverable Relay's own) is not re-refined; it is executed or left for its own run. Outside a cycle the ordinary placements apply. (APP-1581, 2026-09-21; worked case: the W39 membership write force-moved seven tickets to Todo, five never triaged — A1-451, A1-452, MRP-56, APP-1302 and MBN-301 — and an on-demand fire triaged them in place, APP-1583.)
- **`human` and unassigned → assign the operator** with an @mention (`@aledpritchard`) leading the specific action, per the assignee discipline above. **Not before a date the ticket itself sets.** Where the ticket carries a future Linear due date, or its body states an explicit future review date, still make the lane repair by assigning the operator, so that the ticket is on his surface. Post **no @mention, no question and no comment**, though. The ticket has already said when it is to be asked, and asking early spends the Owner's attention on a question whose answer cannot yet have changed. (Worked case: A1-429, a gate whose body reads *"On or after that date the stand-up asks the Owner one question"* against a 2026-09-21 review date and due date, was assigned with an action comment by the 2026-09-19 sweep, two days early — APP-1550, APP-1549.)
- **A consequential one goes to the operator, not into a queue.** Where the ticket is a launch, a cutover, or another irreversible action, surface it to him at **Urgent** with the recommendation rather than quietly labelling it into a build lane.
- **Before routing a ticket to `human`, or raising one to the Owner as an open approval, read the committed cycle-goal document for that ticket's team.** An Owner ruling filed as a cycle commitment moves no field on the ticket and appears in no comment on it, so neither this sweep's `fields` read nor a thread read to the end can find it: the ticket's labels and its thread are both consistent with a decision that has already been made somewhere else. The read is **one document** — the team's current-week commit, `<team>.cycle-goal.<ISO week>`, resting on one of the vertical's projects, at its *Committed by* block — and it is **not a wider sweep** — **with exactly one named second document, and no others** (APP-2702). That second document is the vertical's standing **`<vertical>.owner-session-agenda`**, and only its ***Open — decisions for the session*** section. `convention-comms-owner` names that agenda and fixes its two sections, and `skill-operating-loop` step 8 makes the *Open* section the register of open items and nothing else — it *"holds only open items"*, and a ruled item moves to the decision log and drops off — so an item still sitting there is, by the agenda's own construction, a question the Owner has not yet ruled. Read that one section in the same act as the commit document. Where it carries **the same question this route turns on** — the provenance of the very ruling the commit document is being read for — the correction **reports the conflict and does not treat the question as settled**: it names both surfaces and their dates, leaves the ticket's lane exactly as it stands, says in terms that the agenda is holding that question open for the Owner's session, and routes nothing on the commit document alone. The agenda entry is the more specific and the later of the two, and a pass that re-derives *already approved* from the commit document without reading it rules a question that had been reserved. Two things this does not do. It does not make the agenda a general input to this pass: nothing outside that one section is opened, and an agenda carrying no matching question changes nothing about the route. And it does not settle the conflict — reporting it is the whole of the act, because the question was reserved for the Owner and this pass is not him. (Worked case, **reported** from the filing run's reads and unverified here: a `[triage]` comment on MBN-336 self-corrected that ticket's own earlier routing on the stated ground that `mbn.cycle-goal.2026-W43` had already approved both re-routes as operator instructions — removing `human`, clearing the assignee and moving the ticket to Todo — while `bara.owner-session-agenda`, refreshed the day APP-2585 closed and still the live version at that read, carried the identical question as its open item 2, categorised there as a ruling's provenance and explicitly *not foldable*. No harm landed: both re-routed tickets still read `human` and assigned. **Observed live, not reported:** this bullet is the only bounded cycle-goal read in canon; `APP-2585` appears in exactly one file store-wide and that file is this one; and the agenda, its canonical name and its two fixed sections are carried by `convention-comms-owner`, with `skill-operating-loop` step 8 making *Open* the register of open items only — APP-2702.) **The bound is otherwise unchanged**, and the exclusion that follows reaches every document except the agenda just named: do not open the earlier weeks' goals, the vertical's other documents or the stand-up entries, because the commit document is the one surface where a ruling is filed rather than written onto the ticket. Where it names the ticket, or names the decision the ticket exists to carry out, the ruling stands: route the ticket to the executor the commit names, cite the ruling's date and the document in the one comment the pass already posts, and do **not** add `human`, do not assign the Owner and do not ask him to approve or bounce. This is the route-to-human side of `skill-operating-loop`'s *Reversible and zero-cost acts proceed* — an act that implements a plan the Owner has already ruled is not his to re-approve — and that principle is read there rather than restated here. **The asymmetry is what pays for the extra read.** One document read per route-to-human write is cheap, bounded and deterministic. Handing back a settled ruling is not: it spends the Owner's attention on a question whose answer cannot have changed, and it then reads on his stand-up brief as a decision waiting on him when none is, so the same mistake is paid for twice and in the scarcest thing the loop has. (Worked case, **reported** from the filing run's reads: the 2026-10-22 sweep found MBN-336, *"RE-ROUTE: take MBN-288's verdict and MBN-280's publish off the `human` lane"*, carrying no executor; it moved the ticket to Refinement, added `human`, assigned the Owner, asked him to reply approve or bounce, and commented that "nothing has moved it off `human` yet, so it's still yours to clear this once." `mbn.cycle-goal.2026-W43` — **observed** this run — records under *Committed by Aled — 2026-10-19* that both re-routes "are approved with it and filed as operator instructions" to `operator-bara`. MBN-336 exists to execute that approval and the operator was its executor, so the sweep handed a settled decision back to the person who had made it. The ruling is on the commit document and on no comment on MBN-336: a thread read to the end would not have caught it. Fifth limb of the family at APP-1643, APP-2420 and APP-1935 / APP-1976 / APP-2167, and the first whose ruling sits in a commit document rather than on a thread — APP-2585.)
- **And before writing any `agent`-group value, confirm the value is consumed — the precondition binds this sweep too (APP-2669).** `skill-operating-loop` states it: before work is routed to an executor value, confirm from canon — not from the board — that **some skill reads a queue filtered by that value** and that the work falls **inside a slice that executor's profile declares live**; where either fails, the route is a no-op that looks like progress, and the move is to name the missing consumer as the work rather than to dispatch. That clause sits in the file governing the **operator** loops, and this pass is not an operator loop, so as written it did not reach the surface that writes more `agent`-group values than any other. It binds here, **by reference and not restated** — a route this pass writes is subject to the same two confirmations as a route an operator loop writes, and `skill-operating-loop` remains the one home of the rule. The exposure is specific to **horizontal and planning** executor values: a delivery route has `skill-build-ticket`'s claim gate and a moving state to answer it inside a cadence, and a horizontal route has neither, so the ticket rests in the one shape every read treats as healthy — correctly routed, correctly labelled, climbing `convention-linear`'s age ladder to Urgent, and read by nothing. And where the motive for the route is to get a decision off the Owner's desk, that is a good instinct that does not by itself make a lane readable: the destinations available are the vertical's operator or a delivery-loop value, never a horizontal planning agent with no consumer. A decision that is genuinely the Owner's is parked under *Assignee discipline* with the ask written — exception (3) of the *Refinement comment sweep* above is this section's own remedy for exactly that — rather than re-routed into a queue nothing reads. (Worked case, the instances **reported** from the filing run's reads and unverified here: APP-2439 was drained on 2026-10-20, establishing by first-hand measurement that no skill anywhere reads a queue filtered by `ATL-4S` and that Atlas holds one live slice, cycle review and commit proposal. On 2026-10-21, the day after, this pass relabelled A1-673 from `human` to `ATL-4S` and cleared the assignee so that "Atlas's next strategy pass picks up the cascade/park mechanics". It surfaced five days later only because a1.Heroes fell inside an initiative sweep; on a project outside one it would have sat as MRP-19 did — correctly labelled, Urgent, unassigned and unconsumed at 110 days. **Observed live, not reported:** the precondition's only home in canon is `skill-operating-loop`, and this file carries no executor-reachability test of any kind — APP-2669.)
- **No project → home it, or surface it.** The second invariant in the same read, and it is **not scoped to Todo: no ticket reaches or rests in any open state without a project.** The read widens with the invariant — **one issue-list call per delivery team per fire, filtering on a null project across every open status type, carried until the ticket is placed** — and it explicitly includes **Refinement rows carrying the human lane value, which no other pass reaches at all**. A Todo-only invariant leaves a hole it cannot see by construction: this skill's own guardrail sets the human lane value on a clearly human-owned Refinement ticket precisely so that it *drops from the poll*, and every human-lane read downstream is project-scoped, so a projectless human row resting in Refinement is read by the poll it was evicted from, by the Todo sweep it does not sit in, and by the project-scoped reads it has no project to appear in — which is to say by nothing. A projectless ticket in any open state is swept by nobody once it leaves this pass — coordinate, plan and the daily report all enumerate per live project. Where the parent's project or the `domain:*` label makes the home unambiguous, set it and comment one line; where it is ambiguous (a ticket spanning two projects), set the likelier one and flag the split in the same comment rather than leave it homeless. The filing-time rule that should have prevented it is `convention-ticket`'s (a run-filed ticket inherits its parent's project); this catches the Owner's hand-filed tickets and every run that forgot. (Worked case: A1-361, filed mid-run with no labels and no project on 2026-08-16, spanning `aledpritchard-com` and `meirionpritchard-com`, still projectless on 2026-09-02 — APP-984.)
- **No `operator-<venture>` label → add it.** The third invariant in the same read, and the one the refine-time writer structurally cannot reach. *Set the vertical's `operator-<venture>` label at refinement* above makes refine the only writer in canon; this sweep exists precisely because a ticket authored straight into Todo — or force-moved there by a cycle commit (`convention-linear` *Issue states*) — never passes refine, so it never passes that writer either, and the operator's **scope** and **queue** reads (`convention-linear` *Operator attribution*) are defined over a label nothing on this path sets. The read is already in hand: `labels` is in this sweep's `fields` set, the vertical resolves off `convention-linear`'s team routing table — by **project** on Apps, where bot.Trader is `operator-bottrader` and everything else `operator-apps` — and the write is one `addLabels` add that evicts nothing and is evicted by nothing. Do it on every Todo row the sweep reads, including rows it is otherwise leaving untouched, and fold it into the one comment the pass already posts rather than commenting for the label alone. Like the executor repair above, this is routing hygiene: it does not change placement, does not gate promotion, and is never a reason to hold a ticket. **It closes new arrivals, not the standing population.** Rows already past Todo — In Progress, In Review, Blocked — are reached by no pass that writes this label, and the one-shot backfill the refine rule names has been shown not to hold: APP-1568 closed Done on 2026-09-22 as a *bounded pass*, and the unlabelled share of team A1's read population measured roughly a fifth to a quarter across three weeks while the population churned, which is the signature of unlabelled arrival rather than of loss. A creation-time default on the team or project template would close it at the source; that is a **workspace-config lever and therefore the Owner's**, named for him rather than authored here. (Worked case, read live 2026-10-13: A1-298 — Todo, in cycle, `human`, no `operator-a1`; A1-639 — Todo, `P1-XEL`, no `operator-a1`; both past the refinement gate and unlabelled. The sixteen-ticket `DS CHECK:` series the filing note led with is **not** evidence for this bullet: those rows read **Backlog** under `agent:R3-LAY`, pre-refine, where the existing writer still applies and an empty operator read is evidence about refinement throughput rather than about this mechanism, per the APP-1274 / APP-1275 ruling already in this file. The rate figures are reported from the filing note and not re-derived. APP-2314.)
- **A standing not-ready comment older than N days → return to Refinement + `human`.** `skill-fleet-dispatch` skips an un-runnable Todo ticket and posts one *not ready — input unresolvable* comment naming the missing input; it is forbidden from writing state, and its own text says the ticket "belongs back at the refinement gate, which is triage's write to make". This is that write. A Todo ticket carrying a fleet-dispatch not-ready comment whose `createdAt` is older than N days (default 3 — the comment's age *is* the hold duration; keep no per-run counter) with no state change since is moved to **Refinement + `human`**, assigned to the operator, with one comment naming the missing input and the fix (a file key, a built-surface URL, a re-route). Where the not-ready comment records that the input needs human perception or physical hardware (fleet-dispatch's *re-route to* `human` disposition), the move is the same and the comment says the ticket is the operator's to do, not to enrich. Do not enrich a `P1-XEL` body while APP-963 stands — until `use_figma` is confirmed unattended-writable, enrichment only reintroduces claim-then-Block churn (APP-762). (Worked case: A1-295, A1-343, A1-346, A1-358, APP-122 and APP-508 — six `P1-XEL` Todo tickets re-fetched, re-tested and re-reported every daily sweep from 2026-08-10 with nothing pushing any of them back to the gate — APP-991.)

(Worked case: A1-268, *"CUTOVER: go live on meirionpritchard.com"* — Todo, Medium, Launch milestone, carrying the `siteUrl`, host-conditional-noindex and `robots.txt` changes D023 requires to change together — was created straight into Todo on 2026-07-29 with no `agent`-group value and no assignee, unownable since creation, and surfaced only incidentally by an unrelated read the next day. Its blocker A1-267 is the weaker instance: Todo + `human`, unassigned. Both were authored in the same sitting, 2026-07-30, APP-730.) This is the mirror of the stranded-`F0-RGE`-in-Refinement blind spot (APP-400): right label and wrong state there, right state and no label here.

## Guardrails

- **Act on safe, unambiguous moves; hold only the consequential.** Triage's default is to *act*, not to propose-and-wait. A refined leaf is moved to its **correct resting state** per the four placements above — **Todo + executor** when clean, **Todo + executor + blocked-by** for a sequencing dependency (the builder skips it while blocked and auto-picks it up when the blocker clears), **Refinement under `R3-LAY`** for a harvest dependency, or **Refinement under `human`** where a genuine operator decision remains (including a decision-gated leaf in an active/greenlit epic — never left in Backlog) — rather than held in Backlog under a comment awaiting a separate confirm. Note the invariant: an agent executor (`F0-RGE`) never rests in Refinement — a human gap parks under `human`, a harvest wait under `R3-LAY`. **The invariant's "correct it" action applies only to a stranded ready leaf in an active flow; a pre-labelled `F0-RGE` leaf in a dormant, un-greenlit project (no active siblings) is not corrected to Todo but relabelled off `F0-RGE` and surfaced to the operator — see the invariant's dormant-project carve-out.** This is what convention-ticket / convention-linear require: a refined leaf ready-except-for-a-sequencing-dependency belongs in **Todo-with-blocker**, not parked. It applies on **all** delivery teams, not only os.Claude; os.Claude is simply the same default, with repo-native and publish work going straight to Todo. Reserve **hold-and-ask** strictly for **consequential or ambiguous** calls — those still go to the operator in-thread, never a guess (the guardrail below). (Supersedes the earlier blanket "suggest-mode first". This reverses the act-first rejection recorded against APP-283 / APP-292 (Canceled), on a fresh, direct operator instruction — 2026-06-30, when A1-108 / A1-109 sat in Backlog under `R3-LAY` while fully refined and only dependency-blocked, and the operator flagged the hold as slowing refinement. The consequential/ambiguous escalation below remains the unattended-safety rail, so dropping blanket suggest-mode does not remove it.)
- **Comment idempotency.** When triage *does* hold-and-ask — a consequential or ambiguous call, or a recommendation surfaced to the operator — a standing recommendation is posted once, not re-posted every poll. Before commenting a routing, decision, or surface recommendation, check whether the latest pm/agent comment on the ticket already carries the **same standing recommendation** and nothing has changed since it — no new operator comment, no state, label, assignee, or attachment change. **A blocked-by or related source reaching a done state counts as a material change** for this test, not only changes on the leaf itself: a harvest source going Done since the last comment must re-trigger the sweep, never be silenced as "nothing changed" (APP-408). This is why the harvest and blocked sweeps run before idempotency silencing. If nothing material has changed, stay silent: the standing recommendation holds. Re-comment only when the recommendation itself changes, the ticket changes materially, or the operator has replied. This prevents near-identical comments accumulating on tickets correctly held awaiting the operator (worked case: APP-324, A1-78, each carrying four duplicate Relay routing comments, 2026-06-29). Distinct from APP-304's fix, which relabelled *human-owned* tickets to `human`; these are agent-owned and Forge-ready, so the gap is comment idempotency, not executor labelling.
- **Human-owned Refinement tickets get migrated, not re-read every poll.** A clearly human-owned ticket parked in Refinement under `agent:R3-LAY` matches the poll on every run, and the read-only rule otherwise offers no terminating action — so it re-surfaces unboundedly, costing comment-reads and obscuring genuinely new `R3-LAY` work. The executor-hygiene relabel in the *Refinement comment sweep* is the terminating action: set the `agent`-group value to `human`, assign the operator, and it drops from the poll. Apply it the first time such a ticket is seen rather than re-evaluating it each run (worked case: ~5 pre-convention human-owned Refinement tickets — APP-176, APP-123, APP-130, COS-235, COS-167 — re-surfacing every triage poll, 2026-06-30).
- **Report the rows not reached — an unmeasured remainder reads identically to a clean sweep.** The bounded pass (*Trigger*, the five-per-team clause) leaves eligible rows unworked by design, and that is correct; what is not correct is a run whose report is silent about them, because a board with nothing left to triage and a board whose queue the run never got to produce the same output. So every run states, per delivery team, how many eligible Backlog rows it worked and how many it did not reach, and names the oldest first-touch row it left — and, alongside those counts, **names which of the four sweeps it did not reach**: refinement comment, harvest, blocked-state, executor-presence. A sweep that never ran reads identically in the output to a sweep that ran and found nothing, which is the same defect one level up from the unmeasured row remainder, and it is the more misleading of the two: an unswept Blocked lane reports as a clear one. A run that reached every sweep says so in one line (APP-1469). Nothing else measures this: the delivery loop scans `agent:F0-RGE` in Todo and never sees Backlog, and `skill-task-health` Pass A checks that triage produced *an* output, not a complete one. A silent remainder is the one failure a sweep cannot report on itself. (APP-1207.)
- **A comment may claim only what the run read back — field by field.** Canon already binds the read-the-write-back on a state write, and binds it again for the description headings a refinement comment claims (*Refinement*, the type-template bullet). Generalise it: **every field a comment asserts — labels, state, assignee, priority, relations, description — is re-read after the write and before the comment is posted**, and the comment reports the read-back, not the intent. Where a field did not take, **name it in the comment** as not landed rather than omitting it, because an omission leaves the remaining prose reading as a completed repair. One `save_issue` returning without error is not evidence that its four fields landed. The asymmetry is what makes this worth a rail: a partial write is recoverable, because the ticket still reads as unrouted and the next poll picks it up; a comment describing a repair that did not happen is not, because every later reader — a subsequent triage pass, a coordinate pass, a stand-up — treats the comment as the state and skips the ticket. (Worked case: A1-434 carries a `[pm-triage]` comment posted 2026-09-15T06:14:46Z claiming a four-part repair — the standing `type:bug` `## Definition of done` pasted, `F0-RGE` + `operator-a1` set, routed to Todo, assignee cleared. None of the four landed. Re-read live 2026-09-18, three days on, the ticket carries `labels: []`, sits in **Backlog**, is still assigned to Aled Pritchard, and its description still holds only `## Objective` / `## Scope` / `## Done when` with no `## Definition of done`. The claimed repair still has not landed, while the ticket reads as routed to anyone trusting the comment. APP-1474.)
- Never executes code, opens branches, or merges.
- Consequential or ambiguous calls go to the operator, never a guess.
- **Canon changes: spot, capture, and stop — never author the wording here.** When triage converges on a canon change (to `convention-linear`, `convention-ticket`, a skill, etc.), file a `FRICTION:` note to the Pulse queue and stop. Do **not** author the proposed canon wording — not even as a "draft for review" — here: authoring and packaging is the Pulse drain's job (`skill-ops-retro` / `task-pulse-retro`), which assesses the change against current canon and consolidates it. A triage session reaching the drain step is doing the drain's work in the wrong place (worked case: 2026-06-30, APP-403). The completion pull to write it out is exactly what this guardrail resists: the note captures the observation; the drain authors the artefact.
- **"Never a ticket" means never a delivery/Forge ticket — the `PUL-5E` capture note is correct.** Filing a `FRICTION:` capture note to the Pulse queue is the *right* action, not a forbidden one. The forbidden routes are a canon edit routed to Forge as a delivery ticket, and an in-place `SKILL.md` edit. Do not let "canon changes never go through a ticket" discourage the legitimate capture note.

**Blocker discipline.** Blocked-by relations are for genuine dependencies only: shared files that would conflict, artefacts that must exist first (assets, builds, merged tooling), or decisions that gate scope. Strategic sequencing — platform order, milestone order, "do this before that" — is carried by project milestones and the operator's promotion to Todo. Never encode sequencing preferences as blocks. Do not add a blocked-by relation merely because tickets are thematically sequential or because one would logically follow the other.

**Repo-wide baseline tickets.** A ticket that touches many files across a repo (format pass, lint sweep, large-scale refactor) is a genuine dependency for any parallel ticket editing the same files. When such a baseline ticket is in flight (Todo → In Review), identify any simultaneously-actionable tickets that edit overlapping files and add blocked-by relations to them so they are not worked concurrently. Sequencing via blocks here prevents merge conflicts at the source, complementing CI and the merge queue.

## Setup

- Deployed as a **Cowork scheduled task** (cloud) via a loader config — `task-triage` reads this skill. Cadence: a few times a day (mind the ~1h floor).
- Connector: Linear only.
- Routine prompt: "Run the triage skill."

On finish, run skill-ops-retro capture on this run's friction: **search the Pulse queue first and add the evidence to a same-root note if one exists, otherwise file a new FRICTION note** for the drain pass to assess, in capture step 3's literal shape — team Apps, project os.Claude, `FRICTION:` title, labels `task` + `work:configuration` + `PUL-5E`, Backlog, unassigned — filing the friction, never the run report. This run's own report of the sweeps it ran, the candidates it polled and the batches it repaired belongs on its run-log surface (`convention-agent-runtime`), never in the Pulse queue — **and where the run found no friction, it files nothing.** A clean run is the commonest outcome and has no note to file: it says so in its own report and on its run-log surface, and the Pulse queue stays empty of it. (Worked case: five `task-triage` run reports have been filed as `PUL-5E` notes — APP-1710, APP-1802, APP-1808, APP-1713 and APP-2267 — while this clause has been live on `skill-coordinate`'s own closing line since its three run-report notes were drained. The clause's absence here is the difference, which is why it is supplied rather than the prohibition restated — APP-2267.)

**Name the surface: this artefact's run-log surface is the os.Claude initiative — I-9, *os.Claude — harden & run the Claude delivery loop*.** `convention-agent-runtime` supplies the default — absent a named surface, the vertical's own initiative is the run-log surface, **and the loader or artefact is edited to name it in the same pass** — and this clause is that naming, so the phrase above resolves to a destination rather than to nothing instead of falling back to the Pulse queue, which is the one surface canon forbids it. Post the run's own report of **what it swept, what it wrote and what it skipped** as **one comment on I-9**, naming every state, label, priority, assignee and relation write ticket by ticket with the ticket IDs — one comment per run, never one per touched ticket, never a repeat where nothing was written — and **never** as a ticket in the Pulse queue. The third branch above stands unchanged by this: **where the run found no friction it files nothing**; a clean run says so in its own report and in its I-9 comment, and the Pulse queue stays empty of it. The name belongs in this file rather than in the loader because `task-triage` carries no behaviour of its own, and naming it in canon is what stops the default being re-derived every fire. (APP-2385, which was closed on 2026-10-16 asserting a re-test it had not run: the `convention-agent-runtime` half landed, the artefact half was never made, and the convention change was live and inert until this line. Re-tested 2026-10-19 — the loader stands unchanged at sixteen lines with no occurrence of "run-log", "initiative", "post" or "report". The note's own premise that no durable non-ticket surface exists is false and is corrected in `convention-agent-runtime`: the workspace holds 24 initiatives, 23 of them not cancelled, I-9 among them; the note's query was name-filtered, so it measured which artefacts name a surface and read that as which surfaces exist. Measured scale behind the five notes listed above: at least eighteen `FRICTION: Nth triage run…` tickets in the Pulse queue, roughly four times the worked-case list, plus a dozen `coordinate run report` tickets in the same shape under a different title.)
