---
name: "skill-ops-retro"
type: skill
license: CC BY-NC-SA 4.0
description: Turn friction observed while running the operator's skills, tasks, and routines into ready-to-add canon artefacts — a new or updated skill, task, routine, convention, or agent profile the operator saves. Use this whenever running the skill-ops-retro routine, or when the operator asks to review, tidy, retro, or improve the skills/routines, asks "what could be better about how Claude is run", or pastes a transcript and asks what could be fixed or optimised. Also use it as the final step of any other skill, to capture that run's friction. Has a capture mode (file a FRICTION note) and a two-pass drain — refine reads, decides and emits an author manifest; retro produces and presents the packages. Proposes only for canon — never edits a SKILL.md, never applies a canon change via a ticket, never routes a canon edit to Forge; it does file the repo-lane ticket for a repo-native dependency of a drained change. Apply this rather than ad hoc tinkering, so improvements land as artefacts the operator can add.
---

# skill-ops-retro

A retro routine for the operating system itself. It turns friction — encountered while running a skill, or spotted when reviewing one — into improvements to the operating canon. It works in **two modes: capture files a `FRICTION:` note to the Pulse queue; drain turns that queue into ready-to-save canon artefacts. The drain runs as two daily passes — a refine pass (`task-pulse-refine`) that reads the queue and makes every judgement call, emitting an **author manifest**, and an author pass (`task-pulse-retro`) that consumes the manifest and only produces and presents the packages.** It never edits canon in place — the operator is the gate (per convention-linear, detected drift or a proposed change is raised for the operator, never applied silently).

**The drain's only canon output is a ready-to-add canon artefact** — a new or updated skill, task, routine, convention, or agent profile that the operator adds in one step. Capture, by contrast, *does* file a Linear note and produces no artefact: "only output is an artefact" describes the drain's canon output, and is never a reason to skip filing in capture mode. The drain may *also* file a repo-lane delivery ticket where a drained canon change needs a matching repo edit (see step 4a) — that is the repo half, not a canon-apply ticket. Claude is canon; the claude-ops repo is a downstream mirror that ops-sync brings up to canon afterwards.

## Two modes, one purpose

The work splits into **capture** and **drain**, because the surface that *spots* friction is rarely the surface where a `.skill` can be *saved*. Filing a Linear note is the one capture action every surface can do — including Claude Code, which can write Linear but cannot save to the skills store. So friction is always captured to the Pulse queue first, and the artefact is produced later, on the drain pass, where the save button works. Centralising through the queue also fixes two failures of per-session saves: a `.skill` buried in one of many sessions is easy for the operator to miss, and concurrent autonomous sessions each saving canon would clobber one another's changes. The queue is the single point where all intake collects; the batch drain is the single point where it is consolidated and saved.

**The Pulse queue** is the friction inbox: `FRICTION:`-prefixed Backlog tickets in Apps / os.Claude carrying `agent:PUL-5E` (see convention-linear). It is capture, not application — a note records an observation; it is never a proposal to "change canon", and never routes a canon edit to Forge.

### Capture mode

Triggered as the final step of another skill, mid-run when friction is spotted, or by a headless / Claude Code / scheduled run that cannot reach the save button. **File a `FRICTION:` note to the Pulse queue** — do not attempt to produce or surface a `.skill` here.

1. **Spot.** Identify friction worth capturing: a redundant or wrong query, a dead-end, a wrong assumption, a missing convention, an ambiguous instruction, a place the wording could be tightened. A single observation is a small note, not a redesign — record what was seen, not a fix.
2. **Search the queue before filing — append to a same-root note, never open a near-duplicate.** Search os.Claude Backlog *and* the Blocked/surfaced set for a `FRICTION:` note on the **same root cause or target artefact** — and run that search **by the `PUL-5E` label across the workspace, never by project or by team**, for the same reason drain step 1 does: the label *is* the queue's definition, os.Claude is only where a note is supposed to be filed, and a project-scoped search returns clean on a same-root note filed anywhere else. **If one exists, add the new evidence to it** — a fresh instance, a new worked case, or a sharper diagnosis all strengthen the drain's assessment and its instance count — and do **not** open a second ticket; only a genuinely distinct root earns a new note. This is the capture-side half of the dedup discipline: near-duplicate *notes* are the largest avoidable driver of queue growth (three notes for one problem — the concurrency family APP-717 / APP-803 / APP-805), and merging at capture is cheaper than leaving it to the drain's collation pass (drain step 1e). Then apply a **comment-level** guard on top, the same shape as `skill-review-pr`'s `[qa] HEAD: <sha7>` key: if the most recent recurrence comment already asserts the **same observation** (the same root-blocker set, the same eligible count, no materially new information), **do not post another**. A note carrying six restatements of one finding is harder for the drain to assess than one carrying the finding plus a bare count, and the end-of-run report and the operator notification already carry the recurrence. Post a recurrence comment only when something **material has changed** since the last one; where a bare recurrence must be recorded at all, prefer a single running tally ("recurred: N runs, last <date>") edited in place over a fresh comment per run. This is the comment-idempotency guard of `convention-linear` — *a surfaced item escalates by age, it never collects repeat comments* (APP-384) — applied to capture, so an avoided duplicate note does not reappear as a duplicated comment thread. (Worked case: APP-723 collected six near-identical recurrence comments across four days, each correctly declining to file a duplicate *note* while posting a duplicate *comment* — APP-738.) **And search recently-Done notes too — the dedup rule is queue-scoped, the recurrence is Done-scoped.** A search confined to os.Claude Backlog and the Blocked/surfaced set finds nothing when every prior note on the same root has been **drained to Done**, so the loop correctly files note N+1 on every run and the recurrence count exists nowhere. So extend the same-root search to **recently-Done `FRICTION:` notes** — the last ~30 days is enough — and branch on what it finds. Where the match is **open**, append the new evidence to it as above. Where the match is **Done**, the recurrence is **not recorded on the drained note at all.** The Owner ruled on this directly in the A1-656 session, **2026-10-19**: *"if a note is already closed, why add more to it? Either it took hold or it didn't – if it did and was closed out then adding a note to a dead ticket is pointless; but if it didn't take hold then we need to file a new one"*. So the branch is the Owner's own test — **did the fix take hold** — and **neither limb writes to the closed ticket**. Where the fix **took hold**, the recurrence needs nothing recorded: the note is closed, the change is live, and a tally on a dead ticket informs no reader and no pass. Where it **did not take hold**, the recurrence is carried on the **open ticket-side action that note produced**, as a single running count ("recurred: N runs, last <date>") edited in place there — never on the drained note. And where that drained note's canon change has already landed and the root *still* recurs, the finding is no longer a canon gap and a fifteenth note cannot close it — the remedy is the ticket-side action carry-forward in `## Ticket-side actions` (the Guardrails rule below), which carries the action with its first-named date and recurrence count and is read each run by `skill-coordinate` Pass 4. The comment-level guard above applies to the tally unchanged and is not weakened by it: the tally is one count edited in place, never a comment per run. (Worked case: the delivery-loop zero-eligible signature filed fourteen separate notes, APP-1318 → APP-2305 → APP-2334, each run correctly finding no *open* same-root note because every predecessor had been drained to Done, while the single root blocker A1-398 sat Todo, High and Owner-held for ~36 days and 15 candidates scanned to 0 eligible. APP-2334.)
3. **File the note** in Apps / os.Claude (per convention-linear):
   - **Title** — `FRICTION:` prefix, specific not generic (names the skill/area and the friction).
   - **Observed friction** — one or two sentences: what happened, in which skill/run, and the instance count if known.
   - **Light notes** — any pointer the drain pass would want (a candidate target artefact, a suspected cause). Not a prescribed fix — drain assesses against current canon, not against this note.
   - Labels: `type:task` + `work:configuration`. Executor: **`agent:PUL-5E`** (not the Backlog default `agent:R3-LAY` — this is what keeps it out of the Relay→Forge loop). State: Backlog. Unassigned.
   - **The whole shape, literally — every field set in the create call, none left for triage to repair.** `save_issue` with: team `Apps`; project `os.Claude`; title beginning `FRICTION:`; labels `["task", "work:configuration", "PUL-5E"]` — the bare names the workspace holds, displayed as `type:task` and `agent:PUL-5E` (convention-linear *Type*); state `Backlog`; no assignee. A note missing any one of them is the filing-invariant failure `convention-ticket` names: it rests in Backlog looking filed, and the drain's queue read, which keys on `PUL-5E`, may never see it. Read the created issue back and repair a missing field in the same run.
   - **A run report is not a FRICTION note — file the friction, not the report.** A run's own summary of what it swept, wrote and skipped belongs on its run-log surface (`convention-agent-runtime`), never in the Pulse queue. Where a run found friction, file that friction as its own note in the shape above, one root per note, and leave the report where it belongs. **And where a run found none, file nothing.** A clean run is the commonest outcome and it has no note to file: it says so in its own report and on its run-log surface, and the Pulse queue stays empty of it. This branch is written down because the closing capture step every skill carries — *"search the Pulse queue first and add the evidence to a same-root note if one exists, **otherwise file a new FRICTION note**"* — has only two branches as written, so a run with nothing to capture reads it as an obligation to file *something*, and the only thing it has is its report. Restating the prohibition does not reach this; supplying the missing branch does. (Worked cases, all filed **after** the rule above landed: four full run reports as `PUL-5E` notes — APP-1710, APP-1802 and APP-1808 from `task-triage`, APP-1713 from `task-fleet-dispatch` — one of which names the reading in its own words, "filing this as the standing per-run friction/observation note per `skill-triage`'s closing instruction". APP-1808, 2026-09-29.) (Worked cases: seven notes filed by QA and delivery legs short of this shape — no labels or project, `R3-LAY` in place of `PUL-5E`, or no `work:` value — APP-1545, APP-1444, APP-1534, APP-1346, APP-1513, APP-1552, APP-1535; and three `skill-coordinate` run reports filed as `PUL-5E` notes — APP-1555, APP-1550, APP-1527. Counted by the 2026-09-19 triage run — APP-1549.)
3a. **The queue's second note kind is a `PROPOSAL:` note — the same queue, distinguished only by the title prefix.** A `FRICTION:` note records something that went wrong; a `PROPOSAL:` note asks for something that does not yet exist. What a surface may propose is set by its tier (Owner ruling, Aled 2026-09-29): an **agent** proposes the skills, tools or conventions that would help it deliver what it was dispatched to deliver; an **operator** proposes what it needs to hit its goals, **including a new remit or a change to its remit, justified against a goal**; the **assistant** proposes what she needs to serve the Owner better, including the preferences of his she has learned. Everything else about the filing is identical to a `FRICTION:` note and is not restated here: Apps / os.Claude, executor `agent:PUL-5E`, labels `type:task` + `work:configuration`, state Backlog, unassigned, every field set in the create call and the created issue read back. The filing invariant of step 3 applies unchanged and no second label is added, because the queue is defined by the `PUL-5E` value and the prefix names the note's *kind* — a label would split a queue canon defines by one value.
   - **Every `PROPOSAL:` note carries a justification block** — the goal or the run evidence it serves, what changes if it is approved, and what happens if it is not. This is not decoration to be trimmed: the Owner's standing condition is that a change's justification is clear to him **before** he approves it, so a note without one is **incomplete** rather than merely terse, and the drain has nothing to assess it against. A proposal that cannot name what it changes is an opinion.
   - **At most three per run, each citing something from that run as its evidence.** A proposal with no run behind it is a wish, and an unbounded list is how a queue built for observations becomes a suggestion box the drain cannot clear.
   - **Routing — a request for a new remit or a changed mandate is an Owner *what* and is never ruled by Pulse.** It takes the surface-to-Owner disposition and enters the decisions-needed set carrying its justification block, where the Owner answers it. A proposed **skill, tool or convention** is a *how* and is assessed by the drain like any other note, against current canon. The assistant's observations of the Owner's own preferences go **to him to confirm** and are never saved silently as learned fact.
   - The per-tier obligation itself is stated once, in `core-operating-model` Layer 3, and is **not** restated in the individual `agent-*` and `operator-*` profiles, which inherit it by reference.
   (Worked case: the Owner asked on 2026-09-29 that each tier be able to propose what it needs — agents the skills and tools they deliver with, operators their remit, the assistant his preferences — and the queue had no shape for it: every note in it recorded friction that had already happened, so a request for something new had nowhere to be filed and arrived as prose in a thread. The prefix was already in informal use before any rule existed — APP-1662 was filed with a `PROPOSAL:` title and drained as one — so what is written down here is the shape already in use, plus the justification block and the cap. APP-1849.)

4. **Note it.** When embedded, a one-line note that friction was queued, so it does not bury the host skill's output. A clean run captures nothing.

### Drain mode — two daily passes: refine then author

Triggered by the two scheduled loaders — **`task-pulse-refine`** (the refine pass, first each day) and **`task-pulse-retro`** (the author pass, second) — or on demand ("run skill-ops-retro", "drain the queue", or a pasted transcript), in which case one session runs both passes in order. **Turn the queue into ready-to-save artefacts.**

The drain is split into two passes because reading, collating and assessing the queue and *authoring* its canon were exhausting one context window, deferring authorable work by capacity even when nothing was Owner-blocked (APP-875, the structural remedy for the producer-heavy queue of APP-634). **Where the boundary sits is a single rule (Owner decision, Aled 2026-09-03, APP-1094): if a step involves reading or a judgement call, it is refine's; if it involves producing a package or saving, it is retro's.** The first cut of the split left retro re-reading canon, re-assessing, re-collating and re-testing blockers — the 2026-09-03 author run spent its whole budget on 1a verification, 1c blocked-clearance, comment reads and target-grouping and authored nothing — so the boundary is now fixed by that rule rather than by which steps looked like "reading". The step detail below is shared by both passes; the two passes and their handoff:

* **Refine pass (`task-pulse-refine`) — owns all judgement.** Verify prior saves (step 1a, **in full** — detect the absent change *and* list its re-production as a manifest row), blocked-clearance (1c, **in full** — test each blocker and return cleared notes to Backlog), read the queue (1), sort and measure both rates (1d), collate and merge duplicates (1e), read each note's comments (1f), assess against current canon (2), classify (3), and decide each note's disposition (5). It **enacts every judgement disposition itself**: closes a duplicate (1e), closes an *assessed, not warranted* note to Done with its one-line reason, surfaces a *warranted-but-not-authorable* note to Blocked (+ Urgent + assigned to the Owner with the specific question, or with its blocked-by relation), names a config action (4c) and surfaces its note. It then writes the **author manifest** (step 3a) — one row per target artefact, `READY` or `OWNER-GATED`, each `READY` row carrying the exact change (anchor + new text) and the notes that fold into it — and the decisions-needed set in full. The refine pass **authors no `.skill`** and never closes a note as *incorporated*; those are the author pass's.
* **Author pass (`task-pulse-retro`) — owns only production and save.** Reads the manifest; for each `READY` row, a subagent re-reads the live canon it targets, applies the specified change, validates the frontmatter (4b), packages the `.skill`, presents it for save, files the repo-lane ticket the row names (4a) and closes the row's folded notes as *incorporated* (5). The parent logs the run's canon decisions (5a) and writes a short report (6). Retro does **not** re-assess, re-collate, or re-test blockers, and never touches the Blocked queue or an `OWNER-GATED` row. Its only judgement is the **match-check**: if a row's anchor no longer matches live canon (a concurrent save moved it), kick that one row back to the queue — comment `[pulse-retro] stale — re-refine` on its folded notes, leave them in Backlog — and move on. That comment is **mandatory, never a silent drop**: a failed match that posts nothing leaves the row's notes indistinguishable on the board from notes never reached, and the miss stays invisible until someone greps for it (APP-1119, the `operator-bara` row). Net effect: retro is "read manifest → produce and present the green rows → report".

