task-pipeline-skill 1.27.0 → 1.29.0

package/CHANGELOG.md

@@ -1,5 +1,111 @@
 # Changelog
 
+## v1.29.0 — a sixth axis, and three summaries that each read as complete
+
+**Re-derivation** joins the rotation axes in `references/audit.md`: take a number the
+audit already produced and produce it again with a command of a **different shape**,
+then print both. Not a second opinion — a second route. Re-running the same command is
+a spell-check of the first run; only a differently-shaped question can come back
+disagreeing. The exit criterion is **the pair printed**, never "verified", never
+"matches": a re-derivation reported as agreement is a claim about a measurement nobody
+can see.
+
+It earns its place from this repository's own record. Four applications, two of which
+refuted something already written down as fact: the version invariant called *four-way*
+over five surfaces (`CONTRIBUTING.md:74`), and a graph shrink read as legitimate
+tightening at 864→839 and as erosion at 839→798 — **same procedure, opposite answers**,
+which is the whole argument for the axis in one line.
+
+**The enumeration had already drifted, and nothing could see it.** Measured before
+writing a word of doctrine: `audit.md` defined five axes, the Cursor rule summarised
+four, `README.md` three. Each reads as complete on its own, because a list of three
+orthogonal things is a convincing list of three orthogonal things. The Cursor rule now
+carries all six (it is self-contained by contract and cannot point anywhere); README
+stops enumerating and names the file that defines them — deleting a restatement is how
+every count this repository got wrong has been fixed.
+
+A guard now derives the axis keys from `audit.md` **at check time** and requires any
+paragraph naming three or more of them to name all of them. Its first run accused
+`stages.md` of enumerating three axes whose three hits were 595 lines apart and meant
+different things; scoped to the file, the predicate was measuring vocabulary rather
+than enumeration. The unit is the paragraph, and the guard says so in its own comment.
+
+**Found by the false positive:** `gates.md` was titled *the two axes* over a file with
+Axis A, B and C, and four surfaces repeated the two. README's prose named two and never
+mentioned degrees of freedom at all — the axis about how much latitude an instruction
+leaves, which is the one that gets skipped. All five sites corrected, and the count is
+now computed from the `## Axis` headings by a claim-registry class, alongside a second
+class for the rotation axes. The two are separated by the qualifier, because *axes* is
+polysemous in this corpus and a guard that conflates them reports drift that is not
+there.
+
+**Review round.** Four findings, none from the probes. The guard re-read thirty
+surfaces already cached; the flattening idiom had been hand-rolled three times, each
+commenting on the earlier ones, and is now `_flatten()`; the spec claimed a guard that
+did not exist. And the Cursor rule's **own** Gates section still said *"two axes"* with
+no Axis C — introduced by this PR, fifty lines below an edit it made. Nothing could see
+it: the claim registry's corpus held neither the Cursor rule nor the command file.
+Both are in it now, and the count moved 6 → 7 the moment they were.
+
+A second round found the same I/O class at two more call sites. Re-deriving its size
+with a differently-shaped command — an instrumented run rather than a grep of the
+source — put it at **25 reads of `audit.md` and 668 `.md` opens per run**, against an
+estimate of "3+". The two named sites are fixed; the rest is carry-over row 12 with the
+number attached, because a class measured and then left unmentioned is the TODO this
+repository refuses to keep.
+
+A third round found the sibling of the idiom the second round found — the
+paragraph-split, hand-rolled at four sites — now `_paragraphs()`, whose docstring says
+what the unit costs. And it found that the new **rotation axes** claim class was
+permanently dormant and had **never been watched failing**: dormant is green by design
+here, which is exactly why a dormant class still needs its plant. It has one now.
+
+Guards: 136 → **144**.
+
+## v1.28.0
+
+### Eight ways to say "I don't know", and no way to count them
+
+This bundle has eight vocabularies for declining to claim — `partial`, `unknown`,
+`cannot verify from diff`, `review`, `dormant`, `skip`, `recalled`, `ungated` — spread
+across sixteen reference files. Only one of them, `unknown`, blocks anything. **None of
+them appeared beside a verdict**, and `grep` for a counter returned zero.
+
+So `PASS` read as *verified*. It never read as *"green, and here is what nobody claimed
+and what nothing looked at"*, which is the only thing a gate can honestly mean.
+
+**The obvious fix is a ratchet, and it is wrong.** A ratchet may only shrink. A count of
+abstentions under that rule puts pressure on exactly one thing: **claiming more**. A run
+that reaches `abstained: 0` is not more careful — it has stopped saying *I don't know*,
+which is the cheapest way to make the number fall. Refusals and wrong answers are
+communicating vessels; squeeze one column and it reappears in the other, silently, because
+a wrong claim looks like a claim.
+
+`gates.md` therefore gains a second kind of counted set — a **disclosure**. Printed beside
+the verdict exactly like a ratchet, and carrying the opposite rule: **no floor, no
+direction, and never a target.** A target on an abstention count is an instruction to guess.
+
+Two of them, kept apart because they are different facts:
+
+| | Counts | How to read it |
+|---|---|---|
+| `abstained` | claims the run **declined to make** — `partial`, `unknown`, `cannot verify from diff` | a **choice**. Rising can mean the work got harder or the run got honest |
+| `unlooked` | checks that **did not look** — `dormant`, `skip` | a **state of the corpus**, not a decision; it falls as the project grows the inputs |
+
+`recalled` and `ungated` are deliberately not counted: the first is a property of one claim
+and already lives in the ledger, the second a property of the whole run and said once in
+words. Collapsing all eight into one number would be the false precision this change exists
+to avoid — a figure nobody can act on.
+
+Both print beside every worked verdict in the doctrine, both are required by the stage-6 and
+stage-10 gates, and a guard holds the four verdict formats together — one statement on four
+surfaces is this repository's most recurrent defect.
+
+**Where this came from.** The programme that produced it started from a review of the
+hallucination-mitigation literature, whose one directly importable idea was that
+*uncertain refusals* belong in the results table **next to** factual errors, because the two
+trade off. Everything else in that literature the doctrine already had. This is the import.
+
 ## v1.27.0
 
 ### A retirement trigger whose counter only some work moves

