task-pipeline-skill 1.16.1 → 1.17.0

package/CHANGELOG.md

@@ -1,5 +1,103 @@
 # 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
+
+The bundle offered a place (`conventions.md`: *"CI: the workflow run."*) and a claim
+(`release.verify`: *"CI green on the tagged commit"*) with no method between them.
+Both are satisfiable by believing them, which is the class `gates.md` named in
+v1.14.0: **an actor's own reply is not evidence about the world**, and the test —
+*what does it print when it did not look?*
+
+The occasion was v1.15.0's own release. `validate` was `completed/failure` on a push
+to `main` and on the release tag. The failure was **correct**: the repository's own
+*Every v\* tag must be contained in main* guard, firing on a tag that was not yet an
+ancestor — precisely the defect v1.6.1 built it for. The guard worked, and **nothing
+obliged anyone to read it**. A guard nobody reads is a fail-open hook with extra
+steps; it surfaced only because the run happened to poll the API.
+
+- **`conventions.md` gains *The CI verdict***: the commands (`gh run list … --json
+  databaseId,name,status,conclusion,headSha`, then `gh run view … --log-failed`), an
+  **unauthenticated fallback** on the `check-runs` API, and **three states** —
+  concluded, in progress (*"it was still running when I looked"* is a report, not a
+  verdict), and **no run found**, said out loud, because a project without CI is a
+  legitimate state and not a green one.
+- **Read the log, not just the verdict.** A conclusion says *that* it failed; only the
+  log said *what* — the guard's name, the orphan tag and the one-line fix. A bare "CI
+  failed" hands the next reader a search the log had already finished.
+- **Two paths because one credential died.** `gh`'s token expired mid-run that night,
+  and `gh auth status` reported it invalid from a **cached** verdict while `gh api
+  user` succeeded. The doctrine names the live call, never the status command.
+- **Bound at stages 7, 8 and 9** — every stage of this flow that pushes. The incident
+  hit at the merge and again at the docs push; binding stage 8 alone would have caught
+  neither. The gates cite `conventions.md`; a guard rejects a second copy of the
+  commands.
+- **It reports, it does not block** — the shape stage 8 already used for deploy logs.
+  Blocking would make a project *without* CI cheaper to ship from than one with it.
+
+### Fixed — the negatives floor may no longer lag its own workflow
+
+`MIN_EXPECTED` is a number in a living document, so rule 8 binds it: it must **equal**
+the workflow's count, not merely sit below it. Its own comment records the first lag
+(20 while the workflow carried 34); v1.15.0 was the second — four canon self-tests
+landed and the floor stayed at 104 while the file carried 108. A floor below the count
+cannot notice losing the difference, which is the entire job. Now guarded, and the
+guard was watched rejecting a lowered floor.
+
 ## v1.16.1 — 2026-08-06
 
 ### Fixed — frontmatter that a regex called valid and a YAML parser silently dropped

package/CONTRIBUTING.md

@@ -235,7 +235,21 @@ commands and all three signal states — with a state missing, a graph that coul
 be measured prints like a fresh one.
 *(guard: `never requires it — a run passes intake quoting a`)*
 
-**31. The evidence-docs navigator indexes the canons and never copies them.**
+**31. A CI run's verdict is read, never assumed — and every stage that pushes says so.**
+`references/conventions.md` → *The CI verdict* keeps the commands, the unauthenticated
+fallback and all three states; stages 7, 8 and 9 cite it rather than carrying a second
+copy. A workflow run that nobody reads is the fail-open hook with extra steps: this
+repo's own `validate` was red on a push to `main` and on a release tag, the guard that
+failed was correct, and nothing obliged anyone to look.
+*(guard: `never names it — the run it triggers is closed on an unread verdict`)*
+
+**32. The negatives floor equals the workflow's count.**
+`MIN_EXPECTED` is a number in a living document (rule 8). Below the count it cannot
+notice losing the difference — it lagged at 20 against 34 once, and at 104 against 108
+in v1.15.0.
+*(guard: `a floor below the count is a floor that cannot`)*
+
+**33. The evidence-docs navigator indexes the canons and never copies them.**
 `skills/evidence-docs/SKILL.md` is a second skill in the same plugin: the ten canons as
 a one-line index, a pointer to their one home, and a table of where to go next. The
 guard holds the index to the doctrine's own list, requires the pointer, and resolves
