---
name: "skill-coordinate"
type: skill
description: Cross-board PM coordination for Aled's delivery projects. Use whenever running the coordinate routine, or when PM comments have landed on tickets across any state and need to be processed. Sweeps the live delivery projects for new Aled/agent comments since the last run, applies decisions, advances handoffs, unblocks cleared dependencies and auto-promotes ready tickets to Todo, surfaces the root blocker starving downstream work with its blast radius, surfaces tickets stranded awaiting the operator (approved-but-unmerged, a fleet deliverable left in Todo, any ticket in review with no verdict), and surfaces structural issues (duplicates, missing parents or milestones, mis-homed children, projectless parents, epic scope-bleed) as proposals only — escalating an unanswered proposal by age rather than re-commenting. Never merges, marks Done, or touches Pipeline. Trigger this rather than ad-hoc coordination so body edits, routing changes, and structural proposals follow consistent conventions.
license: CC BY-NC-SA 4.0
---

# coordinate

The cross-board PM coordination skill. Runs as a scheduled Cowork task on the Linear connector. Follows `convention-linear` throughout.

## Trigger

Scheduled poll across the **live delivery projects**, resolved at run time rather than read off a list. Resolve them with one small `list_projects` call and keep those whose status is `statusType == started`, across the teams Apps, MBN, A1 and **Mr Pritchard** — the same liveness gate *Project liveness is the second axis* states below, used here as the scope definition itself rather than only as a filter applied to a named set. **The scope is the query, not an enumeration.** Teams are named here because a whole missing team is the failure a sweep cannot report; projects are not, because a project list is stale the moment a project is created, renamed or parked, and it goes stale silently. Mr Pritchard is named among the teams explicitly — it was absent for weeks and each run resolved it from the convention-wins tie-break below rather than reading it off the list, which held only because MRP happened to have no started project; that no longer holds (APP-594). (Worked case: re-tested live 2026-09-18, `list_projects` returned **44 projects, of which 14 carry `statusType == started`** — a1.Advisory · Advisory & fractional page, app.AgentArt, a1.Agents, bot.Trader-B, a1.Firmup · Firmware updates, mbn.brand, mbn.website, a1.Muse · Funnel diagnostic, a1.assoc-one, Articles, a1.MeirionPritchard · Work section, os.Claude, app.Luna, bot.Trader. Measured against the enumeration this replaces: `Luna MVP — Retirement Navigator` had been renamed `app.Luna`, and two live Apps projects — app.AgentArt and bot.Trader-B — were not named at all, so a run reading the list rather than the board would have carried a renamed project and missed two live ones. Any fresh enumeration would need the same correction again, which is why there is none — APP-1470.) Note MRP runs the **editorial** state set, not the engineering one — `Defined` for refined-and-parked, `In Review` where another team would use Blocked, `Published` / `Scheduled` for done (`convention-linear` *Issue states*). **Where the team set named here and `convention-linear`'s team table disagree, the convention wins** — the team set changed on 2026-07-14 (careerOS demoted to projects under Apps, MBN promoted to its own team), and a scope list that predates a restructure misses a whole team's work silently, which is the one failure a sweep cannot report (APP-521). Never touches the Pipeline team (Network / Roles / Advisory / Pitches) — that is relationship work, not delivery.

For each ticket in scope, the run checks whether any comments warrant action. The **watermark rule** (below) ensures efficiency and idempotency: only genuinely new, unprocessed input is acted on.

## The trigger-boundary rule

This rule guards against two PM legs touching the same ticket. coordinate's scope is defined precisely to avoid collision with exec, qa, and merge.

**coordinate processes:**
- Comments from Aled on tickets in **any** state except In Progress under `agent:F0-RGE`.
- Comments from other PM legs (pm-intake, triage) that contain open questions Aled has since answered in a subsequent comment.

**coordinate does NOT process:**
- Tickets currently **In Progress** carrying `agent:F0-RGE` — exec owns those while being worked.
- Exec, qa, or merge handoff comments (those are state-transition records, not PM instructions).
- GitHub PR review comments — those belong to the qa or exec leg.
- Comments already processed and acknowledged in a prior run (the watermark prevents re-processing).

**Watermark:** for each ticket, find coordinate's most recent comment. Only comments posted *after* that watermark from Aled (or from any other pm leg with new content) are candidates. If no prior coordinate comment exists on the ticket, the beginning of the ticket's history is the watermark.

**Coordinate's own comments are found by their `[coordinate]` marker, not by author.** Every comment this skill posts leads with that marker (*Guardrails*), and the connector's `author` field is stamped as the account owner regardless of who wrote it (`convention-linear`, *Reading Linear safely*), so "coordinate's most recent comment" is a search of comment **bodies** for the most recent `[coordinate]`-prefixed one — never a filter on `author.name`. Without the marker the watermark is specified against a signal the skill does not emit, and the pass fails in both directions at once: it re-processes comments it has already answered, and it reads its own unprefixed note as an operator comment (an unprefixed comment is the operator's) and answers itself. On a ticket whose coordinate comments predate this rule there is no marker to find — treat it as having no prior coordinate comment, per the sentence above, and let the next run's marked comment establish the watermark. (APP-1208.)

**Comment ordering — `list_comments` uses `updatedAt` desc by default.** Any skill that re-touches a comment (edits it, adds a reaction, or references it in a sweep) bumps its `updatedAt` — which resurfaces it at the top of the next query. `limit: 1` therefore does **not** reliably return the chronologically latest comment; it returns the most recently *touched* comment. When scanning for the watermark or Aled's latest instruction, use `orderBy: createdAt` and a sufficient limit so the correct comment is found.

**Candidate selection — bound the comment pull, don't pick by feel.** No connector primitive returns "tickets with a comment created after T", and `updatedAt` on `list_issues` is dominated by **bulk plan / triage / milestone writes** — dozens of tickets across projects routinely share one identical second-precise `updatedAt` stamp from a sweep, not from an operator comment. So a recency filter floods on bulk-touched tickets while still missing comment-only changes, and hand-picking "high-signal" candidates is judgement-by-feel that can silently skip a genuine operator instruction on a bulk-touched ticket. Until a comment-feed filter exists (see the connector ask below), select Pass 1 candidates by a **bounded, repeatable** rule:

- Scope to **non-terminal states** (exclude Done / Canceled / Duplicate).
- **Exclude the os.Claude Pulse queue from the delivery candidate read.** In os.Claude, `agent:PUL-5E` canon-intake notes (`FRICTION:` / `CANON:` / `PROPOSAL:`, Backlog or Blocked) are the Pulse friction queue — drained by `task-pulse-retro`, never coordinated — yet the sweep otherwise reads all 60+ of them each run only to identify and discard them, a ratio that worsens as the queue grows between drains. Filter them out of the candidate set up front by their `agent:PUL-5E` executor rather than reading then discarding; the @mention override below still admits any single note the operator explicitly points coordinate at. Coordinate-side counterpart of triage's `PUL-5E` exclusion (APP-552). (APP-791.)
- Within those, pull `list_comments` (orderBy `createdAt`) only for tickets whose `updatedAt` is later than coordinate's watermark **and** whose latest change is **not** a known bulk-sweep signature — many tickets sharing one identical `updatedAt` stamp is the tell of a bulk write, not an operator comment.
- **Always** include any ticket where the operator has @mentioned coordinate or the `claude-code` label since the watermark.

This keeps the per-ticket comment read bounded and the same across runs, so detection is repeatable rather than budget- and judgement-dependent. **Connector ask (non-canon, for the operator):** a workspace/team comment feed filterable by `createdAt > T` and author would remove the inference entirely — the same connector lever as the compact-`list_issues` ask (APP-288).

**Read volume — sweep per team per coordination-relevant state, never one wide query.** A wide `list_issues` sweep (whole team, all states, recency window) returns full descriptions and overflows the tool-result limit on an active week (~75–77k chars per team at `-P3D` / limit 50, `hasNextPage: true` on both — task-coordinate, 2026-07-11, APP-493), forcing a fragile grep-and-zip recovery that risks mis-attributing status or labels. Sweep instead per team **per coordination-relevant state** — Blocked, In Review, Refinement, and Todo — with a short `updatedAt` window matched to the run cadence, and page through `hasNextPage` rather than assuming one page covers the window. Two companion cautions: comments do not reliably bump issue `updatedAt`, so the state-targeted sweep is the dependable candidate surface, not recency alone; and the `state` filter matches by state *type*, not name (Backlog and Refinement conflate — convention-linear *Reading Linear safely*), so bucket returned tickets on their `status` field client-side. Where even a narrowed read overflows, fall back to convention-linear's out-of-band subagent parse.

**Pass a compact** `fields` **set first — that is the cheapest defence, ahead of any narrowing by state (APP-1323).** The read discipline above was written against overflow and timeout before `list_issues` exposed `fields`, and it prescribes the most expensive shape that works: per project × per coordination state, paged, with halving retries. `fields` changes the arithmetic. Pass a compact set — `["title","status","statusType","labels","assignee","project","projectId","parentId","updatedAt","url"]` — and each row returns those keys only, with the long `description` omitted, so a whole live-project sweep returns in one call on a team that overflowed at 75–77k characters unfielded. Bucket the returned rows on `status` client-side, exactly as the state-type caution above already requires. The per-state split and the `limit: 15` / halve-on-timeout page discipline are **retained as the fallback**, not as the default: reach for them when a fielded read still overflows or times out. This is the same discipline `skill-triage` applies to its Backlog poll and this skill already applies to its projectless and cycle-membership reads; it was simply never brought back to the general sweep. **Nothing here relaxes *Candidate selection*.** The cheaper read exists so the bounded, repeatable selection rule stays affordable at fifteen live projects — not so a run can substitute a recency-and-priority sample for it. Selecting candidates by "human-labelled, Blocked or In Review, Urgent or High, recently touched" is the judgement-by-feel that rule forbids, and it can silently skip a genuine operator comment on a ticket that is none of those things.

**And the budget is read against the live project count this run resolved, not against the count the worked cases were measured on (APP-2700).** The arithmetic above and the pass-deferral grace below are both stated against fifteen live projects, which is what the cases that produced them measured — and the live set is not a constant. It is resolved fresh on every fire by the Trigger liveness gate, it moves with the portfolio, and a run planning its reads against the remembered figure while sweeping a materially larger set is budgeting for a board it is not looking at. The symptom is quiet and it is the dangerous one: the per-run budget silently buys a smaller fraction of the sweep each time the set grows, and what gives way first is not a pass declared dropped but a pass bounded to a plausible-looking sample — which is the one substitution *Candidate selection* forbids, arriving as a budget consequence rather than as a choice. So **the run states, in its own report, the live project count it resolved on this fire, and reads its budget against that number**, alongside the passes and projects the declaration rule below already requires. The fifteen in the clauses either side is the provenance of that arithmetic and stays as that; it is not the figure a run plans against. **And no standing replacement number is written here**, deliberately: a count copied into canon goes stale in exactly the way this rule exists to catch, so canon holds the derivation and the run holds the number. Where the resolved count is far enough above the worked cases that the budget plainly cannot cover the sweep, **that is itself a finding and is reported as one** — at that point the constraint is the budget rather than any single pass, the operator is the only one who can move it, and project rotation becomes this run's default rather than its exception, declared as such in the report rather than taken silently. (Worked case: the 2026-10-27 scheduled run resolved **21** live `statusType == started` projects across A1, Apps, MBN and Mr Pritchard, against the ~14–15 every case this skill cites for read-volume and pass-deferral planning was measured on — roughly 40–50% growth with no change to the per-run budget. It completed Passes 1 and 2 only; Pass 1 could not be run exhaustively across the full candidate population at that scale and was bounded to the @mention and `claude-code` override plus a targeted sample, which surfaced two real items but is a sample rather than the selection rule. Passes 3, 5, 6 and 7 did not run. The 21-project enumeration, the per-pass outcomes and the growth figure are that run's **report** — the live project set was not re-resolved here — while the two clauses this paragraph sits between were grepped against the live store. APP-2700.)

