[Half-state patrol] check-half-states live sweep — generated view (please pin)

[os-warren]

os-half-state-sweep — machine-findable marker for this generated view.

Generated view — not a second tracker. Authority lives on each card and PR (one-board rule); this body is rewritten IN PLACE by the scheduled patrol workflow (.github/workflows/half-state-patrol.yml) on every run, and the edit history is the archive. Report-only: every row is patrol input, never a gate verdict, and this sweep never fixes a state. Each predicate and the protocol clause it enforces are documented in scripts/pm/check-half-states.mjs.

Swept 2026-09-03T19:46:25.264Z · run 33797924065 · commit 101ad2cc13fafd8a3879ffc4a6ce6133c02ed832 · trigger schedule

The timestamp above is the patrol's own heartbeat: a Swept line that stops advancing means the standing caller died, which is the failure this anchor was created to make visible. Read it before you read the rows.

check-half-states: swept 391 open pm-/p0-labeled issue(s), 508 open issue(s) in the unscoped pass (H13–H15, H18), 23 open PR(s) (merge state read on 1 of 1 H16 candidate(s)) and 960 recently-merged PR(s) in objectstack-ai/objectstack — 192 half-state(s) found. H8's merged window is a TIME cap of 8 day(s), read in 10 page(s) (horizon reached: a delivery inside the window was seen, not merely the first N rows). H22 read 506 recently-closed issue(s) for pm:* state residue, COUNTED into the census line above and filed as no row at all (ruled 2026-08-31, 批 #13; folded #14072) (older closed carriers are outside the window by design). H22's closed-card window is a TIME cap of 3 day(s), read in 6 page(s) (boundary reached: paging ran past the horizon, not merely the first N rows). It is a CLOSURE horizon: rows are selected on closed_at, while paging is bounded by updated_at — the stream is consumed by closed-issue ACTIVITY (~188.3/day, measured 2026-08-31), not by closures (~11/day), which is why the page cap it replaced covered a ragged 2.1 days of update-recency rather than the closure window it read as. H23 read 472 squash commit message(s) from the default branch, carrying 21 closing-keyword binding(s) across 21 message(s). H23's commit window is a TIME cap of 3 day(s), read in 5 page(s) (boundary reached: paging ran past the horizon, not merely the first N rows). The open listings (H1–H18 inventory, H13 unscoped pass, open PRs) is an EXHAUSTIVE listing, read in 16 page(s) (complete: paging reached the end of the stream, so this IS the whole population). Hold comments read on 104 of 104 H17 candidate(s). Blocked-by: comment fallback read on 76 of 76 candidate(s). Restart-when: hold comments read on 57 of 57 H9 candidate(s). Blocker liveness (H19): targets resolved on 66 of 66 distinct Blocked-by: target(s) named by open pm:blocked card(s). Dispatch liveness (H20 + H27): remote branch read on 10 of 10 distinct claimed branch(es) named by open pm:dispatched card(s) past the 60-minute threshold — one read serving both rows, so H27's 24h population is a subset of this one and costs no request of its own. Seat liveness (H32): marker thread read on 5 of 5 HELD seat post(s) whose lane is countable on THIS board — a seat held for a sibling repo's lane is out of scope here (its inventory is unreadable from this sweep, so an empty-looking queue would mean nothing), and an unread thread makes H32 decline to judge that seat rather than accuse it. Gate-removal patrol (H35): 0 removal(s) of a gate-semantic label read from 0 page(s) of the repo-wide issue-event stream over the last 12h — no per-card timeline fetch. 0 of them are UNJUDGEABLE (a gate that only ever had ONE carrier leaves 「双载体同笔清标」 no evidence in either direction, so neither H31 nor H35 can say cleared-or-stripped). Shared-file holds (H36): changed-file page read on 22 of 22 open PR(s) — a pair needs both sides read, so a shortfall can only MISS a hold, never invent one. Family folds (H37): 2 live shared branch(es) claimed by more than their own chain head, and a member comment page read on 166 of 166 open pm:queue card(s) — that second read is bought ONLY when a fold is live, so 0 of 0 is a board with no fold in flight rather than a pass that skipped one, and an unread member can only MISS a drifted write, never invent one. Dangling references (H40): 369 of 400 attempted resolution(s) answered, over 4280 distinct # reference(s) read off the LIVE board — 531 open card(s)/PR(s) and 372 already-cached comment thread(s), so comment coverage is the gated subset rather than the whole board, and merged/closed archive is out of the corpus by design. 1212 number(s) were answered free from listings already in hand, and 2668 were NOT ATTEMPTED at the 400-resolution budget (newest-first; this pass reached down to #12185) — not attempted is not clean. 31 do(es) not resolve and 0 could not be judged — ⛔ only HTTP 404 is read as unresolvable, a CLOSED card resolves normally and is never a finding, and no cause is asserted for any of them. Suppressed content is invisible, so every count here is a LOWER BOUND. Report-only: findings are patrol input, not a gate verdict.

Findings