@@ -243,8 +257,7 @@ every relative link **from the navigator's directory** — it sits one level ove
 everything it names, which is canon 4 in the file that publishes canon 4.
 *(guard: `index that has drifted from its doctrine`)*
 
-**32. 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
+**34. 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

@@ -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 |
@@ -66,7 +66,7 @@ Every gate is **typed**: `auto` — the orchestrator verifies it itself, pass/fa
 | 5 | Dev | tasks DONE (three review verdicts each), TDD green per task | auto |
 | 6 | Tests | full suite green, new code covered | auto |
 | 7 | Lint + deploy | lint clean + suite green before deploy | manual |
-| 8 | Post-deploy | clean boot / honest degradation | auto |
+| 8 | Post-deploy | clean boot / honest degradation, **and the CI verdict read rather than assumed** | auto |
 | 9 | Docs + wiki | the propagation matrix walked and the documentation gate green with its ratchets printed; every stale source-ledger row updated; docs + wiki synced; the code graph refreshed and checked against the docs | auto |
 | 10 | **Acceptance** | every REQ accounted for with evidence; every check leaned on seen failing once; operator signs off; the retro written — pruned before anything was added, every lesson carrying its commit | manual |
 
@@ -213,6 +213,27 @@ obsidian-wiki setup --vault /path/to/your/vault
 It is a **recommendation, never a gate** — no stage blocks on a missing wiki, and
 nothing asks twice in one run.
 
+### The CI verdict — read the run, never assume it
+
+A push either triggered a workflow run or it did not, and either way the run's own
+reply is the only evidence. *"CI is green"* written without a command behind it prints
+the same whether it looked or not.
+
+This repository learned it the direct way: `validate` was `completed/failure` on a push
+to `main` and on a release tag, the guard that failed was **correct** — a tag that was
+not yet an ancestor of `main` — and nothing obliged anyone to read it. A guard nobody
+reads is a fail-open hook with extra steps.
+
+So stages 7, 8 and 9 — every stage of the flow that pushes — require the verdict to be
+**read and quoted**: the conclusion with its run id, the failing step's log on anything
+but success, and one of three states, including **`no run found`** said out loud,
+because a project without CI is a legitimate state and not a green one. Two command
+paths, authenticated and not, because a dead token must not end the check. It reports;
+it does not block.
+
+Method: [`conventions.md`](plugins/task-pipeline/skills/task-pipeline/references/conventions.md)
+→ *The CI verdict*.
+
 ### The code graph — reach, and a second opinion on your docs
 
 A grep finds a **name**. A graph finds **reach**: what actually calls this, what

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.1 |
+| **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/cursor/rules/task-pipeline.mdc

@@ -243,7 +243,17 @@ not authorize an outward, irreversible action — stage 7 stops and asks.
    outward → explicit user go, or the specific standing authorization recorded in
    the stage-0 brief.
 8. **Post-deploy** (auto) — tail logs / health-check; clean boot or an honest
-   degradation report (never silent success).
+   degradation report (never silent success). **Read the CI verdict, never assume
+   it** — `gh run list --branch <b> --limit 1 --json databaseId,name,status,conclusion,headSha`,
+   then `gh run view <id> --log-failed` on anything but success (unauthenticated
+   fallback: `curl -s https://api.github.com/repos/<owner>/<repo>/commits/<sha>/check-runs`).
+   Quote the conclusion with its run id, quote the failing step, and state one of
+   three states: concluded / in progress (wait and re-read — "it was still running"
+   is a report, not a verdict) / **no run found**, said out loud, because a project
+   without CI is a legitimate state and not a green one. Probe credentials with a
+   live call, never `gh auth status`, which answers from cache. This binds every
+   stage that pushes — 7, 8 and 9 — not just this one. It reports; it does not
+   block.
 9. **Docs + wiki** (auto) — **the phase-1 source ledger is the work list**: every
     source the harvest read gets updated if this run changed or disproved it. Module
     docs and runbooks in the SAME change; the knowledge wiki via `wiki-update` when

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "task-pipeline-skill",
-  "version": "1.16.1",
+  "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.1",
+  "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/pipeline.example.json