**The author manifest.** The handoff is documents, not per-note prose — an **index plus one child document per target**, the same index-plus-children shape `convention-decision-log` uses for the same reason: `get_document` overflows at ~50KB and hard-errors past ~61k characters (`convention-linear`, *Reading Linear safely*), and one 2026-09-03 refine run produced 48 READY targets whose merged change text ran to ~230,000 characters, unreadable as one document (APP-1097). The **index** is the os.Claude project document `osclaude.pulse-manifest`: one row per target artefact in the table below, each `READY` row linking to its child, followed by the decisions-needed set, the rates, the split and the watermark. **The operative ceiling is the single-call read, and ~25KB is the trigger for the moves below rather than a target the index must reach.** What must hold is that the author pass can read the index in one `get_document` call, comfortably inside the ~50KB overflow and the ~61k-character hard error named above; that read is the pass's only entry point and it is the test. The ~25KB figure is where the section moves start, and it is not a boundary anything was ever measured against. With every movable section already moved, the sections canon requires to **stay** — the `READY` row table, the *Seven things the author pass must hold* section, the `OWNER-GATED` table, the decisions-needed set in full, and the headline rates and completeness split — can together measure well above ~25KB at a normal queue size while the single-call read still passes with room to spare. Canon's own worked case below says exactly this: the 2026-09-07 index measured ~33,700 characters stored once the movable sections were out, read back cleanly in one call, and is recorded as the **fix**. So an index above ~25KB whose movable sections have already moved is **not a defect to report, and not a reason to move a required section out** — it is the required residue at that queue size, and the only test it owes is the single-call read. Report a ceiling problem when the **read** is at risk: when the stored index approaches ~50KB, or when a required section can no longer be read with the rest. At that point the question is which required section becomes movable at the cost of the author pass taking a second read, and that is an Owner-gated shape change, not a measurement. (Worked case: on the 2026-10-26 refine run the shape lever was fully spent — the how/where rulings, run-log, config and ticket-side actions in `osclaude.pulse-manifest.decisions`, the Blocked enumeration in `osclaude.pulse-manifest.decisions-1c`, the run-log in `osclaude.pulse-manifest.decisions-runlog` — and the required residue still measured 33,545 characters stored across 19 `READY` rows, a ten-item decisions-needed set and an eight-row `OWNER-GATED` table. The read returned inline in one call. Reported against the ~25KB figure it reads as a failure with no remaining move; reported against the single-call read it passes, which is what it did — APP-2672.) That ceiling is held first by **shape** and second by **formatting** — the number of sections the index carries is the lever that decides whether it fits at all, and reference style is the cheap one applied after it. Two moves hold it. First, the index carries **one line per row, not a prose change summary**: the change text lives only in the child, and the index's `change` cell is a short label. Second, where the index would still exceed ~25KB, **move whole sections out into the child document** `osclaude.pulse-manifest.decisions` — the how/where rulings, the run-log, and the config and ticket-side actions — which the index links in a short pointer section; the **decisions-needed set stays in the index**, because it is the set the Owner reads. Reference formatting is a **second** lever, and a narrower one than it first looks: Linear re-expands a **bare** `APP-####` or `A1-###` reference into a full issue mention on save, so writing bare references to save characters returns nothing (measured on the 2026-09-07 index: 18,560 characters sent, 50,024 stored) — but a backticked identifier is stored as inline code and is **not** expanded. Observed on the 2026-10-23 index, whose every identifier was written in backticks: no issue mention was generated anywhere in it and it read back in a single `get_document` call, against a bare identifier in an issue body stored the same week at 193 characters where its backticked form is 11. So **the saving is real and its size is not a constant** — it scales with the index's reference density, and no run should quote a figure for it that it did not measure on the document in front of it. Two things follow. Write the index's identifiers in backticks, which is the index's own house style and costs nothing. And do not read "shape is the lever" as "formatting cannot be one": the section count remains the lever that decides whether the index fits at all, and reference style is the cheap one applied after it, never instead of it. **Scope this to the manifest documents and nothing else** — `convention-linear`'s rule that a ticket reference in a **comment or a ticket body** is written bare so Linear resolves it into a live mention is unaffected and is the opposite choice for a good reason: there the expansion is the point, and a document nobody navigates from is not. The author pass must be able to read the index in a **single** `get_document` **call**, because the index is the pass's only entry point — an index it cannot read is a hard stop to report, never a reason to improvise. **And an index it *can* read may still be untrustworthy.** Before authoring from the index, the pass runs a **freshness test**: compare the index's stated refine date against the **header date** of a sample of its `READY` rows' children — the header, not the timestamp, because a successful `save_document` can leave `updatedAt` unadvanced, so the header is the field that round-trips reliably and `updatedAt` only ever corroborates (stated in full below; APP-1417). **An index older than its own children means a refine run is in flight or incomplete** — the children have been rewritten by the fan's workers and the parent's full-replace of the index has not yet landed — so the pass is reading a mid-flight handoff whose rows may be yesterday's. That is the **same hard-stop class as an unreadable index**: report it and stop. Never author from a mid-flight index, and never reconstruct the row set from the children directly — the children carry the change text, but only the index carries which rows are `READY` this run. **The test has a second limb, and it is the calendar one.** Everything above compares the index against its own children, which is an **internal** consistency check: it passes cleanly on an index that is entirely self-consistent and two days old. That is the case that actually occurred. `osclaude.pulse-manifest` was last written 2026-09-15T04:53Z; `task-pulse-refine` produced no index on 2026-09-16 or on 2026-09-17; `task-pulse-retro` fired on both days; and the 2026-09-17 author run drained all 22 `READY` rows of a two-day-old manifest, of which **8 were fully stale** — every anchor already matched the target text, the fix having landed by some other route — and **13 more produced a package whose new text was already present verbatim in live canon**, a no-op (APP-1516). So the pass **also compares the index's stated refine date against today**. Where the index is not from today's refine run, the pass **degrades explicitly** rather than draining it as if current: it reports the staleness in step 6, naming the index's stated refine date, today's date and the gap in days; it authors nothing from a row whose folded notes are already **Done**, checked per row immediately before that row is authored; and it says plainly — in the report and in every comment it writes — that the run was authored from a stale index. This is not a new contract. `core-operating-model`'s catch-up contract (APP-993) already binds every scheduled artefact to state its fire time against its cadence, to degrade or refuse *explicitly* where the cadence does not hold, and to have the consumer read the freshness of the output it depends on and state whether it consumed or fell back; its declared replay order already names `task-pulse-refine`→`task-pulse-retro`. Only the instantiation was missing here. Note the two limbs stop differently, and deliberately: a **mid-flight** index is a hard stop, because the row set itself is untrustworthy, while a **stale** index is a degrade, because its rows are settled and some remain genuinely authorable. Draining a stale index is not the defect; draining it while reporting it as current is. The child header line is fixed by canon (`Refine <date> · target · new/edit · status · folded notes`) precisely so this test is deterministic rather than a judgement about how a brief happened to be worded — **and the header date, not `updatedAt`, is what the test keys on.** A successful `save_document` can leave `updatedAt` unadvanced (`convention-linear`, *Reading Linear safely*), so the timestamp is sound as a positive signal and unsound as a negative one: an advanced `updatedAt` proves a child was rewritten, an unadvanced one proves nothing. Read each sampled child's header date and compare it against the index's stated refine date; where the two agree, the handoff is settled. `updatedAt` corroborates and never decides — an index whose `updatedAt` trails a child's while the header dates agree is not a mid-flight handoff. The header is content and round-trips reliably; the metadata does not. Keying the hard stop on the timestamp fails in both directions, and the flattering one is the worse: a genuinely re-emitted child reads as untouched and the pass proceeds believing the handoff settled. (Worked case: two successive `save_document` patches to `osclaude.pulse-manifest.convention-linear` on 2026-09-14 both returned success and both changed the stored content, confirmed on read-back, while `updatedAt` stayed at `2026-09-14T04:01:40.524Z` across both — on a run where the same field advanced normally on another child forty minutes earlier. APP-1417.) (Worked case: on 2026-09-09 an author pass reported that the refine run had rewritten the manifest children but never rewritten the index. The timestamps say otherwise — the eleven children were written 06:03–06:24Z, `osclaude.pulse-manifest.decisions` at 06:30:52Z and the index itself at 06:32:39Z, twelve minutes after the note was filed at 06:20:42Z. The index rewrite landed; the author pass had simply read it first. The defect is a refine/retro overlap, not a missing write, and canon covered only the overflow case — APP-1206.) The same expansion applies to every Linear document a pass must read back, `osclaude.log-decisions` (APP-906) and the per-cycle goal documents included, so size any of them by sections rather than by reference style. (Worked case: the 2026-09-04 index reached 56,083 characters across 50 `READY` rows and 9 `OWNER-GATED` rows and `get_document` overflowed reading it — the exact failure the index-plus-children shape was created to avoid, reappearing in the index itself. On 2026-09-07, moving the rulings, run-log and named actions into the decisions child took the index from 50,024 stored characters to a clean single-call read — APP-1148; APP-1097 is the antecedent this extends.) Each **child** is `osclaude.pulse-manifest.<target>`, headed `Refine <date> · target · new/edit · status · folded notes`, **with every identifier on that line written in backticks — the target name and each folded note ID alike** — because the backtick rule stated above for the manifest documents' identifiers reaches the header line too, and the two instructions otherwise read as conflicting on exactly the line that matters most. The header is the only line the author pass's freshness test reads, so a bare note ID in it is expanded by Linear into a full issue mention on save and the test's one input is mangled. (Worked case, **observed** this run: a child saved with its header's folded-note identifier bare had that identifier expanded into a full issue mention, and the same child re-saved with the identifier in backticks read back clean.) The child carries the full change set for that one artefact (anchor + operation + new text per change, the frontmatter check, and any repo-lane ticket, config action or ticket-side action); a child that would exceed ~45KB is split into numbered changes across two documents and the index row links both. All are **full-replaced by each refine run** (one writer — refine; retro only reads), so a row that sits unauthored for several days is re-emitted current rather than accreting comments (the comment-idempotency guard of `convention-linear` and capture step 2, APP-384 / APP-738); a child not re-emitted this run is stale and retro ignores it. Because Linear's renderer normalises spacing around nested backticks in inline code, an anchor is matched as **text, not byte-exact** — the author subagent match-checks against the live file by meaning-preserving whitespace, and where an anchor carries nested code spans the refine worker may also leave a byte-exact copy in the session outputs folder (`manifest-<target>.md`). **A child's figures divide into the ones that decide and the ones that corroborate, and only the deciding ones may stop a row.** What decides is the **header date on line 1** and the **anchor's own uniqueness against the live file** — the anchor is what the apply depends on, so `grep -F -c` = 1 on it is the pass/fail. Everything else a child states about the target — a line number, a line count, the count of a short marker string, a byte size — **corroborates and never decides**, because each of them can differ from the live file while the anchor still matches exactly once and the change still lands correctly. So **a secondary figure corroborates and never decides**: a mismatch on one is reported in the row's return, never treated as drift and never a reason to hold the row, and the pass confirms the anchor and proceeds. Two ways such a figure goes wrong with nothing having drifted, both of which have occurred. **A line count depends on a convention the child does not state** — `wc -l` counts newlines and returns 212 on a file ending in a newline where a split on newlines returns 213 for the very same bytes — so a child quoting one and a pass measuring the other disagree by exactly one on a file neither has touched. Quote a line count only with the command that produced it, or do not quote it. **And a short marker string is bound by nothing**: the anchor's uniqueness rule does not reach it, so it can occur twice where the child expected once. A marker string that is not unique corroborates nothing and should be lengthened until it is, or dropped. **A child also never restates its own header date in prose.** Line 1 is the only place the child's own date is written. A document-resolution section that quotes a date is quoting the header it read *before* replacing it, which is a different date by construction, and a reader cannot tell that from a claim about the child's own date — so the prose names what it resolved and why, and never a date that will be read as the child's. (Worked case: on the 2026-10-26 author pass the `task-cycle-planning` child carried an expected line count of 213 against a measured 212 and a marker-string count of 1 against a measured 2, and its document-resolution section stated a header date other than its own line 1. The worker treated the header line and the primary anchor as authoritative, confirmed the edit by its own seam test and did not hold the row — the right call, and the one canon did not name. Re-derived on the live file afterwards, the line-count half was not drift at all: `wc -l` returns 212 and a split returns 213 on the same bytes. The header-date half is visible in the 2026-10-26 `skill-ops-retro` child too, whose resolution prose quotes a 2026-10-23 header while its own line 1 reads 2026-10-26 — APP-2683.) **And the anchor-uniqueness test is weaker than it reads on these files, so it takes two counts rather than one.** Canon fixes the deciding test as `grep -F -c` = 1 on the anchor, and these canon files are **one paragraph per line**: `-c` returns the number of *lines containing* the string and not the number of occurrences, so it can return 1 while the string occurs twice in that one line — and an anchor that occurs twice is not unique whatever `-c` says. (Worked case, **observed** live this run: `routine-delivery-loop` carries the sentence `Fill the closing declaration's blank with the elapsed figure` **twice**, where `grep -F -c` returns **1** and an occurrence count (`grep -o … | wc -l`) returns **2**.) So the deciding test is `grep -F -c` = 1 **and** an occurrence count of 1, both measured and both reported in the row, and where either exceeds 1 the anchor is lengthened and re-measured before the row is marked `READY`. This is `APP-2683`'s finding that a short marker string is bound by nothing, reaching the **primary** anchor rather than a secondary figure: the one figure in a child that may stop a row is the one the rule as written did not fully bind. The index row shape:

| target artefact | new/edit | status | folded notes | change (anchor → new text) | why / question |
|---|---|---|---|---|---|

* **`status`** is `READY` (retro produces it this run) or `OWNER-GATED` (waits on an Owner decision, prerequisite, or config action — already surfaced to Blocked by refine; retro skips it).
* **`change`** is the exact edit for a `READY` row: for an edit, the anchor text in live canon and the new text that replaces or follows it; for a new artefact, the full body. It is precise enough that retro writes without re-deriving anything — a `READY` row retro cannot apply mechanically was not ready, and goes back as stale.
* **`folded notes`** lists every note ID the row incorporates, so retro knows exactly which notes to close as *incorporated* once the package is presented. **A note whose fix spans more than one target artefact is `folded` on exactly one row — its primary — and `evidence` on the others.** Only a `folded` note is closed; an `evidence` note is listed for context and left to the row that owns it, and the closing comment on the primary names **every** artefact the note's fix touched, so step 1a can verify each of them by a targeted read. Listing one note as folded on two rows makes the author pass close it twice and leaves step 6's reconciliation — rows presented, folded notes closed, rows kicked back — unable to balance, which is the one signal that reconciliation exists to give. This is the refine-side counterpart of that fix (APP-1119).
* **`close text`** is the *incorporated* close itself, written out in full by refine — one block per folded note, in the child document beside `change` — and posted **verbatim** by the author subagent, which composes no close of its own and adds no sentence to the one it is given. Refine already holds everything a correct close needs: it authored the change, so it holds the evidence string, and it is the judging pass, so it is the only pass that can name the condition that should now clear and its by-when date. Supplying the text makes the close mechanical in exactly the way `change` already makes the edit mechanical, and a row whose `close text` is missing is as unready as a row whose anchor is missing. The reason the close is **supplied rather than described** is that the author subagent is fanned one-per-row and its whole input is that row: a rule stated in step 5 is not in front of the writer at the moment it writes, so restating it in a third place is not the fix — that is the shape that has already failed. (Measured by step 1a: of the 35 *incorporated* closes the 2026-10-05 author pass wrote, **18** commented on or hedged about the save and **34 of 35** named no falsifiable condition with a by-when date; the 2026-10-02 pass was 5 of 14 and 0 of 14. Both limbs were already categorical in step 5 — APP-1008 for the save, APP-1033 for the date — and both were hardened on 2026-10-02. A third consecutive pass of breach after hardening makes the rule's *placement* the defect rather than its wording: it is written where refine reads, and the close is written somewhere else.) **The close text's shape is fixed too, and the shape is where it failed next.** Supplying the text is not enough if the parts step 1a needs are not *inside* the block the author posts: write each change's evidence string **into the `close text` block itself**, as its own labelled line — `Evidence string in canon: "<phrase>"`, one per change — never in a sibling section of the child, however clearly headed. The author posts the block and nothing else, so a string outside it does not exist. **And a close is read back after it is posted and compared against the supplied block**, because the failure mode is not a wrong close but a short one: a verbatim post truncated part-way reads on the board as a terse close rather than a lost one, and nothing downstream distinguishes them. (Measured by step 1a on 2026-10-13 against the 2026-10-12 batch: of 15 *incorporated* closes, **4** carried no evidence string at all, covering **6 of 21** changes, and **1** carried no dated condition. Reading the three children settled the cause both ways — three were refine-side, with the strings parked in a `## Evidence strings` section below the fenced block while the author posted that block byte-for-byte, and one, APP-2207, was author-side, its complete and compliant close posted truncated at the first paragraph so that both the evidence line and the whole condition block were dropped. The one child that got it right carried an `Evidence string in canon:` line inside the block — APP-2296.) **And a close is not complete until both halves have been read back.** The read-back rule above covers only the posted comment; a close also writes the note's **state** (Done, step 5's *Incorporated*) and clears its cycle, and nothing has asked that write to be confirmed the same way the comment is. A close-comment can post complete and verbatim — and read back as such — while the state write it describes never lands, because the comment and the state write are two separate calls with two separate failure points, and a worker that reads back only the first has verified half the close. So the author subagent re-reads the issue after the state write, and again after the cycle-clear write, exactly as it already re-reads the posted comment, and names both read-backs before counting the note as closed; a note whose comment read back clean but whose state write is unconfirmed is reported as open, never folded into a closed count. (Worked case, session-observed, 2026-10-28: a prior run posted fifteen complete, correctly-shaped *incorporated* close comments, each read back and matching — and left all fifteen notes sitting open in Backlog with no state change at all. The comment half of the close had been verified; the state-write half had never been read back to confirm it was even attempted.) **And the prohibition on save-state commentary and on pre-save counts belongs inside this spec, because this is where the close is now composed.** The reason the close is supplied rather than described applies a second time, one level up: the writer of the close text is a refine fan worker whose whole input is one target's child-document spec, so it reads these `close text` requirements and not step 5, and a rule stated there is not in front of it at the moment it writes. So both categorical limbs are restated here, where the text is composed — a `close text` block carries no commentary on whether the save landed, and no count taken before the save: every figure it states is measured against the file as it stands after the change, or it is not stated. The pre-save count is the worse of the two, because the save is what invalidates it — the block ships a number its own edit has already made wrong, and ships it as evidence. (Observed by this run's own step 1a against the 2026-11-05 batch of nineteen closes: `APP-2892`'s close asserts an evidence string occurring "zero times in `skill-ops-sync`, which also carries no mention of `APP-2846`", both of which return 1 post-save, so the close ships a figure its own save invalidated; and `APP-2859`'s close recites its full pre-save absence ladder inside the close block. Both are the `APP-2507` / `APP-2482` defect, categorical in step 5 since 2026-10-22 and recurring after hardening — and now originating in refine's supplied text rather than in the author pass's composition, which is what makes the placement rather than the wording the defect. Session-observed; no queue note folds this finding.)

**And each evidence line names the artefact it belongs to.** The line's full form is `Evidence string in canon: "<phrase>" (<artefact>)` — one line per change, never one line per close, and never a bare list of phrases following a list of artefacts. A close that names two artefacts and then gives two strings with nothing binding them does not say which phrase to grep in which file, so step 1a's artefact check has to guess the pairing; a bare grep run against the wrong file of the pair returns **0** on a change that in fact landed, and the loss it then reports is the checking pass's own rather than the save's. That is the costly direction: a false absent sends the next drain to re-author a change already in live canon, which is the no-op class step 3's match-check exists to prevent. Where one change touches one artefact there is one line. Where a package spans artefacts there is **one line per artefact**, each with its own phrase, and the phrases need not be the same text — what binds them is the parenthesis, not the wording. (Worked case, **observed** by this run's own step 1a: the 2026-10-20 batch's `APP-2414` close named two artefacts and then listed two evidence strings with no binding between them, and the bare grep came back 0 on a pairing the pass had no way to read off the close. The parenthesised artefact is also the form `convention-artefact-format` carries on the format side as of this run, so the two files agree on one shape rather than each describing the line in its own words. `APP-2486`.)

**And the evidence string is copied from the change's own new text, never retyped.** The two rules above fix where the evidence line sits and what it names; this fixes how the string itself is produced. A phrase typed out a second time from memory drifts in exactly the ways the fallback rule below catalogues — a word order swapped, a clause truncated, a terminal mark changed — and the result is indistinguishable afterwards from a lost save: step 1a greps the string the close gives it, gets **0**, and reports an absence the change never had. So the phrase in the `close text` block is **copied from the change's own new-text fence**, and refine **greps it against that fence before emitting the row**: a phrase not present verbatim in the new text is a mis-transcription, not a short evidence string, and the row is not ready until the two match. The two greps are a pair — **1** against the row's own new text and **0** against the live file, the second because the change has not been saved yet — and together they make the string in the close and the string in the change the same bytes. (Measured by this run's own step 1a: of the **46** evidence strings in the 2026-10-21 batch, **three** returned 0 as written and were then present on the second fallback, so the string had been mis-transcribed in the close rather than the change lost. Each cost a false zero and three further reads, and the fallback rule below absorbed the cost quietly, which is why it recurred — session-observed, 2026-10-22 refine run.)