• H38 #6017 — pm:seat post is STALE — its lane domain:spec carries a Claim: on The most common action in any app — set a field on the current record — has no declarative form for a ROW action, while the BULK form is fully declarative #14092 written 0.1h AFTER this post's last event (claim 2026-09-03T19:34:16.000Z, post 2026-09-03T19:25:28.000Z). A shift dispatched work and did not record it, so every number the post states — 在飞 / 队列 / 决策箱 / the round number — describes a round that has since moved on, while updated_at makes the post read as SETTLED rather than as stale. ⚠️ This is the measured shape: one seat ran ~31h to wave 4 and dispatched five cards under a title still claiming the previous round. ⛔ Not an accusation of carelessness — the same post already carried this exact lesson in its own ledger, written one shift earlier, and the next shift reproduced it; that is the evidence prose does not hold here, not evidence about any seat. Remedy: refresh the seat post (or post a round marker) so the successor reading it sees the round that is actually running. Report-only: ⛔ this row never writes a label, a title or a marker.
• H38 #6021 — pm:seat post is STALE — its lane domain:services carries a Claim: on revert(plugin-sharing): drop the NULL-inclusive business-unit screen added by #14949 before 17.3 is cut; keep the strict member screen (ADR-0131 D8) #15030 written 6.7h AFTER this post's last event (claim 2026-09-03T19:24:24.000Z, post 2026-09-03T12:39:43.000Z). A shift dispatched work and did not record it, so every number the post states — 在飞 / 队列 / 决策箱 / the round number — describes a round that has since moved on, while updated_at makes the post read as SETTLED rather than as stale. ⚠️ This is the measured shape: one seat ran ~31h to wave 4 and dispatched five cards under a title still claiming the previous round. ⛔ Not an accusation of carelessness — the same post already carried this exact lesson in its own ledger, written one shift earlier, and the next shift reproduced it; that is the evidence prose does not hold here, not evidence about any seat. Remedy: refresh the seat post (or post a round marker) so the successor reading it sees the round that is actually running. Report-only: ⛔ this row never writes a label, a title or a marker.
• H38 #6023 — pm:seat post is STALE — its lane domain:devx carries a Claim: on 155 of 158 scripts/** self-tests have no assertion floor: a battery that never ran is indistinguishable from one that passed #13799 written 2.4h AFTER this post's last event (claim 2026-09-03T16:17:49.000Z, post 2026-09-03T13:53:42.000Z). A shift dispatched work and did not record it, so every number the post states — 在飞 / 队列 / 决策箱 / the round number — describes a round that has since moved on, while updated_at makes the post read as SETTLED rather than as stale. ⚠️ This is the measured shape: one seat ran ~31h to wave 4 and dispatched five cards under a title still claiming the previous round. ⛔ Not an accusation of carelessness — the same post already carried this exact lesson in its own ledger, written one shift earlier, and the next shift reproduced it; that is the evidence prose does not hold here, not evidence about any seat. Remedy: refresh the seat post (or post a round marker) so the successor reading it sees the round that is actually running. Report-only: ⛔ this row never writes a label, a title or a marker.
• H26 #11286 — pm:blocked on 1 target(s) that can never CLOSE: #7497 (pm:on-hold). The unlock predicate is "the Blocked-by: target closed", and pm:on-hold / needs-user-decision are by definition states a card sits in WHILE OPEN — so this block has NO MECHANISM THAT WILL EVER RELEASE IT. Every existing check passes on this card (the line is present, the target resolves, the target is open, the label is correct), which is why the measured instances were found by a human reading and by no gauge; H9 asks the mirror question about the HELD card and nothing asked about the WAITING one. ⚠️ Not a claim that the block is wrong — waiting on a deferred card is sometimes exactly right. It says the wait is indefinite BY CONSTRUCTION, so the release has to come from the target's own state changing (a ruling answered, a hold restarted) and someone has to want that.
• H19 #11331 — pm:blocked while 3 of 4 Blocked-by: target(s) — read from body OR comment — are CLOSED (#12400 (closed 2026-08-29T15:16:12Z), #12456 (closed 2026-08-26T03:58:22Z), #13464 (closed 2026-08-31T01:10:40Z)): the block has outlived its blocker. Nothing else here asks this question — H4 asks whether the line EXISTS, H14 asks the REVERSE index — so an expired block sits with a well-formed line, a correct label and no row anywhere: one measured card sat ~4.5h past its blocker's close and was found only by a human walking the graph, another was released only by a manual triage pass. 1 target(s) are still open (#13563), so this is a PARTIAL discharge and the card may still be legitimately blocked — the row reports it, it does not decide it. Report-only, and the release is NOT this script's to make: the state model gives it two mechanical double-checks (pm:blocked/pm:on-hold row, 「放行双查」) — ① release only against the condition carried by the MOST RECENT conversion comment, never an earlier blocker on the thread (a condition already spent, re-fired, reinstates an expired premise as the current one), and ② refuse to release when the card carries a MERGED PR newer than that conversion comment (the card moved on after the condition was written, so the cited fact can be true and no longer current). This row surfaces the candidate; the unlock sweep releases it — ⛔ never a label written from this script. When that release does happen, its paired write includes 「同笔摘 assignee」: a card returned to pm:queue still carrying the assignee of the seat that parked it is dispatchable to the queue view and taken to the claim rule at the same time (H24), which is the state the unlock scan was measured leaving behind — ⚠️ agent identity only, a HUMAN assignment is ⛔ never cleared by an agent.
• H26 #11331 — pm:blocked on 1 target(s) that can never CLOSE: #13563 (needs-user-decision). The unlock predicate is "the Blocked-by: target closed", and pm:on-hold / needs-user-decision are by definition states a card sits in WHILE OPEN — so this block has NO MECHANISM THAT WILL EVER RELEASE IT. Every existing check passes on this card (the line is present, the target resolves, the target is open, the label is correct), which is why the measured instances were found by a human reading and by no gauge; H9 asks the mirror question about the HELD card and nothing asked about the WAITING one. ⚠️ Not a claim that the block is wrong — waiting on a deferred card is sometimes exactly right. It says the wait is indefinite BY CONSTRUCTION, so the release has to come from the target's own state changing (a ruling answered, a hold restarted) and someone has to want that.
• H19 #11333 — pm:blocked while 2 of 4 Blocked-by: target(s) — read from body OR comment — are CLOSED (#12400 (closed 2026-08-29T15:16:12Z), #12456 (closed 2026-08-26T03:58:22Z)): the block has outlived its blocker. Nothing else here asks this question — H4 asks whether the line EXISTS, H14 asks the REVERSE index — so an expired block sits with a well-formed line, a correct label and no row anywhere: one measured card sat ~4.5h past its blocker's close and was found only by a human walking the graph, another was released only by a manual triage pass. 2 target(s) are still open (#13457, #13458), so this is a PARTIAL discharge and the card may still be legitimately blocked — the row reports it, it does not decide it. Report-only, and the release is NOT this script's to make: the state model gives it two mechanical double-checks (pm:blocked/pm:on-hold row, 「放行双查」) — ① release only against the condition carried by the MOST RECENT conversion comment, never an earlier blocker on the thread (a condition already spent, re-fired, reinstates an expired premise as the current one), and ② refuse to release when the card carries a MERGED PR newer than that conversion comment (the card moved on after the condition was written, so the cited fact can be true and no longer current). This row surfaces the candidate; the unlock sweep releases it — ⛔ never a label written from this script. When that release does happen, its paired write includes 「同笔摘 assignee」: a card returned to pm:queue still carrying the assignee of the seat that parked it is dispatchable to the queue view and taken to the claim rule at the same time (H24), which is the state the unlock scan was measured leaving behind — ⚠️ agent identity only, a HUMAN assignment is ⛔ never cleared by an agent.
• H26 #11333 — The wait is TRANSITIVE: #13457, #13458 are itself pm:blocked, so this card is waiting on a card that is waiting. A single-level predicate cannot see past one hop, and the measured chain was real one level up and FALSE two levels up (the target was an H19 finding on the same sweep — both of ITS blockers had closed). This row does not chase the chain; it says to look one level further.
• H4 #11809 — pm:blocked with a Blocked-by: line in NEITHER channel — not in the body, and not in any comment on the thread (both were read). Either channel discharges the duty: seats park the line in a comment on purpose, because rewriting a body through the MCP escaping hazard ([finding] GitHub MCP issue reads return HTML-escaped bodies, so any seat that appends a line by rewriting a card body may store ' literals into its code blocks #8813) is the riskier write. So this is not a formatting nit — no machine reader anywhere knows what this card is waiting for. The unlock sweep greps this literal line, so without it in SOME channel nothing can ever return this card to the queue — the block outlives its blocker in silence.
• H4 #11810 — pm:blocked with a Blocked-by: line in NEITHER channel — not in the body, and not in any comment on the thread (both were read). Either channel discharges the duty: seats park the line in a comment on purpose, because rewriting a body through the MCP escaping hazard ([finding] GitHub MCP issue reads return HTML-escaped bodies, so any seat that appends a line by rewriting a card body may store ' literals into its code blocks #8813) is the riskier write. So this is not a formatting nit — no machine reader anywhere knows what this card is waiting for. The unlock sweep greps this literal line, so without it in SOME channel nothing can ever return this card to the queue — the block outlives its blocker in silence.
• H19 #11925 — pm:blocked while 2 of 4 Blocked-by: target(s) — read from body OR comment — are CLOSED (#12037 (closed 2026-08-26T01:52:11Z), #12038 (closed 2026-08-28T05:57:39Z)): the block has outlived its blocker. Nothing else here asks this question — H4 asks whether the line EXISTS, H14 asks the REVERSE index — so an expired block sits with a well-formed line, a correct label and no row anywhere: one measured card sat ~4.5h past its blocker's close and was found only by a human walking the graph, another was released only by a manual triage pass. 2 target(s) are still open (#12034, #12036), so this is a PARTIAL discharge and the card may still be legitimately blocked — the row reports it, it does not decide it. Report-only, and the release is NOT this script's to make: the state model gives it two mechanical double-checks (pm:blocked/pm:on-hold row, 「放行双查」) — ① release only against the condition carried by the MOST RECENT conversion comment, never an earlier blocker on the thread (a condition already spent, re-fired, reinstates an expired premise as the current one), and ② refuse to release when the card carries a MERGED PR newer than that conversion comment (the card moved on after the condition was written, so the cited fact can be true and no longer current). This row surfaces the candidate; the unlock sweep releases it — ⛔ never a label written from this script. When that release does happen, its paired write includes 「同笔摘 assignee」: a card returned to pm:queue still carrying the assignee of the seat that parked it is dispatchable to the queue view and taken to the claim rule at the same time (H24), which is the state the unlock scan was measured leaving behind — ⚠️ agent identity only, a HUMAN assignment is ⛔ never cleared by an agent.
• H26 #11925 — The wait is TRANSITIVE: #12036 is itself pm:blocked, so this card is waiting on a card that is waiting. A single-level predicate cannot see past one hop, and the measured chain was real one level up and FALSE two levels up (the target was an H19 finding on the same sweep — both of ITS blockers had closed). This row does not chase the chain; it says to look one level further.
• H26 #11975 — pm:blocked on 1 target(s) that can never CLOSE: #13515 (pm:on-hold). The unlock predicate is "the Blocked-by: target closed", and pm:on-hold / needs-user-decision are by definition states a card sits in WHILE OPEN — so this block has NO MECHANISM THAT WILL EVER RELEASE IT. Every existing check passes on this card (the line is present, the target resolves, the target is open, the label is correct), which is why the measured instances were found by a human reading and by no gauge; H9 asks the mirror question about the HELD card and nothing asked about the WAITING one. ⚠️ Not a claim that the block is wrong — waiting on a deferred card is sometimes exactly right. It says the wait is indefinite BY CONSTRUCTION, so the release has to come from the target's own state changing (a ruling answered, a hold restarted) and someone has to want that.
• H26 #11978 — The wait is TRANSITIVE: #11975 is itself pm:blocked, so this card is waiting on a card that is waiting. A single-level predicate cannot see past one hop, and the measured chain was real one level up and FALSE two levels up (the target was an H19 finding on the same sweep — both of ITS blockers had closed). This row does not chase the chain; it says to look one level further.
• H26 #11979 — The wait is TRANSITIVE: #11978 is itself pm:blocked, so this card is waiting on a card that is waiting. A single-level predicate cannot see past one hop, and the measured chain was real one level up and FALSE two levels up (the target was an H19 finding on the same sweep — both of ITS blockers had closed). This row does not chase the chain; it says to look one level further.
• H19 #12036 — pm:blocked while 1 of 1 Blocked-by: target(s) — read from body OR comment — is CLOSED (#12412 (closed 2026-09-03T04:52:57Z)): the block has outlived its blocker. Nothing else here asks this question — H4 asks whether the line EXISTS, H14 asks the REVERSE index — so an expired block sits with a well-formed line, a correct label and no row anywhere: one measured card sat ~4.5h past its blocker's close and was found only by a human walking the graph, another was released only by a manual triage pass. Every target it names is closed: nothing this card declared a wait on is still running. Report-only, and the release is NOT this script's to make: the state model gives it two mechanical double-checks (pm:blocked/pm:on-hold row, 「放行双查」) — ① release only against the condition carried by the MOST RECENT conversion comment, never an earlier blocker on the thread (a condition already spent, re-fired, reinstates an expired premise as the current one), and ② refuse to release when the card carries a MERGED PR newer than that conversion comment (the card moved on after the condition was written, so the cited fact can be true and no longer current). This row surfaces the candidate; the unlock sweep releases it — ⛔ never a label written from this script. When that release does happen, its paired write includes 「同笔摘 assignee」: a card returned to pm:queue still carrying the assignee of the seat that parked it is dispatchable to the queue view and taken to the claim rule at the same time (H24), which is the state the unlock scan was measured leaving behind — ⚠️ agent identity only, a HUMAN assignment is ⛔ never cleared by an agent.
• H19 #12211 — pm:blocked while 1 of 1 Blocked-by: target(s) — read from body OR comment — is CLOSED (#12343 (closed 2026-09-02T14:19:35Z)): the block has outlived its blocker. Nothing else here asks this question — H4 asks whether the line EXISTS, H14 asks the REVERSE index — so an expired block sits with a well-formed line, a correct label and no row anywhere: one measured card sat ~4.5h past its blocker's close and was found only by a human walking the graph, another was released only by a manual triage pass. Every target it names is closed: nothing this card declared a wait on is still running. Report-only, and the release is NOT this script's to make: the state model gives it two mechanical double-checks (pm:blocked/pm:on-hold row, 「放行双查」) — ① release only against the condition carried by the MOST RECENT conversion comment, never an earlier blocker on the thread (a condition already spent, re-fired, reinstates an expired premise as the current one), and ② refuse to release when the card carries a MERGED PR newer than that conversion comment (the card moved on after the condition was written, so the cited fact can be true and no longer current). This row surfaces the candidate; the unlock sweep releases it — ⛔ never a label written from this script. When that release does happen, its paired write includes 「同笔摘 assignee」: a card returned to pm:queue still carrying the assignee of the seat that parked it is dispatchable to the queue view and taken to the claim rule at the same time (H24), which is the state the unlock scan was measured leaving behind — ⚠️ agent identity only, a HUMAN assignment is ⛔ never cleared by an agent.
• H26 #12753 — pm:blocked on 1 target(s) that can never CLOSE: #8901 (pm:on-hold). The unlock predicate is "the Blocked-by: target closed", and pm:on-hold / needs-user-decision are by definition states a card sits in WHILE OPEN — so this block has NO MECHANISM THAT WILL EVER RELEASE IT. Every existing check passes on this card (the line is present, the target resolves, the target is open, the label is correct), which is why the measured instances were found by a human reading and by no gauge; H9 asks the mirror question about the HELD card and nothing asked about the WAITING one. ⚠️ Not a claim that the block is wrong — waiting on a deferred card is sometimes exactly right. It says the wait is indefinite BY CONSTRUCTION, so the release has to come from the target's own state changing (a ruling answered, a hold restarted) and someone has to want that.
• H19 #13366 — pm:blocked while 2 of 2 Blocked-by: target(s) — read from body OR comment — are CLOSED (#14222 (closed 2026-09-03T05:34:30Z), #14225 (closed 2026-09-03T04:54:28Z)): the block has outlived its blocker. Nothing else here asks this question — H4 asks whether the line EXISTS, H14 asks the REVERSE index — so an expired block sits with a well-formed line, a correct label and no row anywhere: one measured card sat ~4.5h past its blocker's close and was found only by a human walking the graph, another was released only by a manual triage pass. Every target it names is closed: nothing this card declared a wait on is still running. Report-only, and the release is NOT this script's to make: the state model gives it two mechanical double-checks (pm:blocked/pm:on-hold row, 「放行双查」) — ① release only against the condition carried by the MOST RECENT conversion comment, never an earlier blocker on the thread (a condition already spent, re-fired, reinstates an expired premise as the current one), and ② refuse to release when the card carries a MERGED PR newer than that conversion comment (the card moved on after the condition was written, so the cited fact can be true and no longer current). This row surfaces the candidate; the unlock sweep releases it — ⛔ never a label written from this script. When that release does happen, its paired write includes 「同笔摘 assignee」: a card returned to pm:queue still carrying the assignee of the seat that parked it is dispatchable to the queue view and taken to the claim rule at the same time (H24), which is the state the unlock scan was measured leaving behind — ⚠️ agent identity only, a HUMAN assignment is ⛔ never cleared by an agent.
• H26 #13457 — The wait is TRANSITIVE: #14034 is itself pm:blocked, so this card is waiting on a card that is waiting. A single-level predicate cannot see past one hop, and the measured chain was real one level up and FALSE two levels up (the target was an H19 finding on the same sweep — both of ITS blockers had closed). This row does not chase the chain; it says to look one level further.
• H26 #13458 — The wait is TRANSITIVE: #13457 is itself pm:blocked, so this card is waiting on a card that is waiting. A single-level predicate cannot see past one hop, and the measured chain was real one level up and FALSE two levels up (the target was an H19 finding on the same sweep — both of ITS blockers had closed). This row does not chase the chain; it says to look one level further.
• H19 #13566 — pm:blocked while 1 of 2 Blocked-by: target(s) — read from body OR comment — is CLOSED (#14291 (closed 2026-09-02T17:21:31Z)): the block has outlived its blocker. Nothing else here asks this question — H4 asks whether the line EXISTS, H14 asks the REVERSE index — so an expired block sits with a well-formed line, a correct label and no row anywhere: one measured card sat ~4.5h past its blocker's close and was found only by a human walking the graph, another was released only by a manual triage pass. 1 target(s) are still open (#14970), so this is a PARTIAL discharge and the card may still be legitimately blocked — the row reports it, it does not decide it. Report-only, and the release is NOT this script's to make: the state model gives it two mechanical double-checks (pm:blocked/pm:on-hold row, 「放行双查」) — ① release only against the condition carried by the MOST RECENT conversion comment, never an earlier blocker on the thread (a condition already spent, re-fired, reinstates an expired premise as the current one), and ② refuse to release when the card carries a MERGED PR newer than that conversion comment (the card moved on after the condition was written, so the cited fact can be true and no longer current). This row surfaces the candidate; the unlock sweep releases it — ⛔ never a label written from this script. When that release does happen, its paired write includes 「同笔摘 assignee」: a card returned to pm:queue still carrying the assignee of the seat that parked it is dispatchable to the queue view and taken to the claim rule at the same time (H24), which is the state the unlock scan was measured leaving behind — ⚠️ agent identity only, a HUMAN assignment is ⛔ never cleared by an agent.
• H33 #13609 — pm:dispatched whose latest Claim: comment (2026-09-02T05:29:18Z) PREDATES 2 triage-ruling comment(s) on this same card, the newest posted 2026-09-03T15:54:10Z — so the order this card is in flight under was written before the ruling that now stands on its thread, and cannot be carrying that ruling's constraints. ⚠️ The row asserts an ORDERING, not a state of mind: whether the dispatcher wrote blind to a ruling already there or was overtaken by one posted after is not observable and does not change the remedy. The measured cost of the first reading: a dispatch order INVERTED a standing ruling — the ruling scoped the work to option 1 executed as a sweep and said 「file, don't fold in」 about options 2/3, and the order forbade the sweep and pointed the dev at 2/3. The dev followed the later ruling and reported the conflict, seeing one of three contradictions. Remedy: re-read the ruling against the dispatch order NOW, while the work is still in flight and the correction is a message rather than a rollback — and if they disagree, say so on the card so the dev is not left arbitrating between two orders. ⛔ This is not a new rule: the re-read step exists, and the same session it failed on had already been saved by it twice that day. Report-only: ⛔ never a label written from this script.
• H20 #13609 — pm:dispatched with a complete claim comment naming claude/issue-13609-delete-fanout-reverification, claude/issue-13609-meta-datasource-stale-entry — and NO SUCH REMOTE REF EXISTS, ~2294 min after the claim was posted (threshold 60 min). Claiming and dispatching are two acts with a gap between them: the claim is an atom (assign + label swap in one write, the claim comment, a race re-read) and LAUNCHING the dev is a third act outside it, so a seat interrupted between the two leaves exactly this card — every field correct, every gauge reading "in progress", nobody working it. It is invisible from the card itself: only the absence of something elsewhere is wrong. The measured specimen sat 74 min before a patrol tick compared branch heads. ⚠️ This symptom is IDENTICAL to a dev agent that died (no branch, no PR, no report) and the remedies are OPPOSITE — a dead agent needs a probe, an undispatched claim needs a dispatch — so read the claiming seat's own action sequence before assuming either. ⛔ This row keys on NO REF AT ALL, never on "no PR yet": a dev inside a long build legitimately has a ref and no PR for over an hour. One reading to rule out first: if this card's delivery already MERGED, the branch is gone by design and the missing paired write is H8's, not this one. Report-only: the remedy is a DISPATCH or a withdrawn claim, ⛔ never a label written from this script — the same posture H14 holds for pm:blocking and H19 for a released block.
• H19 #13681 — pm:blocked while 1 of 2 Blocked-by: target(s) — read from body OR comment — is CLOSED (#14394 (closed 2026-09-02T18:39:19Z)): the block has outlived its blocker. Nothing else here asks this question — H4 asks whether the line EXISTS, H14 asks the REVERSE index — so an expired block sits with a well-formed line, a correct label and no row anywhere: one measured card sat ~4.5h past its blocker's close and was found only by a human walking the graph, another was released only by a manual triage pass. 1 target(s) are still open (#14456), so this is a PARTIAL discharge and the card may still be legitimately blocked — the row reports it, it does not decide it. Report-only, and the release is NOT this script's to make: the state model gives it two mechanical double-checks (pm:blocked/pm:on-hold row, 「放行双查」) — ① release only against the condition carried by the MOST RECENT conversion comment, never an earlier blocker on the thread (a condition already spent, re-fired, reinstates an expired premise as the current one), and ② refuse to release when the card carries a MERGED PR newer than that conversion comment (the card moved on after the condition was written, so the cited fact can be true and no longer current). This row surfaces the candidate; the unlock sweep releases it — ⛔ never a label written from this script. When that release does happen, its paired write includes 「同笔摘 assignee」: a card returned to pm:queue still carrying the assignee of the seat that parked it is dispatchable to the queue view and taken to the claim rule at the same time (H24), which is the state the unlock scan was measured leaving behind — ⚠️ agent identity only, a HUMAN assignment is ⛔ never cleared by an agent.
• H20 #13799 — pm:dispatched with a complete claim comment naming claude/issue-13799-batch2-roster-floor — and NO SUCH REMOTE REF EXISTS, ~206 min after the claim was posted (threshold 60 min). Claiming and dispatching are two acts with a gap between them: the claim is an atom (assign + label swap in one write, the claim comment, a race re-read) and LAUNCHING the dev is a third act outside it, so a seat interrupted between the two leaves exactly this card — every field correct, every gauge reading "in progress", nobody working it. It is invisible from the card itself: only the absence of something elsewhere is wrong. The measured specimen sat 74 min before a patrol tick compared branch heads. ⚠️ This symptom is IDENTICAL to a dev agent that died (no branch, no PR, no report) and the remedies are OPPOSITE — a dead agent needs a probe, an undispatched claim needs a dispatch — so read the claiming seat's own action sequence before assuming either. ⛔ This row keys on NO REF AT ALL, never on "no PR yet": a dev inside a long build legitimately has a ref and no PR for over an hour. One reading to rule out first: if this card's delivery already MERGED, the branch is gone by design and the missing paired write is H8's, not this one. Report-only: the remedy is a DISPATCH or a withdrawn claim, ⛔ never a label written from this script — the same posture H14 holds for pm:blocking and H19 for a released block.
• H26 #13807 — The wait is TRANSITIVE: #13909 is itself pm:blocked, so this card is waiting on a card that is waiting. A single-level predicate cannot see past one hop, and the measured chain was real one level up and FALSE two levels up (the target was an H19 finding on the same sweep — both of ITS blockers had closed). This row does not chase the chain; it says to look one level further.
• H33 #13906 — pm:dispatched whose latest Claim: comment (2026-09-01T18:30:27Z) PREDATES 1 triage-ruling comment(s) on this same card, the newest posted 2026-09-02T05:23:59Z — so the order this card is in flight under was written before the ruling that now stands on its thread, and cannot be carrying that ruling's constraints. ⚠️ The row asserts an ORDERING, not a state of mind: whether the dispatcher wrote blind to a ruling already there or was overtaken by one posted after is not observable and does not change the remedy. The measured cost of the first reading: a dispatch order INVERTED a standing ruling — the ruling scoped the work to option 1 executed as a sweep and said 「file, don't fold in」 about options 2/3, and the order forbade the sweep and pointed the dev at 2/3. The dev followed the later ruling and reported the conflict, seeing one of three contradictions. Remedy: re-read the ruling against the dispatch order NOW, while the work is still in flight and the correction is a message rather than a rollback — and if they disagree, say so on the card so the dev is not left arbitrating between two orders. ⛔ This is not a new rule: the re-read step exists, and the same session it failed on had already been saved by it twice that day. Report-only: ⛔ never a label written from this script.
• H20 #13906 — pm:dispatched with a complete claim comment naming claude/issue-13906-execctx-authz-seams — and NO SUCH REMOTE REF EXISTS, ~2953 min after the claim was posted (threshold 60 min). Claiming and dispatching are two acts with a gap between them: the claim is an atom (assign + label swap in one write, the claim comment, a race re-read) and LAUNCHING the dev is a third act outside it, so a seat interrupted between the two leaves exactly this card — every field correct, every gauge reading "in progress", nobody working it. It is invisible from the card itself: only the absence of something elsewhere is wrong. The measured specimen sat 74 min before a patrol tick compared branch heads. ⚠️ This symptom is IDENTICAL to a dev agent that died (no branch, no PR, no report) and the remedies are OPPOSITE — a dead agent needs a probe, an undispatched claim needs a dispatch — so read the claiming seat's own action sequence before assuming either. ⛔ This row keys on NO REF AT ALL, never on "no PR yet": a dev inside a long build legitimately has a ref and no PR for over an hour. One reading to rule out first: if this card's delivery already MERGED, the branch is gone by design and the missing paired write is H8's, not this one. Report-only: the remedy is a DISPATCH or a withdrawn claim, ⛔ never a label written from this script — the same posture H14 holds for pm:blocking and H19 for a released block.
• H26 #13909 — pm:blocked on 1 target(s) that can never CLOSE: #13937 (needs-user-decision). The unlock predicate is "the Blocked-by: target closed", and pm:on-hold / needs-user-decision are by definition states a card sits in WHILE OPEN — so this block has NO MECHANISM THAT WILL EVER RELEASE IT. Every existing check passes on this card (the line is present, the target resolves, the target is open, the label is correct), which is why the measured instances were found by a human reading and by no gauge; H9 asks the mirror question about the HELD card and nothing asked about the WAITING one. ⚠️ Not a claim that the block is wrong — waiting on a deferred card is sometimes exactly right. It says the wait is indefinite BY CONSTRUCTION, so the release has to come from the target's own state changing (a ruling answered, a hold restarted) and someone has to want that.
• H19 #14034 — pm:blocked while 1 of 1 Blocked-by: target(s) — read from body OR comment — is CLOSED (#14865 (closed 2026-09-03T17:59:30Z)): the block has outlived its blocker. Nothing else here asks this question — H4 asks whether the line EXISTS, H14 asks the REVERSE index — so an expired block sits with a well-formed line, a correct label and no row anywhere: one measured card sat ~4.5h past its blocker's close and was found only by a human walking the graph, another was released only by a manual triage pass. Every target it names is closed: nothing this card declared a wait on is still running. Report-only, and the release is NOT this script's to make: the state model gives it two mechanical double-checks (pm:blocked/pm:on-hold row, 「放行双查」) — ① release only against the condition carried by the MOST RECENT conversion comment, never an earlier blocker on the thread (a condition already spent, re-fired, reinstates an expired premise as the current one), and ② refuse to release when the card carries a MERGED PR newer than that conversion comment (the card moved on after the condition was written, so the cited fact can be true and no longer current). This row surfaces the candidate; the unlock sweep releases it — ⛔ never a label written from this script. When that release does happen, its paired write includes 「同笔摘 assignee」: a card returned to pm:queue still carrying the assignee of the seat that parked it is dispatchable to the queue view and taken to the claim rule at the same time (H24), which is the state the unlock scan was measured leaving behind — ⚠️ agent identity only, a HUMAN assignment is ⛔ never cleared by an agent.
• H26 #14133 — pm:blocked on 1 target(s) that can never CLOSE: #15013 (needs-user-decision). The unlock predicate is "the Blocked-by: target closed", and pm:on-hold / needs-user-decision are by definition states a card sits in WHILE OPEN — so this block has NO MECHANISM THAT WILL EVER RELEASE IT. Every existing check passes on this card (the line is present, the target resolves, the target is open, the label is correct), which is why the measured instances were found by a human reading and by no gauge; H9 asks the mirror question about the HELD card and nothing asked about the WAITING one. ⚠️ Not a claim that the block is wrong — waiting on a deferred card is sometimes exactly right. It says the wait is indefinite BY CONSTRUCTION, so the release has to come from the target's own state changing (a ruling answered, a hold restarted) and someone has to want that.
• H26 #14314 — The wait is TRANSITIVE: #14313 is itself pm:blocked, so this card is waiting on a card that is waiting. A single-level predicate cannot see past one hop, and the measured chain was real one level up and FALSE two levels up (the target was an H19 finding on the same sweep — both of ITS blockers had closed). This row does not chase the chain; it says to look one level further.
• H26 #14343 — The wait is TRANSITIVE: #14791 is itself pm:blocked, so this card is waiting on a card that is waiting. A single-level predicate cannot see past one hop, and the measured chain was real one level up and FALSE two levels up (the target was an H19 finding on the same sweep — both of ITS blockers had closed). This row does not chase the chain; it says to look one level further.
• H19 #14372 — pm:blocked while 1 of 1 Blocked-by: target(s) — read from body OR comment — is CLOSED (#14318 (closed 2026-09-02T10:04:42Z)): the block has outlived its blocker. Nothing else here asks this question — H4 asks whether the line EXISTS, H14 asks the REVERSE index — so an expired block sits with a well-formed line, a correct label and no row anywhere: one measured card sat ~4.5h past its blocker's close and was found only by a human walking the graph, another was released only by a manual triage pass. Every target it names is closed: nothing this card declared a wait on is still running. Report-only, and the release is NOT this script's to make: the state model gives it two mechanical double-checks (pm:blocked/pm:on-hold row, 「放行双查」) — ① release only against the condition carried by the MOST RECENT conversion comment, never an earlier blocker on the thread (a condition already spent, re-fired, reinstates an expired premise as the current one), and ② refuse to release when the card carries a MERGED PR newer than that conversion comment (the card moved on after the condition was written, so the cited fact can be true and no longer current). This row surfaces the candidate; the unlock sweep releases it — ⛔ never a label written from this script. When that release does happen, its paired write includes 「同笔摘 assignee」: a card returned to pm:queue still carrying the assignee of the seat that parked it is dispatchable to the queue view and taken to the claim rule at the same time (H24), which is the state the unlock scan was measured leaving behind — ⚠️ agent identity only, a HUMAN assignment is ⛔ never cleared by an agent.
• … 157 further row(s) omitted to fit GitHub's issue-body limit; the full list is in the workflow run log.

