task-pipeline-skill 1.16.2 → 1.17.0

package/CHANGELOG.md

@@ -1,5 +1,58 @@
 # Changelog
 
+## v1.17.0 — 2026-08-06
+
+**A carried-in claim is a recollection — `learned.md` rule 16, and the four places
+it binds.**
+
+A long autonomous run advanced one roadmap row per iteration and was correct every
+time: gates green, defects planted and watched to fail, docs closed in the same
+change. What was wrong was the sentence between the iterations — *"the remaining
+rows are these"* — taken from a list that had reached the context through a
+compaction, had once been a filtered subset, and had lost its provenance on the
+way. Eleven iterations later one command over the register printed **36 open rows
+out of 99**. Nothing had failed, because nothing compares a run's belief about the
+work-list against the register: the claim only ever existed in prose.
+
+The same class had already bitten that project twice from the other side, and its
+own roadmap names the property — seven rows reading `blocked` on producers the
+dependency board recorded as delivered, *"no gate can catch it because it breaks
+nothing, it only removes work from consideration"*. **Stale state does not throw.**
+It narrows what gets considered, and every downstream gate then passes honestly on
+the smaller world.
+
+Rule 8 was the neighbour and not the same rule: it governs a number *inside a
+document*, checked when that document is. Rule 16 governs a fact that crossed a
+**session boundary** and is being reported as current — where there is no document
+to check, only a memory that reads like one.
+
+What changed:
+
+- **`references/learned.md`** — rule 16 with its incident, and two binding rows:
+  stage 0 harvest, and stage 10 plus every loop iteration.
+- **`references/knowledge-sources.md`** — a new source (the task register, read for
+  its *state*, with a command) and a new section, *Carried-in claims — measured or
+  recalled*. Every inherited claim starts `recalled`; before it is acted on **or
+  reported to the operator** it is re-derived and marked `measured`, or it is not
+  stated. Three claims go stale most reliably and all three are cheap: the
+  work-list, `green`, and a blocker or premise.
+- **`references/continuity.md`** — in loop mode the harvest's documents may be
+  carried between iterations; the work-list line may not, because the previous
+  iteration is what invalidated it. And *"next up is X"* in a closing report is a
+  claim about the board — the one sentence in the cycle no gate reads.
+- **`references/audit.md`** — a third exit criterion at stage 10: the work-list is
+  re-measured and **printed beside the count the run opened with**. A pair of
+  numbers that has to agree cannot be filled in without looking, which is what
+  keeps the measurement load-bearing instead of ceremonial.
+- **`references/grill.md`** + **`templates/brief.md`** — one autonomy-sweep row:
+  which register holds task state, and the command that reads it. Settled once; a
+  project without one records it empty and the rule costs nothing.
+- **Guard + negative self-test** — the rule's own failure mode applied to itself:
+  doctrine carried in one file reads like doctrine in force. The validator names
+  each consumer, so a file that drops its citation fails rather than silently
+  ending the coverage. Guard count 119 → 120.
+
+
 ## v1.16.2 — 2026-08-06
 
 ### Added — a CI run is checked by reading it, not by assuming it

package/README.md

@@ -58,7 +58,7 @@ Every gate is **typed**: `auto` — the orchestrator verifies it itself, pass/fa
 
 | # | Stage | Gate | Type |
 |---|---|---|---|
-| 0 | Harvest + intake grill — **mandatory** | source ledger written; the documentation inventory answered into `docs/DOCMAP.md`; intent reconciled against as-built; shared understanding + autonomy sweep; brief locked | manual |
+| 0 | Harvest + intake grill — **mandatory** | source ledger written **with the work-list measured, not recalled**; the documentation inventory answered into `docs/DOCMAP.md`; intent reconciled against as-built; shared understanding + autonomy sweep; brief locked | manual |
 | 1 | Docs study | contracts grounded on current docs | auto |
 | 2 | Brainstorm + decompose | design approved; UI verdict recorded; every REQ answered; platform: module map approved | manual |
 | 3 | Spec | committed + reviewed; UI: super-ux chain validated, linter green | manual |

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.16.2 |
+| **Version** | 1.17.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.16.2",
+  "version": "1.17.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

