task-pipeline-skill 1.33.0 → 1.38.0

package/plugins/task-pipeline/skills/task-pipeline/references/continuity.md

@@ -140,6 +140,16 @@ whole cycle that no gate reads. It cites the measurement or it is not written
 `B-NNN`, not a description**: *"next up: B-014"* can be checked against the file,
 *"next up: the export fix"* cannot.
 
+**And it is printed, in one fixed shape** ([`progress.md`](progress.md)):
+
+```
+▶ <topic> · <module> (N/M) · <id> <stage> <gate> · iter <N> · gates <N/M> · next B-NNN
+```
+
+The iteration number is a count of `iter:` lines in `.task-pipeline/run.md`, not a
+number the agent is carrying. After a compaction the agent's count is gone and the
+file's is not — which is the argument the build ledger already won one stage down.
+
 ## Parked at a manual gate
 
 A fixed interval firing into a `manual` gate is a nag. Five minutes later it fires

package/plugins/task-pipeline/skills/task-pipeline/references/exposure.md

@@ -37,9 +37,16 @@ defect. Until then it is named honestly.
 ## The components, each named
 
 ```
-exposure: 99 unverified · never checked · 31 releases since the last human confirmation
+exposure: N unverified · never checked · N releases carry one
 ```
 
+**The example carries no numbers, deliberately.** It said `99 unverified` and
+`31 releases since the last human confirmation` until 2026-08-10 — one figure lifted
+from this repository's live count, which drifts, and one wording the code has never
+printed. A worked example that disagrees with its own output teaches the wrong format
+to every reader who trusts the doctrine over the terminal, and this one disagreed in
+both directions at once.
+
 - **unverified** — rows whose `Human` reads `never`.
 - **since** — days since the newest `Human` date. When **no** row has ever been
   confirmed, this prints the literal **`never checked`**, not `0 days`: zero would read

package/plugins/task-pipeline/skills/task-pipeline/references/gates.md

@@ -272,6 +272,24 @@ one flipped a row whose cell was already empty, so nothing was planted. A silent
 check is a claim about two things, and the probe is the one to doubt first — prove
 your edit landed in the text the check actually parses.
 
+**Three assertions, and the third is the one hand-rolled probes keep missing.** A
+plant that trips some *other* check has proved that other check works. Three probes
+in one day passed that way: one removed 1 of 3 identical lines and left the shape
+intact; one decremented a number inside an **already-released** section; one deleted
+the shouted spelling of a phrase and left the lowercase one. Each landed somewhere
+real and demonstrated nothing about the guard it was written for. So:
+
+1. **the substitution landed** — `replace` matching nothing returns the string
+   unchanged and raises nothing;
+2. **the exit code is non-zero** — not a `FAIL` line on stdout;
+3. **the message that fired belongs to the guard under test** — named up front, not
+   recognised afterwards.
+
+`test/probe.py` does all three (`npm run test:probe` self-tests the harness, including
+its own failure branches, because a harness whose failure path has never executed is
+the thing it exists to stop). Declare the plant as `Plant(label, path, old, new,
+expect=<the guard's own words>)` rather than hand-rolling a fourth copy of the loop.
+
 **Record the probe.** One line per section, in the change that ships the check.
 Otherwise the next reader has to redo it to know whether it was ever done.
 

package/plugins/task-pipeline/skills/task-pipeline/references/knowledge-sources.md

@@ -64,15 +64,20 @@ Rules for the list:
 - **The wiki and the graph are optional; the harvest is not.** With no wiki, no
   graph and no doc repos, the harvest is sources 1 and 3–7 and takes two minutes.
   Skipping it is never the answer.
