task-pipeline-skill 1.12.0 → 1.14.0

package/CHANGELOG.md

@@ -1,5 +1,94 @@
 # Changelog
 
+## v1.14.0 — 2026-08-05
+
+### Added — false success: the failure mode that removes the reason to look
+
+Every incident this repository has recorded of a mechanism reporting a win it never
+checked was fixed as its own instance, because the class had no name to be swept by:
+the hook that fails open (any exit code but `2` is non-blocking, so a **crashed**
+guard *allows* the action), the cancel that accepted an id that was never scheduled
+and returned success, the counter that asserted the new number was present instead of
+the old one being gone — green for three releases while four surfaces printed the old
+one — and R-002's batch of edits reporting done while one edit never applied.
+
+- **`references/gates.md` gains the class**: the law (*an actor's own reply is not
+  evidence about the world*), the five known shapes, the test that separates a checked
+  pass from a silent one — *what does it print when it did not look?* — and two rules:
+  verify by re-reading rather than by the reply, and assert the **absence of the old**
+  rather than the presence of the new.
+- **`references/audit.md` gains a fifth axis.** The four existing axes read for
+  wrongness, which is exactly what a false success is not. The new axis asks where a
+  mechanism can report a win it never checked.
+- **The other files cite the class, never restate it.** `continuity.md`'s cancel rule
+  became one named instance instead of a second definition.
+
+### Added — effect verification: the diff cannot show what the task did
+
+`v1.12.0` added a hygiene gate over what a task **wrote**. It is blind to what a task
+**did** — a file moved, a job cancelled, a service restarted, a record migrated — and
+the implementer's report is not evidence about any of it.
+
+- **`references/build.md`**: the implementer contract now requires a `verified-by:`
+  line for every step whose effect lives outside its own diff, carrying the command
+  that *confirmed* the state rather than the one that caused it. The hygiene-gate
+  section names its own blind side and tells the controller to read those lines back.
+- **`references/review.md`**: a new rubric item — **Effect verification** — rated
+  **Important**, not Minor. A finding that never blocks is a finding the fix loop
+  never sees.
+
+### Guards — 80 → 94
+
+Fourteen new checks, each with a negative self-test whose plant asserts it landed
+before the edit. Two invariants added to `CONTRIBUTING.md`, both citing a literal the
+validator actually prints. The negatives floor moved 80 → 94.
+
+**One defect found by this run's own discipline:** the first draft of these guards was
+appended *below* the validator's verdict block, so on a clean run they executed after
+`PASS` was printed and on a corrupted one they never executed at all — fourteen guards
+that could not fail. The negatives runner caught it because it requires positive
+evidence (`OK:` in stdout), not merely a non-zero exit. A runner that accepted silence
+would have shipped the exact defect this release is about.
+
+## v1.13.0 — 2026-08-05
+
+### Added — the read-back: four rules that existed and were never handed over
+
+Stages 3 and 4 produced documents stating things nobody verified: that a named
+check exists, that the spec agrees with decisions already made, that the
+self-review happened at all, and that the change still costs what it was worth.
+
+Five defects, and **four of them are one shape.** The rule already lived in this
+bundle, in a stage that never handed it to the stage which had to obey it. The
+evidence-for-checks rule sits at stages 6 and 10; the rejected-alternatives rule
+sits at stage 2; `learned.md` rule 14 has sat at stage 9 since v1.4.0. Stage 3
+names checks, contradicts decisions and writes DoDs — and read none of them back.
+
+So the fix is one mechanism applied four times. `spec.md`'s self-review now asks
+whether every check it names is real, reads back the brief's `Decisions locked`
+table **and** the alternatives stage 2 rejected, and prints the cost.
+`planning.md` asks whether every command, path and file a DoD names resolves.
+`learned.md`'s stage map binds rule 14 at 3 and 4, not only at 9.
+
+**The fifth is a genuine absence, and it prints rather than decides.** Nothing
+anywhere asked whether a change had outgrown its worth. The new checkpoint counts
+surfaces, guards and REQ rows now versus at stage 2 and prints all three — the
+stage-3 gate is the operator's, and an agent that narrows the task on its own
+judgement breaks *never narrow the task silently*.
+
+**Both self-reviews now leave a committed trace.** A `## Self-review` section,
+identical in shape across the two files, every line a **computed number rather
+than a tick** — because a number nobody computed is visible as such and a
+checkbox never is. `planning.md` already demanded the REQ set difference be
+*printed*; this extends that principle to the rest of the checklist.
+
+Three guards prove the files carry the items, with four probes. What they cannot
+prove is that a run in someone else's repository performed a self-review — and
+that boundary is stated in the spec, in the guard's own comment and here, because
+a guard claiming otherwise would be the exact defect this release fixes.
+
+Negative self-tests: 76 → 80.
+
 ## v1.12.0 — 2026-08-05
 
 ### Added — a gate for the defects an agent leaves behind

