task-pipeline-skill 1.19.0 → 1.20.0

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # Changelog
 
+## v1.20.0
+
+### State that accumulates locally is created from nothing everywhere else — `learned.md` rule 18
+
+The retro says this class has recurred longer than any other: three sightings across forty entries
+before 2026-08-07, and four more that day alone. Its worst instance: a CI job that started an empty
+database, created the runtime role, and ran the suite — with nothing between those steps applying
+the schema. **1039 failed, 1339 errors, 4704 × `UndefinedTable`**, every suite touching a table, for
+as long as the repository had real tests. Invisible locally by construction: the compose database is
+migrated once by hand and stays migrated, so every author has a schema and the runner has none.
+
+Local state is *cumulative*; CI state is *constructed*. A green obtained on the cumulative one
+carries an unstated premise, false in the only environment that matters.
+
+- `references/learned.md` — rule 18 and incident 18.
+- `references/tdd.md` — "The green from residue": run the suite once against a freshly created
+  instance, and name it in the report. "Green" and "green against a database created ten seconds
+  ago" are different claims; only the second predicts CI.
+- `references/grill.md` + `templates/brief.md` — sweep row `0 Fixtures`: what persists between runs
+  here, and the command that recreates it from nothing.
+- `test/validate.py` — a guard, watched failing against two planted defects.
+
 ## v1.19.0
 
 ### The copy you are about to edit may not be the copy that ships — `learned.md` rule 17

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.19.0 |
+| **Version** | 1.20.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) |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "task-pipeline-skill",
-  "version": "1.19.0",
+  "version": "1.20.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.19.0",
+  "version": "1.20.0",
   "author": {
     "name": "ssheleg",
     "url": "https://x.com/sshlg93"

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

@@ -142,6 +142,7 @@ explicit "stop and ask me here":
 | run-wide | the model decision ([`model-tiering.md`](model-tiering.md)); what to decide autonomously vs escalate |
 | run-wide Pacing | the **run mode** ([`continuity.md`](continuity.md)): does the run advance item-by-item with no check-in between items, and on what interval? Read `pipeline.json` → `run.loop` first — a recorded mode is the answer and is not re-asked. **Absent, it is off**: recommend it, take the answer, record it. It never collapses a `manual` gate or an outward act, so this row buys pacing, not authorization |
 | 0 Harvest | doc sources beyond this repo — other repos, hosted doc systems, the knowledge wiki, **the code graph** ([`knowledge-graph.md`](knowledge-graph.md): built / installed-not-built / absent) — and whether stage 9 may write to them (another repo is outward: propose + PR, never a direct push) |
+| 0 Fixtures | what **persists between runs** on this machine — a database, a volume, a cache, generated files — and the command that recreates it from nothing. A suite green against accumulated state carries a premise that is false on every runner (`learned.md` rule 18) | the recreate command, stated |
 | 0 Source | for a repository with an upstream — **is this checkout the one that ships**. `git rev-list --count HEAD..@{u}`, printed, before the first edit. Behind means stop and pull: an edit on a stale copy deletes newer work by fast-forward, and nothing complains (`learned.md` rule 17) | the count, stated |
 | 0 Work-list | which register holds task **state** — a roadmap, a board, a backlog, a tracker — and the **command that reads it**. Recorded once; the harvest and every loop iteration re-run it, and a closing report that names what is left cites it. No register → record the row empty, and the rule costs nothing ([`knowledge-sources.md`](knowledge-sources.md) → *Carried-in claims*) |
 | 0 Setup audit | doc map absent or stale: run the entry audit over the existing documentation before building on it ([`setup.md`](setup.md))? Asked once; a refusal is recorded and never re-asked |

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

@@ -42,6 +42,7 @@ to be enforced and is not is the same failure as a gate that prints `FAIL` and e
 | 15 | **Identity before coordination** | any lease, lock, claim or run id | ask what two instances with the same identity would do, and make the tool answer it | two instances demonstrably get two identities |
 | 16 | **A carried-in claim is a recollection** | any run resuming from a summary, a handoff or a compacted context | re-derive the claim from its source before acting on it or reporting it | every state claim the run makes is marked `measured` with the command behind it, or it is not made |
 | 17 | **The copy you are about to edit may not be the copy that ships** | any run editing a repository that has an upstream — a skill, a plugin, a vendored library, a fork | `git rev-list --count HEAD..@{u}` **before the first edit**; non-zero means stop and pull | the run states the count it measured, or it has not started |
+| 18 | **State that accumulates locally is created from nothing everywhere else** | any run whose tests, migrations or fixtures read a database, a cache or a checkout that persists between runs on this machine | run the suite once against a **freshly created** instance of it, not the one that has been here for weeks | the run names the fresh instance it used, or the green is a green from residue |
 
 ---
 
@@ -127,6 +128,8 @@ run's belief about the work-list against the register; the claim only ever appea
 
 **17 · The stale source.** A machine keeps its skills in two places: the working copy it publishes from and the installed plugin it runs. On 2026-08-07 the working copy was **two commits behind its own origin** — `v1.16.2` against `v1.18.0` — and the newer commits carried rule 16 itself. The repository was clean, nothing had diverged, and `git status` said so; the copy was simply never pulled. An edit made there would have landed on top of 1.16.2, and the release would have **silently deleted rule 16 and everything else in two versions** — not as a conflict, which git would have shown, but as a fast-forward over work that was already published. The project's own instruction names that directory as the source, so the person doing it would have been following the documentation. Nothing in the pipeline asked the one question that separates a source from a copy of one, and the check is a single command.
 
+**18 · Residue.** A service's CI job started an empty database, created the runtime role in it, and ran the suite. Nothing between those two steps applied the schema. The result was **1039 failed, 1339 errors, 4704 × `UndefinedTable`** — every suite that touches a table — and it had been that way for as long as the repository had real tests. It was invisible because it is invisible *locally*: the compose database is migrated once, by hand, and stays migrated, so every author's machine has a schema and the runner's has none. The same day, in the same repository, a second instance: sixteen production tables owned by the **serving** role, because a migration had once been run as whoever was at the keyboard. Neither is a test defect. Both are the difference between state that accumulates and state that is created, and the only thing that tells them apart is running against something new.
+
 The same class had already bitten that project twice from the other side, and its roadmap names the
 property exactly: seven rows read `blocked` on producers the dependency board recorded as delivered,
 and *"no gate can catch it because it breaks nothing — it only removes work from consideration"*;

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

@@ -11,6 +11,7 @@ into this skill; nothing to install.
 
 - The iron law
 - Red → green → refactor
+- The green from residue
 - Tests that stay honest
 - Stage 6 — consolidation and the suite gate
 - When stuck
@@ -63,6 +64,26 @@ Tests stay green. No new behavior enters here.
 
 Then the next failing test.
 
+## The green from residue
+
+`learned.md` rule 18. A suite that passes here and fails on a runner is usually not flaky and not
+environment-specific — it is reading **state that accumulated on this machine** and is created from
+nothing everywhere else. A database migrated once by hand months ago, a cache warmed by an earlier
+run, rows a previous suite left behind, a checkout whose generated files were never regenerated.
+
+Local state is *cumulative*; CI state is *constructed*. Every green obtained on the cumulative one
+carries an unstated premise, and the premise is false in the only environment that matters.
+
+Once per feature, and always before calling a suite green:
+
+```bash
+# whatever "new" means here — a fresh database, a clean volume, a new container, a fresh clone
+docker compose down -v && docker compose up -d && <migrate> && <test>
+```
+
+Name the fresh instance in the report. "The suite is green" and "the suite is green against a
+database created ten seconds ago" are different claims, and only the second one predicts CI.
+
 ## Tests that stay honest
 
 - **Before writing a test, name the production change that would make it fail.**

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

@@ -120,6 +120,7 @@ is not neutral — it is a scheduled interruption.
 | run-wide | Decide autonomously vs escalate to me | … |
 | run-wide Pacing | Run mode: item-by-item with no check-in between items, and on what interval? (the skill's `references/continuity.md`; read `pipeline.json` → `run.loop` first) | … (**absent ⇒ off**; it never collapses a manual gate or an outward act) |
 | 0 Harvest | Doc sources beyond this repo — other repos, hosted docs, the knowledge wiki, the code graph; and may stage 9 write to them? | … (another repo is outward: propose + PR, never a direct push; graph built / not built) |
+| 0 Fixtures | the command that recreates local persistent state from nothing, and the run's statement that the suite was seen green against it (`learned.md` rule 18) | |
 | 0 Source | `git rev-list --count HEAD..@{u}` before the first edit, printed. Behind means stop and pull — an edit on a stale checkout deletes newer work by fast-forward and nothing complains (`learned.md` rule 17) | |
 | 0 Work-list | Which register holds task **state**, and the command that reads it — re-run at every harvest, at every loop iteration and at the close | … (e.g. `bash scripts/board.sh`; none → record empty) |
 | 0 Setup audit | … (yes / no — recorded either way) | doc map absent or stale: run the entry audit over the existing documentation before building on it (the skill's `references/setup.md`)? Asked once; a refusal is recorded and never re-asked |