-- **Source 7 is read in full, not queried.** It is capped at ten instructions
-  precisely so that this is cheap, and it is the one source that *binds* the run
-  rather than informing it.
+- **Source 7 is read in full where it is bounded, and queried where it is not.** The
+  standing instructions (capped at ten) and the run stamps (one line each) are read;
+  the *Recent log* is queried by the task's nouns like the archive. Measured on the
+  file this doctrine was written for, the log was **74% of it** — and it is the one
+  section nothing caps. Source 7 is still the source that *binds* the run rather than
+  informing it; that is why the part which binds must stay cheap enough to read.
 
 ## The retro's standing instructions — an instruction source, not background
 
 `docs/superpowers/retro.md` ([`retrospective.md`](retrospective.md)) is the one
-harvested source that is **read in full rather than queried**: the standing
-instructions are capped at ten precisely so that this is cheap. They are what
+harvested source whose binding part is **read in full rather than queried**: the
+standing instructions are capped at ten precisely so that this is cheap, and the run
+stamps are one line each. Its narrative log is queried, not read — an uncapped section
+inside a source that binds is how the capped part stops being read. They are what
 previous runs of this pipeline got wrong *in this project* — the rules no check
 could decide — and they bind this run.
 

package/plugins/task-pipeline/skills/task-pipeline/references/learned.md

@@ -47,6 +47,7 @@ to be enforced and is not is the same failure as a gate that prints `FAIL` and e
 | 19 | **An empty measurement is a refused measurement** | any command run to establish a fact — a count, a probe, a query, a suite | assert the output is **non-empty and shaped as expected** before reading meaning into it; a command that printed nothing did not answer | the run quotes the output it read, not the conclusion it drew from silence |
 | 20 | **When a thing exists twice, ask which one is used — not whether they agree** | any artifact with a second copy: two build files, a vendored library, a schema and its mirror, doctrine in two documents | find the **consumer** and read what it names; the copies cannot answer this about themselves | the run names the file the build/test/deploy actually reads, quoted from the consumer |
 | 21 | **A step that consumes what a later step produces is a deadlock, not an ordering** | any sequence where a check reads state another step writes — a prune reading stamps, a gate reading a ledger, a report reading counts | trace each input to the step that writes it; if that step is downstream, the check has never run on real data | every check names the step that produces its input, and that step is upstream of it |
+| 22 | **An operation that changes nothing reports the same as one that changed everything** | a substitution whose needle is absent · a command whose output is suppressed at a decision point · an edit issued against a shape the file does not have | assert the effect, not the call: a replacement must report how many times it matched, and a command whose exit code governs the next step is never piped or silenced | four incidents in two programmes, each invisible until something downstream failed — an import that never landed, a doctrine phrase worded differently, a `gh` call refused behind `>/dev/null`, and a test piped to `head` so that `$?` belonged to `head` |
 
 ---
 
@@ -189,6 +190,7 @@ answer would have exposed it in a minute.
 | 0 Inventory · 9 Docs · any register write | 8 (compute), 14 (targets resolve — including every commit SHA in the retro), 15 (identity before a lease) — see [`documentation.md`](documentation.md) |
 | 0 Harvest · any run resuming from a summary | 16 — the work-list and every inherited state claim re-derived before use, [`knowledge-sources.md`](knowledge-sources.md) → *Carried-in claims* |
 | any check you write | 4, 5, 7, 10, 11 — the procedure is [`gates.md`](gates.md) |
+| **every stage** · any edit, any command whose result is read | 22 — a no-op is indistinguishable from success unless the effect is asserted; never suppress the output of a command a decision depends on |
 | 3 Spec · 4 Plan | 2 (both directions), 8 (compute, never restate) |
 | 5 Dev | 9 (generators seed green), 12 (tests create their own state), 13 (local infra) |
 | 6 Tests | 4, 5, 10, 11 — every new check probed both ways, measured, and asserted on its exit code |
@@ -264,7 +266,7 @@ evidence that something left, and the log below says what.
 
 ### Retired
 
-**Numbers issued so far: 21.** This is the high-water mark, and it is the only number
+**Numbers issued so far: 22.** This is the high-water mark, and it is the only number
 this file states about itself — deliberately, because the gap that proves a rule left
 cannot be computed from the table alone: **deleting the highest-numbered rule shrinks
 the maximum with it, and no gap ever opens.** That false negative shipped in the first