package/CONTRIBUTING.md

@@ -124,6 +124,13 @@ scripts are validated by one iterated block, not two copies, and both must keep
 `# ---------- VERDICT` marker with nothing after it.
 *(guard: `the VERDICT block must be last and must `)*
 
+**Stages 3 and 4 must keep reading their rules back.** `spec.md`'s self-review asks
+whether every check it names is real, reads back the brief's decisions and stage 2's
+rejected options, and prints the cost; `planning.md` asks whether every command a DoD
+names resolves; `learned.md` binds rule 14 at both stages. Both files carry a
+committed `## Self-review` section of computed numbers rather than ticks.
+*(guard: `the self-review no longer asks `)*
+
 **11. Every reference over 100 lines carries a `## Contents` list**, and the list is
 compared against that file's own `##` headings. The guidance asks for it because a
 long file gets previewed with a partial read; the comparison is because a hand-kept
@@ -203,7 +210,22 @@ releases and the link checker stayed green throughout, because it resolves from
 file's home. Name the file in a code span instead — the same rule the Cursor rule
 follows, for the same reason. *(guard: `resolves only from`)*
 
-**28. Every invariant above names the guard that enforces it, and that guard exists.**
+**28. The False success class has one home, and the files that use it cite it.**
+`references/gates.md` defines it — the law, the did-not-look test, and its two
+rules; `audit.md` (the fifth axis), `build.md`, `review.md` and `continuity.md`
+point at that section instead of restating it. Every incident this repository has
+recorded of a mechanism reporting a win it never checked was fixed as its own
+instance, because the class had no name to be swept by.
+*(guard: `the False success class is gone`)*
+
+**29. A side effect is confirmed by re-reading the state, never by the reply.**
+`references/build.md` binds the implementer to a `verified-by:` line for every
+step whose effect lives outside its own diff, and names the hygiene gate's blind
+side; `references/review.md` rates an effect asserted without one as **Important**,
+not Minor. A finding that never blocks is a finding the fix loop never sees.
+*(guard: `the report no longer requires verified-by lines`)*
+
+**30. 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

package/README.md

@@ -129,6 +129,7 @@ until it is installed.
 | any loop | [`loop-guard.md`](plugins/task-pipeline/skills/task-pipeline/references/loop-guard.md) — churn detection, caps, the break protocol |
 | 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 |
 | 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 |
 

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.12.0 |
+| **Version** | 1.14.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 (15 evals, 5 categories). **Never executed** — see [`evals/RESULTS.md`](evals/RESULTS.md) |
@@ -38,7 +38,7 @@ apply.
    instruction surface, and every one is linked directly from `SKILL.md`.
 2. Read `templates/docgate.sh` before seeding it; it is the only shipped script a
    host project will run on its own repository.
-3. Run `npm run test:all` — 76 guards, each with a negative self-test that plants a
+3. Run `npm run test:all` — 94 guards, each with a negative self-test that plants a
    defect and requires rejection.
 4. Run `python3 evals/run.py` for the behavioural protocol, and read
    `evals/RESULTS.md` for what has actually been observed.
@@ -54,7 +54,7 @@ apply.
 - **Versions are pinned by git tag** and mirrored into `sshlg-skills`'s catalogue.
   Rollback is `git checkout v<previous>` or pinning the previous plugin version;
   the previous version is never deleted.
-- **Behavioural evidence is missing, not merely thin.** 76 structural guards prove
+- **Behavioural evidence is missing, not merely thin.** 94 structural guards prove
   the skill is well-formed. Until `evals/RESULTS.md` carries a dated run, nothing in
   this repository proves it *behaves* — triggers correctly, stays quiet on a
   question, or performs the steps it documents.

package/cursor/rules/task-pipeline.mdc

@@ -197,6 +197,13 @@ not authorize an outward, irreversible action — stage 7 stops and asks.
    exact values every later task inherits. Self-review it for placeholders,
    contradictions, ambiguity and scope before showing it. For UI tasks, run the UX
    chain FIRST (see super-ux below) and embed it.