**A run that cannot complete all seven passes says so, and the skipped passes run first next fire (APP-1323, APP-1387).** The seven passes are a sequence, and a run whose budget runs out part-way through is a normal event at fifteen live projects, not a defect. What is a defect is a silent partial: **a skipped pass and a checked-and-clean pass are indistinguishable to the next reader unless the run says which it was.** A report that reads like a completed sweep while Passes 3, 5, 6 and 7 never ran leaves the operator believing the board was checked for surface-and-flag items, parent rollups, decision-log divergence and cycle membership when it was not — so a Pass 3 duplicate or a Pass 6 divergence can go unfound across many firings with nothing recording that it was never looked for, because the next run makes the same choice independently and the same passes starve every time. So: **name the passes that ran and the passes that did not, by number, in the run's own report**, alongside the candidate count and the projects swept — and on the next fire run the deferred passes **first**, before Pass 1, so the rotation is bounded rather than a standing preference for the early passes.

   **And a rotation promise is discharged or re-declared — the next run names the last run's deferred list and says what it did with it (APP-2657).** The rule above makes a short run declare what it dropped and commits the next fire to taking it up first. Nothing makes the *second* half observable, and the gap is not symmetric: a missing declaration is caught by the next reader, while a declaration that is never honoured reads as a correct run every time, because each report is well-formed on its own and only the sequence shows the starvation. The effect is the same standing preference for the early passes the declaration was written to end, with better paperwork around it. So a run reads the previous run's report before it chooses scope, and its own declaration names three things rather than two: the passes and projects it ran, the ones it deferred, and **what became of the ones the previous run deferred** — discharged, or deferred again with the reason stated as a reason this run could not take them first. A pass deferred on the same ground three fires running is itself the finding, reported on the same footing as a starving blocker relation, because at that point the constraint is the budget rather than the pass and the operator is the only one who can move it. This stays a declaration rule: it sets no Nth-run cadence, which the rule above rules out, and it asks for no separately-scheduled sweep, which is the Owner's scheduling surface rather than canon's. (Worked case: the 2026-10-23 run deferred Passes 3, 5, 6 and 7 and stated next-run priority #1 as "take up first per the rotation rule"; the 2026-10-24 run deferred the same four for the same reason, and the 2026-10-25 run — split across four team-scoped sub-sweeps — discharged Pass 5 and deferred 3, 6 and 7 again. The discharge was visible only because a reader compared three reports by hand, which is the comparison this rule moves into the run. The reports and their wording are the filing leg's **report** and are unverified here; the canon rule they are read against was checked against the live store — APP-2657.)

**An absent sweep is recorded as absent**, the same standard `skill-ops-sync` holds for an absent measurement. Passes 1 and 2 are never deferred: an unanswered operator comment and a stale or starving blocker relation are the two findings whose cost compounds daily. *Which* of the remaining passes a short run drops is not itself the question — a run reasonably prioritises passes holding live dated candidates over passes needing a fresh wide read — and that is why the remedy is the declaration plus the bounded next-fire rotation, and **not** a stated Nth-run cadence for the expensive passes. A run that completed everything says so in one line; the declaration is cheap and it is the only thing that distinguishes a clean sweep from a narrow one. (Worked cases: the 2026-09-11 scheduled run resolved 15 `statusType == started` projects across Apps, MBN, A1 and Mr Pritchard, read them per-project with compact fields, then selected ~13 candidates by priority signal and ran Passes 1, 2 and 4 only; Passes 3, 5, 6 and 7 did not run at all and the substitution was visible only because the run filed a note about it. It found nothing actionable, which was the board's state rather than the method working — APP-1323. The 2026-09-12 scheduled run then completed Passes 1, 2, 4, 5 and 7 and dropped 3 and 6 for budget, with nothing in the report distinguishing a dropped pass from a clean one — APP-1387.)

**The same declaration and the same rotation apply to *projects*, not only to passes (APP-1470).** The rule above bounds which passes a short run defers; nothing bounds which *projects* it reads. A run that cannot sweep every live project picks its own subset, the subset is chosen independently each fire, and so the projects that are largest and slowest to read are the ones most likely to be dropped — every time. That is the pass-starvation failure one axis over, and it is worse on this axis: a pass that never runs is at least absent for every project equally, whereas an unread project is a hole in a report that otherwise reads complete. So: **name the live projects the run did not read, or read only in part, in the same declaration**, alongside the passes that ran and did not — and on the next fire read those projects **first**, before returning to projects the last run already covered. A partially-paginated project counts as unread: record the project and the point the pagination stopped, not merely that it was opened. This is an extension of the existing mechanism, not a second scheduled coordinate pass and not a standing per-project priority order — canon already resolves scope live and rotates deferred work to the next fire, so the extension follows the grain; a separately-scheduled sweep for the largest project would be a change on the Owner's scheduling surface rather than a canon rule, and is not proposed here. The effect is that an unread project carries the same next-fire guarantee an unread pass already has.

   **A sweep that loses its own receipts mid-pass reports unconfirmed coverage, which is a third disposition and not the deferred one (APP-2664).** The two rules above bound what a run *chose* not to attempt and commit it to the next fire. A run can also attempt the work, complete some or all of it correctly, and then lose the ability to say which — an in-session context compaction inside a single declared pass erases the tool-call history the coverage claim rests on, leaving the run believing it is mid-Pass-1 with no receipts for what it already did. That is a **memory** boundary rather than a budget one, and it needs a different remedy: a deferred project is re-run, while an unconfirmed project is re-**verified**, and reporting the second as the first either repeats writes already made or lets a genuine hole read as covered. So a sub-sweep that cannot reconstruct its own coverage names those projects **unconfirmed** — never swept, never clean — gives its write count as a range and says it is a range, and the next fire re-verifies them before returning to projects already covered, on the same next-fire guarantee a deferred project has. And because the loss is cheaper to prevent than to reconstruct, a sweep records coverage as it goes rather than at the end: the project just finished, the states swept and the running write count appended to a keyed file in the session outputs folder per `convention-agent-runtime`'s partition-key rule, so a compaction resumes from something durable. Splitting a team-scoped sub-sweep into smaller per-project chunks is the other available cut and is the operator's, not canon's — it changes how the fan is dispatched rather than what a run owes its reader. (Worked case: the Apps sub-agent of the 2026-10-25 run compacted part-way through, re-verified only os.Claude of its six assigned projects, could not tell whether app.Triage, app.DS-Quality, app.Foundry, app.AgentArt and osclaude.vitals had been swept or were genuinely empty, and reported its own Linear writes as a reconstructed 7–9 rather than an exact figure. It named the gap rather than reporting a clean sweep, which is this skill's absent-sweep standard arriving by judgement one layer in. Single observed instance, one sub-agent, one run; the sub-agent's reads and write count are its own **report** and are unverified here — APP-2664.)

(Worked case: the 2026-09-15 scheduled run resolved 14 live projects and read 13 of them with compact fields, but **os.Claude — by this skill's own worked cases the largest and most overflow-prone project in the workspace — was never read at all**, not even a first fielded pass, because the other projects' reads had consumed the run's practical budget; and `a1.MeirionPritchard · Work section` returned `hasNextPage: true` with its second page never fetched. Both gaps were visible only because the run filed a note about them — APP-1470.)

**A timeout is not an overflow — cap the page, and halve it on a timeout rather than trusting a fixed number.** Everything above is written against overflow, and prescribes narrower *scope* as the remedy. A correctly-scoped call can still **time out**: `list_issues(project: "os.Claude", state: "Blocked", limit: 50)` returned `timed out after 180s`, and the identical call at `limit: 25` returned ten issues in seconds (task-coordinate, 2026-07-20, APP-594). Overflow wants narrower scope; a timeout wants a smaller page. So the working shape is project + state paged through `hasNextPage`, not one big page — but the page cap is **adaptive, not a fixed 25**: the `limit: 25` floor is not stable, because a project's state bucket grows over time. On 2026-08-13 the same `os.Claude` + `Blocked` sweep timed out at both `limit: 50` **and** `limit: 25`, returning only at `limit: 15` — the os.Claude Blocked bucket had grown to ~15+ `agent:PUL-5E` canon-intake notes and the page that once cleared in seconds no longer did (APP-844). So: **start os.Claude state sweeps at `limit: 15`, and on any 180s timeout retry the same call at half the page** (25 → 12 → 6 …) until it returns, rather than treating any single number as the permanent working page. The deeper driver is that the growing Pulse friction queue inflates every os.Claude state read: canon already says to exclude `agent:PUL-5E` from the candidate set up front (the bullet above, APP-791), but `list_issues` has **no negative/exclude label filter**, so the exclusion can only run client-side *after* the read has already paged the queue — the read cannot dodge the notes it is meant to drop. Draining the Pulse queue more often is the real relief; the halving cap is what keeps coordinate reading until it does. A server-side negative-label (or comment-feed-by-`createdAt`) filter is the connector ask that would remove the class — noted, not owned here.

**Project liveness is the second axis — gate the sweep on it before reaching for the fallback.** State-scoping alone is not sufficient, because the binding constraint is no longer *which state* but *which project*. A parked project keeps its full inventory in Refinement indefinitely, and that inventory is re-read on every run for zero candidates: Apps / Refinement still overflowed at 76,607 characters with the state gate applied correctly, and the overwhelming majority of it was Luna MVP — Retirement Navigator and app.fitness leaves — both project-status **Hold**, untouched since 2026-06-15 / 2026-07-02, every one of them discarded by *Candidate selection* as a bulk-sweep signature. The A1 side, which carries no such ballast, returned five tickets cleanly (task-coordinate, 2026-07-15, APP-530). So **resolve the team's projects first (`list_projects`, one small call) and sweep only those whose status is live — `statusType == started` — skipping Hold, Backlog, Completed and Canceled.** This is the same gate `task-daily-report` already applies to its reporting, and it reads project status for what it means: Hold exists precisely to park a started project, and a parked project's tickets are not coordination candidates.

The scope reduction this buys is deliberate, and it has one hole worth naming: an operator comment landing on a ticket inside a Hold project would otherwise go unprocessed until the project restarts. The existing escape hatch closes it — *Candidate selection*'s "**always** include any ticket where the operator has @mentioned coordinate or the `claude-code` label since the watermark" is **not** subject to the liveness gate. So the rule is: a parked project's *inventory* is out of scope; a parked project's ticket the operator has explicitly pointed at is not. Where a project's status is genuinely stale rather than deliberate, that is a project-status hygiene item to surface in Pass 3, not a reason to widen the sweep back out. `statusType == started` is a coarse proxy and the staleness cuts both ways: a **Hold** project carrying live work should be restarted, and — the direction that bit — a **`started`** project with no ticket activity in N days is dormant-but-unparked, re-swept every run for zero candidates while its status still reads live. Both are surfaced in Pass 3 (*Dormant started project*, APP-871), never resolved by widening the gate. A third case completes the family: a **just-restarted** project — Hold → `started` within the last N days (default 7) — is live to the gate but is under operator re-triage, and is handled in Pass 3 (*Just-restarted project*, APP-1036) rather than swept for strands as though it had never been parked.

## Behaviour

The run executes seven passes in sequence.

### Pass 1 — Comment sweep

For each delivery ticket **not** In Progress under `agent:F0-RGE`, and where new eligible comments exist since the watermark (selected per *Candidate selection* above):

1. Read the new comments and the ticket body together.
2. **Closed open question** — if the comment answers an open question in the body: apply the answer to the body directly, then reply confirming ("Applied @aledpritchard's answer: [summary]. Body updated.").
3. **Routing instruction** — if the comment is an explicit routing signal (e.g. "route to exec", "this is ready", "promote to Todo"): set `agent:F0-RGE`, move to Todo, clear the assignee. Post a confirmation comment. **An explicit authorisation of a surfaced proposal is a routing instruction too.** Where the operator replies on a ticket coordinate has already surfaced in Pass 3, Pass 4 or Pass 6 with an unambiguous instruction to carry it out — "execute now", "do it", "go ahead and park them" — the item is no longer a proposal awaiting a decision; it is an instruction already given, and this pass executes it. The write is bounded to what the proposal named and to reversible state, label and relation writes: park to Backlog, move out of In Progress, set a relation, set `human`. Never Cancel, Duplicate, Done, delete, or a project-status change on the strength of an authorisation — those stay the operator's own writes even when he has said "do it". Acknowledgement is not authorisation: "noted", "will look", "thanks" leave the proposal standing. When the wording is genuinely ambiguous, ask in-thread and leave state unchanged, as for any other comment. The comment-idempotency guard does not silence this: the operator's authorising comment is new information by definition, so the run that reads it executes and confirms in one comment, and later runs stay silent. (Worked case: A1-340, the a1.Muse reconciliation ticket — the operator wrote "From Relay: execute scope step 1 now — park the audit cells, profiles, propositions and blueprints out of In Progress… do not cancel them" on 2026-08-18 and again on 2026-08-22. Prior runs kept reading it under Pass 6's proposal-only framing, and sixteen tickets stayed falsely In Progress for two weeks until a run executed the park on 2026-09-03 — APP-1093.)
4. **State / label / priority change** — apply directly, then confirm in a reply.
5. **Cross-ticket decision** — if the comment implies a follow-on ticket, file it in Backlog and link; otherwise apply in-line.

Post a single summary reply per ticket, not one reply per comment. If a comment's intent is ambiguous, post a clarifying question in-thread and leave all state unchanged until Aled replies.

### Pass 2 — Dependency hygiene

Sweep all delivery tickets with blocked-by relations.

**Scope bound — relations are readable per-ticket only, so this pass reaches only the tickets a run has already fetched (interim canon, APP-976).** The connector exposes `blockedBy` / `blocks` relations **only on `get_issue(includeRelations: true)`**, one ticket at a time — the compact `list_issues` read returns **no relation data even with a `fields` set** requested. So a full `blockedBy`-graph sweep is **not achievable at board scale in one session**: there is no read that returns "every ticket with a blocker" across a team without fetching each ticket individually, which the read-volume and timeout limits in *Trigger* already rule out. Therefore scope every relation-graph task in this pass — the stale **Canceled / Duplicate / Done** blocker-relation cleanup, the all-blockers-cleared harvest and auto-promote, and the root-blocker blast-radius walk — to the tickets a run has **already fetched**: the **Blocked-state set** (swept per *Trigger*), any ticket touched in Pass 1 or Pass 4, **and every `agent:F0-RGE` ticket in Todo** — the delivery loop's own candidate set, a bounded dozen or so, and the one class where an open `blockedBy` routinely coexists with a non-Blocked state, because `routine-delivery-loop` treats an open relation as ineligibility rather than moving the ticket to Blocked. Without that class the root-blocker walk below cannot reach a root whose only dependents sit in **Todo**, which is the commonest shape a starved build chain takes and the one that walk exists for. (Worked case: A1-398 — `human`, `operator-a1`, assigned the Owner, priority Medium, Todo since 2026-09-12 — has been the sole live root blocker on A1-399 → A1-400 / A1-401 across seven consecutive `routine-delivery-loop` runs between 2026-09-24 and 2026-09-29, each of which computed its blast radius correctly in the zero-eligible diagnostic and none of which may write to a ticket it does not own; A1-281 roots A1-282 → A1-285 on the identical shape, In Progress since 2026-08-15 with every acceptance box blank. Every dependent in both chains is in **Todo**, so no run of this pass ever fetched either chain and the escalate-by-age ladder never fired on either root — APP-1801, APP-1726, APP-1318.) A stale `blockedBy` on a **Todo / Refinement / In Review** ticket that no run has fetched is **out of reach** until the connector exposes relations in a list read — it is not a miss to chase harder, it is a read the connector cannot serve. This is a **known connector limitation documented so it is not re-discovered each run**, the same silent-scope class as the comment-feed and negative-label connector asks already noted in this skill (*Candidate selection*, APP-288 / APP-844) and in `convention-linear`. The real fix — a connector-side **relation-bearing list read** (a `blockedBy` / `blocks` `fields` member, or a relations feed) — is an **Owner-owned connector ask, not canon**, and is not encoded as an instruction here. Reference APP-976.

**Stale-relation cleanup (autonomous):** where a blocker is **Canceled** or **Duplicate**, remove the blocked-by relation and comment: e.g. "Removed stale blocker to APP-120 (Canceled). No action needed."

**All blockers cleared (Done/Canceled) — harvest, then auto-promote where ready.** When a ticket's last blocker resolves:

1. **Harvest first (lift, don't re-derive).** If a cleared blocker was a design or decision ticket, lift its locked output into the dependent ticket's body — the spec, tokens, icon name, Figma node, reference SVG, interaction, whatever the build needs — and remove the satisfied relation, so the build leaf is self-contained and Forge never has to chase the design ticket.

   **A harvest reconciles; it does not only append.** Where the cleared blocker's output *reverses* something the dependent already asserts — an acceptance criterion, a note stating a now-superseded decision — strike or correct that text in the same edit, and name in the confirmation comment which criterion the decision overrode. Appending the new spec beside the old leaves the ticket asserting both, and a build leg reading the acceptance criteria in good faith will build the reversed behaviour and look compliant doing it. The source fix is upstream, not here: `convention-decision-log` requires a decision's **Impact** field to name and reconcile every open ticket it supersedes, in the same action that records the decision (APP-724 / APP-725). This clause is the relation-graph net beneath that rule, for the case where the reconciliation did not happen — coordinate is not the owner of it. (Worked case: A1-253's approved ADR reversed A1-219's AC3 in those words; A1-219 kept the reversed criterion, and it was caught only because the build leg read the sibling spike out of curiosity — a run that trusted the acceptance criteria, which is what an acceptance criterion is for, would have shipped the behaviour the ADR exists to prevent — APP-710.)

2. **Auto-promote (refinement gate → Todo) when all of these hold:** the ticket rests in the refinement gate as a state class — **Refinement, or Backlog where triage never moved it** (the two share the `backlog` statusType; bucket on the `status` field, and treat a Backlog ticket as in scope only when it is otherwise fully refined) — and is **fully refined** (`## Acceptance criteria` and `## Definition of done` both present, Pattern A criteria embedded, no open gaps or questions); an **executor is set, or the ticket is a harvest leaf resting under `agent:R3-LAY`** — that is the expected state for the harvest class (`convention-ticket` holds a harvest-blocked leaf "in the refinement gate under the triage marker, not an agent executor"; `skill-triage` placement 3), not an unmet criterion, so coordinate sets the executor at promotion in the same write that moves it to Todo (`agent:F0-RGE` for repo work; the matching connector-fleet value per `skill-triage`'s routing table for design, marketing, discovery, pipeline or scheduling work); **every blocker is Done/Canceled** and its relation cleared (genuinely unblocked); any required **harvest is complete**; and **no standing operator hold applies** (the disqualifier below). Promote to Todo, clear the assignee, and comment confirming. A blocker reaching **Done is the sign-off** for that blocker's output, so no separate operator judgement is needed — that is the whole point of the design/decision ticket existing. Triage's *Harvest sweep* is the primary owner of harvest-then-promote; this step is the relation-graph net beneath it, and it must be satisfiable by the very ticket class it exists to serve. (Worked case: APP-1070, bot.Trader — Backlog + `R3-LAY`, both blockers APP-1068 / APP-1069 Done, harvest lifted into the body, promoted to Todo on 2026-09-02 on the substance of its readiness while matching neither the "in Refinement" nor the "executor label is set" clause as then written — APP-1077.)

   **Standing-hold disqualifier — literal readiness never overrides a deliberate park.** Even when every criterion above is met, do **not** auto-promote if the ticket carries either: (a) a **prior coordinate or operator comment that explicitly reserved promotion to the operator** ("promotion from Refinement remains yours", or the operator having assigned it to himself and left it parked); or (b) a **body-stated dependency that is not encoded as a `blocks` relation** (a soft "depends on / after X" the criteria cannot see). In both cases the face-value criteria understate the real state: the operator has already signalled the call is his, or a dependency exists the relation graph does not carry. Treat it as a hold — leave it in Refinement, stay silent under the comment-idempotency guard, and do not re-surface it every run. Distinguish **"unblocked and never surfaced"** (promote) from **"unblocked, surfaced, and left parked by the operator"** (hold): a ticket coordinate itself previously handed to the operator, or that the operator has deliberately sat on, is his to release, not coordinate's to auto-promote. (Worked case: COS-223 / COS-224 satisfied every Pass 2 criterion on 2026-07-04, but coordinate had recorded "promotion from Refinement remains yours" on 2026-06-16/17 and the operator had left both parked ~3 weeks; auto-promoting would have overridden a standing hold and re-contradicted coordinate's own prior statement — APP-436.)
3. **Otherwise, hold (as before).** If any criterion is unmet — gaps remain, no executor set, harvest outstanding, a standing operator hold applies, or a judgement is genuinely still open — do **not** promote. Post a comment @mentioning Aled with the recommended next move and assign him. If the ticket still carries `agent:R3-LAY`, set the `agent`-group value to `human` in the same action — a decision-gated leaf handed to the operator leaves the triage poll the moment it is surfaced, rather than re-matching every run until a later hygiene relabel (worked case: A1-97, decision assigned 2026-07-09 with `R3-LAY` left in place, re-polled until relabelled 2026-07-11 — APP-492).

Auto-promotion is **case-by-case judgement against the criteria above**, not a blanket sweep of everything in Refinement. It is idempotent: once a ticket is promoted to Todo it leaves coordinate's Refinement scope, so there is no unblock → auto-promote → re-block loop. *(Future: coordinate will promote in concert with Atlas, weighing priority and goals as well as readiness; out of scope for now — for now, promote only on the readiness criteria above.)*

**Stale Done-blocker relation — clear it autonomously (truth-restoring, reversible).** Where a blocker reached **Done** and its `blockedBy` relation was never cleared, the relation is stale: Done is the blocker's sign-off, its output has shipped, so the block no longer represents a real dependency. Provided **no harvest is outstanding on that relation** — a Done *design or decision* blocker whose locked output has not yet been lifted into the dependent stays with the harvest-first flow above, which removes the relation only once its output is captured, so coordinate never clears a pointer Forge still needs — coordinate **removes the stale relation itself** and comments naming the cleared blocker: e.g. "Cleared stale blocker to APP-120 (Done 2026-08-04; output already harvested / none owed). No action needed." This is the same low-risk, reversible write class as the autonomous Canceled/Duplicate cleanup above — a `blockedBy` is trivially restorable, and clearing a Done-blocker relation restores the board to truth rather than deciding anything — so it no longer flags-and-assigns the operator for a mechanical cleanup. The **convention-ticket** discipline for this stale-relation class (when a lingering relation is a defect to clear versus a deliberate soft-hold) is authored by a sibling unit; this clause is coordinate's relation-graph write only, not the convention (APP-868).

**Still genuinely blocked:** leave the relation in place — it is correct, and a correct relation is not a defect to fix. Where the *wait* has become the story, surface the blocker rather than the blocked ticket, as follows.

**Root blocker starving downstream work — surface it once, on the blocker, with its blast radius.** Walk each still-blocked ticket's chain to its **root blocker** — the blocker with no open blockers of its own. Where that root carries the `human` value and has sat unmoved for more than three days, post one comment **on the blocker** naming the two facts nothing else in the system computes: the **count of tickets it transitively blocks**, and **how long it has sat in its current state**. Assign the operator and escalate the blocker's priority per `convention-linear`'s escalate-by-age ladder. Do **not** change its state — promoting, re-routing or closing the operator's own work is not coordinate's call, and the relation itself needs no repair.

**The walk is an explicit per-ticket fetch, and an unwalked chain is reported, not assumed empty (APP-1272).** The compact per-state read returns no relation data at all (*Scope bound*, above), so a Blocked-state ticket's chain is walked only where the run spends a `get_issue(includeRelations: true)` on it. Fetch relations for **every** ticket in the run's Blocked-state set before this pass concludes — that set is already bounded by the per-project, per-state page discipline in *Trigger*, so it is a known cost rather than an open-ended one — and where a fetch is skipped or the budget runs out first, **name the unwalked tickets in the run report**. A Blocked ticket whose relations were never read is an **unwalked chain**, not a chain with no qualifying root, and treating the two as one is how a qualifying root sits unsurfaced for a week while every gate it should have tripped reads green. **Where this run itself sets or first records a** `blockedBy` **relation** — the Pass 1 authorised-reconciliation write is the common case, since *Routing instruction* admits "set a relation" among its bounded writes — walk that chain in the **same** run rather than leaving it to a later one: both tickets are already fetched, so the age and blast-radius check costs nothing beyond the arithmetic, and deferring it is what puts a week between a relation being created and the wait being surfaced. (Worked case: A1-340 went Blocked on 2026-09-03 inside a `started` project, in the swept Blocked-state set and past the liveness gate the whole time, with A1-363 — `human`, assigned to the operator, Todo unmoved since 2026-08-17 — as its sole blocker and the chain's root. Neither gate excluded it and the relation had been set by that same 2026-09-03 run; A1-363 nonetheless carried zero comments until 2026-09-10, 24 days unmoved and a week after the relation existed — APP-1272.)

Two reasons this sits in Pass 2 rather than in the delivery loop's end-of-run report. First, a root blocker parked in **Backlog** is outside every sweep that would otherwise reach it: coordinate's own state scope is Blocked / In Review / Refinement / Todo, `convention-linear`'s escalate-by-age ladder rests on In Review / Refinement, and `task-daily-report`'s long-waiting surface likewise — so it is reachable only **through the relation**, from a ticket that *is* swept. That is the same shape as the projectless parent in Pass 3: a ticket no sweep enumerates is not thereby harmless. (Whether the ladder's own trigger set should extend to Backlog is a `convention-linear` question and is left to that lane; coordinate reaches the blocker through the relation under either answer.) Second, blast radius is what turns a flat list of operator items into a ranked one — "one signature releases three builds" reads identically to "someone must go and do a day's work" until the count is stated. Re-surface only when the count or the state changes; the comment-idempotency guard governs the rest, and an unanswered surface escalates by age (below) rather than repeating.

(Worked case: on 2026-07-30 six of seven `F0-RGE` Todo tickets were blocked behind five human-lane tickets, all assigned to the operator; by 2026-08-05 the queue was 100% inert behind four. APP-674 sat in Backlog from 2026-07-25 while transitively starving three build leaves; A1-225 sat in Backlog 21 days at priority **Low** while holding a build; MBN-252 sat In Review with all four acceptance boxes ticked, needing only a signature to release MBN-251. Every one of those figures was derived by hand, run after run, because nothing computes them — APP-723.)

### Pass 3 — Surface-and-flag

Proposals only. Post a comment @mentioning Aled. Never auto-restructure, create tickets in bulk, delete, or merge.

**The three structural checks run against each live project's full open inventory, once a week — not against the run's recency-windowed candidate set.** *Read volume* above scopes the sweep to a short `updatedAt` window matched to the run cadence, and *Candidate selection* bounds Pass 1 to tickets touched since the watermark. Every check in this pass inherits that scope, and three of them — **missing parent**, **missing milestone** and **epic scope-bleed** — are defects in a ticket's *structure at filing*, which never changes again and therefore never re-enters a recency window. A ticket filed once with no milestone is submitted to these checks on the day it is filed and never again, however long it sits wrong; the recency gate is a bulk-write filter, and here it acts as a permanent exemption. So on the **first run of each week**, and only there — so the budget the seven passes share is spent on this once — read each live project's **open inventory in full**, not candidate-filtered: the compact `fields` set *Pass a compact* above already blesses (`["title","status","statusType","labels","assignee","project","projectId","parentId","updatedAt","url"]`), paged through `hasNextPage`, with the `limit: 15` / halve-on-timeout fallback unchanged. Apply those three checks to every row returned, plus a **milestone-target staleness** check: a milestone whose `targetDate` has passed while its progress is under 100%. Batch the result into **one comment per project** rather than one per ticket — a backlog-debt finding is a list, not an event, and the one-proposal-per-ticket-per-run cap is about events. Everything else holds: these stay **proposals**, never auto-restructuring, and an unanswered one escalates by age rather than repeating. Every other pass keeps its recency scope. **This is not the budget failure APP-1323 / APP-1387 record** — those are about fitting the whole skill into one run, and the answer there was a recency-sampled read; this is about the structural checks never getting full coverage at *any* cadence, which a recency sample cannot fix by definition. It is affordable only because the fielded read is: an unfielded full-project read is the shape those notes were right to refuse. (Worked case: a manual retrofit pass on a1.MeirionPritchard · Work section, 2026-09-24, found about 10 open tickets missing a milestone, 2 missing a parent, one stray debris milestone and one stale milestone target date — some sitting that way since July, none ever surfaced by this pass, all of them inside the defect classes it already names. One project audited; the other live projects are unchecked, and there is no reason to think it unique to this one. APP-1470 records an incomplete pagination on the same project on 2026-09-15, consistent with the same cause — APP-1730.)

**Candidate duplicates:** two tickets in the same project with highly similar titles. Post: "@aledpritchard Possible duplicate: [A] and [B] appear to cover the same ground. Recommend closing one — please confirm."

**Missing parent:** a leaf `type:task` or `type:story` in a project with epics that has no `parentId`. Post: "@aledpritchard [Ticket] has no parent. Consider grouping under [suggested epic] or confirm it stands alone."

**Missing milestone:** a leaf ticket in a project with milestones that carries no milestone. Post: "@aledpritchard [Ticket] has no milestone. Recommend [suggested milestone] — please confirm."

**Mis-homed child:** a child whose `domain:*` label (or evident subject) points to a different team or project than its parent's home — e.g. a `domain:MBN` business deliverable sitting under an os.Claude canon epic, where the canon siblings carry no such domain. Post: "@aledpritchard [Ticket] carries domain:MBN but its parent [epic] is an os.Claude canon epic. Recommend re-homing to [suggested project] — please confirm." Placement is checked one ticket at a time at refinement by triage, but a bulk-authored epic with all children created in one sitting bypasses that gate; this pass is the continuous net that catches it.

**Terminal-state parent with live children:** a parent in **Done or Canceled** carrying at least one child in a non-terminal state. Test the *parent's state against its children's*, not a label — this class is orthogonal to the mis-homed check above and trips none of its tells: the children carry no contradicting `domain:*` label and their subject matches the parent's fine. What is wrong is that the board reads as closed while the work is actively being done, and every roll-up under that epic is wrong. Pass 5 cannot catch it — it only rolls a parent *up* to In Progress, and rolling a **Canceled** epic to In Progress would be wrong anyway. Post: "@aledpritchard [Epic] is Canceled but still parents [N] live tickets ([list]). Recommend a replacement parent, or confirm the children should be re-homed — please confirm." **Never re-parent autonomously**: choosing the replacement epic is a scoping call, and re-homing across a team boundary is destructive.

**Cross-team parent link:** a child whose parent sits in a **different team**. Post it as a proposal naming both, and say plainly that it may be intentional. Since the 2026-07-14 restructure this is nearly always fallout rather than intent — moving an issue between teams renumbers it and leaves its parent behind (`convention-linear`, *The 2026-07-14 restructure*), so live work ends up parented to closed history in the team it came from. Whether a cross-team parent is *ever* legitimate here is an open question for the operator, which is exactly why this is a proposal and not a hard check: proposal treatment is correct under either answer, and can harden into a rule once he settles it.

Both checks come from the restructure's fallout in the **issue graph**, which the text-layer reconciliation missed entirely: APP-521 fixed `convention-linear`'s team table and APP-550 fixed `skill-plan`'s scope, but no artefact owned checking the parent links the renumbering left behind. (Worked case: MBN-135, **Canceled**, still parenting six live Apps / cOS.Build tickets — APP-514 In Progress, APP-507/508/516/517/518; and MBN-191, **Done**, still parenting APP-509 In Progress, which itself parents APP-510/511. The 2026-07-16 run found these **by analogy, not by rule** — that it noticed at all was luck, and luck is not a check. APP-565.)

**Projectless parent — the third member of the readable-but-wrong parent family.** A parent (`type:epic` or `type:feature`) with children, carrying **no `projectId`**, while its children unanimously share one project. Every sweep in the system gates on project liveness — this one, `skill-plan`, `task-daily-report` — and "sweep the live projects" silently means *a ticket in no project is swept by nobody*. A parked project's ticket returns when the project restarts; a projectless ticket never returns at all. The worst case is an outcome epic: it carries the engagement's acceptance criteria and is the ticket the operator closes to declare the outcome met, and its absence breaks the roll-up, so the project board shows the leaves without their parent. Cheap to test — the parent is already fetched. Post: "@aledpritchard [Epic] sits in no project while all [N] of its children are in [project]. Recommend homing it there — please confirm." **Propose, never set it autonomously.** Homing looks mechanical when the children are unanimous, but it is the same class of write as re-parenting, and Pass 3 proposes structural changes rather than making them. (Worked case: A1-110, the a1.Firmup outcome epic parenting nine-plus tickets all correctly homed in `a1.Firmup · Firmware updates`, found only incidentally by an unrelated `get_issue`, 2026-07-21 — APP-622. Sibling of the terminal-state parent and cross-team parent checks above, all three found by luck before they were rules.)

**Projectless ticket of any kind — and the read that can actually enumerate it.** The parent case above is the one a project-scoped sweep happens to reach, because the parent is fetched from its children. A projectless **leaf** is reached by nothing: coordinate enumerates per live project, so a ticket in no project is in no read this skill makes, and the check above cannot fire on it. So widen the case to **any non-Pipeline ticket carrying no `projectId`**, and give it its own read: once per run, per delivery team, a compact-fields `list_issues` (fields including `projectId`, `labels`, `status`, `parentId`) filtered **client-side on `projectId == null`** — the connector has no server-side "no project" filter — under the same `limit: 15` / halve-on-timeout page discipline as every other sweep. Closed tickets are dropped; Pipeline is never read. For each hit, propose a home from its parent's project, its `domain:*` label, or its title, and surface where the homing is genuinely ambiguous — "@aledpritchard [Ticket] sits in no project. Recommend [project] (from [parent / label]) — please confirm." **Propose, never set.** The write-side rule that stops this class arising — a run-filed ticket inherits its parent's project — is `convention-ticket`'s; triage's *Executor-presence sweep* is the Todo-side net; this is the continuous net across every state. (Worked cases: A1-361, filed by an exec leg on 2026-08-16 with no labels and no project, still projectless on 2026-09-02; A1-337, an operator-filed High leaf, the sole gate on firmup Phase 0 → 1, projectless four days — APP-984 / APP-1000.)

**Epic scope-bleed:** an epic whose children span two distinct outcomes or domains — typically capability-building (an OS canon capability) mixed with business-delivery (work that *uses* the capability). The tell is a child set where some carry a `domain:*` label and others don't, or two clearly different outcomes under one parent. Post: "@aledpritchard [Epic] mixes two outcomes — [A] (capability) and [B] (delivery, domain:X). Recommend splitting into separate epics so each closes on its own outcome — please confirm."

**Dormant started project (project-status hygiene — the one Pass 3 item keyed on a project, not a ticket).** The liveness gate (`statusType == started`, *Trigger*) is a coarse proxy: it reads a project as either live or parked, and a project that is `started` but has had **no ticket activity in N days (default 14)** — no state change, no comment, no new leaf anywhere in its inventory — is neither. The gate keeps re-sweeping it every run for zero candidates, and because it still reads as live nothing flags that it has gone quiet, so a genuinely stranded ticket inside it (a Pass 4 In-Review-on-`human` park, say) sits in that silence unnoticed. Surface the **project** once: "@aledpritchard [Project] is `started` but has had no ticket activity since [date] ([N] days) — live but dormant. Recommend setting it **Hold** to park it, or restarting it with a next action — please confirm." The board write — a1.Muse → **Hold**, or a restart — is the **operator's**, never the drain's: coordinate names the dormancy and the choice and does not set project status itself. Surfacing the dormancy keeps the project's inventory reachable in the meantime — it stays `started`, so Pass 4 still sweeps it and can surface the strand within — and is the started-side complement of the Hold-side hygiene the *Trigger* names. Do **not** widen Pass 4 on the strength of dormancy: the strand is surfaced by its own Pass 4 case, and this item only keeps the project's status honest so a dormant project is decided rather than left silently re-swept. One proposal per project per run, escalating by age like any other. (Worked case: a1.Muse, `started` yet untouched around A1-136's 37-day In-Review-on-`human` strand, re-swept every run for zero candidates — APP-871.)

**Just-restarted project (the third member of the project-status family — live, parked, just restarted).** The moment a Hold project flips back to `started`, every strand it accumulated before the park — In Review on `human` since before the park, In Progress on a completed handoff, duplicate pairs, dozens of frozen Refinement leaves — becomes a Pass 4 candidate in the same run, and that run lands exactly when the operator has re-opened the project to re-triage it himself. A faithful sweep would surface a dozen items as noise at the one moment they are least useful. So a project whose status went Hold → `started` within the last N days (default 7) is treated as **under operator re-triage**: suppress Pass 4 strand surfaces on its inventory for the grace window, and report the restart itself **once** as a Pass 3 project-status event ("[Project] restarted on [date] after a Hold since [date]; [N] pre-park strands held back for re-triage until [date]"). The *Candidate selection* @mention override is preserved — a ticket the operator points at inside a restarted project is surfaced regardless — and an unambiguous duplicate pair may still be surfaced, since that is a structural fact rather than a staleness read. When the grace window elapses, Pass 4 resumes on the inventory as normal. **Detecting the transition:** project `stateHistory` is not exposed on `list_projects`, so use the proxy — a `started` project whose tickets carry a bulk `updatedAt` cluster at one timestamp within the window, with no ticket activity for weeks before it, is a restart. Name this as the connector gap it is (a project status-history read), not a rule to re-derive. Do **not** treat the restart as a reason to widen or narrow the liveness gate itself. (Worked case: app.fitness and Luna MVP — Retirement Navigator, both Hold since ~2026-06-15 / 2026-07-02, both reading `started` on 2026-08-22 with `updatedAt` clusters at 14:23; the run held back APP-125, APP-114 and ~30 Luna Refinement leaves by judgement and surfaced only the APP-229 / APP-246 duplicate — APP-1036.)

At most one proposal comment per ticket per run. If an open proposal from a prior run has had no reply, do not re-post — it escalates by age instead (*Escalating an unanswered proposal*, below).

### Pass 4 — Stranded awaiting the operator (surface only)

A ticket whose work is finished but whose *state* still says otherwise has nothing surfacing it: In Review is outside triage's scope, and a Todo ticket looks like ordinary queued work. All the cases below are surfaced to the operator as proposals; coordinate never merges and never declares work finished. Apply the comment-idempotency guard (below) so a stranded ticket is surfaced once, not re-flagged every run.

**Pass 4's candidate set is narrowed by a compact read before any per-ticket read — and a second consecutive deferral is a finding, not a budget note.** *Read volume* above bounds Passes 1–3 and 5–7 with compact fields, state scoping and page caps. It does not bound this pass, and every sub-case below needs a label, thread or relation read per candidate ticket, so at a four-team In Review population the pass costs more than a run holds and gets dropped — invisibly, because a strand has no clock of its own and the run that dropped it still reports a sweep. Two bounds, both cheap. **(i) Select candidates on a compact-fields read keyed on the signal each sub-case already names**, before any thread read: `In Review` plus `agent:R3-LAY` for approved-but-unmerged, `In Review` plus `agent:PR-1SM` for in-review-with-no-verdict, a `started`-type state with no `agent` value at all for the executorless member — one `list_issues` per team per signal, `fields` selected and the page capped (`convention-linear`, *Reading Linear safely*), with the combined-filter count cross-checked rather than trusted. The sub-cases keyed on **relations** keep their per-candidate `get_issue` floor and are therefore ordered **last**, after label, state, project and team have narrowed the set — the ordering `convention-linear` already prescribes for the blocked-by test, applied to this pass rather than re-derived in it. **(ii) A deferred Pass 4 runs first on the next fire, and a second consecutive deferral is reported as its own finding**, on the same footing as a dormant started project. This does not promote Pass 4 to join Passes 1 and 2 as never-deferred; it removes the condition that makes deferring it the cheap option, which is a bound the pass has never had. (Worked case, **reported** from the 2026-10-30 run's own log on I-9: the 2026-10-28 run deferred Pass 4 in full and its same-day addendum committed to running it first on the next fire, ahead of further 3/5/6/7 work; the 2026-10-30 run tried to honour that and could not — `list_issues(team: "A1", state: "In Review")` alone returned 25 rows with `hasNextPage: true` before any per-ticket read, repeated across four teams. Second consecutive deferral of the pass. Same root as APP-2700, the whole-run budget case already folded into this skill, scoped here to the one pass carrying no bound of its own. APP-2770.)

**Approved-but-unmerged (Linear-detectable, actionable).** A ticket In Review carrying the **approval signal** — `agent:R3-LAY` set after review (the operator's approval action, evicting `agent:PR-1SM`), or an approval recorded only as prose in the thread — an operator `approved` comment, or an Owner ruling naming the ticket approved to merge — with **no merge after three days** has had its `@relay` merge signal lapse. Surface it: comment @mentioning the operator with the recommended `@relay` / merge action, and assign him. (Worked case: A1-72 approved 2026-06-25, the `@relay` signal never cleanly given, sat untouched until 2026-06-30.) **An Owner ruling given in the room is the commonest form of this, and the label is the only thing that moves the work.** `skill-merge-pr` reads `agent:R3-LAY` and nothing else, correctly — it must never manufacture its own approval — so a ruling that lands as a comment and never as a label is recorded, visible and inert. This sweep is the net beneath that gap: read the thread, not only the label set, and where an approval is found in prose with no label, surface the ticket naming the `R3-LAY` write as the recommended action. Coordinate never sets the label itself, never merges and never approves; it surfaces. (Worked case: APP-933, an Urgent live drawdown-guard fix, carried *"Owner ruling, stand-up 2026-09-11: Approved — merge"* as a comment with no label. It stayed In Review and was re-presented to the Owner as a fresh decision on the 09-12, 09-13 and 09-14 stand-ups before a delivery run found it — three further days on an already-approved live exposure — APP-1440.)

**In review with no verdict (Linear-detectable, actionable) — whatever route put it there.** A ticket **In Review carrying `agent:PR-1SM`** with **no subsequent `[qa]` / Prism verdict comment after three days**. This check was originally scoped to reviews requested *out of band* — hand-moved or re-scoped into In Review + `PR-1SM` rather than opened by an exec leg inside a loop session — on the reasoning that an exec-opened ticket already has its own session's QA leg watching it. **That reasoning does not survive the session ending.** The QA leg only reviews the PR its own exec leg opened in the **same session**, and no later loop run returns for a ticket it did not open, so an exec-opened PR that misses its same-session QA is stranded in exactly the state the out-of-band case describes: In Review, `PR-1SM`, no verdict, no watcher. Origin was never what made it stranded — the absent verdict was, so the check triggers on the absent verdict alone.

Surface it: comment @mentioning the operator recommending a **standalone Prism / QA pass** over the PR — or Owner approval in lieu of the Prism read where repo access is unavailable — and assign him. **coordinate cannot run Prism itself** (no repo / diff access), so it routes the review to a Forge-surface pass rather than attempting the read in-session, and never declares the PR good to merge — that verdict is Prism's, never coordinate's. **Surfacing is not review.** Both worked pairs below moved only because the operator read the comment and dispatched Prism by hand, so a surface that goes unanswered escalates by age (below) rather than collecting a second identical flag; the missing piece the drain kept finding is the route from "surfaced as stranded" to "a verdict actually runs", not another detector. (Worked cases: A1-200 / PR #64, hand-routed into In Review + `PR-1SM` on 2026-07-17, no `[qa]` verdict, unreviewed five days until the operator asked about the green PR by hand — APP-653. Then A1-120 / PR #77 and A1-236 / PR #78, both **exec-opened** on 2026-07-23 and both therefore skipped by the old out-of-band qualifier: each sat seven days, each moved only by hand, and A1-236's eventual Prism pass returned **changes needed** on two acceptance boxes that had been ticked but not met — so the strand was not benign, and a PR carrying two boxes that read as verified would have merged on green CI and its own self-report — APP-714.)

**False-green CI (named, not yet actionable here).** A PR whose branch predates a CI workflow newly merged to `main` reports "all checks passed" because the gating workflow never ran on it — so the ticket reads mergeable while its defining acceptance criterion was never actually verified (worked case: A1-72 / PR #27, the Playwright workflow added to `main` by A1-73 *after* #27's branch was cut). Detecting this needs **GitHub read access** — the branch-behind state and the workflow set on `main` — which this skill does not have: coordinate is **Linear-only**. It is named here as a known gap for the operator, not encoded as an instruction: either a GitHub-capable leg (qa / merge) owns the false-green guard, or coordinate's connector scope is widened to read PR/CI state. Do not bake in a check coordinate cannot execute.

**Delivered-but-not-handed-off (a Todo ticket whose deliverable has already landed).** A connector-surface fleet ticket — `SO-N4R`, `P1-XEL`, `R3-ACH`, `SC-0UT`, `A1-DE` — sitting in **Todo, unassigned**, whose latest comment is the agent's completed deliverable asking the operator to approve, amend or reject. Forge has a handoff transition for this (exec → In Review + `PR-1SM`); the Cowork-surface fleet's equivalent is a convention nothing enforces, so finished work stays in the queue. Two costs, both real: `skill-fleet-dispatch` can pick it up and redo work already done, and it never surfaces as something needing the operator. Post: "@aledpritchard [Ticket] is still Todo but [agent] posted its deliverable on [date] and asked for your call. Recommend In Review + `human`, assigned to you — please confirm." **Surface, never re-route:** deciding the work is finished is the owning agent's call, not coordinate's. The source fix is a handoff transition on the dispatch side; this pass is the continuous net until it exists. (Worked case: APP-524, Sonar's positioning deliverable posted 2026-07-15, still Todo / unassigned / `SO-N4R` five days later — APP-594.)

**Started-state ticket carrying no executor (Linear-detectable, actionable).** A ticket in a `started`-type state — **In Progress or In Review** — carrying **no `agent`-group value at all** (not a functional `agent:*`, not `human`, not an `operator-*`). The started states are the one region no routing sweep polices: Pass 1 and the `F0-RGE` guardrail only step around In Progress *under an executor*, the executor-presence sweep reads only Todo (APP-730), the `R3-LAY` poll excludes started states, and the Blocked sweep keys on an `agent:*` value the ticket no longer carries — so an executorless started ticket is invisible indefinitely. The standing cause is a **Done→In Progress reopen** that drops the executor and assigns the account owner without re-routing. Surface it: read the ticket's end state and recommend the fitting remedy — where its PR is merged and every AC/DoD box is ticked (the reopen was spurious), recommend **Done**; otherwise recommend re-routing to an executor (`agent:F0-RGE` + Todo, or `human` where it is genuinely the operator's). Assign the operator and comment once. Surface, never resolve: coordinate does not mark Done and does not itself re-route a started ticket it does not own. This is the **started-state member** of the no-executor blind-spot family — no-executor-in-Todo (APP-730), stranded-`F0-RGE`-in-Refinement (APP-400) — each of which got a targeted sweep, while the started states had none. (Worked case: APP-770 and APP-782, bot.Trader, each Done/merged then reopened to In Progress minutes later with no comment, executor dropped, assigned the owner, and invisible to every sweep until the owner opened one by hand — APP-811.)

**Verified reconciliation close (Linear-detectable, actionable) — a mechanical Duplicate, not an operator judgement.** A ticket parked **In Review on `human`, assigned to the operator**, whose exec/triage note records that its work has **already shipped under an identifiable carrier PR** with **every AC verified on `main`**, framed as a Done-vs-Duplicate call for the operator. Once that finding is unambiguous — a named carrier, both ACs met, the verification already recorded by the leg that read the repo — the close is a **record-keeping reconciliation with one right answer, not a judgement**: coordinate closes it as **`Duplicate of <carrier>`** itself with a one-line note, rather than leaving it on the operator. This is the single, bounded exception to *never marks Done* below, and it is tightly gated: coordinate acts only on a **verification another leg already performed and wrote into the ticket** — it never reads the repo itself (it cannot), never re-derives the finding, and never closes a reconciliation whose carrier or AC-status is not already recorded. Anything short of a recorded, unambiguous already-shipped finding stays an operator judgement, surfaced not closed. This keeps the In-Review-on-`human` park for closes that genuinely need the operator's eyes and takes the mechanical ones off his desk (Owner steer, 2026-08-12; APP-827). The *upstream* half — nothing reconciles a Backlog ticket against just-landed PRs before Todo — needs GitHub read a Linear-only sweep lacks and is the operator's connector-scope call (APP-818), owned there, not here.

**The state-no-longer-matches-work family — a ticket resting in a state no sweep owns (surface only).** The cases above each catch one shape of "the board reads active or queued while the work says otherwise". Four more complete the family, and all four arise the same way: a note — or a Pulse drain — can be *canon-complete* while the delivery tickets that surfaced it are left in the wrong state, because moving them is owned by no pass, so the correct behaviour of several passes composes into a permanent no-op. Surface each **once** (comment-idempotency guard) and escalate an unanswered surface by age; coordinate never re-routes or transitions them beyond the verified-reconciliation Duplicate above.

**Stranded Todo — an un-ready fleet ticket re-selected every sweep.** A connector-surface fleet ticket (`SO-N4R`, `P1-XEL`, `R3-ACH`, `SC-0UT`, `A1-DE`) resting in **Todo**, carrying a **standing not-ready / input-unresolvable comment**, with **no state change across three or more `skill-fleet-dispatch` sweeps**. `skill-fleet-dispatch` must not write state (it skips-and-reports), so an un-runnable Todo ticket is re-selected, re-tested and re-held indefinitely — the one-comment guard correctly keeps it silent while the ticket never moves. This is the un-ready sibling of *Delivered-but-not-handed-off*: that case is a *finished* deliverable left in Todo, this is an *un-runnable* one. It is a state-only signal — the standing not-ready comment plus the unchanged state is the whole tell, no prose re-inference. Post: "@aledpritchard [Ticket] has sat Todo on [agent] with a standing not-ready comment since [date], re-selected each sweep with no way to run its input. Recommend Refinement + `human` (its input is unresolvable in the dispatch surface) — please confirm." Surface, never move it: returning an un-ready ticket to Refinement is the operator's write. (Worked case: APP-122 and APP-508, held not-ready on `P1-XEL` every daily sweep after APP-813 drained the routing analysis Done but left them in Todo — APP-874; identical earlier shape APP-566 / APP-524, APP-657.)

**Abandoned dispatch claim — a dispatch-set claim with no hand-off and no movement, in either of its two states.** A connector-surface fleet ticket (`SO-N4R`, `P1-XEL`, `R3-ACH`, `SC-0UT`, `A1-DE`) carrying **no hand-off comment** and **no state change for more than three days**, in either of the two states a dead claim can rest in:

- **In Progress, unassigned** — the claim never cleared. This is the claim-without-a-runner case: `skill-fleet-dispatch` skips it as mid-run (*Idempotent per run*), so no sweep reaches it by construction.
- **Todo, still carrying its dispatch-set `agent` value and unassigned, with a prior In Progress under a dispatch-set label in its `stateHistory`** — the claim was cleared and the ticket returned to the queue, where the missed-handoff guard declines to re-claim a ticket with a prior claim. Returning it to Todo is therefore not a release; it is a move from one silent skip to another.

Both guardrails are right as concurrency and do-not-redo-finished-work protection; their composition is a silent skip on every subsequent run, and the earlier version of this case covered only the In Progress half — which is exactly how its own worked case recurred. Distinguish the family from the completed-handoff case below by the **absence of a deliverable**: there the work is finished and the state lags, here the claim is live-looking and the runner is gone. In the Todo half the executor label is itself the proof of no hand-off, since a hand-off evicts it (`skill-fleet-dispatch`, *The `agent` label is the guard*). It stays a state-only signal — the dispatch-set label, the state, the unassigned assignee, the absent hand-off comment and the age are the whole tell, with no prose inference.

Post: "@aledpritchard [Ticket] has been [In Progress / Todo] on [agent] since [date] with no hand-off — [N] days. The run that claimed it is over. Recommend **[state] + [agent] with the claim explicitly re-armed for one sweep** — the re-arm is a comment whose first line is the literal marker `[re-arm] dispatch claim released — one sweep` — or Refinement + `human` where its input is no longer resolvable — please confirm." **Surface, never re-claim it:** clearing a claim is the operator's write, and the re-arm marker is what releases `skill-fleet-dispatch`'s missed-handoff guard for a single sweep. **The marker is named here because the release must be recognisable to the loop that reads it** — `skill-fleet-dispatch`'s *State history separates a returned run from an un-started one* row defines that marker, its one-sweep consumption, and the age-based release that needs no marker at all; read the mechanism there rather than restating the guard here, and never prescribe a release this pass has invented on its own. Where the ticket sits in a vertical that has an operator, the surface goes to **that operator** (`operator-<venture>`), the standing first escalation target for its own delivery legs (`skill-operating-loop` step 5; `operator-bara`, *Boundaries*) — not to Relay, which owns delivery-loop triage and not connector-fleet dispatch. (Worked case, both halves, one ticket: MBN-263, `R3-ACH`, mbn.brand, Phase 1 · Convert — claimed 2026-08-22 20:13 and never handed off, In Progress **20 days**; the `operator-bara` stand-up of 2026-09-09 noticed the age and flagged it to Relay, which does not own that queue, so nothing acted on the escalation, and it moved only when the Owner asked directly on 2026-09-11. That move was to **Todo**, where it then sat a further **eleven days** untouched by any dispatch run until the Owner asked again on 09-22 — the second half, and the reason this case is no longer keyed on In Progress alone. Sibling of the two cases that produced the guard it hides behind — APP-566, APP-657 — and of the census that mis-read the same ticket's lane, APP-1039. APP-1357; recurrence APP-1645, 2026-09-22.)

**Stranded In Progress on a completed handoff.** A ticket in **In Progress** whose **latest comment is the agent's completed handoff back to the operator** — the build is done (PR opened and CI-green, or the deliverable posted) and the ticket is entirely awaiting the operator — but the state was left In Progress instead of transitioned to In Review. In Progress reads as "an agent is actively building this", which is false, and every sweep steps around it: triage never touches In Progress, the merge leg acts only on In Review + `agent:R3-LAY`, exec claims only Todo. Read the recorded end-state and recommend the fitting move — **In Review** (assigned to the operator, carrying the review executor its handoff names) where a verdict or sign-off is still owed, or **Done** where the PR is merged and every AC/DoD box is ticked and the transition was simply missed. Post the recommendation @mentioning the operator and assign him. Surface, never transition it: declaring the build finished is the owning leg's call and the state write is the operator's. Sibling of the executorless-started case above (APP-811) — there the executor was dropped, here it is present but the state was never advanced. (Worked case: A1-296, a Forge follow-up built PR #102, handed all remaining items back to the operator at 11:21, and left the ticket In Progress ~23 hours until the operator noticed — APP-877.)

**Reviewed and ready for the Owner, with nothing watching it.** A ticket in **Todo or In Review** whose **blocking tickets have all gone Done**, whose **latest comment is an operator or agent analysis that ends in a named Owner call** — a recommendation to accept, a sign-off request, a short set of plain-language judgement calls — and which has had **no state change and no new comment for more than three days**. This is the *ready-for-the-Owner* strand, and it is the one shape in this family that nothing in canon reaches. `convention-linear`'s *Escalating a stalled decision item* ages an item that has **already been surfaced** — it presumes `human` and an assignee, which this ticket has neither of; Pass 2 auto-promotes only out of the refinement gate, and this ticket is already past it; and the Pass 4 cases above each key on a signal it does not carry — not In Review with `PR-1SM` and no verdict, not a started state with no executor, not a Todo ticket with a standing not-ready comment, not In Progress on a completed handoff. So a reviewed ticket whose only outstanding need is the Owner's call rests in a state every sweep reads as ordinary queued or in-flight work, and it ages with no rising signal at all. **Threshold: three days**, the same rung the *in review with no verdict* case uses — the analysis is done and the wait is pure latency, so the two deserve the same patience. Post: "@aledpritchard [Ticket] has been [state] since [date] with its blockers Done and [leg]'s analysis posted on [date] leaving [N] call(s) for you — [N] days with nothing since. Recommend **In Review + `human`, assigned to you** — please confirm." **Surface, never move it**, per this pass throughout. The recommended move is deliberately the one that hands the item to machinery that already exists: once it rests In Review + `human` + assigned, it is on `convention-linear`'s escalation ladder and in `task-daily-report`'s long-waiting-operator-item line, so it climbs by age from then on. Do **not** build a second ladder here — the defect is that the item never reached the first one. (Worked case: MBN-280, the policy/trust pages sign-off, promoted to Todo on 2026-09-10 with its full review MBN-283 completed and posted on 09-11, leaving three plain-language judgement calls for the Owner exactly per APP-1352's pattern. Then **11 days of nothing** — no comment, no escalation, no nudge — until 2026-09-22, the day after the Owner had to direct on 09-21 that it be brought to him rather than wait for the Friday window. The analysis itself was sound; the whole failure was the gap between "ready for the Owner" and the Owner seeing it — APP-1661, 2026-09-22.)

**Stranded In Review on `human`, awaiting the operator's own close.** A deliverable resting **In Review carrying `human`** (or an `operator-*` value), **assigned to the operator**, unmoved for **more than three days** with no operator comment — a strand the two In-Review cases above miss, because they key on `agent:R3-LAY` (approved-but-unmerged) or `agent:PR-1SM` (no verdict), not on an In-Review park awaiting the operator's own judgement. Surface it once with the recommended close or decision and the age, then escalate by the *Escalating an unanswered proposal* ladder rather than re-flagging. This case is doubly hidden inside a **dormant-but-unparked** project: the project stays `started` yet quiet, so the liveness gate keeps re-sweeping it for zero candidates while nothing flags that it has gone dormant — that gate-coarseness is now itself surfaced as a project-status hygiene item in Pass 3 (*Dormant started project*, APP-871), so the dormancy no longer hides the strand — and the *Candidate selection* @mention override and a targeted `get_issue` remain the routes that reach a specific strand the operator points at, as for the projectless parent. (Worked case: A1-136, In Review 37 days with zero comments inside a1.Muse, a started-but-dormant project re-swept every run for zero candidates — APP-871.)

**Blocked with every blocker cleared — one comment marks the clearance and nothing marks the state.** Pass 2's stale-relation cleanup is deliberately a **relation-only** write, and `convention-linear` is deliberate that **Blocked → Todo is the operator's move** ("the operator clears it and moves it back to Todo"), not this skill's. Between those two correct rules nothing carries the follow-through. The Refinement-gate *all blockers cleared → harvest, then auto-promote* logic in Pass 2 is scoped to Refinement and Backlog-refinement-gate tickets and does not reach a **Blocked**-state one; no case in this family covers it; and Pass 2 re-fetches relations only for a ticket already in view, never on a recheck cadence. So a Blocked ticket whose last blocker was cleared carries exactly one comment saying so and then silence — indistinguishable from a Blocked ticket still genuinely waiting. Surface it the way the rest of this family is surfaced: a ticket in **Blocked** carrying **no `blockedBy` relations**, whose own thread shows the last one cleared **more than three days ago**, with **no state change since**. Post: "@aledpritchard [Ticket] has been Blocked since [date] with no blockers left — the last one was cleared on [date], [N] days ago. Recommend **Todo** — please confirm." **Never move it:** the transition is the operator's by convention, so this is a surface under the comment-idempotency guard and the escalate-by-age ladder, exactly like the cases above, and the clearance comment's own `createdAt` **is** the age — keep no per-run counter. The read this needs is the cheap half of the pass: the live Blocked set is small, and Pass 2 already fetches relations for the tickets in it. (Worked case: the 2026-09-24 run swept the five live Blocked tickets — MBN-254, A1-362, A1-351, APP-1226 and APP-1378 — and found **2 of the 5**, APP-1226 and APP-1378, whose `blockedBy` relations had been cleared by a run five days earlier on 2026-09-19. Each carried a correct clearance comment from that run — "worth a quick look before treating this as ready", "worth a CI re-check now that runners are back" — and each was still sitting in Blocked, unmoved, with nothing in the thread in between. A1-362 was genuinely still blocked, its blocker A1-429 open, which is the case this check must not flag. Two of five is a small sample and a high hit rate — APP-1712.)

**Ticket-side action handed over by the Pulse drain (read the manifest, then enact or surface).** The three cases above are found by sweeping the board; a fourth arrives by hand-off, and no reader has ever collected it. `skill-ops-retro`'s stranded-ticket guardrail requires a drained note whose subject is mis-routed or stranded tickets to **name the ticket-side action** — return to Refinement + `human`, or re-route — for this pass to surface or for triage to write. That action is written into the *Ticket-side actions* section of the Pulse author manifest, a document in os.Claude; coordinate sweeps the delivery board, and nothing told it to read that document. So the drain's correct behaviour and this pass's correct behaviour composed into exactly the permanent no-op the family above describes, reached through the hand-off rather than through the sweep. Read the *Ticket-side actions* section of the current `osclaude.pulse-manifest` index as one of this pass's inputs, following the index's pointer where that section has been moved into `osclaude.pulse-manifest.decisions` to hold the index inside its single-read ceiling, and treat each row as a named, decided action on a named ticket. A document is already a pass input here — Pass 6 reads the decision logs and Pass 7 the per-cycle goal document (`convention-linear` *Documents and the decision log*) — so this is one more read, not a new capability, and it is the same reader-beneath-a-write-time-obligation shape as Pass 6 one level up: the obligation to name the action is the drain's, and this is what notices when naming it moved nothing.

**Enact what is already inside the remit, surface the rest, and report both.** Where the named action is one of the reversible board writes coordinate already makes — a state, a label, an assignee, a `blockedBy` relation — **enact it** on the ticket the row names and comment once naming the manifest row it came from, never a Cancel, Duplicate, Done, delete or project-status change. This is the bounded execution the Pass 6 rule already permits on an authorised proposal, applied to an action the drain decided rather than one the operator authorised in-thread; re-surfacing a decided, reversible write only moves the stall from the manifest to the operator's desk. Where it is anything else — a close, a cancel, a re-scope, a write on a ticket the row does not name — **surface it** with the ticket, the action as the manifest states it, and how long it has been outstanding, measured from the row's first-named date, then escalate by age like any other Pass 4 surface rather than re-flagging. Then **report both sets at the end of the run**, each with its ticket and its named action, closing this loop the way `skill-ops-sync`'s parity report closes the canon→repo one. An action that is neither enacted nor reported is indistinguishable from one that was never read, which is the whole defect.

**Two boundaries keep the read narrow, and neither is optional.** **A manifest action is a hand-off, not an instruction to invent work:** enact only what the named action states, on the ticket it names — a sibling that looks equally stranded, or a wider remedy the row implies but does not state, goes back as surfaced, never enacted. And **a stale action is not a live one:** read only a section carrying the **current refine date**, because the manifest is full-replaced by each refine run, so an older index is superseded and an action still live is re-emitted by the next refine. The drain-side pair of this change — making *Ticket-side actions* a named, stable section carried forward across the full-replace, with a first-named date and a recurrence count — is authored in `skill-ops-retro` alongside it, and this read is written against that shape. (Worked case: A1-388, whose re-route was named as a ticket-side action in the 2026-09-04 manifest and reached nobody in the four days that followed. **Observed** this run by `get_issue`: A1-388 is In Review carrying `agent:PR-1SM`, unassigned, unchanged since 2026-09-03 10:49Z — about 118 hours — and it `blocks` A1-381, which in turn `blocks` A1-382, A1-383, A1-384 and A1-386, so the chain from A1-388 to the six build leaves under epic A1-377 is confirmed rather than assumed. **Reported** by `routine-delivery-loop`, in its comment on APP-1149 and in APP-1108 / APP-1129: five consecutive zero-output runs — 2026-09-03 16:09Z, 09-06 00:14Z, 09-06 09:14Z, 09-07 12:28Z and 09-08 00:14Z — the last of them 13 candidates and 0 eligible across four repos, with every one of the 13 held by a root blocker sitting in a human lane or an unpromoted state. This is APP-631's finding for dispositions — "named for action" is not a filing, it is prose in a thread no mechanism reads — reached again for hand-offs, and it is APP-552 / APP-600's rule left unapplied: a scope exclusion must name the pass that picks the work up, and that pass must be verified to do the job — APP-1149.)

### Pass 5 — Parent state rollup

A parent `type:epic` or `type:feature` frequently sits in **Backlog / Refinement / Todo** while its children are already **started (In Progress, In Review or Blocked) or Done** — a stale board signal: the outcome is clearly underway but does not read that way. Roll the parent's state up to reflect its children.

- **Trigger — state it as the statusType test, not an enumerated pair.** A parent (`type:epic` or `type:feature`) has at least one child in a **`started`-type state (In Progress, In Review or Blocked) or Done** (`completed`), and the parent is itself in a not-started state (Backlog / Refinement / Todo). Test the child's **statusType**, not a named pair: any child that is `started`-type or `completed` means the outcome is demonstrably underway, so the whole `started` family qualifies without re-listing. A child worked to In Progress and then landing in **Blocked or In Review** leaves a not-started parent reading falsely in exactly the way a plainly In-Progress child does — the old "In Progress or Done" enumeration missed both, which made each run re-decide by feel whether a Blocked/In Review child counts, the judgement Pass 5's precise wording exists to remove (APP-655).
- **Action:** move the parent to **In Progress**. Re-fetch the parent's current state with `get_issue` immediately before the write (per convention-linear *Reading Linear safely*), and apply the comment-idempotency guard — a parent already In Progress needs no action and no comment.
- **Hard boundary — never auto-advance a parent to Done.** An epic or feature is an outcome the **operator closes** when all its children are done (skill-triage *Behaviour*; convention-linear *Structure*). Only the "work started" transition (→ In Progress) is automated; completion stays the operator's. A parent whose children are *all* still Backlog or Todo stays put — a child in a `started`-type state (In Progress, In Review or Blocked) or Done triggers the rollup, never a child merely in Todo (`unstarted`) or Backlog.
- **Separate axes — no double-count.** Issue-level parent state and Linear *project* status are different axes: this rolls up the parent **issue** only, and never writes project status or touches the daily-report reporting gate (`statusType == started`). A re-opened child under an already-closed parent is out of scope (rare) — leave it.

(Captured 2026-07-07, APP-453; candidates on that run included A1-41, A1-110, COS-160 with children already In Progress/Done, versus A1-112 whose children were all Backlog and correctly stayed put. The `started`-family clarification came from A1-241 — a feature in Backlog whose child A1-242 had been worked to In Progress and then Blocked on repo access: demonstrably underway, but Blocked is `started`, not literally "In Progress or Done" — APP-655. **The generalisation has since been exercised on a state set that is not engineering's, and holds:** MRP-23, the Mr Pritchard fleet-series epic, sat in `Defined` with its one child MRP-24 in `In Review` — Mr Pritchard's editorial substitute for engineering's Blocked, carrying `human` per `convention-linear`'s state-mapping table — and rolled up to In Progress on 2026-09-10. `In Review` there means something closer to "parked awaiting the Owner's own call" than "stalled mid-build", and the rollup still read correctly: the series is demonstrably underway even where the specific child waits on him. So the test is read off the child's **statusType** and nothing else — never off what the state is called locally, and never off what the wait is understood to mean on that team — and a run meeting an unfamiliar state set applies it rather than re-deriving whether it transfers — APP-1271.)

### Pass 6 — Decision-log reconciliation

For each live delivery project in scope, read the recent decision-log entries the project maps to — the index-plus-weekly-child-document structure `convention-decision-log` defines, filed as Linear documents per `convention-linear`, read newest-first — and reconcile each consequential decision against current board state. This includes the **per-client** decision logs the practice scaffolds: `playbook-client-onboard` stands one up per account, so the set of logs to reconcile grows with every new engagement, and a one-time inspection does not hold — the reader has to run on the cadence the entries are written at.

`convention-decision-log` already requires a decision to **name and reconcile the open tickets it supersedes** — repointed, re-scoped, or waived — in the same action that records it. That write-time obligation is the rule, and it is not restated here: Pass 6 is the **reader** beneath it, for the case where the obligation was not met and nothing noticed. The residual gap after such a miss is a missing reader, not missing prose — an entry can be canon-complete while the board it should have moved was never touched, and no other pass owns comparing the log against the board, so the correct behaviour of every board-scoped pass composes into a permanent blind spot exactly where the write failed.

**Test both directions — a one-directional check catches only half:**

- **A decision that STARTS work, with nothing on the board to see.** An entry that commissions an engagement, epic, milestone or ticket while **no matching project / epic / ticket exists**. There is nothing in any state for a board-scoped sweep to reach, so every other pass steps around it by construction — the work was decided but never created, and the decision log is the only place it exists. Post: "@aledpritchard The [date] decision-log entry [ref] commissions [work] but no matching project/epic/ticket exists on the board. Recommend creating [the structure] — please confirm."
- **A decision that STOPS work, with the stopped thing still reading live.** An entry that supersedes, waives, re-scopes or repoints existing work while the tickets it names (or should have named) **still sit In Progress / Todo / In Review as though live**. The board asserts the opposite of the decision. Post: "@aledpritchard The [date] decision-log entry [ref] [waives/re-scopes] [work], but [N] tickets ([list]) still read [state]. Recommend reconciling them to [the decided state] — please confirm."

A one-directional check that only tested the second direction would miss the first entirely, because the first leaves nothing on the board to test against — the sharpest failure the miss below exposed.

**Why coordinate is the right home**, despite `convention-project-status` ruling it "the weaker fit" for cross-project HEALTH writes: both objections invert here. The frequency objection — coordinate runs several times a day, treated there as too often for a health write — is the *point*, because the failure mode is precisely a divergence sitting undetected for days. And the ticket-flow objection — that a cross-project write is not ticket flow — does not hold, because **reconciling a decision against the tickets it supersedes IS ticket flow**: it is the same relation between a decision and the open tickets it moves that the Pass 2 harvest-reconcile clause already sits beneath. Coordinate already sweeps the live projects, already surfaces structural mismatches as proposals, and already describes itself as a net beneath `convention-decision-log`'s requirement that a decision reconcile the open tickets it supersedes — so the reader belongs here.

**Proposal only.** Coordinate never auto-applies a decision-log reconciliation — it neither creates the missing structure nor transitions the stranded tickets; it is the surfacing / net layer, and the board writes that carry the decision out stay the operator's.

**The proposal-only guardrail governs divergences coordinate found, not writes the operator has authorised.** Once the operator has replied on the surfaced ticket explicitly authorising the reconciliation, it is a Pass 1 routing instruction (*Routing instruction*, above) and is executed there — bounded to the reversible state writes the proposal named — rather than re-surfaced or left to age. A surfaced divergence with no reply stays a proposal however old it is, per *Escalating an unanswered proposal*; a surfaced divergence the operator has said "execute now" on is not unanswered, it is answered, and the answer is an instruction. (APP-1093.)

One proposal per divergence per run, escalating an unanswered surface by age like any other (*Escalating an unanswered proposal*, below).

(Worked case: a 2026-08-06 a1.Muse decision-log entry recorded a **£10,400 engagement** but reconciled none of the tickets it superseded — the write-time obligation went unmet and **nothing noticed for eight days**: no project / epic / ticket for the engagement (the STARTS-work direction, invisible to every board sweep), ~16 tickets left falsely In Progress (the STOPS-work direction), three billing milestones with nowhere to hang, and five daily briefs reading amber throughout. A board-only sweep could not have caught the missing engagement — the decision existed only in the log — which is why Pass 6 reads the log, not just the board. APP-885.)

### Pass 7 — Cycle membership and the derived unplanned share

With cycle automation switched off on the delivery teams (Owner decision, Aled 2026-09-03, APP-1007), "in the cycle" is a decision rather than a side effect of status — and this pass is what makes the decision measurable without anyone labelling at the door (APP-1095). Once per run, for each team that runs cycles — **Apps, A1, MBN** — and only where the team has a live committed cycle:

1. **Resolve the cycle and its commit. **`list_cycles(teamId, type:"current")` for the UUID, never the literal `"current"`; check `endsAt` against the session clock and skip a team whose cycle has lapsed (`convention-linear` *Reading Linear safely*). Then read the team's per-cycle goal document (`<team>.cycle-goal.YYYY-Www`, `convention-linear` *Documents and the decision log*) and take its **committed ticket list** — that list is the definition of *planned*. Where no goal document exists for the current cycle, the cycle has no commit this boundary: stamp nothing, add nothing, and report it once ("no commit for cycle N — Pass 7 skipped").
2. **Derive membership** per `convention-linear`: a team-scoped compact-`fields` read (fields including `cycleId`, `labels`, `status`, `statusType`) filtered client-side on `cycleId == <uuid>`, never the `cycle` param, under the usual page discipline; cross-check the count against the cycle's `issueCountHistory` and carry a mismatch as a caveat in the run report, never as a reason to infer absence (APP-890).
3. **Classify — planned versus unplanned is derived from structure, never from a label** (Owner ruling, Aled 2026-10-19, APP-2400, logged in `osclaude.log-decisions.2026-W43`: "Planned vs unplanned is derived, not labelled"; supersedes APP-1788's label route). *Planned* is the committed list taken in step 1 (APP-1095). A member is **unplanned by derivation, never by label** where it was created **after the commit's `commit_ts` and before the window closes** *and* serves the goal by structure: it sits in the goal's project (`basis: project`), is a child of a committed ticket (`child`), or has a blocks, blocked-by or related relation to one (`relation`) — taking the first basis that holds, in that order. This is a classification of the membership step 2 already read, not a second membership read, and it is a **read**: no label is applied, none is removed, and an amended commit simply reclassifies on the next run with no write at all. Standing-target tickets are planned by construction and are never counted here (`task-cycle-planning` Step 3). Terminal-state tickets are classified too, so the boundary retro's share is honest. Where the team's `planning-week` record holds only an upper bound for the commit (`commit_ts_upper_bound: true`, as on the backfilled weeks), classify anyway and carry that caveat beside the figure rather than dropping the member.
4. **Add only.** Any ticket in a `started`-type state (In Progress, In Review, Blocked) on one of these teams with **no cycle at all** is added to the current cycle, and is **added with no label of any kind** — the unplanned classification is derived in step 3, so the membership write is the whole of this pass's write. The one exception is unchanged: a ticket carrying `agent:PUL-5E` is never added to a cycle (`convention-linear` *Never in a delivery cycle*; Blocked is started-type, and the parked notes are exactly what the *Started issues* automation was left off to keep out). A ticket added here is then classified by the same derivation as every other member, and counts as unplanned only where that derivation says so — being added by this pass is not itself the finding.

**Add only — the narrowest membership write in the system.** This pass never removes a ticket from a cycle, never moves one between cycles, never touches a committed ticket's membership, never labels, and never comments: **the derivation is the record**, and a comment per classification would flood the threads it exists to keep quiet. Since the Owner ruling of 2026-10-19 (APP-2400) the planned/unplanned call is a read, so the single write left in this pass is the step 4 add — which makes it idempotent by construction twice over: an already-added ticket is added once, and a reclassification writes nothing at all. The add is a membership write by an agent, but it is **not** a commit and is never read as one: the approval marker Aide tests is the Owner's goal-document write, not membership (`task-cycle-planning` Step 4, APP-987). Nothing in this pass is gated on a workspace label existing — the retired `cycle:unplanned` route was (APP-1788), and the derivation is not. Consumers: `task-cycle-planning` reports the planned/unplanned share per team at each boundary **from this derivation, not from a label count** (APP-2400); `skill-plan` reads a rising share as a planning signal.

**Report the derived share, and report it as unsourced rather than as zero.** The planned-versus-unplanned **share** is the signal, and it is only a trend if a figure exists at each boundary. So in the same run, after classifying, record per team into the run report: the cycle's member count, the committed count, the count unplanned **by derivation**, the share as `unplanned ÷ (committed + unplanned)` expressed as a percentage, and the basis (`project` / `child` / `relation`) that carried each unplanned member — that is the figure the boundary consumers read back. **Where the derivation cannot run — no commit for the cycle, or no `commit_ts` on the team's `planning-week` record — report the absence instead of a share.** A derived count of zero and an underivable cycle are the same number and different facts, and reported as a share the second reads as "nothing unplanned this cycle" — a false zero a boundary run then carries forward as a trend. The line to write is "cycle N, [team]: [M] members, [C] committed, unplanned share **not derived** — [no commit for this cycle / no `commit_ts` on the planning-week record]; no figure for this boundary", never "0%". Where the record holds only an upper bound (`commit_ts_upper_bound: true`) that is **not** an absence: report the share with the caveat beside it. Where the run ended **before** this pass — Pass 7 is last, and last is what a bounded run drops (APP-1387, APP-1470) — say that in the run report too, rather than leaving the boundary to read silence as nothing to report: a derived artefact that was never produced must say so, which is the shape APP-1273 records. Consumers act on the difference: `task-cycle-planning` is required to state the share as steady, rising or falling against the prior boundary and cannot do so from a figure it could not source, and `skill-plan` must not read an unsourced zero as a falling share. **No Owner config action gates this pass any more** — the derivation needs no label in the workspace, so both halves, the add and the report, run wherever there is a commit. (Worked case, now settled: the 2026-09-25 boundary run enumerated complete current-cycle membership for all four delivery teams — Apps 88 members, A1 73, MBN 18, Mr Pritchard 11, 190 rows in total, each read with `labels` selected — and not one row carried `cycle:unplanned`, one of seven boundaries in which the label was never applied at all. That run concluded that a stamp written at the time, by the pass that can see how each ticket entered, is what tells a healthy share from an unhealthy one, and that recomputing at the boundary cannot — APP-1788. **The Owner ruled the other way on 2026-10-19 (APP-2400) and the question is settled against the stamp:** the structural derivation reproduced the W39–W42 figures with no writes at all, so a point-in-time recomputation from `commit_ts`, project, parent and relations is exactly what the measure is, and the label route is superseded. Do not re-argue it. What survives from that run is the reading, not the mechanism: A1's 82% was in-flight decomposition of committed goal work and **healthy**, Apps' 85% was a machine lane nobody sized and **not** — which is why the basis is reported per member, so the two stay distinguishable without a label anyone has to remember to write.)

## Escalating an unanswered proposal — by age, not repetition

Pass 3 and Pass 4 surface to the operator **once**, and the comment-idempotency guard then keeps every later run silent. That is right as far as it goes, but silence collapses two different states into one: *the operator saw the proposal and chose to sit on it*, and *the operator never registered it*. A named structural defect can therefore persist indefinitely with no rising signal, and coordinate's own guard is what keeps it quiet. This section is the structural-proposal sibling of `convention-linear`'s *Escalating a stalled decision item — by age, not repetition*, and it divides the work the same way: the guard governs **comments** (do not restate), the ladder governs **priority and attention** (do escalate).

**What counts as answered.** Any operator reply on the thread, or any material change to the ticket (state, labels, assignee, project, parent, a cleared blocker), closes the proposal. A deliberate park *is* an answer — the standing-hold disqualifier in Pass 2 exists precisely to respect it — so a ticket the operator has replied on is never escalated, however long it then sits.

**The ladder**, measured from the `createdAt` of coordinate's own surfacing comment:

- **Under seven days** — stay silent. The idempotency guard already covers this window.
- **At seven days unanswered** — escalate **once**: raise the ticket's priority by one rung (to **High**, then **Urgent**, per `convention-linear`), assign the operator, and post a **one-line** note giving the age and pointing at the original proposal. The note names the wait; it never restates the proposal, or the escalation becomes the repetition it exists to replace.
- **At the top rung** — stop. Do not re-comment and do not invent a further rung. An Urgent item with an unanswered proposal is visible in the daily brief as a long-waiting operator item (`task-daily-report`), and past that the answer is the operator's to give. The ladder having no terminal rung is a known limit, not a licence to keep climbing: MBN-258 was escalated to Urgent on 2026-07-17 against a 2026-08-01 initiative target, then had nothing further to do while that date passed unanswered (APP-723).

**Never escalate by changing state or the `agent` value.** Escalation raises priority and sets the assignee, nothing else. A Pass 3 structural proposal and a Pass 4 stranded surface remain proposals however old they are — applying one because it went unanswered would convert a hold into a write, which is the exact boundary those passes exist to hold.

**Re-reach an unswept ticket the way the proposal found it.** The proposals most in need of escalation often sit on tickets no sweep enumerates — a projectless parent, or a ticket inside a Hold project — so the escalation candidate set is rebuilt by the route that found the defect, not by a fresh project-scoped sweep: a projectless parent is re-reached from its children, using the same `get_issue` on the parent that the Pass 3 check already performs. An escalation that depends on the ticket being swept cannot fire on the one class of defect that most needs it. (Worked cases: A1-110, the a1.Firmup outcome epic, proposed for homing on 2026-07-22 and still projectless **19 days** later, invisible to every project-scoped sweep in the system and re-found only by a targeted `get_issue` from a child; APP-524, Sonar's positioning deliverable, surfaced as delivered-but-not-handed-off on 2026-07-20 and unchanged **21 days** later, while `skill-fleet-dispatch` could still re-select it and redo the work — APP-758.)

## Guardrails

- **Every comment coordinate posts leads with `[coordinate]`.** A Pass 1 confirmation, a Pass 2 hold or block note, a Pass 3 proposal, a Pass 4 stranded surface, a Pass 6 divergence note, an age escalation — each one opens with the literal marker `[coordinate]` before any other text. The reason is a connector fact, not a style preference: comment authorship is unreliable — the connector stamps every comment's `author` as the account owner whoever wrote it (`convention-linear`, *Reading Linear safely*) — so the body's leading marker is the **only** signal that says which leg wrote a comment. Every other leg already emits one (`[exec]`, `[qa-review]`, `Relay — …`, `pm-triage …`, `[plan]`); coordinate was the one leg emitting none. The marker is what makes the Pass 1 watermark **computable from body content** rather than guessable from authorship, and it keeps the idempotency guard below honest, since "the ticket's last agent comment" is found the same way. An unprefixed comment is the operator's — which is precisely why an unmarked coordinate comment is worse than no comment: the next run reads its own note as an operator instruction. (APP-1208; the matching addition to `convention-linear`'s marker list lands in the same pass.)
- **Comment idempotency — no-new-information guard (every pass).** Before posting any comment — a Pass 1 confirmation, a Pass 2 hold or block note, a Pass 3 proposal, or a Pass 4 stranded surface — read the ticket's last agent comment. If the note about to be posted is substantively the same as the last one (same hold reason, same blockers, same recommendation) and nothing material has changed since it (no new operator comment, no state / label / assignee / attachment change, no blocker cleared), **stay silent and leave the ticket as is.** Only post when there is genuinely new information: a blocker cleared, a state/label change, a new dependency, a changed recommendation, or a fresh operator comment to answer. A held ticket re-surfacing on consecutive runs with the same situation must not collect a near-identical comment each time — that costs the operator a read for zero gain and dilutes the comments that do carry new information. Where a ticket keeps re-surfacing only to be re-held, prefer a one-time structural fix that takes it out of the poll (e.g. a refined human-decision ticket → `human` + assign Aled) over re-commenting every run. (This generalises the Pass 3 "do not re-post an unanswered proposal" rule to all comment posting; the same guard lives in skill-triage.)
- **Escalates an unanswered proposal by age, never by repetition — and never past the top rung.** Silence is only half the remedy: a Pass 3 or Pass 4 surface still unanswered after seven days gets one priority rung and an assignment, with a one-line age note that does not restate the proposal, and nothing more once it reaches Urgent. Escalation never changes state or the `agent` value, and never applies the proposal it was escalating (APP-758).
- **Handing the operator a decision sets `human` in the same write.** Any pass that assigns Aled a named decision on a ticket carrying `agent:R3-LAY` also sets the `agent`-group value to `human` (single-select, so it evicts `R3-LAY`) — the executor-hygiene binding convention-linear prescribes, applied at the moment of surfacing rather than left to a later triage relabel (the APP-304 / APP-459 / APP-492 re-surfacing class).
- Never merges. Merge belongs to merge, gated by an explicit Relay approval signal.
- Never marks Done, and closes a ticket **Duplicate only for a verified reconciliation.** Done is the operator's sign-off; the single close coordinate makes autonomously is a `Duplicate of <carrier>` on a Pass 4 already-shipped finding **another leg has already verified and recorded** (a named carrier, both ACs met on `main`). It never closes on a finding it derived itself, or one whose verification is not already on the ticket — coordinate is Linear-only and cannot read the repo (APP-827).
- **Surfaces an executorless started ticket, never resolves it.** A ticket in a `started`-type state (In Progress / In Review) with no `agent`-group value at all is the started-state member of the no-executor blind-spot family (APP-730, APP-400) and is polled by nothing; Pass 4 surfaces it with the fitting remedy — Done where the reopen was spurious and the PR is merged with every box ticked, else re-route to an executor — and assigns the operator, without re-routing or closing it itself beyond the verified-reconciliation Duplicate above (APP-811).
- **Rolls a parent up to In Progress, never to Done.** Pass 5 moves an epic/feature to In Progress once a child is in a `started`-type state (In Progress, In Review or Blocked) or Done, so the board reads honestly; it never closes a parent — completion of an outcome is the operator's sign-off (as above).
- **Auto-promotes from the refinement gate (Refinement, or an otherwise fully refined Backlog ticket) to Todo only against the Pass 2 readiness criteria** (fully refined, executor set — or a harvest leaf under `agent:R3-LAY`, whose executor coordinate sets at promotion — all blockers Done, harvest complete) **and only when no standing operator hold applies** — a prior coordinate/operator comment reserving promotion to the operator, or a body-stated dependency not encoded as a `blocks` relation, disqualifies auto-promotion however ready the ticket looks (the Pass 2 standing-hold disqualifier). Never promotes a ticket with open gaps, no executor, or genuinely outstanding operator judgement; when in doubt, hold and assign Aled.
- **A harvest reconciles the dependent ticket, it does not only add to it.** Where a cleared decision or design blocker reverses an acceptance criterion or note the dependent still asserts, strike or correct it in the same edit rather than leaving the ticket asserting both (APP-710). This is a net beneath `convention-decision-log`'s requirement that a decision reconcile the open tickets it supersedes — coordinate is not the owner of that rule.
- **Reconciles the decision log against the board, both directions — proposes, never applies.** Pass 6 reads recent per-project and per-client decision-log entries and surfaces divergence from board state in **both** directions: a decision that started work while nothing exists on the board to see, and a decision that stopped work while the stopped thing still reads live — a one-directional check catches only the second. It is the **reader** beneath `convention-decision-log`'s write-time requirement that a decision reconcile the open tickets it supersedes; the residual gap after a 2026-08-06 a1.Muse entry went eight days unreconciled (a £10,400 engagement with no project/epic/ticket, ~16 tickets falsely In Progress, five amber briefs) was a missing reader, not missing prose. Coordinate is the right home despite `convention-project-status` ruling it the weaker fit for cross-project health writes — high frequency is the point and reconciling a decision against ticket state is ticket flow — and every new client adds a decision log to reconcile (`playbook-client-onboard`). Surface only; the board writes stay the operator's (APP-885) — until the operator explicitly authorises one on the thread, at which point it is a Pass 1 routing instruction and coordinate executes the reversible state writes the proposal named, never a Cancel, Duplicate, Done, delete, or project-status change (APP-1093).
- **Clears a stale `blockedBy` relation autonomously — the Done case joins the Canceled/Duplicate one.** Where a blocker is Done and its relation lingered, with no harvest outstanding on it, Pass 2 removes the stale relation itself and comments, rather than flagging the operator for a mechanical cleanup: a `blockedBy` is trivially reversible and clearing a Done-blocker relation restores the board to truth rather than deciding anything. A Done design/decision blocker whose output is not yet lifted stays with the harvest-first flow, so coordinate never clears a pointer Forge still needs. The convention-ticket discipline for the stale-relation class is authored by a sibling unit; this is coordinate's relation-graph write only (APP-868).
- **Surfaces a starving root blocker, never moves it.** Where a still-blocked ticket's root blocker is `human`-lane and unmoved for more than three days, Pass 2 comments once on the blocker with its transitive blocked count and its age in state, assigns the operator, and escalates priority per the convention-linear ladder — it never changes the blocker's state, promotes it, or closes it. The relation itself is correct and is left alone (APP-723).
- **Surfaces stranded tickets, never resolves them.** Pass 4 surfaces an approved-but-unmerged ticket with the recommended merge action, a delivered-but-not-handed-off Todo ticket with the recommended In Review + `human` move, and any In Review + `PR-1SM` ticket carrying no `[qa]` verdict past three days — whatever route put it there (APP-714) — with the recommended standalone Prism / QA pass; it never gives the `@relay` signal, never merges, never runs Prism, and never declares another agent's work finished. It likewise surfaces a ticket whose board-state no longer matches its work-state — un-ready in Todo (recommend Refinement + `human`), In Progress on a completed handoff (recommend In Review, or Done where merged with every box ticked), or In Review on `human` awaiting the operator's own close (recommend the operator's decision, escalating by age) — surfaced once with the fitting move, never transitioned (APP-874, APP-877, APP-871). The false-green CI guard is named, not executed — coordinate cannot read GitHub.
- **Reads the Pulse manifest's ticket-side actions, and enacts only the reversible ones.** Pass 4 takes the *Ticket-side actions* section of the current `osclaude.pulse-manifest` index as an input — following the index's pointer where that section sits in `osclaude.pulse-manifest.decisions` — and, for each named action, enacts it where it is a state, label, assignee or relation write on the ticket the row names (the same reversible class the Pass 6 authorised-write rule permits, never a Cancel, Duplicate, Done, delete or project-status change), and surfaces everything else with its age. It enacts only what the row states, on the ticket the row names, never a wider remedy the row implies; it reads only a section carrying the current refine date, since the manifest is full-replaced each run and an action still live is re-emitted by the next refine; and it reports both the enacted and the surfaced sets at the end of the run, so a hand-off that reached no pass is visible rather than silent. Drain-side pair of `skill-ops-retro`'s ticket-side-action guardrail, and the reader that guardrail assumed (APP-1149).
- **Proposes structural fixes, including a projectless parent — never applies them.** Homing an epic whose children unanimously share one project looks mechanical, but it is the same write class as re-parenting: Pass 3 proposes. A project-scoped sweep is incomplete by construction (a ticket in no project is swept by nobody), so this check is the counterpart to the liveness gate, not an optional extra.
- **Excludes the os.Claude Pulse queue from the delivery sweep.** `agent:PUL-5E` canon-intake (FRICTION/CANON/PROPOSAL) belongs to the Pulse queue, drained by `task-pulse-retro`, never coordinated — filtered out of candidates by executor up front rather than read-then-discarded; the @mention override still admits one the operator points at. Triage-side sibling: APP-552. (APP-791.)
- **Sweeps live projects only — a parked project's inventory is out of scope, an @mention inside one is not.** Resolve the team's projects and gate the sweep on `statusType == started`, skipping Hold / Backlog / Completed / Canceled (the same gate `task-daily-report` uses). This is the second axis after state-scoping and the one that actually bounds the read — a Hold project's Refinement inventory is otherwise re-read every run for zero candidates (APP-530). The *Candidate selection* @mention override survives the gate: a ticket the operator has explicitly pointed at is always in scope, whatever its project's status.
- **Flags a dormant started project, never parks it.** `statusType == started` is a coarse proxy: a `started` project with no ticket activity in N days (default 14) is dormant-but-unparked, re-swept every run for zero candidates while its status still reads live. Pass 3 surfaces it as a project-status hygiene item recommending Hold or a restart; setting the project to Hold (or restarting it) is the operator's write, never coordinate's. This is the started-side complement of the liveness gate — keeping a dormant project's inventory reachable and its strand surfacable rather than silently re-swept, without widening Pass 4 (APP-871).
- **Writes cycle membership only to add a started, cycle-less delivery ticket to the current cycle, and no label is written in that write.** Pass 7 classifies members as planned or unplanned by structural derivation from the committed list, `commit_ts`, project, parent and relations (Owner ruling, Aled 2026-10-19, APP-2400; supersedes APP-1788's label route), and never removes, moves, labels, comments, or touches a committed ticket's membership; a `PUL-5E` note is never added. The add is not a commit — the approval marker stays the Owner's goal-document write (APP-1095, APP-987).
- Never touches the Pipeline team (Network / Roles / Advisory / Pitches).
- Never acts on tickets In Progress under `agent:F0-RGE`.
- Never makes destructive structural changes (delete tickets, remove epics, bulk-reassign) without Aled's explicit instruction. A mis-homed child or a scope-bled epic is surfaced as a proposal — never re-homed or split autonomously.
- Single-select agent group: when routing a ticket to Forge, the label update evicts any prior `agent:*` label. Never set two `agent:*` labels simultaneously.
- Consequential or ambiguous calls go to Aled in-thread; never a guess.

## Setup

- Deployed as a Claude Code cloud scheduled task (cloud, machine off).
- Connector: **Linear only** (GitHub write access not required for this skill).
- Routine prompt: `Run the coordinate skill.`
- Cadence: a few times a day (mind the ~1h floor).

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 passes it ran, deferred and left unread belongs on its run-log surface — **named here and not derived: one `[coordinate]` comment per run on initiative `I-9` (os.Claude)**, which is what `convention-agent-runtime`'s one-comment-on-a-durable-surface rule resolves to for this vertical, and it is written here because that convention requires it to be — *the loader or artefact is edited to name it in the same pass*, and **no artefact's run-log phrase may resolve to nothing**. One comment per run, naming what the run changed ticket by ticket; never one comment per touched ticket, and never a repeat where nothing was written. A long-form report may live in its own artefact or document that the comment links, but **the comment is the run-log and a per-day report ticket is not one** — a ticket is neither a comment nor a loader ticket, so a run report filed as its own issue leaves the run-log phrase resolving to nothing while adding a row to the very queue this sentence forbids (worked case, **reported**: five per-day `coordinate run report` issues filed under Apps / os.Claude between 2026-10-31 and 2026-11-06 — `APP-2798`, `APP-2805`, `APP-2837`, `APP-2857`, `APP-2909` — each holding its whole run summary in the issue description, while `I-9` carried no `[coordinate]` comment after 2026-11-01, so a run orienting from canon's named surface missed up to a week of run history. Whether those five are retired, kept as archive or relabelled is an Owner *what* touching workspace state and **is not settled by this edit** — `APP-2910`). This run's own report goes there, never in the Pulse queue; a clean run captures nothing. (The earlier compact line here said only "file a FRICTION note", and four runs filed their reports as `PUL-5E` notes under it — APP-1527, APP-1550, APP-1555, and APP-1565 with its duplicate APP-1566 — APP-1565, 2026-09-22.)