Family ledger — computed vs rendered, every row family (#13947)

What each row family COMPUTED this sweep, and how much of it reached the list above. rendered below computed means the body's size trim ate the difference; the full list is in the workflow run log. This table is RESERVED out of the render budget BEFORE the finding rows are laid out — the same reservation the H17 index, the H39 census and the H40 section hold — so the trim can never be what removes it. Rows above are ordered by the same band shown here (HALF_STATE_FAMILY_BAND), highest band first, so a row survives the trim on what it IS rather than on how many unrelated rows were laid out before it.

⚠️ 17 family(ies) had rows omitted by the body trim: H12 (0/1), H19 (10/17), H26 (15/23), H36 (0/12), H2 (0/21), H8 (0/6), H9 (0/12), H10 (0/1), H13 (0/4), H18 (0/12), H24 (0/9), H30 (0/15), +5 more in the table.

family	band	computed	rendered
H4	stall	2	2
H12	stall	1	0
H19	stall	17	10
H20	stall	3	3
H26	stall	23	15
H33	stall	2	2
H36	stall	12	0
H38	stall	3	3
H2	state	21	0
H8	state	6	0
H9	state	12	0
H10	state	1	0
H13	state	4	0
H18	state	12	0
H24	state	9	0
H30	state	15	0
H5	inventory	7	0
H6	inventory	11	0
H11	inventory	8	0
H14	inventory	22	0
H15	inventory	1	0

Computed 0 row(s) this sweep, and therefore absent from the table (15): H1, H3, H7, H16, H21, H23, H25, H27, H28, H29, H31, H32, H34, H35, H37. These families were EVALUATED and found nothing — they have no rows to omit. Every family that computed a row is IN the table with its count, whether or not the trim left any of that row family in the body above, so a family missing from the list of findings is never ambiguous between the two readings.

Dangling references (H40)

31 number(s) referred to by the live board do NOT resolve, and 0 could not be judged. ⛔ Report-only, and ⛔ no cause is asserted: a number can fail to resolve because it was deleted, transferred, or made unreachable, and this sweep cannot tell those apart — a reference that fails is a fact, everything after it is a question for a human. ⛔ Do not rewrite the referring text and do not close anything; if a number returns, the reference was always correct. 400 resolution(s) attempted of 4280 distinct # reference(s) read off 2271 live-board text(s) (531 open card(s)/PR(s) + 372 already-cached comment thread(s)); 1212 answered free from listings in hand, 2668 NOT ATTEMPTED at the 400-resolution budget (attempted down to #12185).

• A pnpm check: harvest of dispatch-gates.mjs output silently drops a third of the gate list #13462 — HTTP 404, does not resolve; referred to by #9857
• fix(scripts): resolve bare-identifier callees by lexical scope in the durability swallow census — batch 4 of the #12981 worklist #13459 — HTTP 404, does not resolve; referred to by #9857
• [finding] the durability swallow census still resolves a bare identifier to a same-named CLASS METHOD — 15 name-only resolutions on main, 0 members affected today #13456 — HTTP 404, does not resolve; referred to by #9857
• [finding] The READ-side sibling of the #12981 swallow family: a swallowed read makes a sweep select zero rows and report success — cleanup-package-permissions.ts asserts "no ghost grants" from a read that never answered #13422 — HTTP 404, does not resolve; referred to by #6021, #9857
• [Decision] Something un-parked BOTH of this lane's clause-② PRs within 80 seconds — drafts flipped ready and needs:contract-review stripped, with no review on either #13412 — HTTP 404, does not resolve; referred to by #9857, #13417, #13597
• [finding] The clause-② label protocol says needs:contract-review attaches to the CARD, but contract-review seats scan PRs — 2 measured instances of a parked PR that was invisible instead #13410 — HTTP 404, does not resolve; referred to by #9857, #13417
• feat(plugin-security): extend the packaged-permission-set lock to the restore leg of the write-through #13409 — HTTP 404, does not resolve; referred to by #9857, #13417
• [finding] The os-dev brief's dependency-closure recipe uses a pnpm selector that reads PEER edges — so any optional-peer declaration can make it select a cyclic superset and fail #13402 — HTTP 404, does not resolve; referred to by #6367, #9857
• [Decision] isMissingTableError is a cross-package contract whose home no plugin can reach — two plugin-auth audit writes stay silently dark because of it #13399 — HTTP 404, does not resolve; referred to by #6021, #6367, #9857, #12981
• [Decision] plugin-sharing's refused-backfill report lands at warn where AGENTS.md puts it at error — and the card that was supposed to carry the level is CLOSED #13398 — HTTP 404, does not resolve; referred to by #6021, #9857, #12981
• feat(service-automation): definition-level input-schema refusal is non-retryable (FLOW_INPUT_SCHEMA_INVALID) #13371 — HTTP 404, does not resolve; referred to by #9857, #13417
• [finding] dispatch-gates --residue prints THREE fabricated leads for check:query-options-erasure — literals naming files that have never existed, unannotated because one live sibling keeps the family reachable #13312 — HTTP 404, does not resolve; referred to by #9857, #13326
• fix(build): give each exports condition its own types target in 27 dual-build packages #13299 — HTTP 404, does not resolve; referred to by #9857
• [finding] The ablation restore leg is provable only by a WHOLE-TREE status — an agent that reasons about it without running the preflight has no rule telling it so #13293 — HTTP 404, does not resolve; referred to by #9857, #13257, #13326
• fix(scripts): doc-authoring Rule 3 reaches a GENERATED guidance table #13283 — HTTP 404, does not resolve; referred to by #9857
• [finding] H9 judges the PRESENCE of a Restart-when: line, never the REACHABILITY of the target it names — a hold pointing at an issue that cannot fire passes forever (refused twice over; maintainer call) #13278 — HTTP 404, does not resolve; referred to by #9857, #13597
• [finding] the #5499 investment freeze was LIFTED on 2026-08-11 (both drivers) — the tree still asserts it as live, and in several places that assertion is the stated reason a divergence stays open #13277 — HTTP 404, does not resolve; referred to by #9857
• [finding] Widening check:comment-mask-adoption to scripts/** costs 11 unmeasured rows and still misses every live scanner there #13274 — HTTP 404, does not resolve; referred to by #9857
• [finding] resolveExecCtx 的 .catch(() => undefined) 把执行上下文解析失败静默降级为「无上下文」— 该行为在包管理门上可达什么错误状态,未测 #13255 — HTTP 404, does not resolve; referred to by #9857, #13906, #15020
• [finding] measure-stall-guard-headroom's --self-test is wired into no check:* family, so its 32 assertions never run in CI #13246 — HTTP 404, does not resolve; referred to by #9857
• Widen codehelper to the object-literal stamp position — the blast radius is now measured, and 4 undischargeable unresolved findings are the blocker #13233 — HTTP 404, does not resolve; referred to by #9857
• [finding] dispatch-gates' CONVENTION_GATES docblock states a measured hint set for check:where-matcher that PR #13231 makes false — and the sentence built on it ("all three score silent") #13232 — HTTP 404, does not resolve; referred to by #9857, #13326
• [finding] The "one module-body constant" claim about check-dispatch-gates.mjs is stale in four places — the gate carries three, and its own header still says it derives "for nothing else" #13230 — HTTP 404, does not resolve; referred to by #9857
• tenant-audit: the "write without tenantId" signal is a throttled log warn gated on multi-tenant posture, so it cannot fire in any environment where code is exercised #13178 — HTTP 404, does not resolve; referred to by #6367, #9857, #13564, #13636
• [finding] check-doc-authoring.mjs --self-test exits 0 while registering ZERO cases — and prints its full success line asserting they all hold #13173 — HTTP 404, does not resolve; referred to by #9857
• … 6 further number(s) omitted at the H40_ROW_CAP render budget; the full list is in the workflow run log.

On-hold trigger-file index (H17)

Before dispatching, intersect your dispatch's file surface against this list and NAME any card it hits in the dispatch brief. These are the trigger files open holds declare — the opportunistic-restart mechanism (maintainer-accepted 2026-08-11) whose intersection was measured at 0-for-19 while it lived only as a remembered protocol step (#10034). Report-only: a card here is a hold in good standing, never a finding. Extraction is deterministic — every path shown is a tracked file; anything unverifiable was dropped rather than guessed, so this list under-reports and never invents. (read on 104 of 104 open pm:on-hold card(s); 8202 tracked file(s) in the oracle.)

• #2657 — packages/spec/src/automation/webhook.zod.ts, packages/spec/src/integration/connector.zod.ts, packages/spec/src/kernel/metadata-plugin.zod.ts, packages/spec/src/kernel/metadata-type-schemas.ts, packages/spec/src/security/sharing.zod.ts
• #6009 — packages/drivers/driver-sql/src/sql-driver.ts
• #6736 — packages/plugins/plugin-sharing/src/sharing-service.ts
• #7401 — packages/plugins/plugin-security/src/security-plugin.ts
• #7898 — packages/core/src/security/auth-gate.ts, packages/runtime/src/http-dispatcher.ts
• #8345 — packages/services/service-analytics/src/analytics-service.ts, packages/spec/src/data/currency-fraction-digits.ts, packages/spec/src/data/field.zod.ts
• #8346 — docs/PLATFORM_GAPS_FROM_TEMPLATES.md, packages/spec/src/ui/view.zod.ts
• #8347 — packages/client/src/realtime-api.ts, packages/runtime/src/http-dispatcher.ts
• #8740 — packages/drivers/driver-sql/src/sql-driver.ts
• #8897 — scripts/check-durability-degradation-log-level.mjs
• #8901 — scripts/check-durability-degradation-log-level.mjs
• #8966 — content/docs/deployment/meta.json, content/docs/meta.json
• #9139 — packages/lint/src/data-model-rules.ts, packages/lint/src/validate-security-posture.test.ts
• #10315 — scripts/check-cross-package-test-inputs.mjs
• #10572 — examples/app-todo/package.json
• #10694 — scripts/check-cross-package-test-inputs.mjs
• #12132 — packages/drivers/driver-sql/src/schema-drift.ts, packages/drivers/driver-sql/src/sql-driver.ts
• #12148 — scripts/docs-audit/affected-docs.mjs, scripts/docs-audit/check-drift-comment.mjs
• #12337 — scripts/pm/os-verify-lock.sh
• #12576 — scripts/durability-read-invention.baseline.json
• #12789 — packages/objectql/src/registry.ts
• #12797 — scripts/pm/dispatch-gates.mjs
• #12799 — scripts/check-type-check-coverage.mjs
• #12808 — scripts/check-cross-package-test-inputs.mjs, scripts/pm/dispatch-gates.mjs
• #13419 — packages/metadata/src/__fixtures__/hotcrm-17.1-built-permissions.artifact.json, packages/plugins/plugin-security/src/security-plugin.ts
• #13528 — packages/services/service-storage/src/metadata-store.ts, packages/services/service-storage/src/storage-routes.ts
• #13542 — packages/plugins/plugin-security/src/security-plugin.ts
• #14121 — packages/metadata/src/loaders/database-loader.ts
• #14169 — packages/drivers/driver-mongodb/src/mongodb-driver.ts
• #14290 — scripts/objectui-changeset-digest.mjs

Closed-card pm:* residue (H39 census, informational): pm:dispatched 2109, pm:queue 855, pm:blocking 41, pm:blocked 21, pm:on-hold 14, pm:awaiting-maintainer 1, oldest closed 2026-08-02; 555 carrying both pm:queue and pm:dispatched. H22's 3-day closure window, read separately, holds 58 of 506 closed card(s) still carrying residue (pm:dispatched 39, pm:blocking 13, pm:queue 5, pm:blocked 2, pm:on-hold 1). Archive, not state — no cleanup is owed and none is planned (ruled 2026-08-31, 批 #13); readers scope pm:* queries to open cards, and that reason reaches a residue two hours old exactly as it reaches one from August, which is why the window above is counted here rather than filed as rows (#14072).

rate premise OK — observed ~120.1/day against pinned MEASURED_MERGES_PER_DAY = 137.5/day, measured 2026-08-23 (12d ago) (factor 0.87, band 2x).