**And the by-when the close names is tested for reachability before the row is emitted.** The spec above makes refine the only pass that can name the condition that should clear and its by-when date; nothing in it asks whether that date is **reachable**. A close is tested by a later pass, and those passes fire on a schedule — `task-pulse-refine` on `30 4 * * 1-5` and `task-pulse-retro` on `15 10 * * 1-5`, weekdays only, read from the live scheduled-task store (`list_triggers` on the Claude Code Remote connector), **read 2026-11-11**, never quoted from a note or an artefact — so a by-when on a Saturday or a Sunday is **unmeetable by construction**: no run fires on it to find the condition still true, and the next run that reads it is reading a date already behind it. So the writer of a `close text` block checks the date's weekday before emitting the row, and moves a weekend date forward to the next day the testing pass fires. This limb sits here rather than in step 1c alone for the reason the whole spec exists: the writer of the close is a refine fan worker whose entire input is one target's child-document spec, and a rule written where a date is merely *described* is not in front of the pass that *composes* it. (Observed this run: the 2026-11-10 batch's own `skill-build-ticket` close carries a by-when of **2026-11-28**, a Saturday, alongside eleven weekend by-whens set on the same run's own clearance legs. Step 1c's by-when family carries the matching limb, and the two sites are given it together because the date is composed in both. Session-observed; no queue note folds this finding.) **And where a run's closes name more than one by-when, the date is allocated by the parent rather than chosen by the worker.** The limb above moves an unmeetable date forward and says nothing about where the moved dates land, so a batch correcting several at once sends them all to the same firing day. A pass that meets fifteen conditions on one morning cannot give any of them the read the date exists to buy, and the Owner's agenda sees a wall of simultaneous lapses rather than a queue — which runs against the by-when's own purpose, since the by-when is the only thing that retires an entry from the open-condition set, re-derived from the board each run rather than resumed from a watermark. A fan worker cannot spread what it cannot see: its whole input is one target's child-document spec, so it sees the clusters that already exist and not the ones its siblings are composing beside it, and an instruction to avoid the crowded day moves every worker onto the same new one. **So the writer of a `close text` block proposes its by-when and does not place it** — it states the date it would choose and the load it is avoiding, and the driver allocates across the available weekdays before the rows are emitted. This limb sits here as well as in step 1c for the reason the weekday limb does: the date is composed in both places, and a rule stated in only one of them is not in front of the writer of the other. The forward-only correction, the re-read of a **live** condition, and the gating limb's prohibition on absorbing a lapse by re-dating dependents are untouched. (Session-observed on this run's own authoring fan: of **seven** close blocks carrying a by-when, **four** landed on the same Tuesday, 2026-11-17, each of those four workers having been told that Monday 2026-11-16 carried a large cluster to be avoided, and two of them recording that reasoning explicitly before choosing the same alternative. The parent re-allocated the four to four distinct weekdays once the verification leg found the cluster. No queue note folds this finding.)

**And the identifier citation binds every production, not only a re-production — the same grep, run before the row is emitted.** Step 1a's rule below binds a re-production to carry its folded note's identifier citation forward *exactly as a first production does*, and that wording assumes a first production cites it; nothing in these rules requires it. Fallback 3 of step 1a searches the folded note's own identifier in the target, so the obligation sits at both ends alike: the citation is owed by **every change a row carries**, first production and re-production alike, and a row whose change text does not cite each of its folded notes' identifiers is **not ready**. The test is the one already run on the evidence string — refine greps the identifier against the row's own new-text fence before emitting the row, and a **0** there is a dropped citation rather than a short change. The asymmetry is what earns the line: a dropped citation costs a **false ABSENT** on every later pass that reaches for the identifier first, and under the re-production rule a false absent sends the next drain to re-author a change already in live canon and interrupts the Owner for a save that already landed. (Worked case, **observed** by this run's own step 1a: of the four authored closes in the 2026-10-30 author batch, `APP-2750` and `APP-2751` both landed their change text in full into this artefact — each evidence string present at **1** on the first grep, occurrence 1, at lines 112 and 108 — and neither cites its own identifier anywhere in the live store: `grep -F -c APP-2750` and `grep -F -c APP-2751` each return **0** in this file and **0** across all 178 artefacts. The same batch's `APP-2753` → `skill-operating-loop` and `APP-2754` → `workflow-content-engine` each cite theirs inside their own change paragraph, so the drop tracks the **target file** rather than the batch or the pass. Both dropped paragraphs are densely cited with ten-plus *other* identifiers, so the authoring convention was followed for evidence and dropped only for provenance. The mechanism is **unverified** — whether this artefact's authoring worker's template omits the self-citation, or two workers independently dropped it, is not determinable from this surface; the probe is a read of the two authoring legs' own transcripts. The correlation is observed; the cause is not claimed.)
* A **re-production** (a prior close whose save never landed, 1a) is just another `READY` row, marked `re-produce`, with its change rebuilt by refine from a fresh read of live canon.
* Below the table: the **decisions-needed set** in full, the two queue rates and the completeness split (1d), and the verified-through watermark (1a). The decisions-needed set is written to be answered, not browsed (Owner decision, 2026-08-15, APP-852 — across 40 assessed notes the refine recommendation matched the Owner's answer roughly nine times in ten, yet the handoffs framed most items as open questions of equal weight): (i) **each question leads with a recommendation**, with the reasoning, and reserves a full option set for a genuinely balanced call; (ii) **the set is ranked by cost of delay ÷ size** (`standard-prioritisation`, Method C) — release value, recurrence cost and time criticality over the ticket's native Linear estimate — so a thirty-minute answer that clears seven notes is not presented beside a fifteen-minute one that clears none, which is the pair that sat indistinguishable at Urgent for 24 and 49 days (APP-965 against APP-633, APP-1170). Canon has required this set to be ranked by leverage since 2026-08-15 (Owner decision, APP-852) and supplied no method, so the rank was re-derived by judgement each run and could not separate the two. The method is the standard's; the ranking is **this pass's**, computed here, because the only other candidate reader is scoped out by construction — `skill-attention-sweep` runs on the committed cycle and excludes `PUL-5E` notes (APP-686), and a `PUL-5E` note is never in a cycle (`convention-linear`, *Never in a delivery cycle*). Where the estimate is absent the item is listed as **unranked**, never as small — a missing Owner-lane estimate is an Aide defect (`convention-linear`), and ranking it as cheap is how the cheap-looking item stays at the top for a month; (iii) **answer-once clusters are named** — where several notes reach the Owner as one question, the set carries one question with the notes it clears listed under it, never the same question several times; (iv) **the set is capped in presentation, never in assessment** — it is written in full for the record and presented as the top items that fit the sitting it is read in, with the remainder listed by ID under a *not this sitting* line naming when they return. Uncapped, the set is a report rather than an agenda: sixteen notes with eleven waiting on the Owner will not fit a thirty-minute stand-up, and a well-written report was not enough to create a sitting for twenty-four days (APP-1161). Nothing leaves the set by not fitting; (v) **each item carries its destination, sorted at the point it is surfaced** — canon already fixes the destinations and nothing sorts into them, so a one-word verdict and a twenty-minute design call land in one undifferentiated pile at Urgent. A gate verdict, an unblock or a same-day decision goes to the **daily stand-up** (`skill-operating-loop`, *The gate cadence*); an initiative-level call — strategy, goals, resources, targets — goes to the vertical's **weekly Owner session**; a short item that releases a blocked queue goes to the **post-stand-up unblock gap**, within its admission cap of two decisions per session (`convention-hold-windows` — the gap survives the 2026-10-05 retirement of `work.Unblock` as a window, and the cap counts decisions, not tickets). The shape is stated on the item rather than left for the reader to infer (APP-1161). This set is also where the Owner reads what canon needs him: `task-daily-report` no longer carries a canon sweep (APP-876), and `task-owner-standup` points at this set rather than reproducing it. **And an item's premise is read before it is ranked — the owning project's status first.** Every item in this set cites a ticket, a vertical or a project, and where that project is on **Hold** the question is not a live decision: the hold already answers it, and ranking it as open puts a settled matter at the top of the Owner's agenda. So before an item enters the set, read the owning project's `status` with `get_project`, and where it is Hold the item is **not ranked as a live decision** — it is recorded as held, with the hold's date and where it was ruled, and drops out of the live set. This is `convention-linear`'s escalation-ladder rule — *read the owning project's status before raising priority* — applied to this pass's own ranking rather than to a delivery lane; its worked cases on the delivery loop (APP-1651) and on an operator loop's age ladder (APP-1676) are both closed, so the rule is already proven and only this surface was uncovered. **One check on the top-ranked item's premise is cheap enough to be non-optional**, whatever the set's length, because the top item is the one that reaches the room. (Worked case: the 2026-09-25 refine run ranked "the twelve scheduled tasks disabled 2026-09-15 — was that deliberate? Day 10" as its **top** item, framed as "a plain off switch, not a platform hold", a full day after the Owner had set `bot.Trader` and `bot.Trader-B` to Hold, pulled their cycle-committed tickets, filed APP-1719 to pause Actions and hosting, and recorded the ruling on `bottrader.log-decisions.2026-W39` and on APP-681. The framing was false against the project's own `status` field. `task-owner-standup` then reproduced the item verbatim as item 1 of the day's agenda and the Owner corrected it live in the room — APP-1765.)

A note with no manifest row and no refine comment is unassessed — "not reached" — and stays in Backlog exactly as it is. On a manual "drain now", one session runs the refine steps then the author steps in order; the manifest may be held in-session rather than written, since the same session holds the assessment. **A refine pass establishes its own position in the day before it writes anything — the loader's run-context line is not that test.** `task-pulse-refine` asserts "first of the day, ahead of `task-pulse-retro`" however it was fired, so a hand-fired or re-fired refine carries a false premise about its own place in the sequence and, followed literally, full-replaces an index the author pass has already drained — destroying the record of what retro was handed, which is the document the next run's step 1a reconciliation reads. The author pass has had a two-limbed freshness test since APP-1206 and APP-1516; refine had none. So **before step 1a, read the index** `osclaude.pulse-manifest` **and its own stated refine date, and read** `task-pulse-retro`'s `last_run.fired_at` (one `list_triggers` against the cloud store — the three-way store split in `core-operating-model`). **The calendar comparison is the first gate and it is decisive.** Compare the index's own stated refine date against today before either signal is weighed. Where that date is **not** today, the no-index-for-today branch applies unconditionally and retro's `fired_at` is not consulted at all: yesterday's index is the record of a handoff that finished, not a sign of a run in flight. Signal 2 read on its own is day-agnostic — "retro's last run is after the index's refine date" is true of every already-drained yesterday index — so weighing it first turns the commonest case, a fresh day meeting a stale index, into a re-entry. Only where the index's stated refine date **is** today does retro's `fired_at` decide between the same run resuming and a genuine re-entry. Two signals, three outcomes, tested in that order. No index for today, or an index whose stated refine date is not today → proceed as the day's refine and full-replace the index as usual. Today's index exists, its stated refine date is today, and retro has **not** drained it → proceed; this is the same run resuming. Today's index exists, its stated refine date is today, and retro's last run is **after** that date → this is a re-entry, and the answer is **the on-demand shape above, not a refusal**: run the refine steps over the notes filed since that index, hold the result in-session, hand it straight to the author steps, and **do not full-replace the index, do not re-run step 1a, do not re-close anything**. **No branch of this test may end in a no-write exit.** Every branch either writes the index or hands a held manifest to author steps in the same session, so a pass that exits having written nothing has mis-read the test rather than completed it. **And the hand-it-straight-to-the-author-steps shape is the on-demand single-session case only:** a standalone scheduled refine has no author steps to hand to, so a scheduled run that finds itself on the re-entry branch runs the refine steps and writes the index as usual and reports the re-entry in its own report. (Worked case: on 2026-10-15 the 03:39Z refine read the 2026-10-14 index, which `task-pulse-retro` had already drained at about 09:16Z on 2026-10-14, and the day-agnostic second signal matched the re-entry branch where the intended reading was the first; the pass exited in 66 seconds having written nothing. Measured that day: `osclaude.pulse-manifest` last written 2026-10-14T04:17:54Z; `task-pulse-retro` fired 2026-10-15T09:16:15Z and succeeded; no PUL-5E note closed anywhere on 2026-10-15; and the Backlog queue grew from 10 notes to 35 by the following morning. That the run took the re-entry branch is **unverified** — no transcript is readable from the authoring surface, so the branch is inferred and only the outcome is measured. Second defect in the same re-entry test; the first was the absence APP-2311 added it for. APP-2390.) The one-current-package-per-unsaved-target guardrail already governs any target whose earlier package is still unsaved and is not restated here. A refusal is the wrong answer because the catch-up is cheap, canon already describes its shape, and refusing it costs the Owner a round trip. Report which branch was taken and why. (Third instance of this shape on a third schedule — APP-884 for the weekly operator loop and APP-1655 for `task-a1-operator-loop`, both reported from the filing note and not corroborated against this file — and the first on a pass that full-replaces a consumed handoff. APP-2311.)

**Fan the author pass by target artefact — one tool-scoped author subagent per manifest row.** The author pass is partitioned, not run serially. The manifest is already grouped by target (step 2 requires each target be changed exactly once), so fan **one author subagent per `READY` row**, concurrently. Each subagent owns exactly one canon file: it re-reads that live SKILL.md, match-checks the row's anchor, applies the row's change, validates the frontmatter (4b), packages the single `.skill`, closes the row's folded notes as *incorporated* (5), and returns a compact summary. Because the partition key is the **target artefact, never the note**, no two subagents ever write the same file — the packages cannot clobber one another and the Owner still saves one package per target. **Where a hard coupling forces several targets into one subagent, the prompt's close-list is the union of each grouped row's own `folded notes` cell, read from the index table.** One row per subagent is the rule and grouping is the exception — a save-together dependency between targets is the case that earns it. The exception costs the guarantee the rule was carrying: a single-target prompt is built from one row's own cell and cannot omit anything, while a grouped prompt is composed by hand, and composed from the **prose** describing the dependency it will name the notes that prose happens to mention and silently drop the rest. So a grouped prompt is assembled from the **table**, cell by cell, one row at a time, and names every note it is closing before the subagent starts. Step 6's reconciliation stays the backstop and is not the mechanism: it catches the miss after the fan has returned, at one extra read-and-fix cycle, and it only catches it when it is run against the index's own READY row set. (Worked case: on the 2026-09-29 author pass the convention-naming + convention-decision-log + convention-linear trio went to one subagent whose prompt named APP-1381 — the shared evidence note visible in the dependency prose — and never mentioned APP-1790, the convention-linear row's own primary. It was found by step 6's reconciliation, absent from every subagent's report, and closed by the parent after the fact — APP-1852.) This is the in-session tool-scoped sub-agent shape in `convention-agent-runtime`, and it removes the single-context-window ceiling that forced the refine/author split (APP-875): authoring N artefacts no longer competes for one window. What stays in the **parent**, never fanned: reading the manifest, the `osclaude.log-decisions` writes (one full-replace document — parallel writes would clobber it), the **delivery of every package** — a subagent returns its built package's path in its summary and never calls `SendUserFile` itself, and once the whole fan has returned the parent sends each package with `SendUserFile`, one file per target (step 4, APP-1331) — and the short report (6). A file sent from inside a fanned subagent is not a file the Owner can be assumed to see, and a report of "delivered" over packages he cannot see is the worst form of the failure. **And the restriction is the class, not the one tool — the prompt says so in those words.** `SendUserFile` is one member of it: every Owner-facing channel is the driver's, `PushNotification` and the user-message tools beside it included, whatever a worker's own tool list happens to offer (`convention-agent-runtime`, *Isolation*). A worker sees one row and cannot judge what the run as a whole is worth telling the Owner, and the call is invisible twice over — it arrives ahead of the driver's own message and appears only in the worker's sidechain, never in its return. So each fan prompt **names the whole class explicitly**, beside the `SendUserFile` line it already carries, rather than relying on the driver having loaded `convention-agent-runtime` first. That reliance is what failed: the 2026-10-08 author run's nine prompts each forbade `SendUserFile` verbatim from this section and none mentioned `PushNotification`, because this section named one and not the other — a rule stated where the prompt-composer does not read it is not a rule the fan carries. (Worked cases: the 2026-10-05 run, one of 21 subagents, on `skill-review-pr` — APP-2040, whose canon fix landed in `convention-agent-runtime` and recurred anyway; and the 2026-10-08 run, one of 9, on `skill-operating-loop`, found only by grepping each sidechain for a structural `tool_use` block, since the bare string matches every session's own tool-schema listing — APP-2170. The sidechain evidence is the filing leg's report and is unverified here; that flag covers the transcript identifiers only, not the canon placement, which was read live: `PushNotification` occurs exactly once in the 169-artefact store, at `convention-agent-runtime`'s *Isolation* paragraph, and zero times in this file.) (Worked case: on the 2026-09-18 author pass all 20 fanned subagents sent their own packages; straight after "19 delivered" the Owner asked where the packages were — "for the past week you have stopped writing them here at the first pass … major issue" — and could see them only once the parent re-sent all 19 from the scratchpad. APP-1534.) A row a subagent returns thin, unresolved or stale is left in Backlog, exactly as a serial pass would leave it, and named in the report. (Owner instruction, Aled 2026-08-14; boundary fixed 2026-09-03, APP-1094.)

**Fan the refine pass by target artefact too — the partition key is the same at both ends.** Refine's own fan is partitioned by **target artefact, never by note cluster**: the parent runs a cheap note→target mapping pass first, then fans one worker per target, and each worker owns exactly one `osclaude.pulse-manifest.<target>` child document — no two workers ever write the same file. A note touching several targets contributes its evidence to each of those targets' workers through the mapping the parent hands down. This is the author-fan rule above — *because the partition key is the target artefact, never the note, no two subagents ever write the same file* — extended to the earlier pass, so the two passes are symmetrical rather than one racing where the other cannot. Two consequences follow. The child document's **header line is fixed by canon** (`Refine <date> · target · new/edit · status · folded notes`) and not by a per-run brief, so the freshness test — is this child from today's run? — is deterministic instead of depending on wording a brief happened to choose. And a change with **no natural per-target shape** — a frontmatter sweep across N files — is emitted as one named child document owned by one worker, which the index row links like any other. (Worked case: the 2026-09-04 refine run fanned seven workers by note cluster while the child documents were keyed by target; eleven targets were hit by two or more clusters, `convention-linear` by five. A full-replace at 06:59 discarded a sibling's 06:56 appended section, and a reconciliation worker had to audit eleven shared documents and rebuild four lost sections — APP-1118.)

3a. **Write the author manifest (refine pass).** After classifying (step 3) and deciding each note's disposition (5), write one child document `osclaude.pulse-manifest.<target>` per `READY` target carrying the exact change set (anchor + operation + new text per change) and its folded note IDs — each note folded on exactly one row and carried as evidence on any other row it touches, then full-replace the index `osclaude.pulse-manifest` with one row per target artefact in the shape defined above — `READY` rows linking their child, `OWNER-GATED` rows carrying the question already surfaced — followed by the decisions-needed set in full, both queue rates, the completeness split, and the verified-through watermark. This is the contract the author pass acts on: precise enough that retro re-reads live canon only to match-check and write, never to re-derive the assessment. **The index full-replace is the parent's first action once the fan returns** — before the report, before the `osclaude.log-decisions` write, before anything else the parent still owes. The children are written by the workers and the index only by the parent, so between the first child landing and the index landing the handoff is internally inconsistent, and an author pass that starts in that gap reads current children under a stale row set. The window cannot be removed — the two passes are separate scheduled tasks — but ordering the parent's remaining work **behind** the index write makes it **minutes rather than open-ended**. This and the author pass's freshness test (*The author manifest*) are one fix in two halves: the ordering shortens the window, and the test turns any overlap that remains into a reported hard stop rather than a silent bad read. (APP-1206.) Fan this step by target artefact — one worker per `READY` target, each owning exactly one child document, after the note→target mapping pass and never by note cluster. Keep the index itself readable in a single `get_document` call: one line per row, with the change text only in the child. The index carries the row tables **and the decisions-needed set**; where it would otherwise pass ~25KB, the how/where rulings, the run-log and the named config and ticket-side actions move to `osclaude.pulse-manifest.decisions`, which the index links in a short pointer section. (2026-09-07: 13,458 characters of source once those sections moved out, ~33,700 stored after Linear's reference expansion, read back cleanly in one call — against 56,083 stored and overflowing on 2026-09-04.) A short `[pulse-refine]` pointer comment on each folded note ("in manifest → `<target>`, READY/OWNER-GATED") is optional and, if written, is edited in place rather than re-posted — **and it never carries the close text itself, which belongs in the child document and is the author pass's to post.** A refine-side comment reproducing it asserts an *incorporated* close before any package exists and guarantees a duplicate the moment the author pass does its job. (Worked case, **observed** this run: on the 2026-11-04 refine run two of eleven folded notes — `APP-2851` and `APP-2847`, both on the `convention-agent-runtime` row — were given the full *incorporated* close text verbatim as a `[pulse-refine]` comment at ~05:06Z, and the author pass then posted the identical text again at ~10:26Z, so each note now carries two byte-identical *incorporated* closes; the other nine notes' ~05:0xZ companions are distinct `[pulse-refine]` rulings and not copies, so the defect sat in one row's worker.) A note with no manifest row is unassessed — not reached — and stays as it is.

**And before the index full-replace, the refine pass verifies its own handoff — three mechanical tests the parent runs over the child set it has just written.** The exactly-one-row obligation above is stated and nothing verifies it, which is how the configuration it forbids came to ship. (i) **No note ID appears in more than one row's `folded` column.** That is step 5's invariant — a note whose fix spans targets is folded on exactly one row and carried as `evidence` on the others — now checked at the one moment it is still cheap to fix, instead of surfacing as an unbalanceable step 6 reconciliation after twenty workers have run. (ii) **Every folded-note ID in the index's READY table matches the folded-note IDs in that row's child document**, header line and ticket-side actions both, so an index/child disagreement about who closes a note is caught before the author pass ever reads the index. (iii) **No child document names another row as the holder of a note's close.** Where a package genuinely spans artefacts, the primary row carries the single close block naming every artefact the fix touched, which is the shape step 5 already fixes; a cross-row close pointer is a defect in the handoff and not a thing for a worker to resolve. It must **not** be made ergonomic by having the pointing row declare it — a declared pointer normalises the double-fold step 5 forbids and weakens the one rule that prevents it. **Only the parent can run this check.** Each fanned worker reads exactly one child by design — one row per worker, tool-scoped — so both a cross-row pointer and an index/child disagreement are invisible to every worker that could act on them, and in each case a worker reading only its own child behaves correctly while the pass as a whole does not. Step 6's reconciliation stays as the backstop and is **not** replaced: it is what caught both of these, and a run whose reconciliation tolerance is looser than an exact count would see neither. (Worked case, the run's own narrative and therefore **reported**: the 2026-10-20 author pass over manifest `osclaude.pulse-manifest`, refine fired 03:39:28Z. `APP-1788` was folded on **two** rows — the `convention-linear` row with `APP-2465`, and the `task-cycle-planning` row with `APP-2415` — and each child's ticket-side actions pointed at the other row as the close's holder. The `task-cycle-planning` subagent assumed the close belonged to `convention-linear` and left it untouched; the `convention-linear` subagent correctly left it untouched per its own document; it was closed by neither, the one gap in an otherwise 23-for-23 fold, and it surfaced only in the parent's post-hoc count against the index's own "23 folded notes closed". Separately, the index's *Nine things the author pass must hold* said `APP-2281` was closed by the refine pass and its READY table excluded `APP-2281` from `convention-linear`'s folded column, while the `convention-linear` **child** listed `APP-2281` as folded on its row and instructed its close be posted verbatim — so the worker read its own child, as instructed, and posted it. Two internal sources of one index disagreeing, invisible from inside any single row's fan. `APP-2486`, widening `APP-1119`, whose refine-side counterpart the exactly-one-row rule already is.)

   **Verify a named runtime, machine, harness or data source before writing it into a row — the authoring-side premise check.** `skill-build-ticket`'s step 3a catches a false premise at *claim* time, which is after refine, after promotion, after the claim, and after the canon artefact was already saved; nothing checks the same claim at the point it enters. So where an artefact being authored, or a ticket drained from it, names a **runtime, machine, harness, test runner or data source — or describes the *mechanism* of a named source file** (what it classifies on, what it defaults to, what it validates against) — that claim is verified against the repo or the live config at authoring time, not asserted from a decision comment; and where it cannot be verified from the drain's surface it is written as **unverified** rather than as fact. **And a stated property of the runtime is the same kind of claim as a stated runtime — isolation, uniqueness and persistence are verified, not inferred from a path's shape.** The list above names a runtime, a machine, a harness, a runner, a data source and a source file's mechanism. It does not reach a claim about how a named runtime *behaves* — that a directory is per-leg, that a path is unique by construction, that a value survives a restart — and that is the shape most likely to graduate unflagged, because the path it names is real, the read of it succeeds, and every check a downstream leg can run confirms the path rather than the property. A leg confirming such a claim tests the shape of the path and reports a pass, which is a true answer to a question nobody asked. So a drain writing an isolation, uniqueness or persistence property into a row or a ticket verifies the property itself against the live store or the live config, or writes it **unverified** naming the property rather than the path. (Worked case: APP-2639's AC4 described the per-session scratchpad as "leg-unique by construction" and asked for it to be named as the render-check working location. It is shared: `convention-agent-runtime` calls the session outputs folder a shared directory, with APP-2413's sibling worker overwriting `<scratchpad>/newtext.txt` as its worked case, and `skill-review-pr` says the same citing APP-1513. The exec leg confirmed the path's shape against the runtime, copied the property into `CLAUDE.md`, and produced a section telling legs they are isolated when they are not — one QA bounce, changes-needed, and a clean pass would have committed the false premise to the repo. The QA leg saw the contradiction directly: its own scratchpad already held `a1-803-qa/`, `app2306-qa/`, `qa-APP-2638/` and `qa-APP-2638-scripts/`. The canon reads this change rests on — the shared-directory statement and its worked case — were checked against the live store this run; the ticket's AC wording, the `CLAUDE.md` text and the bounce are the filing leg's **report** and are unverified here — APP-2662.) A mechanism claim is the shape most likely to slip this list, because it names no machine and no runner: it reads as a fact about how the system works rather than as a claim about one file, and the file is the only thing that can settle it. **And the flag travels to every artefact the drain emits from that premise, not only to the one being written.** A single drain routinely produces both a delivery ticket and a canon row from one claim, and the two are written minutes apart into different surfaces by different steps; flagging the ticket and not the row leaves the row reading as settled fact to the next reader, with the ticket's flag nowhere in its line of sight — and the row is the copy that outlives the ticket. So an unverified premise is written unverified into **every** output of the drain that rests on it, each naming the same premise, or it is verified once and written as fact in all of them. This is refine's by the APP-1094 boundary — verification is reading and a judgement call — and it belongs in the row rather than in the package, because retro applies a row mechanically and re-derives nothing. A premise flag also **names which premise it covers**: a premise warning on one unknown reads as a statement that the rest was checked, so a run that flags one unknown does not thereby imply the others were verified. Step 4a's *verify the premise in the target file before filing* is the repo-lane half of this same rule; this is the canon half, and neither substitutes for the other. **Wherever either half reads a repo, it names the ref it read, and the ref is** `origin/main`**.** Fetch first and read `origin/main` — the ref a build leg branches from — never a working tree, never a local checkout's current branch, and never an open PR's branch; then record the ref and its short SHA beside the claim, so a later check compares against a named ref rather than re-deriving the scope. A branch read is the one repo premise no format gate can catch: every file, string and gate it names is real *somewhere*, so the claim reads as perfectly well-formed and nothing in its own text signals the problem — only a read against `origin/main` separates it. Where the repo is not readable from the drain's surface, that is an **unverified** premise naming the repo, not a licence to write the claim as fact. (Worked case: `task-bottrader-watch` was authored from the APP-914 drain, saved as canon, and its build leaf APP-1123 promoted, all stating that "the host" writes the health digest after each daily decision cycle. Verified against `assoc-one/bot-trader` at `main` (`18fa6d4`): the cycle does not run on the host — it runs on GitHub Actions (`.github/workflows/scout-cycle.yml`), by an Owner decision of 2026-08-10 recorded in that file's own header comment; the host runs only the continuous drawdown guard. The word "host" came from a 2026-09-03 *access* ruling — "the host publishes outbound, the watcher never reaches in" — a sound answer to the access question that never addressed which machine runs the cycle. The 2026-09-03 `[pulse-refine]` comment on APP-914 flagged the *credential* as unverified, accurately, and carried that onto APP-1123, while the larger blocker travelled unflagged into both the artefact and the ticket; step 1's fallback — if the document has never been written, file one ticket and stop — means the watch would have failed quietly and correctly forever. APP-1158. A cheaper instance one layer down, 2026-09-07: APP-1122's acceptance criterion read *"CLAUDE.md states the request-time-fetch rule … and the stub-verify approach for local checks"*, and `assoc-one` has no test runner — no `test` script, no vitest/jest/playwright dependency — so the criterion named a practice with no harness behind it. The transmission defect is the same: a FRICTION note's speculative wording ("candidate target: …") graduates verbatim into an acceptance criterion when the note is drained, carrying the speculation's confidence with it. The build leg resolved it correctly by writing to what exists and flagging the interpretation, but that was judgement, not a rule — APP-1155.) (Worked case, the two-output half: the APP-1848 drain emitted both a delivery ticket, APP-1894, and a `convention-artefact-format` row, each stating that `build-manifest.ts` classifies an artefact by the prefix of its filename. APP-1894 carried "premise unverified" and was correctly Blocked at claim under `skill-build-ticket` step 3a; the canon row carried no flag at all and read as settled to every subsequent reader of the artefact-classification rules. **The mechanism claim itself is unverified here and is written as fact in neither direction** — this refine surface reads no repo, so neither the original claim nor its reported correction is recorded; what is recorded is that one premise reached merged canon unflagged from a drain that flagged the same premise on its ticket. The canon-side instance is corrected by `convention-artefact-format`'s own change in this pass, which removes the as-fact assertion rather than replacing it — APP-2007, 2026-10-03.)

1. **Read the queue — scope it by the label, not by the project.** Query for issues carrying agent value `PUL-5E` in **Backlog across the workspace** (or at minimum the whole **Apps team**, project filter omitted), not `project: os.Claude`. The `PUL-5E` value *is* the queue's definition; os.Claude is where a note is *supposed* to be filed, and the two are not the same set. A project-scoped read silently drops any note filed without a project — the filter returns clean, `hasNextPage: false`, and the miss is invisible, which is the one failure a sweep cannot report. Then bucket the results by project and treat a project-less note as a filing-hygiene fix to make in passing (set `project: os.Claude`), never as a reason to skip it. (Worked case: the 2026-07-16 drain read `project: os.Claude` + `PUL-5E` + Backlog, got 17 with `hasNextPage: false`, and reported the queue as fully assessed. Three notes carrying `PUL-5E` in Apps Backlog had **no project set** and were never seen — APP-420, APP-416, APP-378. APP-416 recorded `convention-sanity` as two major versions stale and had sat through four drains unread. Caught only because Aled looked at the board.) Treat the queue as inputs alongside any session-observed friction or a pasted transcript. (Reading-safety traps in convention-linear: the agent-group filter takes the bare value `PUL-5E`; a Backlog filter also returns Refinement, so re-check each ticket's state name.) Previously *surfaced* notes are not in this read — they are picked up by the blocked-clearance pass in step 1c. A note reaches **Done** only once it is incorporated or assessed-not-warranted, never merely because it was deferred, so a warranted-but-blocked note stays visible across drains until it can actually be authored.
1a. **Verify the previous drain's saves actually landed — re-surface a missed one.** A note is closed at *package* time, not *save* time: the drain produces and presents the artefact, but the operator saves it in a separate step, so a package missed in a closed session leaves canon unchanged with nothing to re-raise it — `skill-ops-sync` only detects a save that happened, `skill-task-health` only checks the scheduled layer. So each drain **opens** by checking the previous drain's closes before touching the new queue: query os.Claude for recently-**Done** `PUL-5E` notes whose closing comment reads "incorporated into `<artefact>`", and for each, read the **live** SKILL.md and confirm the named change is present (a **new** artefact → present in the store or not; an **edit** → the closing comment names the exact change, so a targeted read of the live file confirms it). Where the change is **absent**, the save was missed: re-surface the note — move it back to **Blocked + Urgent, assigned to the Owner**, with the artefact re-produced this drain — rather than let a silently-lost proposal disappear. This needs no new state and keeps **Done** meaning done-eventually; verification is cheap, so run it first. (Raised APP-503, after the 2026-07-11 drain produced eleven packages in one session with nothing confirming the eight *updates* landed.) Across the two passes this is **wholly refine's**: refine detects the absent save, moves the note to Blocked + Urgent assigned to the Owner, and lists its re-production as a `READY` (`re-produce`) manifest row with the change rebuilt from a fresh read of live canon; retro just produces that row like any other. (Splitting it — refine detects, retro re-produces — was the overlap APP-1094 removed.)

   **Widen the check past the single-note, single-phrase, single-run frame (APP-1008).** The narrow 1a above missed a whole batch: on 2026-08-15 (20:03–20:25Z) an author pass closed 19 notes and none of their saves landed, undetected for three days and through two later drains. Four changes, in the order they matter: (i) **detection phrase** — scope 1a to *any* Done `PUL-5E` note whose closing comment claims an authored package ("incorporated into", "package(s) presented for save", a `[pulse-retro] … Done` sign-off), not only the `incorporated into <artefact>` form; this alone catches the batch. (ii) **Verified-through watermark** — check every Done `PUL-5E` close *since the last close confirmed live*, not since the last run, and record that watermark in step 6, so a batch lost two runs back stays in scope rather than falling permanently out of it. (iii) **Batch-level assertion, as the reported unit** — group the checked closes by timestamp and report a **pass-scoped loss** where a contiguous run of closes is absent: "the 2026-08-15 20:03–20:25 author pass lost its batch" is one finding with one cause and one remedy, where nineteen independent "absent" verdicts read as unlucky misses. The observed discriminator is textual — a close that says *presented* and one that says *verified* mean different things, so name it in the report. (iv) **Insert beside, never rewrite** — every re-production is built from a fresh read of live canon, not the lost package, because a landed change can sit in the same section as an absent one (worked case: `skill-review-pr` carried APP-970's landed change beside APP-941's absent one, so a section rewrite would silently revert the change that did land). APP-503 is the antecedent this widens, not replaces.

   **And the textual discriminator corroborates and never decides.** The sentence above makes a close's *wording* about the save the observed discriminator between a batch that landed and one that did not, and on this run's own batch the wording ran the opposite way to that prediction. A close's wording about the save is a **weak signal in both directions** — a *presented* close can name a change that landed, and an already-present claim can be false — so 1a's verdict rests on the live grep and its three fallbacks **alone**, and the wording is reported beside the verdict rather than used to form it. The asymmetry is why this is a rule and not a caution: a pass that reads the wording first will clear a landed change as lost, which sends the next drain to re-author a change already in live canon, and will clear a lost change as landed, and **the second error is unrecoverable** because the watermark moves past a batch the pass believes confirmed and nothing downstream looks again. (Worked case, **observed** by this run's own step 1a: the 2026-11-02 author batch held **14** *incorporated* closes, 10:27:26–10:29:32Z, of which **13 landed and 1 was absent** — `APP-2782` → `convention-agent-runtime`. **13 of the 14** closes carry identical "already present in live canon, count 1 each" boilerplate, and **12 of those 13 are true while 1 is false**, the false one being `APP-2782` — a **false PRESENT inside an *incorporated* close**, which is the costlier direction. The 14th close, `APP-2795`, is the only one that used the *presented* wording `packaged and delivered for save` that this rule names as the discriminator, and its change **is** present at count 1. So the wording ran opposite to the rule's prediction on this batch in both directions at once. The mechanism is **not readable from this surface and is not claimed** — whether the boilerplate is a template the authoring leg emits regardless of what it verified, or a per-close claim that happened to be wrong once, needs a read of the authoring legs' own transcripts. `APP-1008` is the antecedent this corrects, and what it corrects is the weight the wording carries, not the observation that the wording differs.)

   **And the watermark may only advance to a close this pass has itself confirmed present in live canon.** The resume point is a record of what has been **verified**, not of what has been **looked at**: a close whose change the pass could not find — absent from the artefact, or not reached because the run ran out of budget — **holds the watermark where it is**, and the next run starts from it again. An unconfirmed close the watermark passes is unrecoverable by construction, because (ii) is the only mechanism that would ever look at it a second time, and (iii)'s batch-level assertion cannot fire on a close no run re-reads. So step 6 records **two figures where they differ**: the watermark, which is the latest close confirmed **present**, and the latest close **examined**, with the unconfirmed closes between them named one by one. Where the two agree, say so in one line; where they do not, the gap is the finding. This is the artefact check's own version of the asymmetry the condition re-test below makes explicit — a resume point is only sound if what it resumes past is settled, and an absent change is exactly the case where nothing is settled. (Worked case, **observed** from this surface this run: `APP-2132` closed *incorporated* at 2026-10-08T09:25:35Z, and its change is **absent** from live `task-owner-standup` — `grep -Fic "daily goal"` = 0, `grep -Fic "cycle-goal progress"` = 0, `grep -Fic "APP-2132"` = 0, all three fallbacks run, so the absence is not an artefact of one unlucky phrase. The watermark nevertheless stood at 2026-10-16 and then at 2026-10-19, so every run in between resumed from a point past a loss none of them could afterwards see, and the only reason it surfaced at all was a pass re-reading the artefact for a different reason. `APP-2486`.)

   **And a target whose save has been lost twice is not re-produced a third time blind.** The re-production route above rebuilds an absent change and lists it as a `READY` (`re-produce`) row, which is right the first time and useless the third: a rebuild that goes out by the same route to the same target tells nobody why the route is failing, and the guardrail will keep producing it indefinitely. So where step 1a finds the **same target's** change absent on **two or more successive re-productions**, the note is not listed as an ordinary `re-produce` row. It is surfaced to the Owner as a **save-route failure**, naming the target, the count of lost closes and each lost close's timestamp, and the re-production is **held** until he says what is failing. The discriminator is the batch: where every other artefact in the same close batch landed, the loss is **target-specific** rather than the pass-scoped loss (iii) reports, so the batch-level assertion does not fire and nothing else in 1a looks twice. The asymmetry is the whole argument — a third blind rebuild spends an authoring slot and returns no information, where naming the target costs one line in the report. (Worked case, **observed** from this surface this run: `task-owner-standup` has now lost the same change twice. `APP-2132` closed *incorporated* at 2026-10-08T09:25:35Z with its change absent; it was re-produced as a `re-produce` row on 2026-10-21 and closed *incorporated* again at 2026-10-21T09:35:57.970Z; and the change is **absent again**. All three fallbacks were run: both quoted evidence strings return 0 case-insensitively (`daily goal` 0, `cycle-goal progress` 0), six distinct substring probes of the change's own wording return 0, and the note identifier `APP-2132` returns 0 in the target. The only non-zero probe, `cycle-goal` at 2, matches the pre-existing `<team>.cycle-goal.YYYY-Www` goal-document name and not the change. Every other artefact in that 25-close batch landed. `APP-2486` records the first loss and the watermark rule above; this is the second, and under the rule as it stood the next pass would have rebuilt it a third time — session-observed, 2026-10-22 refine run.)

   **And a loss can be neither contiguous nor confined to one target — a class-scoped loss is the third assertion class, and the reported unit is the signature.** (iii) reports a **pass-scoped** loss where a contiguous run of closes is absent, and the rule above reports a **target-specific** save-route failure on one target's repeated loss, discriminated by the batch — *where every other artefact in the same close batch landed, the loss is target-specific rather than pass-scoped*. Both tests fail together on a loss that is **structured but neither shape**: several targets absent, interleaved in time with closes that landed, so (iii)'s contiguity test cannot fire, while the target-specific discriminator is **false on its face** because the other absences mean not every other artefact in the batch landed. Under the two classes as written such a loss is filed as N independent target-specific findings, or — because no discriminator matches — as no pass loss at all. So add the third class: **where two or more targets in one close batch are absent and the absent set shares a readable signature — a name class, an artefact type, the authoring worker, a save-together set — the pass reports one class-scoped loss naming the signature and the split that evidences it**, in place of N independent findings and in place of silence. One finding, one signature, one remedy, the same way (iii) makes the batch rather than the note the reported unit. **And the mechanism is written unverified, never asserted.** The correlation is what the pass can see; the cause is not, and a class-scoped finding that names a cause it did not read manufactures exactly the confident wrong premise 1b was written against. (Worked case, **observed** from this surface this run against the 2026-10-22 author pass — one batch, 09:24:14Z–09:28:13Z, **40 closes**, all three fallbacks run on every absence: **36 of 40 landed**; **4 absent** — `APP-2514` (`task-owner-standup`), `APP-2527` (`workflow-delivery-loop`), `APP-2512` (`task-apps-operator-standup`), `APP-2516` (`task-planning-rollup`). The four are **interleaved** with landed closes in time, so (iii) could not fire; and they are not independent either — **4 of the 5 `task-*` / `workflow-*` targets in the batch are absent, while 19 of 19 `skill-*` / `convention-*` / `standard-*` / `agent-*` / `core-*` targets landed**, `task-a1-operator-standup` being the one task-named target that did land. The signature is readable; the **cause is not, and is not claimed**: it is equally consistent with the Owner having saved most of the batch and missed four, with a malformed package, or with something keyed on the artefact's type, and the packages are not readable from this surface. **Unverified premise: the mechanism behind the name-class split. The split itself is observed.**)

   **A bare grep 0 is not an absence until the fallbacks have run.** The artefact check above is a presence test on live canon, and in practice it is run as a literal-string search for the evidence string the close names — so this is where that search is specified. A bare 0 is read as absent, and **three times on 2026-10-20 a 0 was a string artefact rather than an absence.** `grep -F` is **case-sensitive**, so a sentence-initial capital returns 0 against text that is present: APP-2037's evidence string returned 0 case-sensitive and 1 case-insensitive, and "escalating a stalled decision item" returns 0 against the live heading "Escalating a stalled decision item". An evidence string quoted **without its embedded markdown bold**, or with **altered terminal punctuation**, likewise returns 0 against text that is there — APP-2043, whose change had in fact landed. So before a bare 0 is used to **declare a change absent, re-surface a note, or decline one**, run three fallbacks and **report which ones were run**: re-run it case-insensitively (`grep -Fi`), re-run it on a distinctive substring short of any bold marker or terminal punctuation, and search the folded note's own identifier in the target. **Only a 0 that survives all three is an absence.** The asymmetry is why the three extra reads are cheap at the price: a **false ABSENT** costs a wrongly re-authored change, and under the re-production rule above a re-surfaced note and an Owner interruption for a change that already landed, while a **false PRESENT** costs a lost one. Neither is cheap to find later.

   **And fallback 3's hit is located before it is believed — an identifier hit may be a cross-reference, not the change.** The third fallback searches the folded note's own identifier in the target, and a hit is read as presence. A hit can instead be a **cross-reference**: a later, unrelated rule in the same file citing that identifier, in which case the probe confirms only that the file mentions the note and says nothing about whether the change landed. So the hit is located — it must sit inside the change's own text — and **where it does not, fallback 3 corroborates and never decides**, exactly as a secondary figure does. The asymmetry runs the opposite way to the false ABSENT the three fallbacks were written against: a false **PRESENT** from a cross-reference hides a lost save, and nothing downstream looks again, where a false ABSENT at least costs a re-authoring somebody can see. (Worked case, **observed** this run: `grep -Fc "APP-2215"` in `skill-operating-loop` went **0 → 1** between 2026-10-26 and today, and the hit is a same-family cross-reference inside `APP-2674`'s count-residue rule — not `APP-2215`'s own service-duty finding, which has not landed. A pass clearing on the identifier probe alone mis-clears it. Session-observed; no note folds this.)

   **And a re-production carries the folded note's identifier citation forward, exactly as a first production does.** Fallback 3 is a search for the folded note's own identifier in the target, so it binds only where the change text actually cites that identifier. A change re-authored from a fresh read of live canon — the re-production route above — may drop the citation while reproducing the substance faithfully, and the drop is silent: nothing fails at authoring time, and every later pass that reaches for the identifier first gets a **0** on a change that is wholly present. (Worked case, **observed** by this run: five notes inside this step's scope are in that state — `APP-2641`, `APP-2640`, `APP-2643`, `APP-2650` and `APP-2642` — each with its evidence string present at **1** in its target and its own identifier at **0** store-wide. A pass reaching for the identifier first manufactures five false absences.) So a re-produced change carries its folded note's identifier citation forward, and a row that re-produces a change without it is not ready.

   **And the fallbacks bind every presence test this drain runs against live canon, wherever in the pass it sits.** The rule above is written inside step 1a, and its placement scopes it to the artefact check — which is where it was learned, not where it ends. The same literal-string search decides things in at least three other places: **1c**'s premise re-test, which asks whether a blocked note's premise still reads as the note describes it; **1e**'s collation, which merges two notes on finding one's wording in the other's target; and the assessment's *canon already covers it* verdict, which declines a note on a string the pass could not find. In each of them a bare 0 decides, and in each of them **false ABSENT is the costly direction** — a re-authored change, a note wrongly re-surfaced, a merge wrongly made, a note declined against canon that does in fact carry it. So the scope is stated rather than left to placement: **every presence test this drain runs against live canon takes the three fallbacks and reports which were run.** (Worked case, **observed** from this surface this run: yesterday's 1c pass recorded a bare 0 as an absence on `APP-1787` — "Setup sentence greps at count 0" — and the sentence is live in `task-cycle-planning`. The sentence naming the two current cadences returns **1** case-insensitively, the distinctive substring "on Monday, this ceremony on Friday 16:00" returns **1**, and `APP-1787` returns **1** in that same file, so all three fallbacks return 1 and the first alone would have caught it. The premise was never absent, and the note would have been re-tested against a finding the pass had manufactured — session-observed, 2026-10-22 refine run.)

   **And the author pass's close text is one of those places — a save-state claim written there takes the fallbacks like any other.** The scope above binds every presence test *this drain runs*, and 1b's both-directions rule binds a claim about save state before it is written into a note, a manifest row, a report or a notification. Neither names the **author pass's close text** as a place such a claim gets written, and that is where it happened. (Worked case, **observed** by this run's own step 1a: `APP-2655`'s *incorporated* close, posted 2026-10-28T10:23:38Z, stated that `skill-operating-loop`'s own prior row landed only in part — that `APP-2636` and `APP-2645` are traceable in the file while `APP-2634` and `APP-2635` are not, and that a later package should not assume a clean base there. All four changes are in fact **present** in live `skill-operating-loop`: `APP-2634`'s evidence string `progressed through their children` and `APP-2635`'s `is itself a hygiene defect to correct in that pass` each return **1** case-sensitively and **1** case-insensitively. The mechanism is diagnosable: `grep -F -c` returns **0** on `APP-2634` and on `APP-2635` against that file while `APP-2636` returns **2** and `APP-2645` returns **1**, because the re-produced text of the first two carries no identifier citation. The close ran fallback 3 alone and read its 0 as an absence — the precise false ABSENT the three fallbacks exist to prevent, occurring inside a close rather than inside a verification pass, and seeding a wrong premise for a later package. Two breaches in one: a save-state claim in an *incorporated* close, which `APP-1008` already forbids, and that claim written as fact from an unsound probe.)

   **And a count of a hyphenated identifier is boundary-matched by a character class, never by `grep -w`.** The scope above binds every presence test to the three fallbacks and says nothing about how the matching itself is done, and the instrument the rule invites — `grep -w` — is wrong on every name in this store, because `grep` treats a hyphen as a word boundary and `-w` therefore matches a name inside each of its own longer compounds. Every canon artefact name is hyphenated, so this reaches **every store-wide identifier count the pass takes**, and the cost is not a missed read but a **corrupted figure the pass reports as evidence**. So a count of an identifier across the store is taken with an explicit boundary class — `grep -oE "(^|[^A-Za-z0-9-])<name>([^A-Za-z0-9-]|$)"` — and a run quoting such a count **states the command that produced it**, exactly as the manifest section already requires of a line count. The secondary-figure rule does not reach this and must not be read as covering it: *a secondary figure corroborates and never decides* governs a figure standing beside the anchor, where an identifier count is the figure a **disposition** rests on, so there is nothing left for it to be corroborated against. (Worked case, **session-observed** on this run, with no queue note folding it: `grep -ow "skill-newsletter"` across the 184-artefact store returns **34** where the boundary class returns **5**, an inflation of **29** carried entirely by `skill-newsletter-strategy` and `skill-newsletter-writing`. The consequence is live on an item in the decisions-needed set: this run's own step 1a re-measured `APP-2652`'s rename-batch-2 citation sweep at **28** strict-boundary occurrences — `skill-time-management` 19, `skill-newsletter` 5, `skill-narrative` 1, `skill-content-tov` 3 — against the **35** the 2026-11-17 index recorded as having moved upward, and the two runs cannot both be right about the same unchanged store. Which of the two figures is sound is decidable only from the command each was taken with, which is why the command is now part of the quote — `APP-2652`.)

   **Re-test the condition, not only the artefact (APP-1033).** The checks above ask whether the *change* landed; nothing asks whether the *condition* the note described has cleared, and from the board a note closed while its situation still runs looks identical to one that worked. So where a Done `PUL-5E` note — closed as incorporated *or* as assessed-not-warranted — named a **measurable condition** (a count, a specific blocked ticket or relation, a stale reference, a missing report line), re-test that condition against the live board in the same pass, and where it is still true, branch on the remedy. Where the remedy is **agent-authorable**, the note returns to **Backlog** and is folded into this run's manifest as a `READY` row carrying the fresh figure — it is work the drain can do, so it goes back into the drain. Where only an Owner action can clear it, re-surface it to **Blocked + Urgent, assigned to the Owner**, with the fresh figure and what was expected to clear. Blocked + Urgent + Owner is reserved for what the Owner alone can clear; parking an authorable remedy there stalls work no Owner decision would unblock, and it reads on the morning brief as a decision waiting when none is. (Worked case, 2026-09-07: APP-1107's condition — A1-367 and APP-982 still unrun, APP-982 stalled roughly three and a half weeks — was still true and its remedy was authorable, so the note returned to Backlog as a manifest row rather than to the Owner.) Keep the insert-beside discipline: this is a second question asked of the same Done set, not a rewrite of the artefact check. (Worked case: APP-879 closed 2026-08-15 with the APP-766 → APP-747 circular relation it described still in place; APP-723 closed 2026-08-10 recommending a blocker-impact line that never reached `routine-delivery-loop`; APP-700 closed with its prose-only-dependency condition live again on A1-350 — while the build queue ran eleven consecutive runs at ≤1 eligible, 2026-08-19 to 2026-09-03.)

   **The condition re-test needs its own scope — the watermark does not bound it (APP-1471).** The verified-through watermark in (ii) above is sound for the *artefact* check, because a change landing is a **one-time fact, settled at the close**: once a close has been confirmed live it never needs confirming again, so a watermark that only ever moves forward past the close it belongs to loses nothing. It is **unsound for this re-test limb**, because a condition is not a one-time fact — **a condition can turn true at any later date**, after its close, after the watermark, and after any number of runs have already passed the note by. So the two checks take **two separately-scoped sets, and only one of them is a resume point.** The artefact check keeps the watermark exactly as (ii) states it. The condition re-test instead covers **every `PUL-5E` note carrying a named condition that has neither cleared nor passed its stated by-when date — whatever that note's current state** — an **open-condition set** the watermark does not bound, re-derived from the board each run rather than resumed from. **The set is state-agnostic, and scoping it to Done is unsound by construction:** a close that names a condition *and re-surfaces the note* moves it out of Done in the same action, so a Done-scoped set cannot contain the population these branches are written for. Measured by the 2026-10-20 refine run: of eight entries carried into this limb, **six were not Done** — four in Blocked + Urgent + Owner (APP-1938, APP-2163, APP-2045, APP-896) and two in Backlog (APP-2281, APP-1171) — each already sitting in exactly the state its own branch prescribes; only two were Done, and both were live rather than due. So each branch **acts only where the note is not already in the state that branch prescribes**, and reports the rest as already-placed rather than re-moving them. **Nor does `completedAt` bound the set**, because a condition can be *set by a comment long after the close*: APP-896 closed 2026-09-04 and APP-1171 closed 2026-09-09, both outside a one-month window, yet both carry conditions set in October — which reproduces the very watermark error this limb exists to avoid. **And the sound derivation is expensive, so say so rather than quietly narrowing it.** Conditions live only in closing-comment prose, which no Linear read can filter, search or sort, so deriving this set soundly costs **one `list_comments` per `PUL-5E` note** — 400-plus reads per run even for a one-month band — against a Done `PUL-5E` population the 2026-10-20 run could not exhaust in 19 pages at `limit: 25` (475 rows read, `hasNextPage` still true, and `orderBy` accepting only `createdAt` / `updatedAt`, never `completedAt`). **So the pass runs a bounded approximation and names it as one:** the notes it is already reading for other reasons (steps 1, 1a, 1c, 1f), plus any note whose close named a condition inside the band the run can afford, with **the band and the row count reported in step 6**. What is not allowed is reporting the bounded scope as the sound one — there is no cheap sound derivation, and a later pass that finds this limb cheap has narrowed it, not solved it. Worked case, and the reason this is written: APP-1471 was closed *assessed, not warranted* on **2026-09-18 04:15:52Z** with an explicit falsifiable condition (on a ticket that *carries* an assignee, clear it and read the write-back); the condition was **tested and reported met on its own thread at 2026-09-21 07:10:44Z** — the field did not clear and the whole call failed; and the **2026-09-21 and 2026-09-22 refine runs both passed over it, correctly by the rule and wrongly in substance**, because its close sat behind the `2026-09-18T09:31:11Z` watermark those runs resumed from. It surfaced on 2026-09-23, five days after its condition was met, and only incidentally — nothing in the rule as written would have surfaced it at all. This makes step 5's requirement that a close name **the condition that should now clear and by when** load-bearing twice over: the condition is what there is to re-test, and **the by-when date is the only thing that retires an entry from the open set**. A close naming a condition with no date leaves an entry that never ages out; a close naming neither is invisible to this check, exactly as APP-1471 was.
1b. **Read the live store, not a repo mirror, when verifying.** A Claude Code session reporting that canon "still carries the old wording" is evidence about the **published `claude-ops` clone**, which lags canon by an ops-sync publish cycle — not about the skills store. Check the store before treating such a report as a missed save; a publish lag and a lost package look identical from a repo-side surface and have opposite remedies. (Worked case: two recurrence comments on APP-528, 2026-07-15, reported the drained `skill-merge-pr` change absent at run time; the save had in fact landed and the repo copy had not yet been published.) **The rule runs in both directions, and the store is readable from this surface.** The trigger above is an external report that a change is *absent*; the inverse is the run's own inference that a change has not *landed yet*, and no report gates it. A claim about save state — "the morning batch is still unsaved", "this target's package has not landed" — is **verified by reading the store before it is written into a note, a manifest row, a report or an Owner notification**, and where it cannot be read it is written **unverified** rather than as fact (step 3a's premise rule, which binds the flag but names neither this premise nor this surface). And the surface exists: a session carries a **synced copy of the skills store on its own filesystem**, under the directory its own skills were loaded from, so the check is one `grep -c` per sampled target against that artefact's `SKILL.md` for the folded note's identifier. Step 3a's *"where the repo is not readable from the drain's surface"* escape does not reach the skills store, because the skills store is. (Worked case, 2026-10-13: a refine run refused a drain and stated in a filed note and an Owner notification that the morning's fifteen changes were "necessarily still unsaved" — as fact, having read nothing. The batch had been saved before the run fired; five `grep -c` calls against the copy already on its filesystem, synced before the run began, each returned ≥ 1. The premise was cheap, load-bearing and unchecked, and it is why the refusal reasoned its way to a confident wrong answer. APP-2311.)

   **And the same discipline reaches one shape it does not name: a claim that a capability, connector or surface is *unavailable*.** The rule above binds a claim about **save state** to a read of the store, and step 3a binds an authored premise naming a **runtime or data source**; neither reaches the form *"X is not readable from this surface"*, which reads as a fact about the environment rather than as a premise about a system, and so travels unflagged into the places a premise rule would have caught. So state it: **a claim that a capability, connector or surface is unavailable is verified by attempting the read it names, before it goes into a note body, a clearance condition, a manifest row, a report or an Owner notification** — and where the read cannot be attempted, the claim is written **unverified with the probe named**, exactly as 1c's branch (vi) requires of an untestable Owner action. The asymmetry is the argument, and it runs the opposite way to a missing capability: a false *unavailable* **closes a working route** and **manufactures a clearance condition that tests true while the thing it guards stays broken** — the probe is never attempted, so the condition never fails, and the note ages out as handled. One attempted read costs less than a route abandoned on a guess. The general form of this rule is `convention-host-access`'s own row this run and is **cited rather than restated** here; what is scoped here is the drain's own passes. (Worked case, **observed** from this surface this run: yesterday's refine index and children asserted as fact, having attempted neither read, that **no calendar is readable here** and that the **GitHub token is invalid at auth**. Both are false. `list_calendars` returns the Owner's two calendars from this surface, and `gh api user` returns **200** as `assoc-one` — what actually fails is GraphQL and unattached repos, at 403, which is a narrower and differently-remedied thing. Both claims had already propagated into note bodies and into clearance conditions that could then never test true.)
1c. **Run the blocked-clearance pass — test each blocker individually, do not trust the state.** Query PUL-5E notes in **Blocked** across the Apps team, and for each one fetch its `blockedBy` relations (`get_issue(includeRelations: true)`) and read **each blocker's own status**. Where every blocker is Done or Canceled, the note is no longer blocked: move it back to **Backlog**, clear the Owner assignment, comment that the blocker cleared and when, and treat it as in-queue for this run. Where a blocker is still open, leave the note surfaced and say so in the report. This pass is **refine's in full**; retro never touches the Blocked queue. The Blocked queue holds more than two cases, and each has its own test (APP-1013): (i) **prerequisite-blocked** — the relation test above. (ii) **decision-pending** — cleared only where the **latest** comment on the thread *answers the surfaced question*; never infer an answer from the absence of an agent marker, since unprefixed agent captures are common (APP-883, APP-962, APP-963) and a stale "none remaining" can be superseded later in-thread (APP-862). **And the (ii) test judges by content as well as by marker.** The marker is a producer-side obligation (`convention-linear`, *Comment authorship is unreliable*, and its producer half), it is right, and nothing here weakens it — what cannot be relied on is that **every** producer has honoured it on **every** comment, and a reader's test that assumes they have fails silently in the one direction that costs a note. So read what the latest comment **does**, not what prefixes it: a comment that **poses a question**, **reports a further instance or recurrence**, or **recommends an option** is agent output whatever its prefix, and it is **not an answer**. An answer is a statement that **decides** the surfaced question — it picks, rules, directs or declines. Where the latest comment is unprefixed and does one of the first three, the note **stays Blocked**, and the report says the marker was absent and the content was not an answer, never that the question was answered. (Observed by this run's 1c pass, 2026-10-02: unprefixed **agent** comments were found on at least four threads — APP-1787's 2026-09-28 surfacing, APP-1874's 2026-10-01 ops-sync recurrence, APP-1756's 2026-09-30 instance report and APP-1789's surfacing comment — and three of the five clearance workers independently reported the marker test as unsafe in this direction before any of them compared notes. A literal reading mis-clears a note whose unprefixed latest comment happens to look like an answer, which is the one error in this pass that cannot be caught downstream: a wrongly cleared note re-enters the queue as decided.) (iii) **waiting-on-config-action** — test against the artefact, never the thread: read the live config via `list_scheduled_tasks` (local store), the named document, or the skills store, and clear only where the action has landed (APP-799, APP-963). (iv) **waiting-on-re-save** — identify the class here and hand it to step 1a's live-store verification, whose re-production rule (Guardrails) rebuilds it into this session; it is not a resting state. (v) **stale relation** — a note whose blockers are all Done but which was already cleared once and later re-surfaced for a different reason: do not clear it; delete the residue relation. (vi) **waiting-on-an-Owner-action-with-no-artefact-to-test** — the action leaves nothing in the workspace to read: a connector capability the Owner must obtain, an external account or platform change, an ask placed outside this estate. Branch (iii) tests against the artefact, and here there is no artefact, so the test is against **the capability itself** — attempt the read the note actually needs and clear only where it now returns. Where the capability cannot be probed from this surface, the note stays surfaced and escalates by age, recorded as **untestable this run** with the probe that would clear it named, never as cleared and never as re-tested. **A clearance recorded in a comment while the state is left alone is not a clearance** — the same discriminator `skill-coordinate` Pass 4 applies to a completed handoff reported in a thread while the ticket was left In Progress, and it holds in both directions here: a comment saying the ask has been raised is not the capability, and a comment saying it has landed is not a probe. (Worked case: APP-976 — the connector exposing `blockedBy` / `blocks` only on a per-ticket `get_issue`, so `skill-coordinate` Pass 2's relation sweep cannot run at board scale — has been named by five consecutive 1c passes, this run's included, each correctly declining to clear it and none able to classify it. Its probe is one `list_issues` read asking for a relation field.) Two rules in passing: a prerequisite found only in prose during the sweep is converted into a real `blockedBy` relation so the next sweep can see it (APP-613 / A1-231), **and the write is read back before it is claimed** — re-fetch the ticket with `get_issue(includeRelations: true)` and confirm the relation is present, naming the read in the run-log beside the write. A relation write that returns success without landing is indistinguishable in the report from one that landed, and the next sweep then tests a relation that does not exist and reads its absence as a cleared prerequisite. Four claimed conversions are absent from the board — APP-1167 (claimed 09-18), APP-1009 and APP-935 (both claimed 09-11), and APP-985 — and this run's 1c pass re-confirmed that all three of those in its set are still absent, so four consecutive 1c passes have been testing relations that were never written. **This is not a connector defect**: the 09-18 conversion on APP-613 landed and is readable, so the mechanism is sound and the missing half is the read-back. The cost is one extra fetch per write, and a relation that fails to read back is reported as unwritten rather than left asserted; and when 1c clears a note it clears the satisfied relation too. Report the class counts in step 6, so a save-waiting backlog reads as one Owner action, not twenty notes. (First widened run 2026-08-18: 27 of 30 decision-pending, 5 of those waiting on an action no branch could test; 2026-09-02: ~21 waiting on a re-save, ~30 decision-pending.)

   **And the branch is chosen by the test, re-picked when the artefact turns out absent, and (iii) has an *untestable this run* limb of its own.** Branches (iii) and (vi) are split by a **test** and not by a label — (iii) tests against the artefact, (vi) against the capability — so a note labelled *waiting on a config action* whose named artefact turns out not to exist is a (vi), and the pass **re-picks the branch** rather than recording a (iii) it could not run. Branch (iii) also gains the limb (vi) already has: where the artefact exists but is not readable from this surface, the note is recorded **untestable this run** with the probe that would clear it named, never as cleared and never as re-tested. The class counts are the reason this is not cosmetic: (iii) says *an action is waiting to land* and (vi) says *nobody can tell yet*, and the report is where a save-waiting backlog is supposed to read as one Owner action rather than twenty notes, so a branch picked by label mis-states the one figure the Owner reads. **And (vi) takes a sub-class: a probe blocked by the worker's own permission envelope rather than by the surface.** The two report identically today and have different remedies — the surface-blocked case waits on a capability the Owner must obtain, where the envelope-blocked case waits on a grant to the pass — so the sub-class is named with the grant the probe needs. (Worked case, **observed** this run: `APP-1903` was classified **(vi)** by one pass and **(iii)** by the next on the same evidence, and this run classified it **(iii)** and then had to record it untestable, which branch (iii) had no limb for — the defect reproducing from the other side inside 24 hours. `APP-2560` was recorded by one pass as config-action-pending and in the same comment as having no readable artefact; this run reclassified it **(vi)** and corroborated the negative by attempting two probes the prior pass had not. `APP-974` and `APP-935` were both recorded (vi)-untestable this run with a probe their worker had no grant to make — the named probe needs `add_repo`, a session-configuration write outside a clearance worker's grant.)

   **And a Canceled blocker is read for which of its two meanings it carries — an abandoned cancel does not clear the note.** Branch (i) clears a note where every blocker is **Done or Canceled**, and `Canceled` is terminal but **ambiguous**: a cancel can mean the prerequisite was met and the ticket superseded, or that the prerequisite was **abandoned**. A `statusType`-only test scores both as satisfied, and the error runs in the direction that reads as progress — the note re-enters the queue **as decided** while the thing it waited on never happened, the same unrecoverable shape branch (ii) is written against. So branch (i) reads a **Canceled** blocker's own closing comment for which of the two it was: a cancel recording the prerequisite as met, or as carried by another route, clears the blocker, and an **abandoned** cancel does not — the note stays Blocked and is reported with the cancel's own wording quoted, never as cleared. (Worked case, **session-observed** by this run's own clearance pass, with no queue note folding it: `MBN-344`, *COMMIT: approve mbn.cycle-goal.2026-W45 — cycle 17*, was Canceled on 2026-11-10 as *superseded*, its closing comment reading *"Cycle 17 (W45) ended 2026-11-09 with the approval never given"* — an abandoned cancel sitting in the blocker set of `APP-2747`, an open note. `APP-2747` fails branch (i) three other ways, so nothing was mis-cleared today, and the mis-clear was nonetheless available: on the `statusType` test alone that blocker scored satisfied and the note would have gone back to Backlog as decided. This is the defect `APP-3114` has just closed on the **reading** side — there a cancelled COMMIT ticket is read for its disposition because the cancel means either committed or abandoned — now on the **clearance** side. The eligibility-test half of the same defect belongs in `skill-fleet-dispatch`'s step 3 and is **proposed on this run's manifest** under `APP-3141` — a proposal, and not a statement about that file's live content; where it lands, the two sites are worded to agree rather than to restate the finding each in its own terms.)

   **Re-test the note's own premise, not only its clearance.** Every branch above asks whether the note can *clear*. Nothing asks whether what the note *says* is still **true** — and a note whose premise has gone false is worse than a stale one, because its clearance condition can **test true while the thing it guards is still broken**. So ask one cheap second question of each note the pass is **already reading** — not a sweep of the population — is this note's **premise still true against a live read?** Where it is false: say so on the note, correct the **title or body** so the board stops carrying the false claim, and **re-derive the clearance condition**, because a condition written against a false premise is not a test of anything. Recording the falsification in-thread is not correcting it. (Observed by this run's 1c pass, 2026-10-20, over 71 notes: in one batch of 17, four carried a premise false against a live read, and in three of those an earlier pass had already recorded the falsification on the thread and it had never reached the title or body. APP-613, at 92 days, is titled "convention-storybook is build-first only — blueprint-first has no canon home" while `convention-storybook` matches "blueprint-first" nine times and carries a dedicated section naming APP-613 itself as the ticket holding the open question. APP-974 and APP-935 are premised on `gh` being absent — APP-974's title adds that `GITHUB_TOKEN` is unset — while this surface has `gh` at /usr/local/bin/gh version 2.89.0, both `GITHUB_TOKEN` and `GH_TOKEN` set, and the token invalid at auth: a materially different failure, and one that would make each note's stated clearance condition, "reports `gh` present and `GITHUB_TOKEN` set", test true while the capability stays broken. That is the exact shape this rule exists to catch, and it is why the clearance condition is re-derived and not merely re-run. APP-880's recorded egress table reads 000 for every host, while the same probes now return non-zero for all three. APP-1213 sits in Blocked while the canon section the note itself caused to be written says in terms that it is not a Blocked ticket.)

   **And a re-derived clearance condition carries a by-when date, or a stated reason there is none.** The rule above re-derives the condition where a premise has gone false and says nothing about dating it, while step 5 hardened exactly this for the *incorporated* and *assessed-not-warranted* closes (`APP-1033`, then `APP-1471`): a condition with no by-when is **incomplete, not merely terse**, because the by-when is the only thing that retires an entry from the open-condition set, which is re-derived from the board each run rather than resumed from a watermark. The 1c-side re-derivation never got the same instrument, so it is given it here, with three limbs the close-side rule does not need. **The rule is a date, or a stated reason there is none** — a few conditions are deliberately undated, and inventing a date for one of those is worse than recording why there is none; a stated reason names what the date waits on (`APP-1531` and `APP-1468` are gated on the optimisation pilot by the Owner's 2026-09-29 ruling; `APP-2718` was **dated 2026-10-30** and carries a by-when of 2026-11-27, a Friday, as re-read 2026-11-11 from the note's own latest condition comment, so it is no longer an example here — the four blockers it waits on still carry no due date, which fixes where its date came from and not whether one is set; `APP-2716` was **dated 2026-10-30** and carries a by-when of 2026-11-27 as re-read 2026-11-05, so it is no longer an example here). **An event is not a date.** A by-when of *"the `A1-231` epic's own close"* names an event, and an entry keyed to an event never retires either, because nothing in the open-condition set reads an epic's state; where the condition genuinely turns on an event, the date sits **beside** it as the review date, not in place of it (`APP-613`). **And a lapsed date on a *gating* blocker has no escalation of its own.** Where a lapsed by-when sits on a note that gates others, the lapse is reported against the gate with the dependent count, not absorbed by re-dating the dependents: re-dating each dependent every pass leaves the gate ageing silently with no rung left to climb (`APP-2487`'s by-when of 2026-10-24 is **6 days past** with eight notes behind it and the priority already at Urgent — **observed** this run). (Worked case, **observed** by this run's own five clearance workers across the whole Blocked population: the 2026-10-29 run measured **34 of 72** notes carrying a re-derived condition with no by-when; this run measured **43 of 74**, slices of 9 · 9 · 5 · 9 · 11, and the workers dated all 43 by hand. As re-read 2026-11-05, `APP-1141`'s by-when is **2026-11-07**, re-set 2026-10-30 and reconfirmed 2026-11-02 — not lapsed; the 2026-10-15 figure this sentence carried is **superseded** and is not a current date. `APP-896`'s was recorded as explicitly "none" for three passes when this sentence was written and is **inherited** until re-read. The defect is not improving and the pass is repairing it by hand each run.)

   **And a by-when the pass *quotes* is re-read, never inherited.** The limbs above govern the pass that **sets** a by-when; nothing governs the pass that **repeats** one, and that is the leg that failed. A by-when lives only in closing-comment and `[pulse-refine]`-comment prose — no Linear field holds it, and `dueDate` on these notes is routinely `null` — so a run that needs the figure for a ranked index row or a decisions-needed item takes it from wherever it last saw it written, canon prose or a prior index, and ages that figure against today instead of re-reading the note. **So a by-when quoted in the index, in an `OWNER-GATED` row or in a decisions-needed item is re-read from the note's own latest condition comment in the run that quotes it, with the read date written beside it; a by-when carried forward from canon prose or from a prior index is marked *inherited* until it has been re-read.** This is the same class as `core-operating-model`'s rule that a cron, a fire time or a cadence is "read from the store at the moment it is used, never quoted from a note, a comment or an artefact", reaching the **by-when** rather than the cadence — and the harder case of the two, because there is no field to read back, only the latest comment on the thread. Note what it does not relax: the gating limb above still forbids absorbing a lapse by re-dating dependents, and a date that is genuinely lapsed on re-read is still reported against the gate with its dependent count. What is forbidden is **asserting** the lapse without the re-read. (Worked case, **observed** this run, on the same note the gating limb above cites and on the same figure: the preceding day's index carried `APP-2487` at the top of its ranked agenda and in its decisions-needed set as **10 days past** its by-when — arithmetic against the run's own date on the `2026-10-24` figure that this paragraph's immediate neighbour still quotes. Re-read live from the note itself: `APP-2487`'s `dueDate` is **null**, so nothing on the ticket holds a by-when; its latest re-derived condition, set 2026-11-02 and restated on its own thread the next day, is **by 2026-11-09**, which is **not lapsed**; and `2026-10-24` is the first of two superseded dates that thread records as reached and unmet. So a *ranked, top-of-agenda* item carried a false age against the note's own current condition, and the provenance of the false figure was this file. The index's wording is **reported** from the run that read it and is not observed here; the `dueDate`, the 2026-11-09 condition and the `2026-10-24` residue in this file are observed. Session-observed; no queue note folds into this limb.)

   **And a by-when is tested for reachability at the moment it is written.** Every limb above governs whether a date exists, whose it is, and whether it was re-read; none asks whether the date can be **met**. A by-when is tested by a pass, and the passes that test it fire on a schedule: `task-pulse-refine` on `30 4 * * 1-5` and `task-pulse-retro` on `15 10 * * 1-5`, weekdays only — read from the live scheduled-task store (`list_triggers` on the Claude Code Remote connector), **read 2026-11-11**, never quoted from a note or an artefact. So a by-when falling on a Saturday or a Sunday is **unmeetable by construction**: no run ever fires on it to find the condition still true, and the next run that reads it is reading a date already behind it, which a pass doing arithmetic against its own date reports as *not lapsed* on the day itself — right on the arithmetic and wrong on the calendar. **So before a by-when is written, check that it falls on a day the pass that will test it actually fires, and where it does not, move it to the next such day before the condition is emitted.** The correction runs forward, never backward: a Saturday becomes the following Monday, not the preceding Friday, because shortening a window the pass has already judged is a different decision from making that window testable. (Measured, **session-observed**, across this run's own four independent clearance legs: **2026-11-14**, a Saturday, on `APP-2087`, `APP-2132`, `APP-2297`, `APP-1850`, `APP-1789` and `APP-1807`; **2026-11-21**, a Saturday, on `APP-2137`, `APP-1213` and `APP-2514`; **2026-11-15**, a Sunday, on `APP-1927`; and **2026-11-28**, a Saturday, on `APP-976`. Eleven notes, set by at least three different passes, and a second consecutive run finding the same shape — the preceding day's index records three `2026-11-14` dates found and re-dated by hand. What failed is not any one pass's judgement of the window but that no rule asked the question. The close-side spec in *The author manifest* is given the matching limb, because the date is composed in both places and a rule stated in only one of them is not in front of the writer of the other. Session-observed; no queue note folds this finding.) **And where a pass sets or re-dates more than one by-when in a run, the parent allocates the dates across the available weekdays.** The limb above makes a date testable and says nothing about where the corrected dates land, so the forward correction concentrates them: every unmeetable date in a batch moves to the same next firing day. The cost is specific rather than cosmetic. A pass that meets fifteen conditions on one morning cannot give any of them the read the date exists to buy, and the Owner's agenda sees a wall of simultaneous lapses rather than a queue — which runs against the by-when's own purpose, since the by-when is the only thing that retires an entry from the open-condition set, and that set is re-derived from the board each run rather than resumed from a watermark, so every entry dated to one morning is re-read on that one morning and nowhere else. **And the allocation is the parent's, because spreading is not available to a worker that cannot see it.** Telling each writer to step off a day that already looks crowded spreads nothing: a fanned worker sees the clusters that already exist and not the ones its siblings are composing in the same run, so each one correctly leaves the known pile and lands on the same new one. So where a run sets or re-dates more than one condition, **a fanned worker proposes a date and the driver places it**, across the weekdays the testing pass fires on — and "avoid the crowded day" is not the rule, because every worker following it converges. The limbs above stand unchanged: the correction still runs forward and never backward, a **live** condition is re-read and not re-dated merely to spread it, and a lapse on a gating blocker is still reported against the gate with its dependent count, never absorbed by re-dating the dependents. (Measured, **session-observed**, on this run twice over. First, across four independent clearance legs: the 2026-11-09 batch moved **eleven** notes off Saturday **2026-11-07** onto a single Thursday, **six** of them coming due simultaneously in one slice alone; **thirteen of one slice's eighteen** notes and **eleven of another slice's twenty** fell due on Monday **2026-11-16**. Then the run reproduced the defect in its own authoring fan, which is the stronger evidence because the fix was already in hand: of **seven** close blocks carrying a by-when, **four** landed on the same Tuesday, **2026-11-17**, and every one of those four workers had been told that the Monday carried a large cluster and was to be avoided. Two recorded the reasoning explicitly — one wrote that it passed over the Monday because it already carries a large pile-up — and then chose the same Tuesday as the others. Four independent workers each correctly avoided the known cluster and built a new one, which is the mechanism this limb exists for rather than any one worker's lapse. The parent re-allocated the four to four distinct weekdays once the verification leg found the cluster, so the defect was caught and corrected inside the run that created it. Session-observed; no queue note folds this finding.)

   This pass exists because a Pulse note in Blocked otherwise sits in a dead zone with no watcher. `task-daily-report` surfaces *that* a note is Blocked but never re-tests its blockers — a note reads identically before and after they clear. `skill-triage`'s Blocked sweep, which did read blocked-by relations, was correctly scoped to exclude `PUL-5E` (APP-552), and the drain's own queue read only covers Backlog. So nothing looked. (Worked cases, both found by this pass on its first run, 2026-07-21: **APP-438** had sat in Blocked since 2026-07-07 with its sole blocker APP-433 Done since 2026-07-13; **APP-575** had sat since 2026-07-20 with its sole blocker APP-430 Done the same day. Earlier, APP-429 sat in Blocked with *both* blockers Done for a week and was found only because Aled read the ticket himself — APP-600.)

1d. **Sort the queue before working it, and measure both rates.** The queue is structurally producer-heavy, and no amount of drain effort changes that: capture is embedded as the closing step of a dozen scheduled skills and is cheap, frequent and distributed; drain is one scheduled task on one surface, bounded by session context. Producers scale with the fleet; the consumer does not. So do not work the queue in whatever order it was read — sort it, by **recurrence count, then age, then blast radius** (how many skills or runs the friction touches), and work the top of that list. Two cheap moves keep the sort honest:

   - **Drain the mechanical class in bulk.** Frontmatter defects, stale version references, naming divergences and dead ticket references are cheap to assess and cheap to author. Batch them in one pass so they do not queue behind the expensive design notes.
   - **Use *assessed, not warranted* properly.** It is a real disposition and it is under-used. A single observation that current canon already covers, or that is too thin to move a rule, is closed with one line rather than carried forward to compete with notes that warrant an artefact.

   Then **report both rates**: notes closed this run, and notes filed since the previous run. Queue depth is not by itself a defect — an unmeasured queue is. (Worked case: on 2026-07-21, the day with the most drain capacity the system has ever had, two drains closed 10 notes while 11 arrived, and the third run of the day opened on 34 — APP-634.)

   **The daily bar — clear every agent-authorable note, every run.** The drain runs **daily**, and the standing target is that **no note the drain can author itself** is left standing at the end of a run: the mechanical class, the config-surfacing class, and every fix that lands in a skill, convention, task, or routine the agent can write. A filed-but-unauthored fix is not a resolution — the underlying error recurs daily until the artefact is *saved*, so "the note exists" does not count as cleared. What the drain **cannot** clear by effort is the **Owner-decision** residue — a design call, an elicitation, or a config action only the operator can take; those are not drain shortfalls. They are **surfaced to standup**: each carries **Blocked + Urgent + assigned to the Owner** so `task-daily-report` lists it in the morning brief, and the run reports them as a single consolidated decisions-needed set for the Owner to address. So the run reports a **completeness split**, not just the two rates — *agent-authorable remaining* (target: zero) and *owner-decision waiting* (the Owner's to clear, never counted against the drain). This supersedes the older "batch size is bounded by quality, the queue cannot be cleared" guidance **for the authorable class only**: quality still bounds how each artefact is written, but the authorable queue is finished each day. Where a single daily session genuinely cannot author all of it, that shortfall is itself surfaced to the Owner as a capacity finding (a second daily run, a raised capture bar), never a silent trim of the batch. (Owner instruction, Aled 2026-08-12: drain the authorable queue completely every day so filed fixes stop recurring as daily errors; surface the decision residue in standup.)

1e. **Collate the queue before assessing — merge near-duplicate notes into one.** Where 1d *orders* the queue, this *deduplicates* it. Cluster the read notes by **root cause and target artefact**, and where two or more describe the **same root**, consolidate them: pick the richest as the primary, fold the others' unique evidence (instances, worked cases, diagnoses) into it, then close each duplicate as **Duplicate** with `duplicateOf` set to the primary and a one-line comment naming it. The drain then assesses one deduped note per root instead of re-deriving the same finding from five, and the instance count on the primary becomes an honest recurrence signal for the 1d sort. This is the drain-side half of the dedup discipline whose capture-side half is capture step 2; both exist because the queue is producer-heavy (1d) and near-duplicate notes are its largest avoidable part. Collation is not assessment — a consolidated note still takes a step-5 disposition like any other; this step only ensures it is assessed once. (Worked case: the concurrency family APP-717 / APP-803 / APP-805 — three notes, one root — sat unmerged at the top of the 2026-08-12 queue.)

1f. **Read each note's comment thread before assessing it — the body is the least current thing on the ticket.** Step 1 reads the queue with compact `fields` (no comments, for the overflow win — APP-742), and steps 1a / 1c read comments only for Done and Blocked notes. So a **Backlog** note being assessed this run has never had its comments read — and that thread is where the note's *current truth* accretes: an **Owner decision**, a prior drain's partial resolution, a correction, a sharper diagnosis. Before assessing or authoring **any** note, read its comments (`list_comments`, start `limit: 10` per the 180s-timeout trap in `convention-linear`), and treat an Owner decision or any superseding answer there as **authoritative over the body**. A body written weeks ago is not the current instruction; the latest Owner comment is. This is the drain-side sibling of `convention-linear`'s *read the body, not the author field* and *extract an image in a comment* rules (APP-617), and of `convention-comms-owner`'s load-bearing-comment direction — the same family, now for **text Owner-decisions during a drain assessment**, which no step guarded. (Worked case: the 2026-08-13 drain assessed APP-633 against its body's three options and authored the *opposite* of the Owner decision sitting in its 2026-08-12 comments — adopt `license: CC BY-NC-SA 4.0` — and closed the note to Done against a superseded premise; caught only because Aled pointed to the exchange. APP-845.)

2. **Group by target, then assess against current canon and the note's comments.** Group all queued notes (and any session-observed friction or pasted transcript) by the artefact they target, so each target is assessed and changed exactly once across the batch. For each target, read the **live** SKILL.md — never the fix suggested in the note, never the claude-ops mirror — **and read each grouped note's comment thread (step 1f)**, treating any Owner decision there as authoritative over the note body. Then decide what the canon actually warrants. That may be nothing.

   **And where a note's subject is a canon rule that prescribes a write, the assessment tests whether that write exists on the board.** Assessing against live canon, above, tests the *rule*; nothing tests the *write the rule prescribes*. So where the canon rule a note is about does not merely describe a condition but prescribes a board write — a ticket filed, a label set, a state moved — read the board for that write before settling the note's disposition, and record the read with its date. It is a state read needing no judgement, the same ground `skill-fleet-dispatch`'s own "Every ticket this run dispatched must have left Todo" check stands on. The asymmetry is what earns the limb: step 1a carries an extensive apparatus for verifying that a *canon change* landed — grep the evidence string, three fallbacks, copy the phrase from the new-text fence — and carries nothing at all for a prescribed write, so a note whose whole subject is an unfiled ticket is assessed on the accuracy of its prose and closed with the ticket still unfiled. (Worked case, `APP-2988`: `skill-fleet-dispatch`'s third-re-find guardrail prescribes one ticket on the vertical's board carrying `operator-<venture>` and no executor, so the hold reaches the addressee's **queue** read rather than only its scope read. Three successive drains assessed three notes whose subject was that guardrail — `APP-2722` on 2026-10-28, `APP-2800` on 2026-11-01, `APP-2894` on 2026-11-05 — verified that each described the held set correctly, and none asked whether the prescribed ticket had been filed; the hold reached a **fourth** unchanged occurrence with no addressee queue item in existence for it to sit unmoved in. Three independent misses of one check is redesign weight rather than a wording fix. That no such `operator-a1`, executor-free ticket existed before 2026-11-10 is **unverified** here: it is `APP-2988`'s own filing-run board read, reported and not re-observed on this pass. That the three notes exist, name that guardrail and each closed without such a read is **observed**.)

3. **Classify.** Identify **which canon artefact the fix lands in** — a skill, convention, agent or operator profile, task, or routine — and whether it is **new** or an **edit**. That decides how it is handed over (step 4).
4. **Produce one consolidated artefact per target, matched to where it lives.** Produce the **full new or updated artefact** (not a diff or fragment) — when several notes target the same artefact, fold them into a single update rather than one package per note. Build it from a fresh read of current canon, and **re-read the live SKILL.md immediately before packaging**: autonomous sessions run concurrently, so a target may have been re-saved since the queue was read, and a stale base would silently revert that newer change (worked case: skill-coordinate, 2026-06-25). Then package it for the right surface:
   - **Skill, convention, agent or operator profile** → a saveable **`.skill`** file (a zip of the skill directory containing SKILL.md, named exactly as the target skill, no `-v2`/`-updated`/`-new` suffix), so it presents a one-click Save into the skills store. **However many packages a run produces, each is delivered to the Owner as its own file — one** `.skill` **per target, never collected into a further archive.** The zip is the *package* format, not the *delivery* format: a second archive around several packages destroys the affordance this step exists to create, because the Owner must then download, unzip and save each one by hand before any of them reaches the store. A run carrying sixteen packages presents sixteen files. The general instinct to spare a reader a stream of small files does not apply to this surface — here the stream **is** the affordance, and the report (6) is where the run consolidates, not the delivery. (Worked case: the 2026-09-11 author pass zipped all 16 of its packages into `pulse-retro-2026-09-11-packages.zip` and delivered the one file; the Owner flagged it live as the second run in two days to do it. Two sessions sharing no memory but canon re-derived the same wrong default, which is what makes it canon's silence rather than one session's slip — APP-1331.) **And verify the archive's own shape before the package is returned.** The rules above fix what the zip is *named* and how many packages travel in one delivery; neither reads what is *inside* one. So after zipping, run `unzip -l` on the emitted file and confirm the single top-level entry is a directory named exactly `<target>/`, with `SKILL.md` beneath it. This is the **fanned worker's own** check, run before it hands the package back, not the parent's over the batch: the parent verifies content and cannot verify seventeen archive shapes by hand, and the malformation leaves no other symptom — the file name, the file size and the package count are all correct. A worker that runs `zip <target>.skill SKILL.md` from inside its working directory, rather than `zip -r ../<target>.skill <target>/` from the parent, produces exactly this shape, and the store expects a directory matching the artefact's `name` rather than a bare file at the root. (Worked case: of 17 canon packages on the 2026-09-25 author pass, 3 — `convention-mux`, `routine-delivery-loop` and `skill-coordinate` — carried `SKILL.md` at the zip root with no wrapping directory at all. The parent's pre-delivery listing caught them and they were rebuilt before send, so none reached the Owner malformed, but nothing in the per-row instructions had asked for the check — APP-1767. Distinct from APP-1331, which is about the *delivery* shape of several correct packages.) **And the same check reads the emitted file's own name.** `unzip -l` reads what is *inside* the archive and is silent about what the archive is called, so in the same breath — before the package is handed back — confirm the emitted file's name ends `.skill` and not `.zip`, and that its stem is exactly the target with no `-v2`/`-updated`/`-new` suffix. The extension requirement itself is not restated here: canon already carries it twice, in this bullet's own `.skill` wording and in the per-row fan instruction's "packages the single `.skill`", and half the fan obeyed it unprompted — what was missing was any read of the filename at all. That asymmetry is what earns the clause. Every other control passes identically on a misnamed archive: the internal shape just above, the frontmatter checks (4b), the post-edit evidence-string re-measure, the file size and the package count are all green on a `<target>.zip` holding a perfect `<target>/SKILL.md`, so the defect has no symptom until a human reads the filename on the delivery. (Worked case: of 10 fanned packages on the 2026-11-12 author pass, 5 — `skill-portfolio-allocation`, `skill-operating-loop`, `workflow-content-engine`, `convention-github` and `skill-content-case-study` — were emitted with a `.zip` extension rather than `.skill`; the internal zip shape was correct in all ten. The parent caught them and renamed before delivery, so none reached the Owner malformed, but nothing in the per-row instructions had asked anything to read the emitted filename — APP-3069. Distinct from APP-1767 just above, which is the archive's *internal* shape, and from APP-1331, which is the *delivery* shape of several correct packages.)
   - **Routine or task** → the `routine-*` / `task-*` artefact is saved as a `.skill` like any other canon; its **loader config** (the one-line dual-form loader in `core-operating-model`, *The loader line — one form*: the artefact by name, with its `.claude/skills/` path as the fallback — the name half is what resolves on a cloud Cowork task, APP-1101) is the only pasted-block exception — name the exact Cloud Routine / Cowork target and the repo render-source path under `.claude/routines|tasks/` where a config edit is genuinely needed.
4b. **Validate the frontmatter before emitting the package.** The save button enforces constraints this drain cannot test, and it is the one step the drain cannot perform — so a package that trips one fails on the **operator's** desk, *after* step 5 has already commented "incorporated into `<artefact>`" and closed the note. Unless he pastes the error back, the package is silently lost with nothing to re-raise it: the APP-503 shape, arriving by a new route. Step 1a self-heals it a cycle later; not emitting an invalid package is cheaper. So before zipping, check each artefact against the schema in `convention-artefact-format`:
   - **`description` at most 1024 characters** — counted, not eyeballed, and counted **on the parsed YAML scalar, in characters**. The unit here has always been characters and is right; what was missing was the **method**, and three consecutive passes measured bytes instead. **`wc -c` returns bytes** and an em dash is three of them; **`wc -m` returns bytes on this surface too**, because the locale is `LC_CTYPE="POSIX"`; and **the raw frontmatter line is not the unit either**, because a quoted scalar with doubled apostrophes parses shorter than it reads — `convention-github`'s raw `description:` line is 1037 characters, its raw scalar after the key is exactly 1024 (which a raw-line check reads as zero headroom), and its parsed scalar is 1019, headroom 5; the gap is two enclosing quotes plus three doubled apostrophes. So **measure the parsed scalar** — `python3 -c "import yaml,sys; d=yaml.safe_load(open(sys.argv[1]).read().split('---')[1]); print(len(d['description']))" <path>` — and report the **character** figure, the byte figure, and the headroom against 1024 **on the character figure**. (Worked case: `skill-task-health.skill` packaged at 1084 and rejected — *"field 'description' in SKILL.md must be at most 1024 characters"* — recovered only because Aled pasted the error back, 2026-07-15, APP-554. Measured the parsed-scalar way on 2026-10-20, this skill's own description is **1,010 characters / 1,016 bytes**, so the headroom is **14** — not the ~974 this line asserted until today, and not the 1,016 the 2026-10-16 manifest reported, which was its byte count. The headroom is real but thin, and a drain that rewrites descriptions is the run most likely to spend it. The byte-for-character error always runs one way — a byte count is never shorter than a character count — so the check was conservative, never permissive, and no package was ever wrongly rejected on it. APP-2414.)
   - **`description` free of angle-bracket / XML content** — the validator rejects `<...>` in that field and the save fails silently.
   - **`name` matches the target exactly**, with the directory inside the zip named the same (the no-suffix rule above).
   - **`license: CC BY-NC-SA 4.0` present** on every artefact we own — the adopted value (APP-633, Owner decision 2026-08-12, on the reasoning that canon is public-facing via the claude-ops mirror). The five Anthropic-shipped skills (`docx`, `pdf`, `pptx`, `xlsx`, `web-artifacts-builder`) keep their own and are never edited. This is a *structural* check like the single-block one — the save button does not enforce it, so a re-authored package silently drops the key and falls off the adopted value (observed: `skill-coordinate` lost it between passes), giving the estate sweep a half-life. The Owner ruled delivery shape (c) on 2026-09-03 (APP-633): the artefacts still asserting the superseded proprietary string are corrected in one bounded batch (frontmatter key only), and this line — add the key to any emitted package that lacks it — is the forward rule that heals the silent remainder as each artefact is next touched. No further sweep is owed. **Add it in the right *position*: append the key after** `description`**, never insert it positionally after** `type:`**.** Where the key is missing, the edit is an append to the end of the required keys — `name`, `type`, `description`, then the optional keys with `license` last — which is the order `convention-artefact-format` states for anything newly authored. The positional insert is the likely mechanism behind the whole misordered population: a pass that drops the key in immediately after `type:`, because that is where it is already reading, produces exactly the shape observed, and getting it right costs nothing at the one moment the file is being written. Observed against the live store on 2026-09-12: 159 artefacts, 112 carrying `license:`, and **45 of those carrying it before** `description:` — this skill among them. The position is a consistency preference and **not** a defect, so nothing here withholds, fails or returns a package over it, and an existing file is not rewritten for the preference alone (`convention-artefact-format`, *The three-key order is relative, not contiguous* — and the ops-sync run of 2026-09-08 that withheld 25 publish candidates on exactly that misreading). The rule is only that a package *this* pass emits does not add to the population, so the estate converges as each artefact is next touched rather than by a sweep (APP-633).
   - **Exactly one frontmatter block, with `type:` present in it** — a *structural* check, not a save-button one: a duplicate frontmatter block (a stray `name`/`description` header above the real one) **installs cleanly** and fails silently downstream, because the parser reads the *first* block as the frontmatter, so `type:` goes missing and `build-manifest.ts` falls back to defaulting type by directory. This is the check the drain's own packaging step has tripped — twice in two days, both from drain-emitted files (this skill's own double header, APP-939; the stray `</content>` / `</invoke>` wrapper tags in the saved `skill-ops-sync` body, APP-903). So verify the emitted `.skill` carries a single header before presenting it, and never re-save this artefact without re-checking — getting it wrong here reproduces the exact defect being fixed.
   The two save-button constraints are the length ceiling and the angle-bracket rejection; the single-block/`type:`-present check is structural, caught here rather than at the button. The validator's schema is not published, so treat the list as known-and-growing — when a save is rejected for a new reason, that is `convention-artefact-format`'s to record, and the check here follows it rather than restating it.

   **And the occurrence count is re-measured *after* the edit, per change, before the package is built.** Every check in 4b above reads the frontmatter; nothing in this step reads the body the edit just changed. The author subagent's own match-check is a **pre**-edit test — `grep -F -c` = 1 and an occurrence count of 1 on the anchor, as the manifest section fixes it — and it is silent about what the apply produced. The gap is one-sided in the costly direction: an `insert_after` that lands **twice** leaves the anchor still unique, the frontmatter still valid and the `.skill` still well-shaped, so every check in this step passes on a duplicated paragraph and the package ships corrupted with no error and no obviously wrong shape. So after applying each of a row's changes, and before packaging, re-grep the **new text's** own evidence string against the edited file and confirm `grep -F -c` = 1 **and** an occurrence count (`grep -o … | wc -l`) of 1 — the same two counts the row already carries for its anchor, now run on the other side of the edit — and where either returns 2 the insertion is reverted to a single copy and re-measured before the package is built. **Mandatory per change, not per row**, because a row carrying four insertions can duplicate one of them and pass a spot check on another. **And an author pass resumed from a compacted context re-verifies the row set before it authors anything.** A conversation summary is a lossy compression of the session, not a verified checkpoint, so before processing the next claimed-pending row the pass re-reads each remaining row's folded-note state in Linear **and** the scratchpad's already-packaged `.skill` files, and authors only the rows that are pending in both. Trusting the summary's own progress accounting is what drives a pass to re-derive and re-apply canon edits that are already live — a correctness risk on the store itself, not merely a redundant-work one. (Worked case: on the 2026-11-03 author pass a session continuing from a compacted summary was told that 3 of the manifest's 17 `READY` rows were done; an audit of every remaining row's folded-note state in Linear and every claimed package in the scratchpad found **13 of the 17** already fully complete, only `skill-operating-loop`, `task-bara-operator-standup` and `skill-build-ticket` genuinely remaining in Backlog. On the `convention-github` row all four anchors matched live canon at count 1, each of the four `insert_after` edits landed a **second** copy, and all four folded notes — `APP-2836`, `APP-2828`, `APP-2823`, `APP-2831` — had already closed *incorporated* about ninety minutes before that session resumed. The duplication was caught only because the session happened to re-run the evidence-string grep straight after editing and read 2 where it expected 1; the pre-edit anchor check is the only count this file named, so the duplicated paragraphs would otherwise have shipped inside the delivered `.skill`. `APP-2845`. Same hazard class as `APP-2709` (session-level compaction) and `APP-232` (a resumed session unaware of prior work), with a worse consequence than either: those cost telemetry accuracy and duplicated work, this one writes a corrupted artefact. Whatever produces the compaction summary is outside this file's remit and is flagged here, not fixed.)
4a. **File the repo-lane ticket for a repo-native dependency — by default.** Where a drained canon change **creates a matching repo-native edit** (a new artefact `type` that `build-manifest.ts` must learn, a site-render change, a `CLAUDE.md` update), **file the repo-lane delivery ticket rather than only naming it**: an `OPS:`/`FIX:` Backlog ticket on **`agent:R3-LAY`** in Apps / os.Claude (the routing in convention-linear and skill-optimisation-review), with acceptance criteria, linked to the canon change it depends on. This is the **repo lane**, not the forbidden canon-apply ticket — the canon still saves via the button; only the repo half is a ticket, and it flows through Forge normally (worked case: the `operator` type needed `build-manifest.ts` support, filed as APP-407, 2026-07-01). **Verify the premise in the target file before filing:** where the repo file is readable from the drain's surface (the local claude-ops clone), grep or read it to confirm the described string or structure actually exists, and write the acceptance criteria from what was found, not from the symptom as described; where the file is not readable, mark the ticket "premise unverified — confirm the target file before building", so the build leg checks before investing a claim-investigate-block cycle on a false premise (worked case: APP-484, filed against a "Luna MVP" reference the repo `CLAUDE.md` never contained, drained a full exec cycle for zero diff, 2026-07-11 — APP-495). A repo-native problem *unrelated* to a drained canon change is `skill-issue-capture`'s remit, not this. The one thing still never filed is a ticket to **apply the canon change itself** via Forge.

   **Search open Backlog for the same title before filing — this step has no idempotency guard and needs one.** The manifest children are full-replaced by every refine run, so a row that sits unauthored re-emits current each day and this step files its ticket again each time it does; the only thing bounding the repetition is the row being authored. The comment-idempotency guard (`APP-384` / `APP-738`) was carried across to notes and to comments and never to this filing. So before filing, query open Apps Backlog for an `OPS:`/`FIX:` ticket carrying the **same title**; where one exists, file nothing, and name the existing ticket's ID in the row's return, so the next refine run carries that ID rather than re-deriving the finding. (Worked case, **observed** by this run, all five bodies read and diffed first-hand: `OPS: reconcile planning-week.v1.json's rollup input against the never-opened document blocks` was filed **three** times from the same `task-cycle-planning` row — `APP-2681` at 2026-10-26T10:26:58Z, `APP-2707` at 2026-10-27T10:25:16Z and `APP-2726` at 2026-10-28T10:26:41Z, the third by the author pass itself — the bodies differing only in a probe-date sentence and a label; and `OPS: meirionpritchard-com CLAUDE.md gains a test-hazards entry…` was filed twice, as `APP-2682` and `APP-2705`. Five Backlog rows carrying two findings, each inflating the unconsumed `R3-LAY` queue and each able to spend a build slice — `APP-2723`.)

   **Write the ticket against** `origin/main`**, record the ref, and hedge each repo assertion — a repo-lane row carries all three.** The premise check above settles *whether* the described string exists; these three settle how the criteria asserting it are written, and refine writes them into the row because retro files the ticket mechanically and re-derives nothing. (i) **Ref.** Derive every repo assertion from `origin/main` after a fetch, and state the ref with its short SHA in the ticket description — `criteria written against origin/main (<sha7>), <date>` — so the claim leg compares rather than re-scopes. (ii) **Hedge.** Every criterion asserting a repo string, path, gate or file name carries the confirm-before-writing form — *confirm* `<string>` *against the repo before writing it; expected* `<value>` — which converts an unverifiable prose assertion into a named, greppable check without constraining the author, and costs the claim leg a grep instead of a scoping pass. (iii) **Headings.** The row's ticket body carries both literal `## Acceptance criteria` and `## Definition of done` headings with checkbox lists beneath (`convention-ticket`, *Review criteria live inside the build ticket as two literal checkbox sections*), and the row is not marked `READY` until the emitted body has been grepped for both — a manifest that stamps a ticket ready without that grep leaves `skill-triage`'s poll gate and `skill-build-ticket` step 3b catching its defects downstream, which is the gate working and the manifest not. (Worked cases: APP-1226, filed from the refine manifest, carried four of twelve criteria describing a cascade contract — `globals.css` in `@layer globals`, two named gates, a superseded README string, two remaining stylesheet surfaces — that exists only on `origin/claude/a1-387`, the unmerged branch of PR #29, and on no state of `origin/main`. The claim leg blocked it on A1-387 and split the eight ungated criteria out as APP-1282, at a cost of roughly one scoping pass and no code. What caught it was the ticket's own hedging, not any format gate: three of the four affected criteria named the exact string to grep — APP-1283. And APP-1223, stamped *Ready to action* by the same manifest with a well-formed `## Acceptance criteria` section and no `## Definition of done` heading at all, beside four siblings that carried both; triage caught it at the poll before routing, the same class as APP-1037 / APP-1017 — APP-1269.)

   **And a row claiming a carried repo-lane ticket body is unready unless the child actually carries it.** The same rule that makes a missing `close text` unready binds this one: refine writes the ticket body into the child because retro files it mechanically, so an index or run-log asserting a carried body against a child that has none hands the author pass a claim with nothing behind it. Its safe branch is to file nothing and report it, and its dangerous branch is to satisfy the claim by inventing the body, which is the one thing a mechanical filing pass has no guard against. So where the index or `osclaude.pulse-manifest.decisions-runlog` states that a row carries a repo-lane ticket body, the body is in that row's child, and the statement is written only after the child has been re-read. (Worked case: the 2026-10-28 `decisions-runlog` and the index both stated two carried bodies, in the `task-cycle-planning` and `skill-review-pr` children. `osclaude.pulse-manifest.task-cycle-planning` did carry one, filed as `APP-2726` — itself the third instance of the duplicate above — and `osclaude.pulse-manifest.skill-review-pr` was read in full by the author pass and carried no repo-lane ticket body anywhere in it. The pass filed nothing, which was right and was judgement rather than a rule — `APP-2727`.)
4c. **A config fix is named, never filed and never packaged — and the note stays open until it lands.** Where the remedy is a change to a Cowork scheduled-task or Cloud Routine **config** — rewriting a pasted prompt to the loader line, correcting a cadence or a model — it belongs to none of the three lanes: it is a settings box only the operator can type into. Name it with the exact target and the ordering (the config running the drain itself goes last). Do not file it as a repo-lane ticket, do not package it as canon.

   **But naming it is not closing it.** A note whose only remedy is a config action takes step 5's *third* disposition — surfaced to the Owner, **not** Done. Naming an action in a *closing* comment files it nowhere: the ticket shuts, no sweep reads a closed ticket, and the action survives only as prose in a thread. (Worked case: APP-501's drain named "stand up the `skill-goal-review` schedule" as an Owner config action and moved the note to Done. The schedule still did not exist, and the skill had still never run, **seven days later**; it surfaced only because Aled asked about an unrelated ticket that depended on it — APP-631.)
5. **Close or surface each note — never leave a live one silently in Backlog.** Deciding the disposition is a judgement call, so it is **refine's**, and refine enacts the two that need no package — *assessed, not warranted* (→ Done) and *warranted but not authorable yet* (→ surfaced) — in the same pass. **Before choosing surface-to-Owner, classify every open question on the note as *what* or *how/where* (Owner decision, Aled 2026-09-03, APP-1099).** *What* is the Owner's: direction and principle; a new or changed mandate; anything touching money, security posture, credentials or an external account; a control-plane or workspace-config lever; confirming or denying a ruling's provenance; and anything genuinely two-sided. *How and where* is **refine's to rule** (or the owning operator's, for a venture-specific note carrying its `operator` label): which artefact a rule lives in, delivery shape and batching, sequencing, thin-versus-full, fail-versus-caveat, mechanism choice where canon already leans, transport and placement of a read. A how/where call is written on the note as a `[pulse-refine]` ruling **with a citation** of the what it sits inside (the APP-948 rule — never as an unattributed assertion), the note goes straight to a `READY` row with no Owner comment, and the ruling is listed in the report (step 6) so the Owner keeps the overview and retains override. Surface-to-Owner is for *what* calls only: of ~32 calls put to him on 2026-09-03, ~18 were how/where with no trade-off and he took the standing recommendation unchanged in every one — approval without decision, which is the attention this test protects. Only *incorporated* is enacted by **retro**, once the package is presented, because that close asserts a produced artefact (on a manual single-session drain, the same run does both). Each drained note takes exactly one of three dispositions:
   - **Incorporated** → comment the outcome, **naming the exact change** (so step 1a can verify it by a targeted read of the live file) **and quoting, per change, the short distinctive string step 1a should expect to find in the live file** — a handful of words from the new text that occur nowhere else in the target, one per change, written as the evidence 1a greps for. The point is to move 1a's check from a judgement to a grep: a described change makes the next pass decide whether what it found is the change meant, where a quoted string either is present or is not. Where a change is a replacement of existing wording, the evidence string is taken from the **new** side; where it is a deletion, the evidence is the string that should now be **absent**, marked as such, plus any repo-lane ticket filed with its ID — then move it to **Done**. **Clear the cycle in the same write that sets Done, then read it back and report any residue.** A `PUL-5E` note must not carry a delivery cycle (`convention-linear`, *Never in a delivery cycle*), and no writer in this drain adds one — Linear's *Completed issues* cycle automation does, at the moment the note completes, on every note the drain closes. Observed 2026-09-12 06:02–06:05Z on the Apps board: **43 Backlog notes carry no cycle and 59 of the 60 most recently updated Done notes do**, the values tracking successive Apps cycles rather than one stale assignment; reproduced live twice in the same run, APP-1318 and APP-1353 each entering the close with no cycle and each returning `cycleId b11b9c39-ca0d-4644-b368-167c0c2e0042` from a `state: "Done"` write that named no cycle. So the close is a **sequence, not a single call**, and the sequence was measured rather than reasoned. **Pass the state alone in the first `save_issue`, and clear the cycle in a write of its own** — never bundle the clear in with the state. Measured 2026-09-23: the bundled form returned **success with the cycle still set** — a silent no-op, not an error — and the isolated follow-up carrying the clear and nothing else cleared it and read back clear. The bundled clear has **both** failure modes, so there is nothing to be gained by attempting it: it may silently no-op like that, **or** it may error `Could not find cycle "null"` and take the state write down with it, so that the close itself does not land (4 of 24 closes on 2026-09-22 — APP-1647). So the sequence is: write the **state alone**; **re-read the issue**; then issue a **second `save_issue` carrying `cycle: null` and nothing else**; then re-read again. This is one instance of a general rule — clear any nullable param in an isolated write — which `convention-linear` carries in *Writing Linear safely* for `assignee` and `cycle` alike; read it there rather than reasoning from this step. **And if the isolated clear itself errors, report the residue in step 6 and stop:** never retry-loop on it, and never hold the note open waiting for a clear that keeps failing. The note is validly closed once **Done** lands and the residue is named. The in-call clear does not suppress the automation — that was the earlier rule's mistake, and it was a reasonable inference from "a second write is what the automation re-fires against" rather than an observation. Measured on 2026-09-18 across two closes, APP-1521 and APP-1471: each was closed with the state and `cycle: null` in one call, and each returned `cycleId dbe54020-c6e6-4503-918c-ca6fcb8de16a` on the write response **and** on the re-read. A separate follow-up `cycle: null`-only write then cleared it on both, verified absent on a second re-read. **Report honestly at every step, and never assert a cleared cycle that has not been read back.** The close comment states the read and its timestamp, or states that the cycle is still set; it never says the note closed with no cycle on the strength of having asked for one. A residue that survives the second write is a reporting line in step 6, not a failed close — the note is drained either way, and the same discipline applies as to the re-test rule below. **And the write-side clear is a mitigation, not the fix.** The only half that stops the add recurring is the Owner's config action — turn *Completed issues* off on the Apps team, the toggle deliberately left on when *Active issues & due date* was turned off on Apps, A1 and MBN (APP-1007, 2026-09-03) — or, if that automation is wanted for delivery work, the reading-end exclusion of `PUL-5E` from cycle reporting. Neither is this step's to take: a workspace-config lever is named, never filed and never authored (4c). What the drain owes meanwhile is that its own closes do not silently swell the cycle, and that the residue is visible when they do. (Observed figures, 2026-09-12; APP-1386.) **Never write "presented for save" as a Done close** (APP-1008): the phrase is honest about what happened, which is exactly why it is the discriminator for a lost batch — a close asserts an authored change, and whether it *landed* is step 1a's verification next run, reported separately in step 6. **The same rule forbids hedging about the save, and for the same reason.** An *incorporated* close asserts **the authored change and its evidence string, and says nothing about the save** — no "once saved", no "not yet live", no "awaiting", no "packaged … for Aled to save", and no reassurance in the other direction either. The hedge feels like the honest option and it is the one that destroys the signal: the close is the only account of the batch the next pass has, and a close that defers on landing says the same thing whether the batch landed or was lost. Whether it landed is **step 1a's verification next run**, by a targeted grep for the evidence string this close quotes, reported separately in step 6 — so the close's whole job is to name the change and hand 1a the string, and a sentence about the save adds nothing 1a will read. **A close that hedges on the save is as much a defect as one that claims it**, because the two are indistinguishable to the pass that reads them. (Observed by this run's step 1a pass, 2026-10-02: the 2026-10-01 author pass wrote a packaging claim or a save hedge on **all 17** of its *incorporated* closes — "Packaged as `skill-review-pr.skill` for Aled to save", "should be found in the live file once saved", "not yet live until he saves it" — and all 17 changes had in fact landed, each confirmed by a grep for its own evidence string against the live store. A refine pass trusting that text alone would have re-opened and re-authored seventeen landed changes; a genuinely lost batch of seventeen would have read exactly the same.) **And a grep count taken *before* the save is one more way of saying something about the save, so it belongs in no close either.** A line reporting that the evidence strings each return 0 against the live file *at the time of writing*, offered so that a non-zero count afterwards proves the change, is a measurement of the file **before** the save presented as evidence **of** the save. It proves nothing — the strings are expected to be 0 at that moment, the close is written before anything is saved, and 1a's check is a grep against the file *after* the save whatever the close says about the state beforehand. It also reads as diligence, which is why it survives review where a hedge would not. An *incorporated* close asserts the authored change and its evidence string and says nothing about the save **in either direction**, and a pre-save zero is inside that direction, not outside it. (Observed by this run's step 1a against the 2026-10-21 batch of 25 *incorporated* closes: **not one** stated the save was verified present — all 25 used *authored*, *incorporated* or *folded*, which is correct under this rule as written — and exactly **two**, `APP-2507` and `APP-2482`, each closed with the sentence "Each of the three greps 0 against the live synced file at the time of writing, so a non-zero count is the change and nothing else." Those two are the only breach in the batch, and both close texts were read first-hand this run — session-observed, 2026-10-22 refine run.) **A close against a successor states the successor's *coverage*, instance by instance, never merely its existence.** Where a note is closed because another ticket now carries the work — a fix ticket, a consolidation, a later note — the successor's scope is routinely narrower than the note's by design, and a close written against the successor existing loses the difference silently. So the closing comment **enumerates the note's own named instances and says, per instance, which the successor closes**; any instance the successor does not cover keeps the note open, or is filed as its own leaf and named by ID in the same comment. This is the guardrail *A pass may not close a note naming an action it has not taken*, applied to the hand-off rather than to the action, and it is the same falsifiability the *assessed, not warranted* close already owes — a named condition a later pass can re-test. Nothing is owed by the successor's author: a well-scoped ticket that declines a case and says so is doing the right thing, and the obligation sits entirely with the closing pass. (Worked case: APP-1311 raised the truncated-public-summary problem with one confirmed, named instance — `skill-content-truth-capture`, which renders as *"Write a truth capture — a traceable tc."* — and was closed Done on 2026-09-11 06:31 as superseded by APP-1320. APP-1320 hardened the split for a full stop followed by a *non-space* character, fixed 11 artefacts of that class, and its implementation explicitly declines to guess at abbreviations, citing APP-1311 in a code comment. The single instance that raised the note was the one case the successor excluded by design: measured against the live store on 2026-09-12, exactly 1 of 159 artefact descriptions still splits early on a full stop followed by a space, and it is APP-1311's own — APP-1359.)
   - **Assessed, not warranted** → comment one line why, then move it to **Done**. Where the note described a measurable condition, the closing comment (for this close and for *incorporated*) also names **the condition that should now clear and by when**, so step 1a has something falsifiable to re-test next run rather than a closed ticket that looks the same whether or not it worked (APP-1033). **The by-when date is not optional, and the reason is the second limb above.** The open-condition set is **not** bounded by the verified-through watermark — it is re-derived from the board each run rather than resumed from — so the by-when date is the only thing that retires an entry from it. A close that names a condition and no date therefore leaves an entry re-tested every run for as long as the note exists, and a close that names neither is invisible to the check altogether, exactly as APP-1471 was. So a closing comment naming a condition with no date is **incomplete, not merely terse**, and it is not written: give the date, or do not name a condition. The date is the pass's own estimate of when the condition should have cleared, not a promise, and a date that arrives with the condition still true is what puts the note back in front of a run. (Read against the recent Done set, 2026-09-28: **6** closes name a condition with no by-when date, and every "incorporated" assertion in the lost 2026-09-25 batch is undated — so the batch is invisible to the condition limb as well as to the watermark.) **And a closing comment that asserts a condition re-test states the read it ran and the timestamp of that read** — which query or document, against what, at what time — so a later pass can tell a re-test that was run from one that was assumed. **Where the note's own thread already carries an observation contradicting the figure being asserted, the closing comment reconciles the two** rather than restating the stale one. **An unread thread is the same defect as an unrun re-test**: step 1f already requires the thread be read before assessing, and a close is an assessment. (Worked case: APP-1176 was closed 2026-09-09T09:17:50Z with the comment *"Observed at close: the newest project status update on os.Claude is 2026-08-22 … and no '# Morning brief' update exists on any project."* Verified: thirteen `# Morning brief — 9 September 2026` project status updates had been created that morning between 07:16:31Z and 07:17:05Z, and the note's **own** comment at 07:50:08Z had already reported exactly those thirteen. The close asserted a re-test it had not run, against data on its own thread — the APP-1033 defect occurring inside the rule written to prevent it. Session finding, 2026-09-10; no note filed.) **And an *assessed, not warranted* close's citation of covering canon takes the same grep-before-emitting test as an authored change's evidence string.** The evidence string of an authored change is copied from the change's own new text and grepped against it before the row is emitted; a not-warranted close instead quotes a sentence from live canon as the thing that covers the note, and nothing has yet bound that quote to a grep — so the quoted sentence, and any count stated beside it, can be wrong while reading as diligence. The asymmetry earns the rule rather than excusing it: a wrong citation in a not-warranted close is the only record of why the note was declined, and the condition re-test re-reads that close rather than the canon it cites, so a false citation retires a live finding with nothing downstream looking again. So the sentence a not-warranted close quotes is copied from the live file, not retyped, and greps at the stated count before the close is emitted; where the covering rule is present only in split or paraphrased form, the close says so rather than quoting a string that is not there. (Observed by this run's own step 1a against the 2026-11-05 batch: `APP-2886`'s close states the anti-pattern string present at count 1 and the exact string returns 0 — `grep -Fi` also 0, the anti-pattern surviving only as two separate expansions inside one sentence of `convention-secrets`, so the substance holds and the citation does not; and `APP-2858`'s "count 2" holds only on a case-insensitive sub-phrase probe, the exact quoted string being at 1. Session-observed; no queue note folds this finding.)
   - **Warranted but not authorable yet** (it waits on an Owner prerequisite, separate work, or a decision the drain can't take unattended) → **surface it to the Owner; do not close it and do not leave it unmarked in Backlog.** A buried Backlog ticket gives the operator no cue that it needs him — the deferral is invisible. Surface per convention-linear's state semantics:
     - *Blocked by separate work* — a prerequisite that other work must clear (a setup, a baseline, a dependency): move it to **Blocked** and add a **blocked-by** relation to that work. If the prerequisite is not yet a ticket, file it (Owner-assigned where it's his to do) and relate to it. Assign the Owner, and set priority **Urgent**, where the Owner's own action is the blocker.
     - *Waits only on the Owner's decision or answer* — an elicitation, a design call the drain must not guess: move it to **Blocked**, set priority **Urgent**, **assign the Owner**, and comment the specific question. **Blocked + Urgent is the standing "this needs you" signal** — it surfaces the note in the daily brief's Blocked bucket and the os.Claude canon sweep (`task-daily-report`), which a Backlog-assigned note does not reach. This is the deliberate canon-decision exception to convention-linear's "a decision-only item is In Review, not Blocked": canon intake has no In-Review build stage, so Blocked + Urgent is the agreed Owner-surface (decision: Aled, 2026-07-07).
     - *Waits only on a config action the drain must not take* — the remedy is a Cowork or Cloud Routine settings change (step 4c). Comment the exact target, the exact text to set, and the ordering, then move it to **Blocked + Urgent, assigned to the Owner**. Do **not** close it: it closes on the *next* drain, once step 1c confirms the config has landed.

     Keep the `agent:PUL-5E` executor in every case, so the note returns to the drain (via step 1c's blocked-clearance pass) once the blocker clears, the decision is made, or the config is applied.

     **An answered note is enacted in the run that reads the answer.** The Owner's answer arrives as an unprefixed comment on the note, or is transcribed onto it from the sitting where he gave it. Step 1f already reads that thread and treats it as authoritative over the body, and step 1c already returns a cleared note to the queue; this is the closing half — a surfaced note whose question has been answered is returned to **Backlog** and given a manifest row in the **same** run, so a decision the Owner has taken becomes a change rather than a second note for a later drain. A cleared decision left to the next run is the same failure as a named action nobody files (APP-631, APP-1149), one level up.

     **What this is not: refine does not open a decision conversation of its own.** The remedy for an unanswered set is a cap, a sort and a destination — never a per-task session, and never an interactive refine pass. The fleet is thirty-three scheduled tasks; N tasks each opening a decision conversation is N chats and exactly the context-switching the collated sitting exists to prevent (Owner ruling, Aled, 2026-09-08 — *"If we don't collate them into the stand up and unblock sessions then we fall into the old pattern of me context switching constantly, trying to keep track of multiple chats and competing priorities"*; APP-1161).

   A note the drain **did not reach** — an unassessed one still sitting in Backlog when the run ends — is none of the three: it is queued, not deferred, and it stays exactly as it is. Do not close it, do not surface it, and do name it in the report as not reached, so the difference between "assessed and parked" and "not yet looked at" stays legible.

   **And a fourth disposition covers a note this pass assessed, can author, and may not author this run: assessed, authorable, held by the one-change-per-target rule.** Step 2 requires that each target be assessed and changed exactly once across the batch, so where a note's fix lands in an artefact another row already owns this run, the note is authorable and must still wait. It takes none of the three dispositions above, and it is not the not-reached state either — a held note has a finished assessment and a not-reached note has none, which is the whole reason the two are named apart. Forcing it into *assessed, not warranted* closes a live finding, and forcing it into *warranted but not authorable yet* surfaces to the Owner a decision he does not have to take, because nothing about a held note waits on him. So it stays in **Backlog** with a `[pulse-refine]` comment naming the target already owned this run and the row that owns it, keeps `agent:PUL-5E`, and is **not** closed, **not** surfaced to Blocked, and **not** reported as not reached. The report names it as held, with its return condition — the next run after the colliding rows land. **The comment carries the assessment itself**, not merely the reason for the hold: the target, the anchor, the operation and the verdict reached, so the next run re-uses the work rather than paying for it a second time. A hold recording only its own reason converts a finished assessment back into an unassessed note, which is the cost this disposition exists to avoid. **And the count of held notes belongs in the completeness split beside *agent-authorable remaining*, never inside it** (step 6): a note held by the pass's own ordering rule is not a capacity shortfall, and counting it as one reads as a drain that failed to clear its queue when the queue was cleared and the ordering rule bound. (Worked case, session-observed 2026-10-26: APP-2655 — the Owner-ruled "the workflow is the single source for a process" — lands in `workflow-venture-operating-loop`, `routine-delivery-loop` and `skill-operating-loop`. The latter two were both READY rows of the same run, `routine-delivery-loop` carrying APP-2666 and APP-2663, `skill-operating-loop` carrying APP-2636, APP-2645, APP-2634 and APP-2635. So the note was fully assessed and authorable, and was held; with no disposition to report it under, the pass had to choose between a wrong close and a note that reads as unassessed — APP-2655.)

   **And a hold's return condition is one the drain's own operation can reach.** The disposition above reports the hold with its return condition — *the next run after the colliding rows land* — and nothing requires that condition to be **reachable**. Under step 1d's daily bar, every agent-authorable note is cleared every run, so a return condition phrased as *a run whose sweep set contains no target owned by another row* can never be met: there is always another row, and a hold re-held against the same condition is the silent trim the daily bar forbids, arriving in slow motion rather than in one decision. So a return condition is stated as something a run can reach — a named row landing, a dated re-assessment — and **where the only reachable return is a dedicated run the drain cannot create for itself, the hold is escalated as a capacity finding into the decisions-needed set** rather than re-held a second time. That is step 1d's own remedy for a capacity shortfall (a second daily run, a raised capture bar), surfaced to the Owner and never a silent trim. (Worked case, **observed** on the live store this run: the three rename-batch notes were given the return condition *"the first refine run whose sweep set contains no target owned by another row that run — i.e. a dedicated run"* by the 2026-10-29 ruling. Measured this run, batch **1**'s sweep set is **39 files** and contains `skill-ops-retro`, `skill-operating-loop` and `routine-delivery-loop`; batch **2**'s is **29 files** and contains `workflow-content-engine`; batch **3**'s is **33 files** and contains `convention-linear`, `core-operating-model`, `skill-operating-loop` and `workflow-content-engine` — every one of today's own rows. The three have now been held **7 days**, 2026-10-23 to 2026-10-30, on a condition no run can meet. Session-observed; no note folds this.)

   Once the operator saves an authored artefact, ops-sync detects Claude is ahead and raises the publish ticket to the repo.
5a. **Log the run's consequential canon decisions — in the same action that settles them.** Where this drain *settles or reverses* canon — adopts a new mechanism, closes a standing question, or supersedes an earlier decision — write an `osclaude.log-decisions` entry per `convention-decision-log` (standard entry format, with the Impact field naming and reconciling any open ticket the change supersedes) **this run**, never as a deferred "record later" note, and never only in the note's closing comment. A routine incorporation that merely applies what canon already implies needs no entry; a change to *how* canon works does. Because the drain is the highest-frequency canon-settling surface, it also confirms the **current ISO-week `osclaude.log-decisions` child document exists** as it goes, and treats a week that carried settled canon with no child doc as a gap to open (create it and log into it) rather than a silent lapse. This closes the recurrence at its main source — the W28–W30 log gap arose because heavy canon activity settled with nothing writing the entries, and nothing swept for decisions-made-but-not-logged (APP-711). Two residuals are named for the operator in the report, not authored here: the one-off **backfill of W28–W30** from ticket / drain history (a data task, not canon, so not reconstructed blind), and a periodic cross-check for canon settled *outside* a drain (a candidate light addition to `skill-optimisation-review`'s monthly review, since the drain step above only covers the drain path).
6. **Report.** Short summary (retro reports what it produced; the queue measurements below are refine's, carried in the manifest and restated here from it, not re-derived): artefacts produced (which, what changed, save or paste), repo-lane tickets filed (IDs), config actions named for the operator, **near-duplicate notes merged by the collation pass (step 1e)**, **notes returned to the queue by the blocked-clearance pass (step 1c)**, notes drained to Done, **notes surfaced (which, and what they now wait on)** — presented as the consolidated decisions-needed set for standup — **every how/where ruling made this run, one line each with the note and the citation** (APP-1099: the Owner reads the overview without the approval step), **the run-log — every state, label, priority and assignee write this run made, ticket by ticket** (Linear keeps no history for label, priority or assignee writes, so this line is the only record an audit or a capture can cite — Owner decision 2026-09-03, APP-923; the rule for every unattended run is in `convention-agent-runtime`), notes left queued and not reached, and **the completeness split plus the two queue rates**: *agent-authorable remaining* (target zero) and *owner-decision waiting*, alongside closed-this-run vs filed-since-last-run. Report **authored-and-presented separately from verified-landed** — never merge the two counts (APP-1008) — **and state the verified-landed count against the evidence strings those closes named**, naming the string grepped and the file it was found in, so the count is a set of hits rather than an assertion. **This does not make saving verifiable inside the pass, and nothing here should be read as if it did.** An author pass cannot distinguish a package it has presented from one the Owner has saved; the whole 2026-09-25 batch was lost with every closing comment honest, and step 1a caught it at **day 3**, across two intervening days on which no weekday run fired. Only the next run's read of live canon establishes that a save happened. What the evidence strings buy is that the read is cheap and mechanical, so a lost batch surfaces on the first run that looks rather than on the run that happens to look carefully — and record the **verified-through watermark** (the timestamp of the latest Done close confirmed present in live canon) so the next run's step 1a resumes from it rather than from "the previous drain". Before writing this report, re-read the live file for each artefact emitted this run, so a batch save-failure surfaces in the run that caused it rather than at the head of the next. State plainly that **this session is the complete current save set** — every unsaved package re-produced into it, one per target — and that unsaved packages from earlier sessions are superseded and must not be saved (the re-production guardrail), so the Owner can save this session alone with no risk of conflict. **Reconcile every folded note of every presented row before reporting.** Row by row: for each row the pass presented, confirm each of its folded notes was closed as *incorporated*, and name any row presented while its notes stayed in Backlog; and name every row whose anchor failed to match live canon, with its notes left in Backlog and `[pulse-retro] stale — re-refine` posted on each of them. Rows presented, folded notes closed, and rows kicked back as stale are three counts that must agree with the manifest's `READY` row set — a disagreement is itself the finding, and it is reported as one. **This reconciliation reads the live board, never the fan's own self-reported returns alone** — a fresh read of each folded note's current state — because a subagent's summary states what it posted and attempted, not what the board now shows, and a close whose comment landed while its state write silently failed reads as fine from inside that one return. The batch-level check is the backstop for exactly the gap the per-row read-back (*The author manifest*, close text) exists to close at the row level: it catches a row whose own read-back was skipped, wrong, or never run. (Worked case: the 2026-09-03 author pass left `task-cycle-planning` (APP-1054) and `skill-plan` (APP-892) landed but unclosed, each costing a full re-assessment the next day, and dropped the `operator-bara` row on an un-matchable anchor with no comment, invisible until a grep — 5 notes affected, APP-1119.) Every figure in the report and in any Owner notification is marked **observed** or **reported** per `convention-comms-owner`, which carries the attribution rule itself; and the pass leads with what it **owns**, carrying a relayed cross-lane item below that, attributed, rather than leading with the largest figure in the queue (APP-1150). Then any non-canon observations named for the operator, and anything skipped. No preamble, no sign-off.

## Guardrails

- **The drain is two daily passes; the boundary is reading-or-judgement versus produce-or-save.** The refine pass (`task-pulse-refine`) reads, collates, verifies prior saves, clears blockers, assesses, decides every disposition, enacts the non-package ones (not-warranted → Done, surface → Blocked), and emits the author manifest (the `osclaude.pulse-manifest` index plus one `osclaude.pulse-manifest.<target>` child per `READY` target, anchor + new text). The author pass (`task-pulse-retro`) consumes the manifest: produces and presents each `READY` row, closes its folded notes as incorporated, logs, reports — and does no assessment, no collation, no blocker test, and never touches Blocked or an `OWNER-GATED` row. The one overlap that stays is retro's re-read of live canon before packaging, because concurrent saves move canon — and it is a **match-check** against the row's anchor, never a fresh assessment: a stale anchor kicks that one row back as "stale — re-refine". The split exists because one session could not both read the queue and author its canon within one context window (APP-875); the boundary was fixed by rule on 2026-09-03 (APP-1094) after retro had drifted back into assessment.
- **The author pass fans one subagent per manifest row.** Author each `READY` row in its own tool-scoped subagent, concurrently; the parent keeps the manifest read, the decision-log write, delivery of every package (subagents return paths; the parent sends each with `SendUserFile`, one file per target, after the fan returns — APP-1534), and the short report. One file per subagent means packages never clobber, and the fan removes the single-window ceiling behind the refine/author split (convention-agent-runtime; APP-875). Every Owner-facing channel stays with the parent on the same footing — `PushNotification` and the user-message tools as much as `SendUserFile` — and each fan prompt names the class, never one member of it (APP-2040, APP-2170).
* **An index older than its own children is a hard stop, not a mid-flight read to work around.** Before authoring, the author pass compares the index's stated refine date against the **header date** of a sample of its `READY` rows' children, with `updatedAt` as corroboration only. Where the index is behind them, a refine run is in flight or incomplete: **report and stop**, exactly as for an index that cannot be read in one call. Never author from a mid-flight index and never rebuild the row set from the children. (Worked case: 2026-09-09 — an author pass read the index twelve minutes before refine full-replaced it and reported the index as never rewritten; the children were current and the index was not, APP-1206.)
* **A failed anchor match is commented, never silently dropped — and every presented row is reconciled.** Where the author pass cannot match a row's anchor against live canon, it posts `[pulse-retro] stale — re-refine` on **every** one of that row's folded notes, leaves them in Backlog, and names the row in the report; this is mandatory, not the pass's discretion. And before reporting, the pass reconciles **every folded note of every presented row**: a row presented whose notes were never closed as incorporated, and a row dropped on a failed match, are each named by name. Without both, a lost row reads exactly like a row that was never reached. (APP-1119: `task-cycle-planning`/APP-1054 and `skill-plan`/APP-892 landed but stayed in Backlog, each costing a full re-assessment; the `operator-bara` row was dropped with no comment and found only by a grep.)
- **Capture is a note, not a fix; drain produces the artefact.** The only ticket capture ever touches is a `FRICTION:` note in the Pulse queue. Drain never files a **canon-change** ticket and never routes a canon edit through the delivery loop — that downstream-first inversion is what this skill exists to avoid. A `FRICTION:` note records an observation for retro to assess; the canon change is still produced as a `.skill` and **saved by the operator**, and **Forge never executes a canon edit**.
- **A deferred note is surfaced, not buried — and reaches the Owner's brief, not just the board.** *Warranted but not yet authorable* is a real third outcome beside incorporated and not-warranted. When the drain defers such a note it moves it to **Blocked** with a **blocked-by** relation to the prerequisite (prerequisite-blocked), or to **Blocked + Urgent, assigned to the Owner** with the open question (decision-pending) — never leaves it unmarked in Backlog, where the operator has no cue it needs him. Blocked + Urgent is the signal `task-daily-report` reads, so canon-needing-the-Owner is as loud in the morning brief as delivery-needing-the-Owner; a Backlog-assigned note is invisible to the brief (root cause: os.Claude is gated out of the brief unless a canon item is Blocked/assigned; fixed with the paired `task-daily-report` canon sweep). It keeps `agent:PUL-5E` and returns to a later drain when the blocker clears. A note is **Done** only when incorporated or assessed-not-warranted. (Worked case: the APP-428 planning-and-time family and APP-438 surfaced to Blocked with blocked-by relations, APP-442 to Blocked + Urgent assigned to the Owner, 2026-07-07.)
- **Emit a valid package, not just a correct one.** The frontmatter check in step 4b is not housekeeping: the save button is the one step the drain cannot perform, so an invalid package fails after the note is already closed, which is the APP-503 lost-package shape by another route. Assess-against-current-canon says *what* to write; this says the file must actually install.
- **Repo-native dependencies are filed, not just named.** When a drained canon change needs a matching repo edit (a new `type` in `build-manifest.ts`, a render change, a `CLAUDE.md` update), file the repo-lane Forge ticket (`OPS:`/`FIX:`, `agent:R3-LAY`) by default and link it to the canon change. This is not the forbidden canon-apply ticket — the canon still saves via the button; only the *repo* half is a ticket. The distinction is the three-lane split in `core-operating-model`: canon saves, repo is a PR.
- **A config change is a fourth surface — named, never filed.** Rewriting a scheduled-task config is neither canon nor repo; it is the operator's settings box. Name it and stop (step 4c).
- **A close is verified, not assumed — a missed save re-surfaces.** Because a note is closed when its artefact is *packaged*, not when it is *saved*, the refine pass opens each run by re-checking prior "incorporated into `<artefact>`" closes against the live store, re-surfaces any whose change never landed, and lists its re-production as a `READY` manifest row (step 1a). Nothing else confirms a save happened — ops-sync only detects Claude-ahead, task-health only checks the scheduled layer — so without this check a package missed in a closed session is silently lost. Verify against the **store**, not a repo clone (step 1b).
- **The latest retro session is the complete, self-sufficient save set — every unsaved package is re-produced into it.** The Owner saves from the newest drain session and nothing older, so that session must carry a current package for *every* change still unsaved. So a lost note is not merely re-surfaced to Blocked — its package is **re-produced into the current session**: for each change 1a finds absent from live canon (a Done close whose save never landed) and each note in the APP-1013 *waiting-on-save* class, refine lists a `re-produce` row and retro rebuilds the `.skill` this run from a fresh read of live canon, folded with any new note targeting the same artefact so there is exactly **one current package per unsaved target**. This is what makes saving safe and conflict-free: because every package in the session is built on the latest live canon and no target appears twice, the Owner can save the whole newest session without hunting across older sessions and without any risk that an older session's package silently reverts a change — the newest session **supersedes** all earlier unsaved packages, which are void the moment this drain re-produces them. State this explicitly in step 6: "this session is the complete current save set; disregard unsaved packages from earlier sessions." The re-production load is real and can exceed one session's authoring budget — where it does, that is the capacity finding of step 1d, surfaced to the Owner (a second daily run, a raised capture bar, or authorising the drain to save), never a silent trim that leaves an unsaved package stranded in an older session. (Owner instruction, Aled 2026-09-02, sharpening the APP-1013 ruling: *"I would always like any unsaved packages to be resurfaced in the latest retro session, so I can confidently act on the latest session and save knowing I can't create conflicts."*)
- **FRICTION vs FIX/OPS/DRIFT.** A `FRICTION:` note (Pulse queue, `agent:PUL-5E`) is canon-improvement intake, drained into a save-ready artefact. A runtime or repo problem unrelated to a drained canon change — a defect, a tool error, an artefact missing from the repo — is `skill-issue-capture`'s remit (`FIX:`/`OPS:`/`DRIFT:`, routed to Forge or the operator), not this.
- **Assess against current canon, not the note.** The drain proposes whatever a fresh read of the live SKILL.md warrants, which may be nothing — not whatever fix the note suggested.
- **Read the note's comments before assessing it — they outrank the body.** A queued note's comment thread is where its current truth accretes (an Owner decision, a prior drain's partial fix, a correction); the body is the least current thing on the ticket. Read the comments before assessing or authoring any note (step 1f) and treat an Owner decision there as authoritative over the body — otherwise canon is authored against a superseded premise and closed as Done (APP-845, the APP-633 miss).
- **Propose canon, never apply it** — Claude never edits canon itself. The canon output is a proposal the operator saves; only the repo-lane half is filed as a ticket.
- **Match the artefact to where it lives.** A skill, convention, agent or operator profile installs as a `.skill`; a routine or task also saves as a `.skill`, with only its one-line loader config as a pasted exception.
- **One opportunity per artefact.** Don't bundle unrelated fixes; don't split one fix across several.
- **Consolidate per target; build on the very latest canon.** All canon-improvement intake funnels through the Pulse queue and is drained in batch, so the operator saves a consolidated set in one place rather than hunting saves scattered across sessions. Several notes touching one artefact merge into one update, and the live canon is re-read just before packaging so a concurrent save is never clobbered.
- **Calibrate to evidence.** A single observation is a small wording fix, not a redesign. Count instances (including recurrence comments on the note) before escalating scope.
- **Scope the queue read by the label, never by the project.** `PUL-5E` defines the queue; os.Claude is only where a note *should* be filed. A `project`-scoped read drops project-less notes silently and reports clean (APP-420/416/378 sat unread through four drains). Query the label across the workspace, bucket by project afterwards, and fix a missing project in passing.
- **Dedup at both ends — append at capture, merge at drain.** Near-duplicate *notes* are the largest avoidable part of queue growth. At capture, search the queue first and add new evidence to a same-root note rather than open a second (capture step 2). At drain, collate the read queue and merge same-root notes into one primary — closing the rest as Duplicate — before assessing (step 1e). A note that genuinely names a *distinct* root is never suppressed; only restatements of one already filed are folded in.
- **Batch size is bounded by quality; the authorable queue is still cleared in full every day.** Size the authoring of any *single* artefact by how well it can be assessed and written, sort the queue first (step 1d), and collate it (step 1e). But quality bounds *how each artefact is written*, not *whether the authorable queue is finished*: the daily bar (step 1d) is that every agent-authorable note is cleared each run, because a filed-but-unsaved fix recurs as a daily error until it lands. The *owner-decision* class is different — it is surfaced to standup and never counted as a drain shortfall. So report the completeness split and the two rates every run (step 1d/6); where a single daily session genuinely cannot author the whole authorable set, surface that as a capacity finding for the Owner (a second daily run, a raised capture bar) rather than quietly trimming the batch. "Not reached" stays legitimate for a genuinely unassessed note within a run; it is not a resting place for an authorable fix whose error recurs daily. (Supersedes the earlier "do all of them is no longer available" reading for the authorable class — Owner instruction, Aled 2026-08-12; earlier context APP-634, the 2026-07-16 over-cautious drain.)
- **A pass may not close a note naming an action it has not taken.** Either take the action, file it in the lane that owns it, or keep the note open and surfaced until it lands. "Named for action" is not a filing: it is prose in a thread no mechanism reads, and it vanishes the instant the ticket closes. This does not reopen step 4c — a config action is still never filed as a ticket and never authored — it fixes the *disposition*: the note stays open, not the action's lane. (APP-631, from APP-501's lost root cause.)
- **A friction note *about mis-routed or stranded tickets* is half-resolved by the canon edit — the ticket-side action is filed, not merely named.** Where a drained note's subject is specific delivery tickets sitting in the wrong lane or state (routed to a surface that cannot run them, left in Todo or In Progress after a handoff), the canon change stops the *class* recurring but does not move *those* tickets, and no pass owns moving them by default — so the correct behaviour of several passes composes into a permanent no-op and the tickets recur on every sweep. Naming the action for `skill-coordinate`'s Pass 4 to surface was not a filing, because that reader did not exist — Pass 4 sweeps the delivery board and had never been told to read the Pulse manifest — and because the manifest is full-replaced each run, so an un-actioned item silently disappeared rather than accumulating. So the ticket-side action — return to Refinement + `human`, or re-route — is written into a **named, stable section of the manifest**, `## Ticket-side actions`: in the index, or in `osclaude.pulse-manifest.decisions` where that section has moved out under the ~25KB rule, with the index's pointer section naming which. Two things follow. `skill-coordinate` Pass 4 **reads that section as one of its inputs** and reports what it enacted, closing this hand-off the way `skill-ops-sync` closes the canon-to-repo one. And the section is the **one exception to the full-replace**: each action is carried forward with its first-named date and a recurrence count, so an action unactioned for N runs reads as escalating rather than as new. The note still stays open until the action lands. This is the drain-side pair of the `skill-coordinate` Pass 4 stranded-state family (APP-874 / APP-657 / APP-566), and it is the conclusion APP-631 reached for dispositions — *"named for action" is not a filing: it is prose in a thread no mechanism reads* — now reached for hand-offs. (Worked case: A1-388's re-route was named in the 2026-09-04 manifest and was still unmoved on 2026-09-08, across five consecutive zero-output `routine-delivery-loop` 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 A1-388 In Review + `agent:PR-1SM` and unassigned since 2026-09-03 10:49Z, roughly 118 hours. APP-1149.) **And the scope is not only tickets in the wrong lane — it also covers a root blocker held outside the agent lanes that a loop has re-derived N times.** Where a delivery or feasibility loop keeps returning zero eligible work because one ticket that sits outside every agent lane has not moved, the same composition holds: the loop behaves correctly, the note is correctly filed, the blocker is correctly untouched by every pass — and the only thing that accumulates is notes. That blocker **is** a ticket-side action in this sense and is written into `## Ticket-side actions` the same way, with its first-named date and recurrence count, so the Nth run reads as escalating rather than as new. The named action is an **escalation to the holder** — an age-and-priority re-ask, or a direct ask — which `skill-coordinate` Pass 4 **surfaces with its age** rather than enacts, because it is not one of the reversible state / label / assignee / relation writes that pass is permitted; where the action *is* such a write on the named ticket, Pass 4 enacts it. The note still stays open until the action lands. (Worked case: A1-398 — SETUP: portal auth environment variables, Todo, High, Owner-held, ~36 days old and the sole root of the a1.OS portal chain A1-399 / A1-400 / A1-401 — was re-derived at full phase-2 read cost by fourteen consecutive `routine-delivery-loop` runs that filed fourteen separate `FRICTION:` notes, APP-1318 → APP-2305 → APP-2334, the last of them 15 candidates and 0 eligible. Fourteen runs, fourteen notes, one unmoved ticket. APP-2334.)
- **A scope exclusion must name the pass that picks the work up, and that pass must be verified to do the job.** Narrowing a sweep is usually right; the failure is justifying it with a hand-off target nobody checked. APP-552 correctly removed `PUL-5E` notes from triage's Blocked sweep, reasoning that they reach the Owner through `task-daily-report` and return to the next drain on their own — neither of which was true, and surfaced notes sat with every blocker Done for days (APP-438, APP-575). Step 1c is the watcher that was assumed and missing. When a skill excludes something, name the owner and confirm the owner acts. (APP-600.)
- **A drain that settles canon logs the decision.** Where the run adopts, reverses, or settles canon — not a routine incorporation — write the `osclaude.log-decisions` entry in the same action per `convention-decision-log`, and confirm the current-week child document exists; the drain is the main canon-settling surface, so an unlogged drain decision is the W28–W30 gap forming again (step 5a, APP-711).
- **Nothing to fix produces nothing.** A clean run captures no note; an empty queue produces no artefact.

## Tone

Calm, precise, sentence case, British spelling, no exclamation marks, outcome before adjective. (cos.tov.)

## Setup (scheduled drain)

- The drain runs as **two Cowork scheduled tasks (cloud), daily and in order**: `task-pulse-refine` first (the refine pass — read, verify, clear blockers, collate, assess, decide and surface, write the author manifest), then `task-pulse-retro` (the author pass — produce and present each `READY` row, close its folded notes). Schedule the refine pass early, before the 09:00 stand-up, and the author pass after it, so the day's Owner-decision residue reaches the morning brief and the authoring runs on a refined queue. **Daily** — the queue is producer-heavy and a filed fix recurs as a daily error until it is saved, so the authorable queue is cleared every day (step 1d). Also run on demand as a single session that does both passes in order. Wiring the second schedule and its one-line loader config is an Owner config action (`core-operating-model`, the config surface) — named, not authored.
- **Connectors:** Linear (read the queue, comment, move to Done, surface a deferral to Blocked / assign the Owner, wire blocked-by relations, file any repo-lane ticket) + the skills store (save the artefacts the operator approves).
- Capture needs only Linear, so every surface — including Claude Code routines — can file a `FRICTION:` note.

## Embedding in other skills

Add one line as the final step of a skill: "On finish, run skill-ops-retro capture on this run's friction: **search the Pulse queue first — **by the `PUL-5E` label across the workspace, never by project or by team**, because a same-root note filed outside os.Claude is invisible to a project-scoped search and the search reports clean — 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." Keep the rules here, not in each skill; the one-liner carries the shape so a leg that files without this skill loaded still files the note whole (APP-1549). Only paste a compact version into a skill that runs where skill-ops-retro won't be loaded alongside it. **And the one-liner carries the third branch, not two.** As first written it has exactly two branches — add to a same-root note, or file a new one — so a run with nothing to capture reads it as an obligation to file something, and the only thing it has is its own report. So the pasted line ends: *"This run's own report of what it swept, wrote and skipped belongs on its run-log surface (`convention-agent-runtime`), never in the Pulse queue — and where the run found no friction, it files nothing."* **And the line carries a fourth branch, for the same-root note that has already been drained.** The three branches above all assume a *live* queue — a same-root note that is open, a distinct new root, or nothing to file. None of them covers the commonest state of a long-running root, which is that every predecessor note is closed: a leg that searches only open notes finds nothing, takes the file-a-new-one branch, and reports having done exactly what the line told it. So the pasted line also directs the leg to **search recently-Done and Duplicate-closed same-root notes as well as open ones** — the last ~30 days is enough — and ends: *"Where the same-root match is closed, **record nothing on the closed note** — a closed note takes nothing: if the fix took hold it needs no tally, and if it did not, the closed note is not where the recurrence belongs (Owner ruling, A1-656 session, 2026-10-19). Where the fix **took hold**, file nothing and record nothing. Where it **did not take hold**, add the recurrence to the **open ticket-side action that note produced** as a single running tally edited in place — 'recurred: N runs, last <date>' — never on the drained note, never as a fresh note, and never as a comment per run."* **The branch belongs in the pasted line and not only in capture step 2, because a branch a leg does not have is a branch it cannot take.** Capture step 2 already carries the Done-scoped search and the tally rule in full, and carries them correctly; but an embedded capture leg does not read capture step 2, it reads the one closing line its host skill pasted, so a rule stated only where the drain reads it is not a rule the capture leg carries. That is the general rule this file has now reached twice, one branch apart: APP-2267 is the antecedent — the missing clean-run branch, where restating the prohibition in capture step 3 did not reach a leg reading only the line — and APP-2334 is the recurrence, one branch later, on the branch next door. (Worked case: the A1-398 root has now collected sixteen `FRICTION:` notes, APP-1318 → APP-2305 → APP-2334 → APP-2404. The tally rule landed in capture step 2 on 2026-10-14 with APP-2334 and was verified live there today; APP-2404 was filed 2026-10-16T12:20:31Z, inside 48 hours, as the **sixteenth** occurrence of that same root, and its own stated reason was that the same-root search found no surviving *open* note — which was exactly true, because every predecessor had been closed Done or Duplicate. The same thread then collected four near-identical recurrence comments in three days: the comment-idempotency case this file already covers in capture step 2, recurring on the very surface the tally branch is meant to replace. Recorded here, not made a rule of — the guard it needs is already written. APP-2334.) Add it to any artefact's closing line as that artefact is next touched, rather than by a sweep. **And the search that finds a same-root note is label-scoped, not project-scoped — the rule drain step 1 already carries, reaching the capture side it was never given to.** Step 1 fixes the drain's own read as *by the label across the workspace, not by the project*, because `PUL-5E` is the queue's definition and a project-scoped read drops a project-less note silently while reporting clean. Capture's same-root search and the pasted line both described an os.Claude-scoped search, so the two halves of one dedup discipline were scoped differently and only the drain half was sound. The asymmetry is what earns the line: a capture leg whose search is project-scoped finds nothing, takes the file-a-new-one branch, and reports having done exactly what the line told it — the same false-clean failure, one step earlier, and the one failure a search cannot report. (Worked case, **observed** this run: `MBN-350` carries `PUL-5E`, `type:task` and `work:configuration` correctly and is filed on team **MBN with no project at all**. The drain's label-scoped read across the workspace found it without difficulty; every os.Claude-scoped same-root search is blind to it, which is the one mechanism that would stop the next unparented-document instance being filed fresh. Session-observed; no queue note folds this finding.) (Worked case: the clause was live on `skill-coordinate`'s closing line and absent from `skill-triage`'s, and `task-triage` filed five run reports as `PUL-5E` notes — APP-1710, APP-1802, APP-1808, APP-1713, APP-2267 — the last of them after the prohibition itself had been hardened in capture step 3. Restating the prohibition does not reach this; supplying the branch in the line the run actually reads does — APP-2267.)