@@ -133,7 +133,7 @@
       ],
       "gate": {
         "type": "auto",
-        "check": "clean boot confirmed (no error spike, live subsystems healthy), or an honest degradation report with next steps"
+        "check": "clean boot confirmed (no error spike, live subsystems healthy), or an honest degradation report with next steps. THE CI VERDICT IS READ, NEVER ASSUMED (references/conventions.md -> The CI verdict): the run's conclusion for this commit is quoted with its run id, the FAILING STEP'S LOG is quoted on anything but success, and one of three states is stated — concluded / in progress (wait and re-read; 'it was still running' is a report, not a verdict) / NO RUN FOUND, said out loud, because a project without CI is a legitimate state and not a green one. 'CI is green' written without a command behind it prints the same whether it looked or not (references/gates.md -> False success). Two command paths, because a credential problem must not end the check: 'gh run list --branch <b> --limit 1 --json databaseId,name,status,conclusion,headSha' then 'gh run view <id> --log-failed', or unauthenticated 'curl -s https://api.github.com/repos/<owner>/<repo>/commits/<sha>/check-runs'. Probe credentials with a live call, never with 'gh auth status', which answers from cache. It reports, it does not block."
       }
     },
     {
@@ -182,7 +182,7 @@
       "npm publish (task-pipeline-skill) — a second job in the same workflow, armed per repository by the PUBLISH_NPMJS variable (NPM_TOKEN granular automation token, or trusted publishing via OIDC); unarmed it falls back to a human 2FA step"
     ],
     "verify": [
-      "CI green on the tagged commit",
+      "CI green on the tagged commit — READ, not assumed: the run's conclusion quoted with its run id, and the failing step's log quoted on anything but success (references/conventions.md -> The CI verdict)",
       "npx github:ssheleg/task-pipeline#<tag> from a clean cwd installs the skill + command",
       "after npm publish: npm view task-pipeline-skill version == <tag>"
     ]

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/conventions.md

@@ -8,6 +8,16 @@ names its doc repos, its knowledge base and its house rules
 Prefer explicit host instructions over detection; if a step's convention can't be
 found, surface it and **ask** rather than guessing.
 
+## Contents
+
+- Lint + test
+- Deploy / release
+- Post-deploy logs
+- The CI verdict — read the run, never assume it
+- Docs + wiki
+- Documentation regime (stage 0, then 9 and 10)
+- Issue tracker (stage 10)
+
 ## Lint + test
 - `CLAUDE.md` usually names the commands. Else detect: `package.json` scripts
   (`npm test` / `npm run lint`), `pyproject.toml` / `ruff` (`ruff check`), `pytest`,
@@ -30,7 +40,61 @@ found, surface it and **ask** rather than guessing.
 
 ## Post-deploy logs
 - Heroku: `heroku logs -a <app>`. Docker / k8s: `docker logs` / `kubectl logs`.
-  CI: the workflow run. Hit the health endpoint if one is defined.
+  Hit the health endpoint if one is defined. **CI: the workflow run — and a run is
+  checked by reading it, below.**
+
+## The CI verdict — read the run, never assume it
+
+A push either triggered a run or it did not, and either way **the run's own reply is
+the only evidence** ([`gates.md`](gates.md) → *False success*). "CI is green" written
+without a command behind it is a sentence that prints the same whether it looked or
+not.
+
+This is not hypothetical. On 2026-08-06 this repository's `validate` was
+`completed/failure` on a push to `main` and on a release tag. The failure was
+**correct** — the *Every v\* tag must be contained in main* guard firing on a tag that
+was not yet an ancestor — and nothing in this bundle obliged anyone to read it. A
+guard nobody reads is a fail-open hook with extra steps.
+
+```bash
+# authenticated
+gh run list --branch <branch> --limit 1 \
+  --json databaseId,name,status,conclusion,headSha
+gh run view <databaseId> --log-failed        # only when conclusion != success
+```
+
+```bash
+# unauthenticated fallback — public repo, no token needed
+curl -s "https://api.github.com/repos/<owner>/<repo>/commits/<sha>/check-runs"
+```
+
+**Two paths on purpose.** A credential problem must not end the check: this repo's
+`gh` token expired mid-run the same night, and `gh auth status` reported it invalid
+from a **cached** verdict while `gh api user` succeeded. Probe credentials with a
+live call, never with the status command.
+
+**Three states, and the third is why this is written down:**
+
+| State | Condition | Record |
+|---|---|---|
+| **concluded** | a run exists for this sha, `status == completed` | the conclusion and run id — and on any non-`success`, the **quoted failing step** |
+| **in progress** | a run exists, not finished | wait and re-read. *"It was still running when I looked"* is a report, not a verdict |
+| **no run found** | no run for this sha | say so out loud — a project without CI is a legitimate state and **not a green one** ([`gates.md`](gates.md) → *Progressive arming*) |
+
+**Read the log, not just the verdict.** A conclusion says *that* it failed; only the
+log says *what*. In the incident above the log named the guard, the orphan tag and the
+one-line fix — a bare "CI failed" would have handed the next reader a search the log
+had already finished. On any non-`success`: read the failing step and quote the line
+that names the failure.
+
+**It reports; it does not block.** Same shape stage 8 already uses for deploy logs — a
+red run the operator has seen and ruled on is a decision, a red run nobody printed is
+the failure. Blocking would also make a project *without* CI cheaper to ship from than
+one with it.
+
+**Promote it when it breaks** ([`gates.md`](gates.md) → *Axis B*): this sits at rung 2,
+a criterion in the stage gates. Promote it to a script the first time a run is observed
+closing a stage with an unread CI verdict.
 
 ## Docs + wiki
 - **Start from the stage-0 source ledger** ([`knowledge-sources.md`](knowledge-sources.md)):

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/references/portability.md