+   **Before handing a spec or a plan over, read your rules back:** does every
+   check you named actually exist (or say `review`)? does anything here
+   contradict a decision already locked, including an option deliberately
+   rejected? how many surfaces, guards and requirements is this now versus
+   when the design was approved — print all three and let the operator
+   decide. Leave the answers as a committed `Self-review` section of
+   computed numbers, not ticks.
 4. **Plan** (auto) — every task names the REQ ids it `Implements:`, and the set of those ids must **equal** the brief's REQ set — a difference is scope lost, print it and fix it. Zero-context tasks: exact paths, complete code in every step,
    the exact command and its expected output, TDD steps, DoD each, dependency graph
    + parallel groups, non-overlapping file ownership. **No placeholders** — no TBD,
@@ -443,6 +450,33 @@ is not portable and silently edits nothing on BSD), run, assert `$?` is non-zero
 restore, assert zero. **Doubt the probe before the check** — four of five silent
 probes on a real project were the probe's fault. Record the probe.
 
+## False success — the failure that removes the reason to look
+
+An actor's own reply is not evidence about the world. A failure is loud and gets
+fixed; a mechanism that reports a win it never checked is silent, so it survives
+every pass that reads for wrongness. Known shapes: a hook that fails open (any exit
+code but 2 is non-blocking, so a crashed guard ALLOWS the action), a cancel that
+accepts an id that was never scheduled and returns success, a check asserting the
+new value is present instead of the old one being gone, a batch of edits reporting
+done while one edit never applied, and a section with no input whose silence is
+read as a pass.
+
+Two rules:
+
+1. **Verify by re-reading, not by the reply.** After a teardown, cancel, delete,
+   disable, publish or migrate — query the authoritative state and assert the new
+   condition.
+2. **Assert the absence of the old, not the presence of the new.** A check that only
+   proves the new value exists stays green while the old one is still shipping.
+
+The test for any mechanism you are about to trust: what does it print when it did
+not look? If that is indistinguishable from what it prints when it looked and found
+nothing wrong, it is not evidence.
+
+**In a build:** every step whose effect lives outside your own diff carries a
+`verified-by:` line — the command that CONFIRMED the state, not the one that caused
+it. A step without one is unverified, not done, and a review rates it Important.
+
 ## Hooks — the limit first
 
 Hooks exist **only in Claude Code**. Elsewhere the same rules run as a self-check

package/evals/RESULTS.md

@@ -37,7 +37,7 @@ or it belongs in a check.
 | Dated runs recorded | **0** | 2026-08-03 |
 
 The bottom two numbers are the honest state of this skill's behavioural evidence.