package/CONTRIBUTING.md

@@ -317,7 +317,39 @@ stall, which is why it is not belt-and-braces. Entry **rotation** ("entries olde
 stamps move to the archive") is a different mechanism and is deliberately out of scope.
 *(guard: `states the cold-retirement condition as five run stamp`)*
 
-**38. Every invariant above names the guard that enforces it, and that guard exists.**This list claims to be *what the validator enforces*; it was eight guards behind when
+**38. Every worked GATE verdict prints both disclosures.** `abstained` — what the run
+declined to claim — and `unlooked` — what a check never looked at. Without them a `PASS`
+reads as *verified* rather than as *"green, and here is what nobody claimed"*. They are
+**not** ratchets and the distinction is load-bearing: a ratchet may only shrink, and an
+abstention count under that rule pressures exactly one thing — claiming more. A run
+reporting `abstained: 0` is not more careful; it stopped saying *I don't know*. Refusals
+and wrong answers are communicating vessels, so a disclosure has no floor, no direction,
+and **may never be given a target** — a target on an abstention count is an instruction to
+guess. This repository had eight vocabularies for declining to claim and, until v1.28.0,
+zero counters.
+*(guard: `a worked GATE verdict omits `)*
+
+**39. A surface that enumerates the rotation axes enumerates all of them.** The axes
+live once, in `references/audit.md`; the Cursor rule summarises them because it is
+self-contained by contract and can point nowhere. Measured on 2026-08-09: the
+definition held five, the Cursor rule four, README three — and each read as complete,
+because a list of three orthogonal things is a convincing list of three orthogonal
+things. The keys are derived from `audit.md` at check time, never hand-listed, and the
+unit is the **paragraph**: scoped to the file, the first version of this guard reported
+`stages.md` for three hits 595 lines apart that meant three different things. Either
+name every axis or stop enumerating and name the file.
+*(guard: `enumerates the rotation axes but names`)*
+
+**40. Counts of "axes" are computed, and the two kinds are kept apart.** `gates.md` is
+built on three of its own (context, enforcement, degrees of freedom) and `audit.md`
+rotates between six; the word is polysemous in this corpus. `gates.md` was titled *"the
+two axes"* over a file with Axis A, B and C, and four surfaces repeated it — including
+README's prose, which never mentioned degrees of freedom at all. Both counts are now
+claim-registry classes, separated by the qualifier, so a guard cannot report drift
+between two things that were never the same list.
+*(guard: `gates.md's own axes`)*
+
+**41. Every invariant above names the guard that enforces it, and that guard exists.**This list claims to be *what the validator enforces*; it was eight guards behind when
 an audit measured it. A claim of enforcement is now checked like any other claim.
 *(guard: `whose message does not appear in`)* — and a cited literal must lie inside
 a **single** string in `test/validate.py`: the check reads that file as text, so a

package/README.md

@@ -131,7 +131,7 @@ until it is installed.
 | run-wide pacing | [`continuity.md`](plugins/task-pipeline/skills/task-pipeline/references/continuity.md) — the loop mode (`run.loop`, default off, never collapses a manual gate) and the context budget (fires on a harness signal, never on an estimate) |
 | 0 + 9 + any settled decision | [`documentation.md`](plugins/task-pipeline/skills/task-pipeline/references/documentation.md) — the inventory, registers and ids, SSOT, the Doc Loop, supersede semantics, the propagation matrix, intent vs as-built |
 | 3 + 4 · every spec and plan | the self-review reads its rules back — is every named check real, does anything contradict a locked decision or a rejected option, and what does this cost now versus at design time. Answers land as a committed `## Self-review` of computed numbers |
-| 6–10 + any check you write | [`gates.md`](plugins/task-pipeline/skills/task-pipeline/references/gates.md) — the two axes, the promotion ladder, gate anatomy, the probe recipe, ratchet floors |
+| 6–10 + any check you write | [`gates.md`](plugins/task-pipeline/skills/task-pipeline/references/gates.md) — the three axes, the promotion ladder, gate anatomy, the probe recipe, ratchet floors |
 | any agent-time enforcement | [`hooks.md`](plugins/task-pipeline/skills/task-pipeline/references/hooks.md) — the `PreToolUse` contract, the fail-open hazard, the Claude-Code-only limit |
 
 **Ported, not depended on.** Stage 0 is adapted from
@@ -431,8 +431,9 @@ Three rules keep the audit from becoming another loop:
   Measured over seven passes on a production repository, by pass six the audit was
   mostly repairing its own previous pass — while the finding count still looked
   healthy. So count both numbers every pass (new findings vs. self-inflicted ones);
-  when the second overtakes the first, **rotate the axis** — seams down one
-  deliverable, then invariants across deliverables, then one class swept end to end.
+  when the second overtakes the first, **rotate the axis**. The axes are orthogonal
+  by construction and there is one list of them, in `references/audit.md` — this line
+  used to restate three of the five that existed, and read as complete while doing it.
 - **A class that repeats twice becomes a gate, not a note.** Once is an incident;
   twice is a category, and a category belongs in lint or CI where nobody has to
   remember it. The third instance in a ledger is how a mechanical defect becomes
@@ -482,12 +483,17 @@ teaches everyone on day one that the gate is noise.
 
 ### Gates and hooks — how a rule becomes something that can say no
 
-Two axes, deliberately not conflated. **The stage gate type** (`auto` = verify it
+Three axes, deliberately not conflated. **The stage gate type** (`auto` = verify it
 yourself; `manual` = wait for an explicit go) is about this pipeline. **The
 enforcement mechanism** is a ladder a rule climbs: a doctrine line → a review
 question → a script check (promote here once the class has occurred *twice*) → a CI
 step → a hook. A rule may sit on several rungs; what it may never do is *pretend* to
-be on a higher one.
+be on a higher one. **Degrees of freedom** is the third and the one that gets
+skipped: how much latitude the *instruction* leaves — an open field where many
+routes reach a good answer, a narrow bridge where the guardrails are the wording.
+Over-constraining costs as much as under-constraining and is harder to see, because
+an agent following the letter past the point where the letter fits still reports
+success.
 
 The skill ships the anatomy of a gate that cannot lie — non-zero exit on any
 failure, the verdict block last with nothing after it, a scope header saying what it
@@ -810,7 +816,7 @@ recommendation, so you arm the whole run in one exchange. Detail:
 | [`references/artifacts.md`](plugins/task-pipeline/skills/task-pipeline/references/artifacts.md) | the canonical document layout each stage writes to |
 | [`references/conventions.md`](plugins/task-pipeline/skills/task-pipeline/references/conventions.md) | how stages 6–10 read the host project's `CLAUDE.md`, and how the documentation regime is detected |
 | [`references/documentation.md`](plugins/task-pipeline/skills/task-pipeline/references/documentation.md) | the doc system: the inventory, registers and ids, SSOT, the Doc Loop, supersede semantics, the propagation matrix, intent vs as-built |
-| [`references/gates.md`](plugins/task-pipeline/skills/task-pipeline/references/gates.md) | the two axes, the promotion ladder, gate anatomy, the probe recipe, ratchet floors, where a gate runs |
+| [`references/gates.md`](plugins/task-pipeline/skills/task-pipeline/references/gates.md) | the three axes, the promotion ladder, gate anatomy, the probe recipe, ratchet floors, where a gate runs |
 | [`references/deploy-targets.md`](plugins/task-pipeline/skills/task-pipeline/references/deploy-targets.md) | stages 7–8: writing the runbook when there is none, the template, per-platform deploy and log verbs, the verification trio |
 | [`references/hooks.md`](plugins/task-pipeline/skills/task-pipeline/references/hooks.md) | the `PreToolUse` contract, the fail-open hazard, placement, and the Claude-Code-only limit |
 | [`references/knowledge-graph.md`](plugins/task-pipeline/skills/task-pipeline/references/knowledge-graph.md) | the code graph: install line, stage-0 reach queries, the stage-9 refresh, the graph↔docs divergence check |

package/SKILL-CARD.md

@@ -12,7 +12,7 @@ harmless.
 |---|---|
 | **Purpose** | Runs a substantial task through ten gated delivery stages — intake grill, docs study, brainstorm, spec, plan, subagent build, tests, lint/deploy, post-deploy, docs+registers, acceptance — refusing to advance until each gate passes |
 | **Owner** | ssheleg ([github.com/ssheleg/task-pipeline](https://github.com/ssheleg/task-pipeline)) |
-| **Version** | 1.27.0 |
+| **Version** | 1.29.0 |
 | **Surface** | Claude Code (filesystem skill + plugin) and the vercel `skills` CLI. **Not** uploaded to the Skills API; custom Skills do not sync across surfaces |
 | **Dependencies** | None required. Optional: `context7` (MCP), `figma` (MCP), super-ux, agent-sync, graphify, obsidian-wiki. Every stage's doctrine ships in-repo; the one conditional requirement is super-ux for the stage-3 UX track on a user-facing task |
 | **Evaluation status** | Suite authored, 5 categories. One recorded run, **self-observed by the author**; **zero blind runs on zero of three models** — the split, and the numbers, live in [`evals/RESULTS.md`](evals/RESULTS.md) and are computed by `evals/run.py` |

package/cursor/rules/task-pipeline.mdc

@@ -404,7 +404,11 @@ its own previous pass while the finding count still looked healthy. So:
   to end (every error path, every count, every status vocabulary), then — where a
   code graph exists — **the graph against the docs**, the only axis that finds an
   absence without reading for it (a hub no document names, an edge the docs deny, a
-  doc naming a module the graph no longer has).
+  doc naming a module the graph no longer has), then **false success** (not "is this
+  check correct" but "what does this mechanism print when it did not look?"), then
+  **re-derivation** — a number the audit already produced, produced again by a
+  command of a *different shape*, with **both printed**; agreement asserted instead
+  of a pair printed is not a re-derivation.
 - **Audit bottom-up.** A missing artefact at a low rung makes everything above it
   meaningless; top-down you polish a surface for a contract that doesn't exist.
 - **A class that repeats twice becomes a check, not a note.** Once is an incident;
@@ -453,7 +457,7 @@ you *read*; the matrix names the documents you *owe*. The document nobody read i
 exactly the document nobody updated. At stage 9, walk the matrix for every change
 type the run produced, then run the documentation gate and print its ratchet counts.
 
-## Gates: two axes, and how to build one that cannot lie
+## Gates: three axes, and how to build one that cannot lie
 
 **Axis A — the stage gate type.** `auto` = verify the check yourself and stop on
 fail; `manual` = wait for an explicit operator go. An auto gate never substitutes
@@ -465,6 +469,17 @@ script check (promote here once the class has occurred **twice**) → CI step
 A rule may sit on several rungs; what it may never do is *pretend* to be on a higher
 one — that is the same failure as a gate that prints `FAIL` and exits `0`.
 
+**Axis C — degrees of freedom**, and it is the one that gets skipped. Axis B says how
+hard a rule bites; this says how much latitude the *instruction* leaves. **high** —
+prose direction, no prescribed sequence, for steps where many routes reach a good
+answer. **medium** — a named order with room inside each step. **low** — run exactly
+this, in this order, for a step that is fragile, irreversible, or must be identical
+every time. Match the level to how fragile the step is, not to how important it feels:
+an open field versus a narrow bridge. **Over-constraining costs as much as
+under-constraining and is harder to see** — a high-freedom step written as low freedom
+produces an agent that follows the letter past the point where the letter stopped
+fitting, and reports success, because it did what it was told.
+
 **Before you run any check:** the base is green (or its known-red baseline is
 recorded); the check has been probed; you have read its scope header and know what
 it does **not** cover; you have read its ratchet floors.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "task-pipeline-skill",
-  "version": "1.27.0",
+  "version": "1.29.0",
   "description": "Full-cycle delivery pipeline for coding agents: a mandatory built-in intake grill, then 10 gated stages (docs, brainstorm+decompose, spec, plan, build, tests, lint/deploy, post-deploy, docs/wiki, acceptance). Every stage's doctrine ships inside the skill — no companion plugin required. This package is the installer CLI.",
   "bin": {
     "task-pipeline": "bin/task-pipeline.js"

package/plugins/task-pipeline/.claude-plugin/plugin.json

@@ -2,7 +2,7 @@
   "name": "task-pipeline",
   "displayName": "Task Pipeline",
   "description": "Runs a substantial task through a mandatory built-in intake grill, then 10 gated stages (docs, brainstorm+decompose, spec, plan, subagent build, tests, lint/deploy, post-deploy, docs/wiki, acceptance). Every stage's doctrine is built into the skill — no companion plugin required — with typed auto/manual gates, a frozen requirement spine that must close with evidence, a loop guard that breaks churn, one provider-agnostic model confirmed up front, and an optional super-ux UX track for user-facing work.",
-  "version": "1.27.0",
+  "version": "1.29.0",
   "author": {
     "name": "ssheleg",
     "url": "https://x.com/sshlg93"

package/plugins/task-pipeline/skills/task-pipeline/SKILL.md

@@ -269,7 +269,7 @@ capable available — see `references/model-tiering.md`).
 | 7 | Lint + deploy | host lint → deploy per host convention | lint clean + suite green before deploy; deploy needs a go (or the brief's specific standing authorization) | manual |
 | 8 | Post-deploy | tail deploy logs / health-check | clean boot or honest degradation report; **a deployed web target is opened, not curled** — a `200` proves the server answered and says nothing about a 404'd bundle or a console full of errors on load (`chrome-devtools`; absent → call it an HTTP response, which is its honest name) | auto |
 | 9 | Docs + wiki | host module docs/runbook rules → `wiki-update` ([obsidian-wiki](https://github.com/ar9av/obsidian-wiki), recommended) → `/graphify . --update` ([`references/knowledge-graph.md`](references/knowledge-graph.md), recommended) | every stale row of the stage-0 source ledger updated; **the propagation matrix walked for every change type this run produced** — the ledger names what you read, the matrix names what you owe — every settled thing recorded with an id, every answered question resolved, and **the documentation gate green with its ratchet counts printed**; docs synced; wiki synced; **the code graph refreshed where one exists** and checked against the docs (a hub no doc names, a doc naming a node the graph lost); **every number computed rather than restated, every named command or file resolvable** ([`references/learned.md`](references/learned.md)); the carry-over count printed beside the verdict | auto |
-| 10 | **Acceptance** | built in: [`references/audit.md`](references/audit.md) (ladder walk) → [`references/acceptance.md`](references/acceptance.md) (coverage table) → [`references/retrospective.md`](references/retrospective.md) (retro: stamp, prune, entry) | ladder walk ran, its absences became REQ rows; every REQ accounted for with evidence from a check seen failing once; ledger has no unresolved row; **axis rotation recorded** (new findings vs self-inflicted, rule 1 of [`references/learned.md`](references/learned.md)), **every closure verified against the artefact rather than the document describing it**, **each correction swept across its class**, **every deferral a printed ratchet rather than a TODO**; **in a multi-repository project, every repository is clean, pushed and pointed at** (below); operator signs off; **every check this close-out leans on — the documentation gate included — has been seen failing once against a planted defect, and its ratchet counts are printed beside the verdict**; **the retrospective written last, and in order — the run stamped with its commit FIRST (the cold-retirement trigger reads that stamp), then the prune with the list at or under its cap and every deletion logged, then the entry; every deletion and every entry carrying its commit, entries older than five stamps rotated into the archive, counts printed** | manual |
+| 10 | **Acceptance** | built in: [`references/audit.md`](references/audit.md) (ladder walk) → [`references/acceptance.md`](references/acceptance.md) (coverage table) → [`references/retrospective.md`](references/retrospective.md) (retro: stamp, prune, entry) | ladder walk ran, its absences became REQ rows; every REQ accounted for with evidence from a check seen failing once; ledger has no unresolved row; **axis rotation recorded** (new findings vs self-inflicted, rule 1 of [`references/learned.md`](references/learned.md)), **every closure verified against the artefact rather than the document describing it**, **each correction swept across its class**, **every deferral a printed ratchet rather than a TODO**; **in a multi-repository project, every repository is clean, pushed and pointed at** (below); operator signs off; **every check this close-out leans on — the documentation gate included — has been seen failing once against a planted defect, and its ratchet counts are printed beside the verdict**; **the retrospective written last, and in order — the run stamped with its commit FIRST (the cold-retirement trigger reads that stamp), then the prune with the list at or under its cap and every deletion logged, then the entry; every deletion and every entry carrying its commit, entries older than five stamps rotated into the archive, counts printed** ; **both disclosures printed beside the verdict** — `abstained` (what the run declined to claim) and `unlooked` (what a check never looked at), neither a ratchet, neither with a floor, neither ever a target ([`references/gates.md`](references/gates.md) → *Disclosures*) | manual |
 
 
 ### Stage 10 in a project of several repositories
@@ -335,7 +335,7 @@ automation is on — `pipeline.schema.json` is the only contract.
 - `references/acceptance.md` — the built-in stage-10 close-out: REQ coverage, evidence, sign-off
 - `references/retrospective.md` — stage 10's last act: the project retro (`docs/superpowers/retro.md`), the three grades of fix, the mandatory prune and its cap of ten
 - `references/documentation.md` — cross-cutting: the doc inventory, registers and ids, SSOT, the Doc Loop, supersede semantics, the propagation matrix, intent vs as-built
-- `references/gates.md` — cross-cutting: the two axes, the promotion ladder, gate anatomy, the probe recipe, ratchet floors, where a gate runs
+- `references/gates.md` — cross-cutting: the three axes, the promotion ladder, gate anatomy, the probe recipe, ratchet floors, where a gate runs
 - `references/deploy-targets.md` — stages 7–8: writing the runbook when there is none, the template, per-platform deploy and log verbs, and the verification trio
 - `references/hooks.md` — agent-time enforcement: the PreToolUse contract, the fail-open hazard, placement, and the Claude-Code-only limit
 - `references/audit.md` — cross-cutting: the L0→L7 ladder and its seams (what was never written), axis rotation, ratchets, proven checks

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

@@ -198,6 +198,7 @@ ledger's, so a list that quietly grew back is visible at the moment it happened:
 ```
 GATE 10 acceptance: PASS — 14/14 REQ verified
   carry-over: 0 unresolved · retro: 7 standing (was 9) · retired 3 · added 1
+  abstained: 2 (1 partial · 1 cannot-verify) · unlooked: 3 dormant
 ```
 
 ## GATE (manual)
@@ -222,6 +223,13 @@ All of:
    ledger or here) and, for `deferred`, a tracker entry.
 7. **No carry-over row is left `unresolved`** — every one has a home, and the
    ledger's counts are printed with this verdict, not just filed.
+7a. **Both disclosures are printed** ([`gates.md`](gates.md) → *Disclosures*):
+   `abstained` — every REQ closing `partial`, every `unknown`, every ⚠️ *cannot verify
+   from diff* the controller could not resolve — and `unlooked`, every check that
+   reported `dormant` or `skip`. They are **not** ratchets: no floor, no direction, and
+   a movement either way wants one sentence. A run reporting `abstained: 0` is claiming
+   it knew everything, which is a stronger statement than any run this stage has ever
+   seen close honestly.
 8. **Every repository is closed, the parent included** — `git submodule status`
    shows no `+`, and each repo is clean and pushed. A submodule is finished when
    its parent points at it.

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

@@ -291,6 +291,25 @@ construction**:
    every pass that reads for wrongness. Sweep the change for actions trusted by
    their own reply. Definition and the known shapes: [`gates.md`](gates.md) →
    *False success*.
+6. **Re-derivation** — take a number the audit has already produced and produce it
+   again with a command of a **different shape**, then print both. Not a second
+   opinion: a second *route*. Re-running the same command is a spell-check of the
+   first run; asking a different question that must land on the same number is the
+   only version that can come back disagreeing. The exit criterion is **the pair
+   printed** — never "verified", never "matches". A re-derivation reported as
+   agreement is a claim about a measurement nobody can see.
+
+   ```
+   claimed:    the version invariant is four-way          (CONTRIBUTING.md, prose)
+   re-derived: grep -rl '"version"\|^## v' --include='*.json' --include='*.md' . \
+                 | wc -l                                  -> 5 surfaces
+   verdict:    REFUTED — the sentence and the corpus disagree; the corpus wins
+   ```
+
+   Rotate onto this axis when the reading axes go quiet **and the change carries
+   numbers**: counts in prose, thresholds, "N of M" claims, anything a document
+   asserts about itself. Its yield is not proportional to effort — it is
+   proportional to how long the first number went unchallenged.
 
 **The crossover is measurable, so measure it.** Every pass, count two numbers: new
 findings, and findings caused by the previous pass's own fixes. When the second
@@ -310,6 +329,7 @@ beside the verdict**:
 ```
 GATE 6 tests: PASS — full suite green (247 tests)
   carry-over: 4 open (was 6) · unresolved: 0 · audit findings deferred: 2
+  abstained: 1 (1 cannot-verify) · unlooked: 2 dormant
 ```
 
 The difference from a TODO is not bookkeeping. A TODO is invisible until somebody

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

@@ -1,4 +1,4 @@
-# Gates — the two axes, and how to build one that cannot lie
+# Gates — the three axes, and how to build one that cannot lie
 
 **One job: turn a rule into something that can say no.** [`audit.md`](audit.md)
 says a class seen twice *belongs in a script*; this file is where that script comes
@@ -32,6 +32,7 @@ elsewhere and is not restated here:
 - Probing — plant, run, restore
 - The false-positive budget
 - Ratchets
+- Disclosures — counted like a ratchet, and deliberately not monotone
 - Where a gate runs
 - Adding a check to an existing gate
 - Rationalizations
@@ -300,10 +301,58 @@ A **ratchet** is a named, counted set that may only shrink, printed on every run
 
 ```
 GATE 9 docs: PASS — propagation backlog: 121 (was 162) · unmarked residue: 0
+  abstained: 0 · unlooked: 4 (3 dormant · 1 skip — no submodules in this repo)
 ```
 
 A ratchet nobody prints is a TODO with a better name.
 
+## Disclosures — counted like a ratchet, and deliberately not monotone
+
+A ratchet may only shrink. **Some numbers must not be**, and printing them under a
+ratchet's discipline inverts the thing they measure.
+
+**Abstention is the case that matters.** This bundle has eight vocabularies for declining
+to claim — `partial`, `unknown`, `cannot verify from diff`, `review`, `dormant`, `skip`,
+`recalled`, `ungated` — and until they were counted, none of them appeared beside a
+verdict. So `PASS` read as *verified* rather than as *"green, and here is what nobody
+claimed"*.
+
+The obvious fix is a ratchet, and it is wrong. A count of abstentions that may only shrink
+puts pressure on exactly one thing: **claiming more**. A run reaching `abstained: 0` is not
+more careful; it is a run that stopped saying *I don't know*, which is the cheapest way to
+make the number fall. Refusals and wrong answers are communicating vessels — squeeze one
+column and it reappears in the other, silently, because a wrong claim looks like a claim.
+
+So a **disclosure** is printed beside the verdict like a ratchet and carries the opposite
+rule: **no floor, no direction, and a movement in either direction wants one sentence.**
+
+Two disclosures, kept separate because they are different facts:
+
+| Disclosure | Counts | Reading it |
+|---|---|---|
+| `abstained: N` | claims the run **declined to make** — `partial`, `unknown`, `cannot verify from diff` | a *choice*. Rising can mean the work got harder or the run got honest; falling can mean either the reverse |
+| `unlooked: N` | checks that **did not look** — `dormant`, `skip` | a *state of the corpus*, not a decision. It falls as the project grows the inputs those checks need |
+
+Three are deliberately **not** counted, and saying which is part of the disclosure:
+
+- **`review`** — *no check can decide this* — is an abstention, and it is the one this
+  section first listed and then forgot, which is exactly the failure it exists to catch.
+  It stays out of `abstained` because it is not a claim the run declined: it is a rule
+  that **declined to be mechanical**, recorded once at rung 2 with its reason (→ *Axis B*).
+  Counted per run it would report the same standing number every time and say nothing
+  about the run.
+- **`recalled`** — a property of one claim, already carried in the ledger beside the
+  command that would re-derive it.
+- **`ungated`** — a property of the whole run, said once, in words.
+
+A vocabulary that is named and then left out of every bucket is the one that goes
+uncounted forever. So each gets its line, including the one that got missed here.
+
+**What makes a disclosure honest rather than decorative** is the same thing that makes a
+ratchet honest: it is *computed*, and it is printed whether or not anyone likes the
+number. What makes it different is that **nobody may set a target for it.** A target on an
+abstention count is an instruction to guess.
+
 ---
 
 ## Where a gate runs

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

@@ -196,6 +196,7 @@ does ([`audit.md`](audit.md) → *What can't be fixed now becomes a ratchet, nev
 ```
 GATE 10 acceptance: PASS — 14/14 REQ verified
   carry-over: 0 unresolved · retro: 7 standing (was 9) · retired 3 · added 1
+  abstained: 2 · unlooked: 3
 ```
 
 A pruned list that nobody prints is a list that quietly grows back.

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

@@ -330,7 +330,10 @@ never that the work was skipped quietly.
   is covered; no `skip`/`xfail` smuggling a red suite past the gate. Never advance
   to deploy on a red or partial run. **The carry-over count is printed beside this
   verdict** — a ratchet nobody prints is a TODO with a better name
-  ([`audit.md`](audit.md)).
+  ([`audit.md`](audit.md)) — **and so are the two disclosures**, `abstained` and
+  `unlooked` ([`gates.md`](gates.md) → *Disclosures*): what the run declined to claim,
+  and what a check never looked at. Neither has a floor and neither may be targeted; a
+  target on an abstention count is an instruction to guess.
 - **Web front end? Then the surface is checked in a browser, not in the diff.**
   A passing suite proves the code does what its assertions say. It does not prove the
   page rendered — a component can be correct and land under a fixed header, a request
@@ -513,7 +516,10 @@ never that the work was skipped quietly.
   a messy run is the failure the file exists to stop. Stage 0 reads the standing
   instructions in full next time, which is why the cap is not negotiable.
 - **GATE (manual):** the ladder walk ran and its absences became REQ rows before
-  the table was written; **the retrospective is written — stamped first, then pruned, then the entry; the
+  the table was written; **both disclosures printed beside the verdict** — `abstained` (what the run declined
+  to claim) and `unlooked` (what a check never looked at), neither a ratchet, neither
+  with a floor, neither ever a target ([`gates.md`](gates.md) → *Disclosures*); **the
+  retrospective is written — stamped first, then pruned, then the entry; the
   list at or under its cap, every deletion logged in the archive with its commit,
   entries older than five run stamps rotated into `docs/superpowers/retro/`, the run
   stamped with its commit, every SHA in either file resolvable, and the

package/plugins/task-pipeline/skills/task-pipeline/templates/carryover.md

@@ -36,6 +36,7 @@ set that may only shrink, and it is printed beside every gate verdict:**
 ```
 GATE 6 tests: PASS — full suite green (247 tests)
   carry-over: 4 open (was 6) · unresolved: 0 · audit findings deferred: 2
+  abstained: 1 (1 cannot-verify) · unlooked: 2 dormant
 ```
 
 That one line is the whole mechanism. Without it, `PASS` reads as *verified*; with