@@ -75,6 +75,7 @@ a row pointing outside the bundle is the defect this file exists to catch.
 | Which companions exist, what is required, self-currency | `references/companion-skills.md` |
 | The code graph: queries, refresh, the graph↔docs divergence | `references/knowledge-graph.md` |
 | How the graph's staleness is measured and stated in the ledger | `references/knowledge-graph.md` |
+| How a CI run's verdict is established, and its three states | `references/conventions.md` |
 | Model policy — tier not id, ask once at preflight | `references/model-tiering.md` |
 | This boundary | `references/portability.md` |
 

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

@@ -345,14 +345,24 @@ never that the work was skipped quietly.
   `partial` ships only with the operator's explicit acceptance. A gap is cheapest to
   close before it ships, and the operator is already present at this gate. **The
   carry-over count is printed beside this verdict.** Deploy is outward → explicit
-  operator go. Respect deploy-from-main rules if the project mandates them.
+  operator go. Respect deploy-from-main rules if the project mandates them. **Before
+  tagging, the CI verdict for what was just pushed is READ, not assumed**
+  ([`conventions.md`](conventions.md) → *The CI verdict*) — a tag on a commit whose
+  run nobody read is how a red `main` ships.
 
 ## 8 — Post-deploy
 - **Freedom: medium** — where the logs live varies; 'clean boot or an honest degradation report' does not ([`gates.md`](gates.md) → *Axis C*).
 - Tail deploy logs / health-check per conventions. Confirm clean boot, no error
   spike, live subsystems healthy.
+- **Read the CI verdict for the deploy's own commit** ([`conventions.md`](conventions.md)
+  → *The CI verdict*): the run's conclusion quoted, the **failing step's log quoted**
+  on anything but `success`, and one of the three states stated — including **`no run
+  found`**, out loud, because a project without CI is a legitimate state and not a
+  green one.
 - **GATE (auto):** clean boot confirmed, or an **honest degradation report** with next
-  steps — never silent success.
+  steps — never silent success. **The CI verdict is one of the reported facts, with
+  its run id** — "CI is green" written without a command behind it prints the same
+  whether it looked or not ([`gates.md`](gates.md) → *False success*).
 
 ## 9 — Docs + wiki
 - **Freedom: low** — the matrix walk and the gate are mechanical; what a doc says is not this stage's call ([`gates.md`](gates.md) → *Axis C*).
@@ -405,7 +415,10 @@ never that the work was skipped quietly.
   written and reconciled**; UI: super-ux layers current + linter green; wiki synced
   (or absent and recommended once); **the code graph
   refreshed where one exists, or the reason it wasn't written into the carry-over
-  ledger** (absent and recommended once is fine); dangling links fixed; **the
+  ledger** (absent and recommended once is fine); dangling links fixed; **the CI
+  verdict read for this stage's own push** ([`conventions.md`](conventions.md) →
+  *The CI verdict*) — this stage pushes like any other and is the one that habitually
+  ends a run, so an unread red here is a red `main` nobody is coming back to; **the
   carry-over count printed beside this verdict**.
 
 ## 10 — Acceptance

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 | … |