package/plugins/task-pipeline/skills/task-pipeline/references/loop-guard.md

@@ -22,6 +22,7 @@ searches.
 
 - Bookkeeping — the thing that makes detection mechanical
 - Detection — any one of these trips the guard
+- The review loop — a cap that measures rather than stops
 - The break protocol
 - When to stop and hand back
 - Rationalizations
@@ -30,7 +31,8 @@ searches.
 
 You cannot detect churn from memory, especially after compaction. Every repeating
 pass appends one line to the run's ledger (`.task-pipeline/build/<plan>/progress.md`
-for stage 5; `.task-pipeline/run.md` for stage-level and program-level loops):
+for stage 5; `.task-pipeline/run.md` for stage-level and program-level loops —
+**seeded at stage 0** from [`../templates/run.md`](../templates/run.md)):
 
 ```
 touch: <file> — pass <N> (<stage|round|module>) — reason: <finding id / gate item>
@@ -40,6 +42,12 @@ One line per file per pass. The reason must name **what forced the edit** — a
 finding id, a failed gate item, an operator instruction. "Cleanup", "polish" and
 "while I was there" are not reasons; they are churn with better manners.
 
+**This ledger was required here from the day the file shipped and written by no run
+until 2026-08-10.** The detection below calls itself mechanical; with no ledger it had
+no input at all, so the guard sat on rung 1 while every reader took it for rung 3
+([`gates.md`](gates.md) → *Axis B*). It is now seeded at stage 0 and named in that
+stage's gate — which is the whole difference between a rule and a rule that runs.
+
 ## Detection — any one of these trips the guard
 
 1. **Revert-oscillation.** An edit restores something an earlier pass in this run
@@ -59,7 +67,48 @@ finding id, a failed gate item, an operator instruction. "Cleanup", "polish" and
 
 Caps that trip the guard by themselves: **5 fix rounds** per task
 ([`build.md`](build.md)), **2 re-entries** per stage per artifact, **3 passes** per
-module in the program loop.
+module in the program loop, and **3 review rounds** per artifact — which is not a stop
+but a measurement, below.
+
+## The review loop — a cap that measures rather than stops
+
+The caps above govern loops that **edit**. A review loop does both: the reader finds,
+the run fixes, the reader reads again. It had no cap at all until 2026-08-10, and this
+repository's own run stamps say what that cost — **ten rounds, ten, eight, four,
+three** — against a stated ceiling of two re-entries per stage. Nothing tripped,
+because a review round was named in no cap.
+
+**A flat cap would have been the wrong fix.** Every one of those runs recorded *"none
+from my probes"* beside its count: the reader was still finding real defects on round
+nine. Stopping at two would have shipped them.
+
+So the cap is a **decision point**. Default **3 rounds** per artifact, recorded in
+`pipeline.json` → `run.review.maxRounds`. On reaching it, stop reviewing and print the
+pair [`audit.md`](audit.md) already defines — new findings, and findings caused by this
+run's own fixes — per round:
+
+```
+review cap reached — 3 rounds — artifact: test/validate.py
+  round 1: 12 new · 0 self-inflicted
+  round 2:  5 new · 1 self-inflicted
+  round 3:  1 new · 3 self-inflicted
+```
+
+- **Self-inflicted ≥ new** — the axis is exhausted ([`audit.md`](audit.md) → *Every
+  pass changes the axis*). Stop. Every remaining finding becomes a board row with its
+  evidence ([`backlog.md`](backlog.md)); none is dropped.
+- **New > self-inflicted** — the reader is still paying. Continuing is then the
+  operator's call, made with the numbers in hand rather than out of fatigue.
+
+**The pair is the whole point.** A round count alone says how tired everyone is; the
+pair says whether the loop still produces anything. Measured on one file once, the
+guard's shapes and the run's own prose disagreed — one still paying, one exhausted —
+so a single number would have stopped the half that was working and continued the half
+that was not.
+
+**Rounds are counted from the ledger, never from memory**: distinct `pass N` values on
+`touch:` lines at the review stage. A round that finds nothing ends the loop by
+definition and needs no counting.
 
 ## The break protocol
 
@@ -109,6 +158,7 @@ far cheaper than a third round of the same argument.
 | Excuse | Reality |
 |---|---|
 | "One more pass and it converges" | Two passes with the same reason already proved it doesn't. The disagreement is above the code. |
+| "The reviewer is still finding things, so keep going" | Then say so with the pair: new versus self-inflicted, per round. If new still leads, that is an argument. Ten rounds with nobody counting is not. |
 | "I'll just revert to what worked" | That is the oscillation, not the exit. Name A and B first. |
 | "The reviewer keeps changing its mind" | Different findings on the same lines mean the requirement is ambiguous. That's a spec question. |
 | "Tidying while I'm in the file" | Untracked edits are what make churn invisible. One reason per change, in the ledger. |

package/plugins/task-pipeline/skills/task-pipeline/references/portability.md

@@ -52,6 +52,7 @@ a row pointing outside the bundle is the defect this file exists to catch.
 | The entry audit and what it inspects | `references/setup.md` |
 | The ladder, seams, axis rotation, ratchets | `references/audit.md` |
 | Loop detection and its caps | `references/loop-guard.md` |
+| **What the run prints about itself** — the header block, the rail, the iteration line | `references/progress.md` |
 | **The run mode** — item-by-item pacing, default off, what it never collapses | `references/continuity.md` |
 | **The context budget** — the evidence rule and what a flush actually updates | `references/continuity.md` |
 | **The board** — the work-list between runs, its computed priority, and the ledger seam it resolves | `references/backlog.md` |

package/plugins/task-pipeline/skills/task-pipeline/references/progress.md

@@ -0,0 +1,190 @@
+# Progress — saying which pipeline this is, and where in it
+
+**One job: make the run's position a printed fact instead of something the operator
+reconstructs from the last thing that scrolled past.**
+
+A pipeline that never says where it is has one specific failure, and it is not
+confusion — it is that **a stage looks done because nothing printed**.
+[`stages.md`](stages.md) opens with a checklist for exactly that reason and then marks
+it *"copy it, tick it"*: an instruction with no gate behind it, which is rung 1
+behaving like rung 3 ([`gates.md`](gates.md) → *Axis B*). This file is that checklist
+promoted to something the run must emit.
+
+**Boundary.** This file decides **what is printed and when**. It decides nothing about
+what is true: every number on the block has a home somewhere else and is read from
+there. A progress line that computes its own counts is the fourth copy of the truth,
+and [`continuity.md`](continuity.md) already says what happens to those — nobody
+maintains them and the next run reads them as current.
+
+---
+
+## Contents
+
+- The two boundaries, and only those two
+- The header block
+- The iteration line
+- The rail is computed, never eleven
+- What each glyph means
+- Every number is borrowed
+- Absent is a word, never a zero
+- The run ledger this reads from
+- Rationalizations
+
+## The two boundaries, and only those two
+
+**Task start** and **iteration close**. Nothing else.
+
+An iteration is already defined — *one item taken to its gate*
+([`continuity.md`](continuity.md) → *What one iteration means*) — and that definition
+is what makes this cheap. Printing per agent turn would put a bar above every tool
+call, and a block that appears fifty times a run is a block nobody reads, including
+the one time it says something.
+
+Between the two boundaries the run prints whatever it normally prints. This file adds
+no narration.
+
+## The header block
+
+Emitted **once, before stage 0's first question**, and again whenever the module
+changes:
+
+```
+task-pipeline v1.34.0 · pipeline-audit · module P1 «the progress print» (1 of 4)
+  0 ✓  1 ✓  2 ✓  3 ▶  4 ·  5 ·  6 ·  7 ·  8 ·  9 · 10 ·
+  ███████░░░░░░░░░░░░░░░░░░░  gates 3/11 · now 3 Spec · manual
+  board B-028 · carry-over 0 rows · exposure 99 never · unlooked 0
+```
+
+Four lines, and each one answers a question an operator otherwise has to ask:
+
+| Line | Answers |
+|---|---|
+| 1 | *which skill, which version, which programme, which module of how many* |
+| 2 | *which stages are closed, which one is live* |
+| 3 | *how far along, what is running now, will it stop for me* |
+| 4 | *what is queued, what is deferred, what nobody has confirmed* |
+
+**The module segment is omitted when there is no module map.** A task that stage 2
+never decomposed has no module, and printing `(1 of 1)` turns an absence into a claim
+— the shape [`audit.md`](audit.md) is built around. Where stage 2 recorded `single
+module: <name>` ([`decomposition.md`](decomposition.md)), print that phrase instead.
+
+## The iteration line
+
+Emitted at the **close** of every iteration, one line:
+
+```
+▶ pipeline-audit · P1 (1/4) · 5 Dev auto · iter 3 · gates 5/11 · next B-025
+```
+
+**`next` cites a `B-NNN`, never a description.** That rule is
+[`continuity.md`](continuity.md)'s and it is the reason this line exists at all:
+*"next up is X"* was already the one sentence in a loop that no gate reads. A board id
+can be checked against `docs/superpowers/backlog.md`; *"next up: the export fix"*
+cannot.
+
+**Nothing queued is `next —`, printed.** A loop that reaches an empty board says so;
+omitting the field is indistinguishable from forgetting it.
+
+## The rail is computed, never eleven
+
+The stage ids on the rail come from the project's `pipeline.json` → `stages[]`. They
+are **not** the eleven in [`../pipeline.example.json`](../pipeline.example.json), which
+is this plugin's *example* flow — a host project replaces it with its own stages
+(`SKILL.md` → *Bring your own skills*).
+
+A bar reading `gates 5/11` in a project with six stages is a false success in the
+purest form the pipeline has: a summary that is confidently wrong about the thing it
+summarises, printed in the place designed to be trusted at a glance.
+
+So the rail carries **no stage count of its own**. Read the array, print what is in it.
+Six stages give six positions.
+
+## What each glyph means
+
+| Glyph | Means | Written when |
+|---|---|---|
+| `✓` | the stage's **gate passed** | the gate's own verdict was recorded |
+| `▶` | in flight | the stage was entered and its gate has not returned |
+| `·` | not entered | — |
+| `✗` | entered, gate returned a failure | the verdict said so |
+| `⊘` | skipped, **with the reason on the same run's record** | the short path, or a stage the brief excluded |
+
+**`✓` means the gate passed — not that the stage was walked.** This is the whole
+integrity of the block. A rail is a summary, and a summary is the easiest artefact in
+a run to write from memory rather than from the record; a glyph set by recollection is
+[`gates.md`](gates.md)'s *false success* with a nicer typeface. Derive each glyph from
+the verdict the gate wrote, in the run ledger, and from nothing else.
+
+**`⊘` may never be silent.** A skipped stage with no recorded reason is exactly what a
+`·` looks like from outside, and the two mean opposite things.
+
+## Every number is borrowed
+
+| Field | Its home |
+|---|---|
+| `board B-NNN` | `docs/superpowers/backlog.md` ([`backlog.md`](backlog.md)) |
+| `carry-over N rows` | the run's carry-over ledger, as printed beside every gate verdict |
+| `exposure N never` | `docs/superpowers/verification.md` ([`exposure.md`](exposure.md)) |
+| `unlooked N` | the gate's own disclosure ([`gates.md`](gates.md) → *Disclosures*) |
+| `gates N/M` | the run ledger's verdict rows, and `pipeline.json` → `stages[]` |
+
+**None of these is recomputed here.** If a number on the block disagrees with the
+number beside a gate verdict, the block is wrong — that direction, always, because the
+gate looked and the block quoted.
+
+This also settles what the block is *not*: it is neither a ratchet nor a disclosure of
+its own ([`gates.md`](gates.md) → *Ratchets*, *Disclosures*). It sets no floor and
+carries no target. It is a **restatement with a citation**, and the citation is the
+only reason a restatement is allowed here at all.
+
+## Absent is a word, never a zero
+
+Where a value does not exist, print the word:
+
+```
+board — · carry-over 0 rows · exposure — · unlooked 0
+```
+
+`exposure —` says *no verification ledger in this project*. `exposure 0` says *nothing
+is unconfirmed*, which is the opposite claim, and it is the same inversion
+[`exposure.md`](exposure.md) refuses when it prints `never checked` rather than
+`0 days`. A zero standing in for an absence is how a project learns it is safe.
+
+`carry-over 0 rows` **is** a real zero and prints as one: the ledger exists and holds
+nothing.
+
+## The run ledger this reads from
+
+`.task-pipeline/run.md`, seeded at stage 0 from
+[`../templates/run.md`](../templates/run.md), one file per run.
+
+It already had a second owner before this file existed:
+[`loop-guard.md`](loop-guard.md) names it as the record that makes churn detection
+**mechanical**, and calls it the only memory that survives compaction. It was never
+written by any run — the detector had no input, and the guard was doctrine wearing a
+script's clothes. One file serves both readers: the guard reads the `touch:` lines,
+this block reads the verdict rows and the iteration counter.
+
+Three kinds of line, appended, never rewritten:
+
+```
+stage: 3 Spec — gate manual — verdict pass — 2026-08-10T14:02Z
+iter:  3 — item B-025 — closed at gate 6
+touch: test/validate.py — pass 2 (stage 7) — reason: F-014
+```
+
+**The counter is a count of `iter:` lines, not a number the agent remembers.** After a
+compaction the agent's memory of "iteration 3" is gone and the file's is not, which is
+the entire argument for keeping it on disk rather than in the reply.
+
+## Rationalizations
+
+| The excuse | What is actually true |
+|---|---|
+| "The operator can see the stages scroll by" | They can see that *something* printed. A stage that ended silently and a stage that never started look identical in a transcript, which is the failure `stages.md`'s checklist was written for and never enforced. |
+| "A progress bar is decoration" | Then delete the numbers and keep the bar. The objection is really to the bar; the four borrowed counts are the payload, and they are the ones nobody prints today. |
+| "I know which stage I'm on, I'll write the rail from memory" | Then the rail is a claim about the run rather than a reading of it, and it will be right until the run it most matters on. Derive it from the verdicts. |
+| "There's no module map, I'll put (1 of 1)" | An undecomposed task has no module. `(1 of 1)` is an invented denominator, and a reader cannot tell it from a real one. |
+| "Printing it every iteration is noise" | One line. The block is four, and it appears at task start. If that is noise, the run is emitting far worse elsewhere. |
+| "The ledger is bureaucracy, I'll count iterations in my head" | Your head does not survive compaction. That is not a hypothetical here — it is why `loop-guard.md` asked for this file in the first place. |

package/plugins/task-pipeline/skills/task-pipeline/references/retrospective.md

@@ -18,7 +18,8 @@ justifies reading it protects one section while the file below it doubles.
 
 | Artifact | Parts | How it is read |
 |---|---|---|
-| `docs/superpowers/retro.md` — **one per project** | **Standing instructions** (max **10**) · **Recent log** (entries from the last five run stamps) · **Run stamps** | stage 0, **in full** — all three are bounded by construction |
+| `docs/superpowers/retro.md` — **one per project** | **Standing instructions** (max **10**) · **Run stamps** (one line each) | stage 0, **in full** — both are bounded by construction |
+| the same file's **Recent log** | entries from the last five run stamps — narrative, and capped by nothing | stage 0, **queried** by the task's nouns. It said *in full* until 2026-08-10, when it measured **74%** of the file: an uncapped section inside a binding source is what makes the capped part get skimmed |
 | `docs/superpowers/retro/YYYY-QN.md` — the archive | every entry and every retirement ever written, append-only | **queried** by the task's nouns; never read end to end |
 
 Seed the archive from [`../templates/retro-archive.md`](../templates/retro-archive.md).
@@ -37,6 +38,8 @@ file exists to stop.
 - The prune — mandatory, and it runs after the stamp
 - The loop closes at stage 0
 - Where a lesson goes when it is not about this project
+- Publishing the insight — the skill learns from every project that runs it
+- What may leave the project — the redaction list
 - Rationalizations
 
 ## Write the entry only for a divergence — and name the layer that owned it
@@ -227,9 +230,92 @@ rule that was retired for going cold is exactly the rule about to be re-learned.
 
 A lesson that would be true in any repository does not belong in one project's
 retro — it belongs in the pipeline's own doctrine
-([`learned.md`](learned.md), which is exactly that list, earned the same way). Open
-an issue upstream and say so in the entry. A local file that accumulates universal
-rules is a fork of the skill that nobody named.
+([`learned.md`](learned.md), which is exactly that list, earned the same way). A local
+file that accumulates universal rules is a fork of the skill that nobody named.
+
+**This said *"open an issue upstream"* for eight releases and named no repository, no
+trigger and no authorization** — an instruction on rung 1 that everybody read as done.
+The rest of this section is the mechanism.
+
+## Publishing the insight — the skill learns from every project that runs it
+
+**One job: stop a lesson dying in the repository that learned it.**
+
+A retro entry is written per project and read by that project's next stage 0. The
+pipeline itself never sees it. So a defect in the **skill** — a gate that loops, a
+doctrine promising what nothing enforces, a rule firing on the wrong shape — is
+rediscovered independently in every project and fixed in none of them.
+
+**Opt-in, per project, off by default** — `pipeline.json` → `retro.publish`:
+
+```json
+"retro": {
+  "publish": {
+    "repo": "ssheleg/task-pipeline",
+    "label": "retro-insight",
+    "redact": "strict"
+  }
+}
+```
+
+Absent, nothing is published, and nothing is asked. **Silence arms nothing** — the same
+floor deploy authorization uses, and for the same reason: this is an **outward act**,
+and an outward act taken from a generic flag is an outward act nobody authorized
+([`continuity.md`](continuity.md) → *The limit, before the capability*).
+
+**The body is printed in full before the issue is opened, every time.** Not a summary
+of it, not its title — the string that will be sent. The operator standing at stage
+10's manual gate is already reading; showing them what leaves the machine costs one
+block and is the only moment anyone can stop it.
+
+```
+── would open issue ──────────────────────────────────────────
+repo:  ssheleg/task-pipeline
+label: retro-insight
+title: [retro] a queue is not a diagnosis
+<the whole body, verbatim>
+──────────────────────────────────────────────────────────────
+opening…  → #24
+```
+
+**No `gh`, no network, no permission?** Print the body, say the issue was **not**
+opened, and carry the exact text in the carry-over ledger. That is the honest
+degradation; a second transport is not.
+
+## What may leave the project — the redaction list
+
+An issue is a **public artefact in someone else's repository**. What travels is the
+*class*; what stays is everything that identifies where it happened.
+
+| Goes | Stays |
+|---|---|
+| the class of failure, stated in the abstract | the file, the function, the line it happened in |
+| which stage owned it and which stage surfaced it | the repository, organisation, branch or commit |
+| the doctrine or guard that missed it, by its name **in this skill** | any host path, absolute or relative |
+| the fix by grade, and the check that would catch it | the code, the config values, the data |
+| whether an existing standing instruction fired | any person, company, customer or product name |
+
+Five rules, numbered so a reader can point at one:
+
+1. **No host paths.** Only paths inside task-pipeline itself — `references/…`,
+   `templates/…`, `test/validate.py`. An absolute path names a machine.
+2. **No host identifiers**: repository, organisation, branch, commit, tag, issue or PR
+   number belonging to the project the run happened in.
+3. **No code, no configuration values, no data** — not a snippet, not a redacted
+   snippet. A shape can be described in a sentence.
+4. **No names**: person, company, customer, employer, product.
+5. **The title states the class, not the incident** — *"a queue is not a diagnosis"*,
+   never *"our export job looped"*.
+
+**The printed text and the sent text are one string.** Redacting after the print, or
+printing a cleaned-up version of what is actually sent, is the false-success shape this
+bundle names outright ([`gates.md`](gates.md) → *False success*): a mechanism reporting
+on itself rather than on what it did.
+
+**When in doubt the rule is subtraction, not judgement.** An insight that survives
+losing a detail is still an insight; a detail that leaks cannot be recalled from an
+index. If removing it makes the entry incomprehensible, the entry was about the project
+and not about the skill — keep it local.
 
 ## Rationalizations
 

package/plugins/task-pipeline/skills/task-pipeline/references/review.md

@@ -16,6 +16,7 @@ install.
 - Reviewer inputs
 - Controller rules
 - The rubric
+- The independent reader — dispatched by a stage, and read by its output
 - Prompt — task review
 - Prompt — scoped re-review
 - Prompt — final whole-branch review
@@ -118,6 +119,61 @@ Review in this order; stop reading the diff only when you've covered all of it.
 Formatting nits that don't change meaning are not findings. Praise is not a
 finding either.
 
+## The independent reader — dispatched by a stage, and read by its output
+
+**One job: stop *"a reader was requested"* from standing in for *"a reader
+reported"*.** Those are different facts and they look identical in a transcript.
+
+The rule this implements has been a standing instruction since 2026-08-08: **a change
+that adds or widens a check gets an independent reader before merge**, because your own
+probes exercise only the shapes you already thought of. Its retirement condition, written
+at birth, was that the reader be *dispatched by a stage rather than by the repository
+happening to run a bot on pull requests*. This section is that stage.
+
+**It happened.** Four pull requests of almost nothing but check work were opened on one
+day; the review application reported **`skipping`** on every one, and twenty-two new
+guards merged with the author's own probes as their only reading. Nothing was violated.
+Nothing read the reviewer's output either.
+
+### Who counts as the reader, in order
+
+1. **A subagent this run dispatches** — the only option whose execution the run can
+   observe end to end. Give it the diff package, the rubric, and the sentence *"the
+   author wrote both the check and its probes; find what neither could see."*
+2. **A review bot on the pull request** — acceptable, and it is a **third party with no
+   contract**: it may skip, rate-limit, or answer about a stale commit. Read its
+   verdict, not the fact that it was triggered.
+3. **A person.**
+
+### The three states, and one of them is not silence
+
+Record exactly one, beside the gate verdict:
+
+```
+reader: 6 findings, 4 confirmed        — read, and it had something
+reader: none found                     — read, and it did not
+reader: NO READER — <why>              — nobody read it
+```
+
+**`NO READER` is a printed state, never an omission.** It carries the same law as
+`dormant` and `skip` ([`gates.md`](gates.md) → *Progressive arming*): a mechanism that
+prints nothing when it looked at nothing is indistinguishable from one that looked and
+found nothing. Where the change added or widened a check, `NO READER` is also carried
+into the close-out as an open requirement rather than a footnote — reporting a gap is
+honest and is not a fix.
+
+### What the reader is asked
+
+Not *"review this."* The dispatch names the blind spot it exists to cover:
+
+- the probes and the checks were written from **one model of the problem** — where does
+  that model not reach?
+- which shapes does the check's **scope** exclude, and is any of them shipped?
+- is there a form of the defect that has **no pair to compare** — a single cell, a lone
+  directive, an absence?
+
+Those three questions come from findings no author-written probe has ever produced here.
+
 ## Prompt — task review
 
 > You are reviewing one task of an implementation plan. Read, in order: