task-pipeline-skill 1.13.0 → 1.14.0

package/CHANGELOG.md

@@ -1,5 +1,55 @@
 # 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

package/CONTRIBUTING.md

@@ -210,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/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.13.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` — 80 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.** 80 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

@@ -450,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 80 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.13.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.13.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/portability.md

@@ -66,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:**