@@ -1,8 +1,8 @@
 {
   "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.16.2",
+  "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 \u2014 no companion plugin required \u2014 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.17.0",
   "author": {
     "name": "ssheleg",
     "url": "https://x.com/sshlg93"

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

@@ -180,7 +180,22 @@ A deliverable is **not** audited when somebody has read it. It is audited when:
 
 1. every rung has its artefact, **and**
 2. **every check you are relying on has fired at least once against a planted
-   defect.**
+   defect**, **and**
+3. **the work-list is re-measured and printed beside the count the run opened
+   with.**
+
+Point 3 costs one command and covers the one claim nothing else reads. A run's
+closing report says what shipped — and then, almost always, what is left and what
+is next. That second half is a statement about the register, and if it came from
+the same list the run started with, it has never been checked against anything. A
+run can be entirely correct and still hand the operator a false map of the work
+([`learned.md`](learned.md) rule 16, [`knowledge-sources.md`](knowledge-sources.md)
+→ *Carried-in claims*).
+
+Printing both numbers is what makes the measurement load-bearing rather than
+ceremonial: **opened 36 open · closed 34 open · 2 rows closed this run.** A row in
+a ledger that nobody reconciles stops being read by the third run. A pair of
+numbers that has to agree cannot be filled in without looking.
 
 **A green result from an unproven check is worth nothing.** This is the iron law of
 [`tdd.md`](tdd.md) — *if you didn't watch it fail, you don't know it tests the

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

@@ -121,6 +121,18 @@ Do not write, and do not believe, that the ledger is what makes the interval saf
 Someone will eventually remove the ledger on the strength of that sentence, and
 the protection they think they are keeping is in the scheduler.
 
+**Each iteration re-measures the work-list.** The harvest's *documents* may be
+carried across iterations — an ADR did not change while you worked. The line that
+says **what is still open** may not: the previous iteration is precisely what
+invalidated it, and a loop that picks its next item from the list it started with
+works a stale board for as long as the loop runs. One command, at the top of the
+iteration, recorded ([`knowledge-sources.md`](knowledge-sources.md) → *Carried-in
+claims*; [`learned.md`](learned.md) rule 16).
+
+This is also where a loop's report goes wrong most quietly. *"Next up is X"* at the
+end of an iteration is a claim about the board, and it is the one sentence in the
+whole cycle that no gate reads. It cites the measurement or it is not written.
+
 ## Parked at a manual gate
 
 A fixed interval firing into a `manual` gate is a nag. Five minutes later it fires

package/plugins/task-pipeline/skills/task-pipeline/references/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 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 |
 | run-wide Escalation | cost of being wrong: decide alone while it stays inside the repository and reversible; escalate price, legal posture, promise, money, reputation, irreversible outward acts. Project exceptions? |
 | 0 Docs regime | where settled things live (the decision home — **one** per project, and an existing `docs/adr/` **is** it), who may write it, whether a lease mechanism is present or the run is `ungated`, the gate command and its ratchet floors, and whether this run may raise a floor ([`documentation.md`](documentation.md)) |

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

@@ -17,6 +17,7 @@ that goes stale when the answer changes.
 - The knowledge wiki — recommended
 - How to harvest — retrieval, not reading
 - Record it — the source ledger
+- Carried-in claims — measured or recalled
 - Phase 2 — validate the answers against the harvest
 - Close the loop — stage 9 updates what stage 0 read
 - Rationalizations
@@ -43,6 +44,7 @@ makes the grill's answers *checkable* instead of merely confident.
 | 3 | **Host agent docs** | `CLAUDE.md`, `AGENTS.md`, `.cursor/rules/` | conventions, commands, deploy path, house rules |
 | 4 | **Domain docs** | `CONTEXT.md` / `CONTEXT-MAP.md`, `docs/adr/` | the glossary and the decisions with their reasons |
 | 4a | **The decision register and the doc map** | `docs/DECISIONS.md` **or** `docs/adr/` — `docs/DOCMAP.md` says which ([`documentation.md`](documentation.md)) | what is already settled, what it superseded, and which documents this run will owe |
+| 4b | **The task register, for its *state*** | `docs/ROADMAP.md`, a board, a backlog, the tracker `CLAUDE.md` names | **what is open right now** — read with a command, never from memory; see *Carried-in claims* |
 | 5 | **Product/UX docs** | `docs/ux/` (super-ux chain), `README`, runbooks | user-facing behavior that is already specified |
 | 6 | **Pipeline history** | `docs/superpowers/specs/`, `plans/`, past `-carryover.md` | what a previous run of this pipeline decided or deferred |
 | 7 | **The retro, in force** | `docs/superpowers/retro.md` ([`retrospective.md`](retrospective.md)) | what previous runs got wrong here — **read in full**: standing instructions (capped at ten), run stamps and the recent-log window, all bounded by construction |
@@ -169,6 +171,49 @@ source nobody will update.
 **"No sources found" is a valid, recorded outcome.** Write the row. An empty ledger
 tells the next run that the search happened and came back empty — silence doesn't.
 
+## Carried-in claims — measured or recalled
+
+The harvest exists because *the operator misremembers*. This section exists because
+**the agent does too**, and it is the harder case: a run that resumes from a
+summary, a handoff note or a compacted context inherits a pile of statements that
+read exactly like findings and have no source attached.
+
+They are not lies and they were not wrong when they were written. They are **stale
+by construction** — a filtered subset that lost its filter, a status true two weeks
+ago, a blocker that cleared while nobody was looking. And unlike a wrong number,
+stale state **does not throw**. It narrows what the run considers, and every gate
+after it passes honestly on the smaller world ([`learned.md`](learned.md) rule 16).
+
+**Every inherited claim starts as `recalled`.** Before it is acted on *or reported
+to the operator*, it is either re-derived from its source and marked `measured`, or
+it is not stated. Add the column to the ledger and use it:
+
+| Claim | Whence | State | Re-derived by |
+|---|---|---|---|
+| 36 of 99 rows open; 4 blocked | `docs/ROADMAP.md` | measured | `bash scripts/board.sh` |
+| the suite is green | prior session | measured | `npm test` → 601 pass |
+| `NBA-046` has no producer | prior session | **recalled** | not checked — do not report |
+
+Three claims that go stale most reliably, and all three are cheap to re-derive:
+
+- **The work-list.** What is open, what is blocked, and *on what*. If the project
+  has a register, the harvest reads it with a command and records the counts. A run
+  that says *"what remains is X"* without this is guessing out loud.
+- **Green.** A suite, a gate, a deploy. Run it; the answer is a minute old, not a
+  session old.
+- **A blocker or a premise.** *"Blocked on Y"*, *"nothing produces this"*,
+  *"that endpoint doesn't exist"*. These clear silently — somebody else's work
+  lands and no signal reaches this run.
+
+**Where the command comes from.** The grill's autonomy sweep settles it once, at
+stage 0: which register holds task state and what reads it. A project without one
+records the row empty and the rule costs nothing.
+
+**And it is per iteration, not per session.** In loop mode ([`continuity.md`](continuity.md))
+the harvest's documents may be carried between iterations — they did not change.
+**The work-list line may not.** It is the one row the previous iteration's own work
+invalidates.
+
 ## Phase 2 — validate the answers against the harvest
 
 This is the payoff, and it belongs to the grill loop
@@ -251,3 +296,6 @@ written list instead of from whatever the search happened to surface.
 | "The operator knows their own system" | They do — a year ago, before three other people changed it. That's the exact case where quoting the doc pays. |
 | "Reading the whole wiki costs too much" | The harvest is a query per task noun, not a read. If it feels expensive, you're reading instead of retrieving. |
 | "I'll update the docs at the end from memory" | The ledger exists because the end is exactly when you no longer remember which sources you leaned on. |
+| "The summary said what's left, that's the same list" | It was a list *once*, under a filter nobody wrote down. Re-deriving it costs one command; being wrong about it costs every iteration after. |
+| "Nothing changed since last iteration" | The previous iteration changed it. That is what an iteration is. |
+| "Re-measuring every cycle is overhead" | It is one command against a file you already have open. The overhead is the eleven cycles spent working from a list that was wrong at cycle one. |

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

@@ -40,6 +40,7 @@ to be enforced and is not is the same failure as a gate that prints `FAIL` and e
 | 13 | **Local infrastructure does not fight the host** | any dev compose or service definition | assume the host already runs the defaults | services reachable with the host's own still running |
 | 14 | **A document may not send a reader to something absent** | any instruction naming a command, file or install | resolve it | the gate fails when the target does not exist |
 | 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 |
 
 ---
 
@@ -115,6 +116,26 @@ than only in that list because it **has** a check. Follow-on, from the first two
 in a process command line matched the throwaway shell of every tool call, and matching the binary
 path hit the same wall. Prefer a fact something authoritative wrote down.
 
+**16 · A carried-in claim.** A long autonomous run advanced one roadmap row per iteration. Each
+iteration was correct: gates green, defects planted and watched to fail, docs closed. What was wrong
+was the sentence between them — *"the remaining rows are these"* — taken from a list that had
+arrived in the context through a compaction, had once been a filtered subset, and had lost its
+provenance on the way. Eleven iterations later a single command over the register printed **36 open
+rows out of 99**, not the handful being worked from. Nothing had failed, because nothing compares a
+run's belief about the work-list against the register; the claim only ever appeared in prose.
+
+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"*;
+and a row filed as *"the object nothing produces"* whose producer had shipped in between. **Stale
+state does not throw.** It narrows what gets considered, silently, and every downstream gate passes
+honestly on the smaller world.
+
+Rule 8 is the neighbour, not the same rule: it governs a number *inside a document*, checked when
+that document is checked. This one governs a fact that crossed a **session boundary** and is being
+reported as current — the case where there is no document to check, only a memory that reads like
+one.
+
 ---
 
 ## The two that are not in the table, and why
@@ -150,6 +171,7 @@ answer would have exposed it in a minute.
 | Stage | Rules that apply |
 |---|---|
 | 0 Inventory · 9 Docs · any register write | 8 (compute), 14 (targets resolve — including every commit SHA in the retro), 15 (identity before a lease) — see [`documentation.md`](documentation.md) |
+| 0 Harvest · any run resuming from a summary | 16 — the work-list and every inherited state claim re-derived before use, [`knowledge-sources.md`](knowledge-sources.md) → *Carried-in claims* |
 | any check you write | 4, 5, 7, 10, 11 — the procedure is [`gates.md`](gates.md) |
 | 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) |
@@ -158,9 +180,10 @@ answer would have exposed it in a minute.
 | 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 |
+| 10 Acceptance · every loop iteration | 16 — the work-list re-measured at close and printed beside its opening count ([`audit.md`](audit.md), [`continuity.md`](continuity.md)) |
 
-**This file is the shipped list; a project keeps its own.** These fifteen were
-earned on someone else's build and travel with the skill. The lessons *your*
+**This file is the shipped list; a project keeps its own.** Every rule in the table
+above was earned on someone else's build and travels with the skill. The lessons *your*
 project buys go in its retro ([`retrospective.md`](retrospective.md) →
 `docs/superpowers/retro.md`), where they are capped, pruned and retired — and a
 lesson there that would be true in any repository belongs here instead, as an issue

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 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 |
 | 0 Docs regime | Where settled things live (register or ADR set — one home, never both); who may write it; lease mechanism present, or is this run `ungated`? Gate command + ratchet floors; may this run raise a floor? | … |
 | 1 Docs | External libs/APIs/SDKs in play; any context7 can't resolve → where their docs live | … |