-Everything else in this repository is proven by 76 structural guards that check the
+Everything else in this repository is proven by 94 structural guards that check the
 *form*; these are the only checks that would speak to the *behaviour*, and they have
 not been run yet. Printed here so "63 of 63 green" is never read as "the skill is
 known to work".

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "task-pipeline-skill",
-  "version": "1.12.0",
+  "version": "1.14.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.12.0",
+  "version": "1.14.0",
   "author": {
     "name": "ssheleg",
     "url": "https://x.com/sshlg93"

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

@@ -228,6 +228,12 @@ construction**:
    doc naming a module the graph has no node for describes something that no longer
    exists. This axis is the only one that finds absences without reading for them,
    which is why it is worth rotating onto when the reading axes go quiet.
+5. **False success** — not *"is this check correct"* but *"what does this mechanism
+   print when it did not look?"* Wrongness is loud and the reading axes above find
+   it; a mechanism that reports a win it never checked is silent, so it survives
+   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*.
 
 **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

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

@@ -188,8 +188,12 @@ Record the implementer's agent identity: fix rounds 1–3 resume it.
 > code exists before a test you **watched fail**: write the failing test → run it
 > and confirm it fails for the right reason → write the minimal code that passes →
 > run it and confirm it passes, with the rest of the suite still green → commit.
-> Assert on real behavior, never on mock behavior. Commit as you go, conventional
-> commits. When done, self-review your diff, then write the full report to
+> Assert on real behavior, never on mock behavior. **Any step with a side effect
+> outside your own diff — a command that moves, deletes, publishes, migrates,
+> restarts or cancels something — is confirmed by re-reading the state it changed,
+> never by the command's own reply; record each one in the report as a
+> `verified-by:` line carrying the command you ran to confirm and its output.**
+> Commit as you go, conventional commits. When done, self-review your diff, then write the full report to
 > `<report path>`:
 > what you built, the files touched, the commits, the test command and its
 > output, decisions you made, anything you're unsure about. Return **only**:
@@ -272,6 +276,14 @@ instruction R-002 — and it is invisible in a status report. Found one task lat
 costs a re-dispatch; found eight tasks later it is fixed by an agent that no longer
 remembers the code.
 
+**The hygiene gate reads what the task wrote; it cannot see what the task did.**
+A file the task moved, a job it cancelled, a service it restarted, a record it
+migrated — none of that is in the diff, and the implementer's report is not evidence
+about it either. Before the review, read back the report's `verified-by:` lines:
+every side-effecting step must carry the command that **confirmed** the state, not
+the command that caused it. A step with no such line is unverified, not done
+([`gates.md`](gates.md) → *False success*).
+
 **The gate never edits. Fixing is yours.** A finding is repaired inside the same
 task, or it becomes a carry-over row with a reason — never a silent pass. A gate
 whose findings nobody acts on is a slower way of ignoring them.

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

@@ -136,8 +136,8 @@ job list should agree with that.
 **Verify the cancel by listing the jobs, never by the cancel's own reply.** A
 teardown call will happily accept an id that was never scheduled and report
 success, which leaves the real job running while the transcript says it stopped.
-List afterwards and read the list. This is the same law the rest of this pipeline
-applies to every gate — a green nobody watched is not evidence — and a loop is
+List afterwards and read the list. This is one instance of a named class —
+[`gates.md`](gates.md) → *False success*, rule 1 — and a loop is
 exactly where breaking it goes unnoticed, because the symptom is a message
 arriving on time.
 

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

@@ -26,6 +26,7 @@ elsewhere and is not restated here:
 - Axis C — degrees of freedom
 - Progressive arming
 - Before you run a check
+- False success — when a mechanism reports a win it never checked
 - Anatomy of a project gate
 - Writing the check itself
 - Probing — plant, run, restore
@@ -136,6 +137,40 @@ Four preconditions. Skipping any of them turns a run into a claim.
 
 ---
 
+## False success — when a mechanism reports a win it never checked
+
+The four preconditions above protect a *check*. The same law binds an **action**:
+
+> **An actor's own reply is not evidence about the world. Confirm an effect by
+> re-reading the state it changed.**
+
+A failure is loud and gets fixed on the pass that finds it. A false success is
+silent and **removes the reason to look**, which is why every shape below survived
+at least one release in this repository:
+
+| Shape | What reported success | What was actually true |
+|---|---|---|
+| Fail-open hook | any exit code but `2` is non-blocking, so a **crashed** guard *allows* the action | the guard never ran |
+| Teardown by reply | a cancel accepted an id that was never scheduled and returned success | the job was still armed |
+| Presence instead of absence | a counter asserted the new number was present, not that the old one was gone | four surfaces still printed the old number, green for three releases |
+| Half-applied batch | a batch of edits reported done while one edit never applied (R-002) | the file was unchanged |
+| Silence read as a pass | a section with no input printed nothing, and the caller counted it as checked | nothing was looked at |
+
+**The test.** For any mechanism you are about to trust, ask:
+*what does it print when it did not look?* If that is indistinguishable from what
+it prints when it looked and found nothing wrong, it is not evidence — give it a distinct `dormant`
+or `skip` state (→ *Progressive arming*), or verify the effect independently.
+
+Two rules follow. Elsewhere in this bundle they are **cited, never restated**:
+
+1. **Verify by re-reading, not by the reply.** After a teardown, cancel, delete,
+   disable, publish or migrate: query the authoritative state and assert the item's
+   new condition.
+2. **Assert the absence of the old, not the presence of the new.** A check that only
+   proves the new value exists stays green while the old one is still shipping.
+
+---
+
 ## Anatomy of a project gate
 
 Ten properties. Each one is here because its absence has shipped.

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

@@ -154,6 +154,8 @@ answer would have exposed it in a minute.
 | 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 |
+| 3 Spec | 14 — every check the spec **names** must resolve at the moment it is named, or be marked `review` |
+| 4 Plan | 14 — every command, path and file a DoD names must resolve |
 | 9 Docs | 8, 14 — every number computed, every target resolvable |
 | 10 Acceptance | 1, 3, 6, 7 — axis rotation recorded, closure verified against artefacts, classes swept, ratchets printed |
 

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

@@ -193,6 +193,34 @@ A checklist you run yourself, inline. No subagent:
 5. **Parallel safety:** no two tasks in the same group write the same file; every
    `depends:` points at a task that really produces what's consumed.
 6. **DoD present and verifiable** on every task.
+7. **Every command, path and file a DoD names resolves.** Walk each task's
+   *Definition of done* and its steps and check the targets exist — a DoD that says
+   `npm run lint:paths` when no such script exists is an instruction the implementer
+   cannot follow and a check the acceptance cannot run.
+   [`learned.md`](learned.md) rule 14 has said *every target resolvable* since
+   v1.4.0 and fired only at stage 9 — four stages after the target is written here.
+8. **Run the hygiene gate** over what this stage wrote and record its counts below.
+
+**R-003 asked of this file, and answered:** `spec.md`'s items 8 and 9 — reading
+decisions back, and printing the cost — deliberately do **not** appear here. This
+stage settles nothing (see below), so it has no decisions to contradict and no scope
+of its own to grow. Its sibling's item 7 does belong, reworded for DoDs.
+
+### The `## Self-review` section — committed, not asserted
+
+Identical in shape to `spec.md`'s, so one habit covers both stages. Last section
+before the gate; every line a **computed number, not a tick**.
+
+```markdown
+## Self-review
+
+- REQ coverage: <n> in brief, <n> covered, difference <set or ∅>
+- Named checks: <n> named, <n> resolve, <n> marked `review`
+- Decisions: checked against <the brief's D-table> and <stage 2's rejected options> — <verdict>
+- Cost: <surfaces>/<guards>/<REQ> now, <…> at stage 2 — <proportionate | grown, and why>
+- Hygiene: <n> checks, <n> findings, <n> open
+- Placeholders: <n> · Ambiguity: <n> found, <n> resolved inline
+```
 
 ## This stage settles nothing — and that is a rule, not an omission
 

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

@@ -58,6 +58,7 @@ a row pointing outside the bundle is the defect this file exists to catch.
 | **The routing default and its boundary** | `templates/routing-rule.md` |
 | The seeded doc map, registers and gate | `templates/docmap.md`, `templates/decisions.md`, `templates/open-questions.md`, `templates/docgate.sh` |
 | Which agent-introduced defects are found, and that the agent fixes them rather than the script | `templates/hygiene.sh`, `references/build.md` |
+| What a stage-3/4 self-review must read back, and that its trace is computed numbers | `references/spec.md`, `references/planning.md`, `references/learned.md` |
 | What a stage reads, and which host files bind it | `references/artifacts.md` |
 | The design conversation, its hard gate, UI detection, user paths | `references/brainstorm.md` |
 | Cutting a platform into modules, brick criteria, build order | `references/decomposition.md` |
@@ -65,6 +66,8 @@ a row pointing outside the bundle is the defect this file exists to catch.
 | The zero-context plan format, parallel groups, set equality | `references/planning.md` |
 | Workspace isolation, the subagent loop, who may write the register | `references/build.md` |
 | The review rubric, diff packages, the three verdicts | `references/review.md` |
+| **False success** — the class, its known shapes and its two rules | `references/gates.md` |
+| **Effect verification** — the `verified-by:` contract and the rubric item that blocks | `references/build.md`, `references/review.md` |
 | The TDD iron law and the suite gate | `references/tdd.md` |
 | The REQ coverage table, evidence rules, the closing question | `references/acceptance.md` |
 | How the host project's own conventions are read | `references/conventions.md` |

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

@@ -88,14 +88,20 @@ Review in this order; stop reading the diff only when you've covered all of it.
    passes regardless of the production code. No `skip`/`xfail`/commented assertion
    smuggling a red suite past a gate. New behavior has a covering test; the failure
    path has one too.
-6. **Error handling and degradation.** Every external call (network, DB, file, MCP,
+6. **Effect verification.** Claims about the world outside the diff — a migration
+   run, a job cancelled, a file moved, a service restarted, an artifact published —
+   carry evidence that the **state was re-read**, not that the command returned
+   success. A report asserting an effect with no `verified-by:` line is an
+   unverified claim, and it is **Important**, not Minor
+   ([`gates.md`](gates.md) → *False success*).
+7. **Error handling and degradation.** Every external call (network, DB, file, MCP,
    API) handles failure, and the failure is reported honestly rather than swallowed.
-7. **Boundaries and clarity.** One responsibility per unit; names that say what the
+8. **Boundaries and clarity.** One responsibility per unit; names that say what the
    thing is; no duplication of a logic block that should be shared; nothing left
    dead.
-8. **Security.** No secrets in code, logs or fixtures; input validated at the
+9. **Security.** No secrets in code, logs or fixtures; input validated at the
    boundary; no new injection or path-traversal surface.
-9. **Docs in the same change.** Module docs, runbooks and (for UI work) the
+10. **Docs in the same change.** Module docs, runbooks and (for UI work) the
    super-ux layers updated alongside the code, not deferred.
 
 **Severities:**

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

@@ -143,6 +143,42 @@ Read what you wrote with fresh eyes and fix inline. No subagent, no second pass:
 4. **Scope:** is this one implementable plan, or does it need decomposition?
 5. **Ambiguity:** can any requirement be read two ways? Pick one and say it.
 6. **Traceability (UI):** does every user-facing requirement name its scenario ID?
+7. **Every check this spec names resolves.** Walk the verification claims — the
+   table, and every sentence that says how something is proven. For each: does that
+   check exist today, or is this plan building it? A check that is neither is **not**
+   a verification: mark it `review` and say so, or build it. This repository's whole
+   doctrine is that a green from a check nobody watched fail is not evidence — and
+   this stage is where checks are first *named*, which is one step earlier than
+   anyone was looking.
+8. **Read the decisions back.** Open the brief's `## Decisions locked` table **and**
+   the register entries stage 2 recorded for the alternatives it *rejected*
+   (`references/brainstorm.md` → *The approved design is a set of decisions*). Does
+   any contract here contradict one? Resolve it **out loud** — amend the spec, or
+   reverse the decision and record the reversal. A spec that quietly contradicts a
+   settled decision re-opens a question the operator already answered.
+9. **Print the cost.** Count the surfaces this spec touches, the guards it adds and
+   the REQ rows, now versus at stage 2. **Print all three and decide nothing.**
+   Growth is information for the operator, whose gate this is; an agent that narrows
+   the task on its own judgement breaks *never narrow the task silently*.
+10. **Run the hygiene gate** over what this stage wrote and record its counts below.
+
+### The `## Self-review` section — committed, not asserted
+
+The checklist above leaves a **committed trace**, last section before the gate.
+Every line carries a **computed number, not a tick**: a number nobody computed is
+visible as such, and a checkbox never is. `planning.md` uses the identical shape, so
+one habit covers both stages.
+
+```markdown
+## Self-review
+
+- REQ coverage: <n> in brief, <n> covered, difference <set or ∅>
+- Named checks: <n> named, <n> resolve, <n> marked `review`
+- Decisions: checked against <the brief's D-table> and <stage 2's rejected options> — <verdict>
+- Cost: <surfaces>/<guards>/<REQ> now, <…> at stage 2 — <proportionate | grown, and why>
+- Hygiene: <n> checks, <n> findings, <n> open
+- Placeholders: <n> · Ambiguity: <n> found, <n> resolved inline
+```
 
 ## Locked contracts are decisions — the register, not only the spec
 

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

@@ -251,7 +251,10 @@ never that the work was skipped quietly.
   `SCR-` screens, the CJM stages the feature serves, and the UX
   patterns/principles from super-ux that apply (`best-practices.md`,
   `ux-design-principles.md`, `component-guidelines.md`).
-- **GATE (manual):** spec committed **and** user-reviewed; **every section carries
+- **GATE (manual):** the **`## Self-review` section written and committed with
+  computed values** — every check the spec names resolving or marked `review`, the
+  brief's decisions and stage 2's rejected options read back with no unresolved
+  contradiction, and the cost delta printed; spec committed **and** user-reviewed; **every section carries
   `covers: REQ-…` and every REQ appears in at least one section**; for UI tasks
   additionally: the super-ux chain (foundation → flows → screens → scenarios) is
   designed, validated and approved; scenarios validated in `docs/ux/scenarios.md`;
@@ -270,7 +273,8 @@ never that the work was skipped quietly.
   paths, complete code in every step, TDD steps with expected output, DoD each,
   dependency graph + parallel groups, non-overlapping file ownership, and the
   Global Constraints block copied verbatim from the spec.
-- **GATE (auto):** **set equality — the REQ ids in the brief equal the union of
+- **GATE (auto):** the **`## Self-review` section written with computed values**,
+  every command, path and file a DoD names resolving; **set equality — the REQ ids in the brief equal the union of
   `Implements:` across plan tasks.** A non-empty difference fails the gate and is
   reported as the explicit list of dropped requirements; this is the seam where
   scope leaks silently, so the check is mechanical, not a judgement call. Plus: