task-pipeline-skill 1.71.1 → 1.73.0

package/CHANGELOG.md

@@ -1,5 +1,119 @@
 # Changelog
 
+## v1.73.0 — 2026-08-20 — the registry could not see the templates, the scripts, or its own registers
+
+
+**The claim registry had the class for this exact incident and it fired on nothing.** Three
+shipped surfaces said *34 reference files* over a directory of 35 — `scripts/graph.py`'s
+`doctrine` docstring and `templates/run.md` twice — and `npm test` printed
+`reference files: dormant (truth 35)`. Two holes, either of which was enough: the pattern
+knew only the word order ``N files under `references/` ``, and the corpus was eight named
+files plus `references/**`, so `templates/` and `scripts/` were never opened. The class now
+reads any phrasing of the count, the corpus reads the templates and the shipped script, and
+the class is armed at three agreeing sites instead of dormant.
+
+**And it never read this repository's own registers.** `docs/DOCMAP.md` names decisions,
+open questions, the board, the ledger and the retro as the registers, and its propagation
+matrix sends *a number stated in a living document* to this registry — which could not see
+any of them. `docs/OPEN_QUESTIONS.md` said *the 250 guards* against a workflow defining 390,
+in a phrasing the guard class already knew. Bringing them in refused 26 statements and every
+one was narration, so a number inside a **dated item** is a record and exempt; on the board
+the discriminator is the State cell rather than the date, because every row names the day it
+was filed and B-001 — open — was stating its description budget and its reference-file count
+as facts about now.
+
+**Fourteen consecutive releases carry no run stamp**, `v1.60.1` through `v1.72.0`, and the
+retro's honest-gap section named only `v1.16.0`–`v1.23.0`. Its *Measured, not recalled*
+receipt could not produce the measurement: it grepped `docs/superpowers/retro.md`, removed at
+v1.53.0, and grepped for a tag's own commit when a stamp names the commit the *run* ended on.
+Rewritten as a tag-range walk that reads the archive too, and a guard now requires every
+release after the newest stamp to be named in that section.
+
+Also: `## Unreleased` is where the guard count lives between a tag and the next bump (B-104);
+`Environment` is a required cell on every verification row with the vocabulary read out of
+the shipped template (B-099's other half); the graph schema states its three node rules
+behind `$ref`s and the checker follows them (B-079, proved by moving them, not by a fixture);
+an open board row's `file:N-M` must quote the phrase it points at, which caught five stale
+citations and then caught this change's own edits four more times; the acceptance ladder is
+policy **`AP-1`** with an owner and an in-force date, and `gates.md`'s *the framework fixes
+no stage count* is scoped to the pipeline's shape; `read:` and `gate:` are reported
+**unattested** instead of claimed *never agent-written*, because the ledger is the file the
+agent appends to at every stage; `validate.yml` no longer re-validates a SHA on its own tag
+push; and every documented `npm` equation is compared against `package.json` — `CLAUDE.md`
+had `npm test` as `validate.py` alone, dropping 129 graph cases.
+
+**What the suite found that no reading did.** This change broke **thirteen** existing
+plants and `npm run test:all` named every one: the two verification-header probes spell
+the whole header and it gained a column; two CHANGELOG probes scoped themselves to
+`^## v` and the count now lives in `## Unreleased`; **seven** graph-schema probes walk
+`node.allOf` inline and the rules moved behind `$ref`. All thirteen were repaired by
+deriving the guard's own scope rather than restating it, which is what `learned.md`'s
+*sweep the class* asks for — and the sweep needed two rounds: six schema probes were
+repaired together and the seventh surfaced on the next full run, having died on
+`KeyError: 'if'` where the others had died on their own asserts. A class fixed in six of
+seven places is the shape standing instruction R-003 exists for.
+
+One of the twelve was sharper than the rest, and it was self-inflicted twice over: the
+honesty note explaining that `OQ-0002` no longer restates a total put an ISO date in the
+row, which made the row a dated record and **disarmed the register plant** — green over
+exactly the stale total it had been written to catch. `OQ-####` now uses its `Status`
+cell, the discriminator the board already uses, and the register plant sits on an open
+board row where no prose edit beside it can turn it off.
+
+Guards: 390 → **412** · property checks 9 → **14**
+
+
+## v1.72.0 — a node says how it will be closed
+
+**B-080 closed, and with it the last of four requirements this pack's own manifesto named
+as unbuilt.** The Proof of Done manifesto cites this repository as its reference
+implementation and filed four gaps against it by id; three closed on 2026-08-17, and this
+is the fourth. The public document now says all four are built and names the commit for
+each.
+
+### `check` — the per-node completion test
+
+A node could not say how it would be closed, while shipped doctrine told the verifier to
+"run the checks the task named". The doctrine read a field the schema did not have.
+
+`check` is a string, **required on every node whose status is not `parked`** — the parked
+node being the one nobody will close, where a placeholder would be confidence without
+correctness. Never a list: a node needing two unrelated checks is a node doing two jobs, and
+one gate made of two commands is `a && b`, which is still one gate. Stated twice on purpose,
+in the schema and in `violations()`, because the schema never runs against a live graph.
+`add --check` is required like `--why`, and a replan entry naming no check is refused before
+the close writes anything.
+
+### The record the manifesto opens with now reads as one event
+
+`residue.md`'s opening record is quoted by an external document and permalinked from a public
+site. It said the inventory was queried "one minute later" beside a `ps` line showing the
+process at 3:12 — two accurate observations of different things, framed so a reader had to
+reconcile them by hand. Both moments are now stated, the interval between them named, and
+**what the record never carried is named too**: the wall-clock times, which `git log --follow`
+proves were never in it. A disambiguation, not a correction — no number changed.
+
+The E4 sentence claimed more than its own block: "that **they** have been up for three days"
+from a measurement of the oldest one. Now "the oldest of them".
+
+### Three plants that could not run, and one row that could not be parsed
+
+CI failed twice on this release's work, and neither failure was noise.
+
+A ledger row wrote a pytest filter as a backticked `-k a|b|c`; markdown does not care about
+backticks, so two pipes split one cell into three and that row carried ten cells against a
+header of eight. Locally the damage sat in a column nothing read, so every gate run passed.
+Every `REQ` row must now match the header's cell count, with the remedy named in the refusal.
+
+Then three schema plants died on `KeyError` before reaching their own `PLANT DID NOT LAND`
+assert, because the new `check` rule added an `allOf` branch keyed on `not: {const: parked}`
+and each plant indexed the const directly. All three traverse tolerantly now. **The assert
+catches a plant that does not land; nothing catches a plant that cannot run** — the third
+instance of that class in three days, and it is filed family-wide rather than here.
+
+Guards: 389 → **390**. The new rule arrived without a plant, which this repository's own standard refuses; that is the plant. `graph.py` 114 → 129 cases.
+
+
 
 ## v1.71.1 — four shapes of a green that measured nothing
 
@@ -55,8 +169,20 @@ only reader that checks.
 and what makes each self-checking. Where a claim genuinely cannot be derived, **say so in the
 row**; correcting it silently a second time teaches readers that somebody else is checking.
 
-Guards: 376 → **376**. No guard was added or removed — this release is doctrine, and each of the
-four rules is cited from the reference that owns it rather than restated.
+> **After the tag, on the same tree.** `v1.71.1` is cut, and the guard-count claim
+> `test/validate.py` reads is the newest `## vX.Y.Z` section's — which post-tag is this one,
+> with no version heading yet open for the work that follows. So the live figure is stated
+> here rather than inside a released sentence, and the released sentence below is not edited:
+> B-080 closed on 2026-08-19 with eight plants and TP-02 with five on the same day, so
+> Guards: 376 → **389**. The guard has no home for a count between a tag and the next bump;
+> filed as `B-104`, and the note is what keeps the number true meanwhile. **The bold belongs
+> on the number alone**: the plant that corrupts this count reads `Guards: N → **M**` out of
+> the raw section, so bolding the whole phrase left the validator reading a count no plant
+> could still corrupt — which is the form this note was introduced with, and no second
+> count-shaped figure belongs in this section for the same reason.
+
+Guards at the tag: 376 → 376. No guard was added or removed — that release is doctrine, and
+each of the four rules is cited from the reference that owns it rather than restated.
 
 Closes #39, #40, #48, #49.
 

package/CONTRIBUTING.md

@@ -518,6 +518,80 @@ runs.
 *(guard: `does not say` and `rule 1 of the list it is printed beside`
 and `no stage names`)*
 
+**56. A node says how it will be closed, and the doctrine that reads that field names
+one the node has.** `agents/verifier.md` ordered the verifier to run *the checks the task
+named* while `graph.schema.json`'s node carried no field in which a task could name one —
+two files shipped on one day, and the instruction pointed at an absence that left the
+verifier the two options the same paragraph forbids: invent a check, or run everything.
+`check` is now a node property, **required on every node except a `parked` one** — the one
+node nobody will close, where a placeholder would be worse than the gap. The rule is
+stated twice on purpose, in the schema and in `violations()`, because the schema is never
+applied to a live graph; both are RUN against a planted graph rather than inspected. And
+the two homes are compared directly: whatever the verifier is told to read off the node
+must be a property the schema declares.
+*(guard: `node declares no` and `rule that can fire` and `off the node, and`)*
+
+**57. The claim registry reads every surface that states a number, including the ones this
+repository writes about itself.** Its corpus was eight named files plus `references/**`, so
+`templates/` and `scripts/` were invisible — three shipped surfaces said "34 reference files"
+over a directory of 35 while the class printed `dormant` — and so were the registers
+`docs/DOCMAP.md` names, where `docs/OPEN_QUESTIONS.md` said "the 250 guards" against a
+workflow defining 390. The corpus now covers both, and a class recognises every phrasing of
+its count rather than one word order. A number inside a **dated item** in a register is a
+record and exempt; on the board the discriminator is the **State** cell, because every row
+names the day it was filed and an open row is a claim about now.
+*(guard: `reference files` and `— derive the number or delete it`)*
+
+**58. Every documented `npm` command means what `package.json` runs.** `CLAUDE.md` glossed
+`npm test` as `python3 test/validate.py`, dropping `graph_test.py` and its 129 cases — the
+suite-outside-the-run class stated the other way round — and called `npm run test:all` "both"
+where it runs eight scripts. An equation is compared against the script body after one level
+of `npm run` resolution, and a bare `npm run X` in a document about this repository must be a
+script that exists. Portable doctrine under `plugins/` and `cursor/` is out of scope: it names
+a host project's commands.
+*(guard: `is glossed as` and `declares no such script`)*
+
+**59. A release either carries a run stamp or is recorded as a gap, and the guard-count claim
+has a home before the bump.** Fourteen consecutive releases had no stamp while the retro named
+only `v1.16.0`–`v1.23.0`, and the receipt that was supposed to prove it grepped a path removed
+at v1.53.0 for a tag's own commit — a stamp names the commit the *run* ended on. Scoped to the
+trailing stretch: 84 of 117 tags predate the register and backfilling is forbidden. Separately,
+the count guard reads the topmost `## ` section, so `## Unreleased` is where the number lives
+between a tag and the next bump, and it must sit above every version heading.
+*(guard: `release(s) after the newest run stamp` and `section sits below a released version`)*
+
+**60. A `file:line` range in an open board row quotes the phrase it points at.** Five
+citations resolved to real lines and pointed at other text; a line number is the most fragile
+address a document carries, because every edit above it moves it and nothing notices. Closed
+rows are records and are left alone; single-line citations cannot be quoted and are disclosed
+as unanchored rather than failed.
+*(guard: `quotes no phrase from it`)*
+
+**61. Every evidence row records the environment it ran in, and a claim of provenance the
+format cannot check is marked unattested instead.** `Observed at` said which tree a check saw
+and nothing said where it ran, so a preview smoke test and a production one entered the record
+in the same shape — in a pack whose own `learned.md` records a suite green on every author's
+machine and 1039 failures on a clean runner. And `read:`/`gate:` were declared *hook-written,
+never agent-written* while both land in the file the agent appends to at every stage: no writer
+field, no provenance check, so the count is reported `unattested` and the claim is not made.
+*(guard: `has no `Environment` cell` and `prints a count and never says`)*
+
+**62. The acceptance ladder is a versioned policy with an owner, and `gates.md`'s
+fixes-nothing sentence is scoped to the pipeline's shape.** Both rules stood unscoped side by
+side for seventy releases — *the framework fixes no stage count and no gate assignment* beside
+twelve fixed criteria — so a reader could take either as the whole rule, and a table accepted
+under v1.20 doctrine was indistinguishable from one accepted under v1.70. The block carries
+`AP-1`, an owner and an in-force date; an amendment moves the version and lands with a decision
+row.
+*(guard: `the acceptance policy carries no` and `stands unscoped beside`)*
+
+**63. A heading may not declare a bound nothing enforces.** The retro's *Recent log* read
+*entries from the last five run stamps* over 25 entries reaching back nine days, borrowing the
+stamp section's wording without its cap — filed twice as B-060 and B-069 and disclosed by the
+file about itself. Checked in the live retro and in `templates/retro.md`, which seeded the
+false bound into every host project.
+*(guard: `declares the bound` and `and nothing enforces it`)*
+
 ## Adding or changing doctrine
 
 - **Change one idea per PR.** These files are read by agents under load; a PR that

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.71.1 |
+| **Version** | 1.73.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, and **one of two browser channels** — `playwright` (CLI or MCP) or `chrome-devtools` (MCP); either satisfies the browser step and neither is required. 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, 5 categories. One recorded run, **self-observed by the author**; **zero blind runs on zero of three models** — the split, and the numbers, live in [`evals/RESULTS.md`](evals/RESULTS.md) and are computed by `evals/run.py` |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "task-pipeline-skill",
-  "version": "1.71.1",
+  "version": "1.73.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 closes with evidence, a work board and a verification ledger that outlive a run, an exposure line naming what shipped unconfirmed, a progress rail computed from the project's own config, a loop guard whose review ceiling measures rather than stops, and stage-3 tracks for what a product does, how it sounds and how it looks. Two modes need no task: `checkup` (what is unverified) and `setup` (audit existing docs). Retro insights can publish upstream as issues, opt-in and redacted.",
-  "version": "1.71.1",
+  "version": "1.73.0",
   "author": {
     "name": "ssheleg",
     "url": "https://x.com/sshlg93"

package/plugins/task-pipeline/agents/verifier.md

@@ -34,7 +34,10 @@ than ending in a question nobody will see.
   "not_done":     ["what was asked and is not"],
   "not_verified": ["what was BUILT and no check touched"],
   "blockers":     [{ "what": "…", "blocks": ["N-009"], "can_continue_around": true }],
-  "replan":       { "possible": true, "add": [], "park": ["N-009"], "why": "…" },
+  "replan":       { "possible": true,
+                    "add": [{ "title": "…", "owner": "implementer",
+                              "serves": "REQ-004", "check": "…" }],
+                    "park": ["N-009"], "why": "…" },
   "evidence":     ["the command and the output that proves each `done` row"]
 }
 ```
@@ -58,12 +61,20 @@ ledger exists to catch.
 
 1. **Read the node's `serves`** — the REQ or the goal clause. That is the standard.
    Not what the diff does; what was asked.
-2. **Run the checks the task named.** Not a check you invented, and not `npm test`
-   alone if the task named something narrower — a green from a check nobody watched
-   fail against a planted defect is not evidence.
+2. **Run the node's `check`.** It is a field on the node — one command, or a named
+   judgement where no command can decide it — and it is what closes this node. Not a
+   check you invented, and not `npm test` alone when the node named something narrower:
+   a green from a check nobody watched fail against a planted defect is not evidence.
+   Where the `check` is a judgement, record the verdict **as** judgement
+   (`references/gates.md`), never as an exit code.
+   **A node with no `check` is a refusal, not a judgement call.** `graph.py validate`
+   exits 1 and names it, because inventing a check and running everything are the two
+   things this step forbids — and until B-080 closed, this paragraph asked for a field
+   the schema did not have.
 3. **`done` takes one row per claim, and each needs a line in `evidence`** — the
    command and what it printed. Paraphrase is not evidence. If you cannot produce
-   the output, the row belongs in `not_done`.
+   the output, the row belongs in `not_done`. The `check`'s own output is the first
+   row: the node said how it would be closed, so the proof it closed is that output.
 4. **`not_done` is not a failure report.** It is what the next iteration picks up,
    so write it as work rather than as blame.
 5. **Every blocker says what it `blocks` and whether the run `can_continue_around`
@@ -72,6 +83,9 @@ ledger exists to catch.
 6. **`replan.possible: false` needs a `why` a person can act on.** A stop with no
    reason is indistinguishable from a stall, and the operator is the one who has to
    tell them apart.
+7. **Every `replan.add` entry names its own `check`.** A node you create is a node the
+   next verifier has to close, and handing it the absence you were handed is how the
+   defect returns one iteration later. `close` refuses the verdict and names the key.
 
 ## Three ways this goes wrong
 
@@ -80,6 +94,7 @@ ledger exists to catch.
 | «The tests pass, so it is done» | The node serves a REQ, not a suite. A green suite that never exercised the requirement proves the suite ran |
 | «Close it and note the gap» | A `done` with a caveat is a `not_done` somebody will read as finished. Split the row |
 | «This blocker stops everything» | Say whether it does. `can_continue_around: true` is what keeps a run moving past one bad node, and guessing it wrong costs either the run or the correctness |
+| «The node names no check, so I'll run the suite» | That is the choice this agent may not make. `validate` refuses the node before you are dispatched; a node whose completion test nobody wrote is a planning defect, and reporting it is worth more than a green suite |
 
 ## Where the doctrine is
 

package/plugins/task-pipeline/skills/task-pipeline/graph.example.json

@@ -14,6 +14,7 @@
       "status": "done",
       "blocked_by": [],
       "serves": "REQ-001",
+      "check": "npm test — graph.example.json validates against graph.schema.json",
       "evidence": [
         "npm test → PASS: task-pipeline structure valid, with graph.example.json validated against graph.schema.json"
       ]
@@ -27,6 +28,7 @@
         "N-001"
       ],
       "serves": "REQ-002",
+      "check": "python3 test/graph_test.py — the validate fixtures",
       "evidence": null
     },
     {
@@ -38,6 +40,7 @@
         "N-001"
       ],
       "serves": "REQ-005",
+      "check": "judgment: the reviewer rules the seven keys sufficient — recorded AS judgement, references/gates.md",
       "evidence": null
     },
     {

package/plugins/task-pipeline/skills/task-pipeline/graph.schema.json

@@ -110,6 +110,15 @@
           "minLength": 1,
           "description": "A REQ id, or a clause of the goal. Required, because a node that serves neither is work nobody asked for — and the pipeline's answer to that is to park it WITH THAT AS THE REASON rather than to do it quietly."
         },
+        "check": {
+          "type": "string",
+          "minLength": 1,
+          "pattern": "\\S",
+          "not": {
+            "pattern": "[\\n\\r]"
+          },
+          "description": "**How this node will be closed** \u2014 the command a verifier runs, or the named judgement that stands in where no command can (`references/gates.md`'s third gate type: name the judge, record the verdict AS judgement). Its output becomes the node's `evidence` row.\n\nRequired on every node except a `parked` one, and that is the whole point of the field: `agents/verifier.md` tells the verifier to run *the check this node names*, so a node with none leaves it the two options that same paragraph forbids \u2014 invent a check, or run everything. Shipped doctrine read a field the schema did not have (B-080); the field the doctrine reads now exists.\n\nOne string, never a list, because the requirement it serves is singular throughout \u2014 one input, one job, one output, one owner, **one** completion test. A node needing two unrelated checks is a node doing two jobs, and the answer is to split it rather than to widen this field. One gate made of two commands is `a && b`, which is still one gate.\n\nA `parked` node is exempt because it is the one node nobody will close, and a placeholder there \u2014 *n/a, parked* \u2014 is the confidence-without-correctness this schema refuses everywhere else. The field survives a park: `park` sets the status and never removes what the node said it would run."
+        },
         "evidence": {
           "type": [
             "array",
@@ -140,57 +149,13 @@
       },
       "allOf": [
         {
-          "if": {
-            "properties": {
-              "status": {
-                "const": "done"
-              }
-            },
-            "required": [
-              "status"
-            ]
-          },
-          "then": {
-            "required": [
-              "evidence"
-            ],
-            "properties": {
-              "evidence": {
-                "type": "array",
-                "minItems": 1,
-                "items": {
-                  "type": "string",
-                  "minLength": 1,
-                  "pattern": "\\S",
-                  "description": "At least one non-whitespace character. `minLength: 1` alone accepts a single space, which is the one shape where this schema and `graph.py`'s verdict gate disagreed — the gate strips, the schema counted. A cross-check fixture comparing the two found it."
-                }
-              }
-            }
-          }
+          "$ref": "#/definitions/rule_check_unless_parked"
         },
         {
-          "if": {
-            "properties": {
-              "status": {
-                "const": "parked"
-              }
-            },
-            "required": [
-              "status"
-            ]
-          },
-          "then": {
-            "required": [
-              "parked_reason"
-            ],
-            "properties": {
-              "parked_reason": {
-                "type": "string",
-                "minLength": 1,
-                "pattern": "\\S"
-              }
-            }
-          }
+          "$ref": "#/definitions/rule_done_needs_evidence"
+        },
+        {
+          "$ref": "#/definitions/rule_parked_needs_reason"
         }
       ]
     },
@@ -248,6 +213,88 @@
           "description": "The reason, written for a person reading it later. The non-whitespace pattern is required for the same reason `parked_reason` needs one: `minLength: 1` counts a space."
         }
       }
+    },
+    "rule_check_unless_parked": {
+      "description": "B-080's rule, factored out of `node.allOf` so it is stated once and referenced. Factoring it exposed B-079: `test/validate.py`'s `_conditionals()` recursed into `allOf` and never followed a `$ref`, so a schema that shares a rule this way read as a schema with NO conditionals and both REQ-006 and REQ-012 were reported missing from a schema that states them. The shipped schema now uses the `$ref` form, so the deref branch is exercised by every run of the gate rather than by one fixture.",
+      "if": {
+        "properties": {
+          "status": {
+            "not": {
+              "const": "parked"
+            }
+          }
+        },
+        "required": [
+          "status"
+        ]
+      },
+      "then": {
+        "required": [
+          "check"
+        ],
+        "properties": {
+          "check": {
+            "type": "string",
+            "minLength": 1,
+            "pattern": "\\S"
+          }
+        }
+      }
+    },
+    "rule_done_needs_evidence": {
+      "description": "REQ-006 as draft-07 states it: `done` implies at least one non-whitespace evidence string. Referenced from `node.allOf`, never inlined, so the rule has one home.",
+      "if": {
+        "properties": {
+          "status": {
+            "const": "done"
+          }
+        },
+        "required": [
+          "status"
+        ]
+      },
+      "then": {
+        "required": [
+          "evidence"
+        ],
+        "properties": {
+          "evidence": {
+            "type": "array",
+            "minItems": 1,
+            "items": {
+              "type": "string",
+              "minLength": 1,
+              "pattern": "\\S",
+              "description": "At least one non-whitespace character. `minLength: 1` alone accepts a single space, which is the one shape where this schema and `graph.py`'s verdict gate disagreed — the gate strips, the schema counted. A cross-check fixture comparing the two found it."
+            }
+          }
+        }
+      }
+    },
+    "rule_parked_needs_reason": {
+      "description": "REQ-012: a parked node names why it is parked. Referenced from `node.allOf`.",
+      "if": {
+        "properties": {
+          "status": {
+            "const": "parked"
+          }
+        },
+        "required": [
+          "status"
+        ]
+      },
+      "then": {
+        "required": [
+          "parked_reason"
+        ],
+        "properties": {
+          "parked_reason": {
+            "type": "string",
+            "minLength": 1,
+            "pattern": "\\S"
+          }
+        }
+      }
     }
   }
 }

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

@@ -319,6 +319,29 @@ spends its length refusing.
 
 ## GATE (manual)
 
+> **Acceptance policy `AP-1` · owner: the operator of the project running this pipeline ·
+> in force since 2026-08-20 · supersedes: the unversioned ladder that stood before it.**
+>
+> This block is the policy, and naming it that closes a contradiction that stood in the
+> shipped doctrine. [`gates.md`](gates.md) → *Axis A — the stage gate type* says which stages are
+> manual is the operator's decision and that **the framework fixes no stage count and no
+> gate assignment** — while the ladder below fixes twelve criteria and the statuses they
+> may take. Both were true and neither was scoped, so a reader could take either as the
+> rule.
+>
+> **The scope, stated once:** `gates.md`'s sentence governs the **pipeline's shape** — how
+> many stages a project runs and which of them are `auto`, `judgment` or `manual`, all of
+> it in the project's own `pipeline.json`. `AP-1` governs **what stage 10's manual gate
+> asks when a project runs one.** A project may drop stage 10, or make it `auto` for a
+> class of work, and `AP-1` then does not apply to it; a project that keeps it manual gets
+> these criteria and this vocabulary, not a per-run selection from them.
+>
+> **Changing it is a decision, not an edit.** An amended criterion moves the version to
+> `AP-2` and lands with a row in the project's decision register, because a policy that can
+> be edited silently is the *«recorded in the slot reserved for what a machine
+> established»* failure one level up: an acceptance standard nobody can cite by version is
+> one every run re-negotiates.
+
 All of:
 
 1. **Every shipped REQ has a verification row, and every row names a REQ its own run

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

@@ -47,12 +47,21 @@ The method most audits use is **horizontal**: compare the documents against each
 other, then do it again. It works, and then it fails in a way that is invisible
 from inside it. Measured over seven passes on a production repository:
 
-| Pass | Findings | …of which the previous pass's own fixes caused |
-|---|---|---|
-| 4 | 12 | 5 |
-| 5 | 17 | 9 |
-| 6 | 13 | 10 |
-| 7 | 19 | 4 |
+| Pass | Findings | …of which the previous pass's own fixes caused | Self-inflicted share |
+|---|---|---|---|
+| 4 | 12 | 5 | 42% |
+| 5 | 17 | 9 | 53% |
+| 6 | 13 | 10 | 77% |
+| 7 | 19 | 4 | 21% — see the note below |
+
+**The trend above is measured over passes four to six, and pass seven is not part of
+it.** 42% → 53% → 77% is the decay this section teaches; the seventh pass fell back to
+4 of 19 and **the record does not say what that pass did differently.** The row stays,
+with the gap named, for two reasons. Deleting a measured row to protect a claim is the
+opposite of what this file asks of every gate it describes — and the vertical pass
+described below cannot be credited for the drop, because it is a separate pass over the
+same repository, not the seventh. Whatever pass seven did, it is unrecorded, and an
+unrecorded cause is what this table has to say about it.
 
 By pass six the audit was **mostly repairing itself**. Not fatigue — arithmetic.
 Each pass edits the corpus the next pass reads, so the newest edits are always the

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

@@ -58,6 +58,15 @@ not the operator confirming it is what they asked for, and no amount of checking
 makes it one. Which stages are manual is the **operator's** decision, recorded in
 their `pipeline.json`; the framework fixes no stage count and no gate assignment.
 
+**That sentence is about the pipeline's SHAPE, and nothing else.** It says a project
+chooses how many stages it runs and which of them wait for a person. It does not say the
+criteria inside a gate are per-run negotiable: where a project keeps stage 10 manual, what
+that gate asks is [`acceptance.md`](acceptance.md)'s policy **`AP-1`**, which is versioned
+and has an owner. The two rules stood side by side unscoped until 2026-08-20 (`B-091`), and
+a reader could take either as the whole rule — *the framework fixes nothing* and *the ladder
+is fixed* are both in the shipped doctrine, which is how an acceptance standard becomes
+something every run re-argues.
+
 ## The judgment gate — a ruling is not a measurement
 
 Two types were not enough, and the gap was not cosmetic. A reviewer's ruling, a check that

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

@@ -369,12 +369,18 @@ deduplicated, and always exiting 0 — a hook that can fail a `Read` breaks ever
 every session. `scripts/graph.py doctrine` reports how many of the bundle's reference files
 a run opened and lists the rest.
 
-Why it is hook-written is the same reason as above: a claim about what somebody read,
-written by the party the claim is about, is not evidence. And why the verb prints
+Why a hook appends it is the same reason as above: a claim about what somebody read,
+written by the party the claim is about, is not evidence. **And that is an intent rather
+than a proof, so the verb reports `unattested`:** the ledger is the file the agent appends
+to at every stage and carries no writer field, so nothing in it separates a hook-written
+line from one an agent typed. Saying *never agent-written* was a provenance claim the
+format cannot support — B-014's class, in the mechanism built to close it.
+
+And why the verb prints
 `unmeasured` rather than `0` when there are no such lines is the same reason again — the
 hook being absent and the run reading nothing are **opposite facts** the ledger cannot
 separate, so it claims neither. A `0` there would be the reassuring answer to a question
-nobody asked, over 34 files nobody checked.
+nobody asked, over 35 files nobody checked.
 
 It is a disclosure: no floor, no direction, never a target. The moment the number becomes
 something to raise, a run will open files to raise it.

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

@@ -27,15 +27,29 @@ Both are checked the same way and this file covers both.
 
 ## The measured reason this file exists
 
-On 2026-08-11, mid-run, a monitor was armed to watch CI. One minute later the
-harness task inventory was queried:
+On 2026-08-11, mid-run, a monitor was armed to watch CI. **What follows is two
+observations of two different things, taken at two different moments**, and each
+one is stamped so that a reader is not left reconciling them. One minute after
+the monitor was armed, the harness task inventory was queried; the process table
+was read after that:
 
 ```
 TaskList              →  "No tasks found"
 ps -eo pid,etime,cmd  →  52693  03:12  /bin/zsh -c … gh pr checks …
 ```
 
-The monitor was **alive and polling**, and the inventory tool reported nothing.
+`etime` is elapsed life, so the `03:12` in that line dates its own reading:
+three minutes and twelve seconds after the monitor was armed, a little over two
+minutes after the inventory had come back empty. The monitor was **alive and
+polling**, and the inventory tool reported nothing. Both readings were accurate.
+They were readings of different things, made about two minutes apart.
+
+**What this record does not carry, said plainly: the wall-clock times.** Neither
+observation was stamped with the hour at which it was taken, so what was
+observed is the two offsets above — one minute to the inventory, `03:12` of
+process life at the `ps` reading — and the interval between them is derived from
+those two. The absolute times are not recoverable from anything this record
+kept, and nothing here reconstructs them.
 
 This is the class this whole doctrine exists to catch: **a check answered by
 something that is not its subject.** An inventory that does not enumerate the
@@ -201,9 +215,9 @@ judgement, the item is reported, not ended** — which puts it back under the ru
 above rather than creating an exception to it.
 
 **A foreign item never becomes spent.** The 18 containers above belong to other
-projects; that they have been up for three days is information for whoever owns them,
-not permission. The third owner state widens what a run may clean **inside its own
-project** and widens nothing at all outside it.
+projects; that the oldest of them has been up for three days is information for
+whoever owns them, not permission. The third owner state widens what a run may
+clean **inside its own project** and widens nothing at all outside it.
 
 ## Rationalizations
 

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

@@ -19,7 +19,7 @@ justifies reading it protects one section while the file below it doubles.
 | Artifact | Parts | How it is read |
 |---|---|---|
 | `docs/evidence/retro.md` — **one per project** | **Standing instructions** (max **10**) · **Run stamps** (max **10**, oldest rotate out) | stage 0, **in full** — both are bounded by a **cap**, which *one line each* never was |
-| the same file's **Recent log** | entries from the last five run stamps — narrative, and capped by nothing | stage 0, **queried** by the task's nouns. It said *in full* until 2026-08-10, when it measured **74%** of the file: an uncapped section inside a binding source is what makes the capped part get skimmed |
+| the same file's **Recent log** | narrative entries, **uncapped by design** — the heading said *entries from the last five run stamps* until 2026-08-20 while the section held 25 going back nine days, a bound in a heading that nothing enforced | stage 0, **queried** by the task's nouns. It said *in full* until 2026-08-10, when it measured **74%** of the file: an uncapped section inside a binding source is what makes the capped part get skimmed |
 | `docs/evidence/retro/YYYY-QN.md` — the archive | every entry and every retirement ever written, append-only | **queried** by the task's nouns; never read end to end |
 
 Seed the archive from [`../templates/retro-archive.md`](../templates/retro-archive.md).

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

@@ -264,8 +264,11 @@ never that the work was skipped quietly.
   decomposition is a decision, never an omission.
 - **Where the queue is a work graph, it is WRITTEN here**
   ([`work-graph.md`](work-graph.md)): `.task-pipeline/graph.json`, carrying the frozen REQ
-  ids so `serves` resolves, one node per unit of work with its owner and what it touches,
-  and an edge per dependency **naming what it hands over**. Then
+  ids so `serves` resolves, one node per unit of work with its owner, what it touches and
+  **the check that will close it**, and an edge per dependency **naming what it hands
+  over**. The check is the planner's job and not the verifier's: a node whose completion
+  test is decided by whoever happens to close it is a node two closes will disagree about,
+  and `validate` refuses one that names none. Then
   `python3 scripts/graph.py validate` — a graph that does not validate is not a queue, and
   `next` refuses to walk one. The reason to prefer it over a prose plan is measured, not
   aesthetic: a 400-node graph and a 4-node graph produce the same 27-byte frontier, so the

package/plugins/task-pipeline/skills/task-pipeline/references/work-graph.md

@@ -40,6 +40,7 @@ turn of every loop.
 | `nodes[].serves` | the REQ or goal clause it exists for. A node serving neither is **parked with that as the reason** |
 | `nodes[].blocked_by` | what must close first. This is what the frontier obeys |
 | `nodes[].touches` | what it **mutates**. Two runnable nodes writing one file is the false parallelism [`planning.md`](planning.md) refuses — *distinct is not the same as independent, and the check is what they touch, never what they are called* |
+| `nodes[].check` | **how this node will be closed** — one command, or the named judgement where no command can decide it. Required on every node except a `parked` one. `agents/verifier.md` runs it and reports its output as the evidence row; before this field existed that instruction pointed at an absence, leaving the verifier the two things it forbids — invent a check, or run everything (B-080) |
 | `nodes[].evidence` | required when `status` is `done`. A node called done by assertion is what evidence exists to prevent |
 | `nodes[].parked_reason` | required when `status` is `parked`. A park with no reason is indistinguishable, a week later, from work quietly dropped |
 | `edges[].payload` | what the dependency hands over. **An edge carrying no named artifact is chronology drawn as architecture** |
@@ -68,6 +69,14 @@ the graph does. Ties break on declaration order, so the frontier is stable betwe
 an unstable one costs more than it looks, because an agent calling `next` twice starts the
 other node.
 
+**One node, one completion test.** `check` is a string rather than a list, because the
+requirement is singular throughout — one input, one job, one output, one owner, one
+completion test. A node needing two unrelated checks is a node doing two jobs, and the
+answer is to split it; one gate made of two commands is `a && b`, which is still one gate.
+A **`parked`** node is the single exemption: it is the one node nobody will close, and
+*n/a — parked* in that field is confidence without correctness. `park` never removes what
+the node said it would run.
+
 **`close` stamps the commit; the verifier never supplies it.** A verdict written after the
 tree moved is evidence about a different tree, and an agent cannot name the wrong commit if
 it is never the one naming one.
@@ -114,6 +123,7 @@ does not have.
 
 | The excuse | Why it is wrong |
 |---|---|
+| *"The verifier will work out what to run."* | Then the node's completion test is decided by whoever happens to close it, and two closes of one node disagree. The field is where the planner says it, and `validate` refuses a node that does not |
 | *"I'll just read the graph, it's only forty nodes."* | Forty is the number today. The property being protected is that four hundred costs the same, and it stops being true the first time the model reads the file |
 | *"The frontier is short; one extra line won't matter."* | It is paid on every iteration of every loop. That is what *the frontier and nothing else* means |
 | *"`blocked_by` already says the dependency, the edge is bookkeeping."* | The edge carries the **payload**. A dependency handing over nothing named is the fake edge with a field around it |

package/plugins/task-pipeline/skills/task-pipeline/scripts/graph.py

@@ -19,7 +19,10 @@ channel ships it. A dependency here would make the graph Claude-Code-shaped.
 states everything JSON Schema can — the required fields, `owner` non-empty, an edge's
 payload, and `done` implying non-empty evidence. What a schema cannot reach is
 cross-document and cross-node: whether an `owner` names a role that EXISTS, whether
-`serves` resolves, and whether the edges cycle. Those three are here. The split is
+`serves` resolves, and whether the edges cycle. Those three are here. So is every rule
+the format states, because the schema is never applied to a LIVE graph — including
+B-080's `check`, without which `agents/verifier.md` instructs an agent to read a field
+that does not exist. The split is
 where the format actually puts it, which is not where the first draft drew it.
 
 Exit codes are the contract (standing instruction R-004 — the next command is
@@ -238,6 +241,25 @@ def violations(graph):
                            "nobody asked for is work the brief cannot account for, and the "
                            "coverage relation cannot reach it")
 
+        # B-080 — the node says HOW it will be closed, and shipped doctrine reads it.
+        # `agents/verifier.md` told the verifier to run *the check the task named* while
+        # the schema had no field to name one, so the instruction pointed at an absence
+        # and the verifier's only options were the two that paragraph forbids: invent a
+        # check, or run everything. A `parked` node is the one exemption — it is the one
+        # node nobody will close, and a placeholder there would be worse than the gap.
+        if n.get("status") != "parked":
+            chk = n.get("check")
+            if not isinstance(chk, str) or not chk.strip():
+                out.append(f"{nid}: `check` is {chk!r} — B-080: a node that cannot say how "
+                           "it will be closed leaves the verifier inventing a check or "
+                           "running everything, and `agents/verifier.md` forbids both. Name "
+                           "the command, or the judge where no command can decide it. Only a "
+                           "`parked` node is exempt")
+            elif any(c in chk for c in "\n\r"):
+                out.append(f"{nid}: `check` contains a line break. A completion test that is "
+                           "two commands cannot say which one closed the node, and the "
+                           "verifier reports its output as one evidence row")
+
         if n.get("status") == "done":
             ev = n.get("evidence")
             if not isinstance(ev, list) or not [e for e in ev
@@ -480,6 +502,16 @@ def verdict_violations(v):
         for nid in rp.get("add") or []:
             if not isinstance(nid, dict) or "title" not in nid:
                 out.append("replan.add entries must be nodes with at least a `title`")
+                continue
+            # B-080 again, at the one place a node is created by a verdict rather than by
+            # a person. Checked HERE so the refusal names the key before anything is
+            # written: leaving it to `violations()` after the close would abort the whole
+            # close over a field the verdict could have been asked for.
+            _c = nid.get("check")
+            if not isinstance(_c, str) or not _c.strip():
+                out.append(f"replan.add entry {nid.get('title')!r} names no `check` — the "
+                           "node it creates has to say how IT will be closed, or the next "
+                           "verifier faces the absence this one was told to read")
     return out
 
 
@@ -679,7 +711,14 @@ def cmd_add(graph, args):
         die("owner %r is not a role this pipeline ships%s — nothing was written"
             % (args.owner, (" — did you mean %s?" % near[0]) if near else ""))
 
-    for name, val in (("--title", title), ("--serves", serves)):
+    check = (args.check or "").strip()
+    if not check:
+        die("`add` needs a --check with something in it: the command that closes this node, "
+            "or the judge where no command can decide it. A node that cannot say how it "
+            "will be closed leaves the verifier inventing a check or running everything — "
+            "B-080, and `agents/verifier.md` forbids both. Nothing was written")
+
+    for name, val in (("--title", title), ("--serves", serves), ("--check", check)):
         if any(c in val for c in "\n\r"):
             die("%s contains a line break. `next` prints one row per node and the loop "
                 "reads those rows, so a break here forges a row for a node that does not "
@@ -729,7 +768,7 @@ def cmd_add(graph, args):
             "allocated from the highest in use" % nid)
 
     new = {"id": nid, "title": title, "owner": args.owner, "status": "pending",
-           "blocked_by": blocked, "serves": serves, "evidence": None}
+           "blocked_by": blocked, "serves": serves, "check": check, "evidence": None}
     touches = list(dict.fromkeys(t.strip() for t in (args.touches or []) if t.strip()))
     if touches:
         new["touches"] = touches
@@ -870,13 +909,21 @@ def cmd_producer(graph, args):
 def cmd_doctrine(graph, args):
     """Which doctrine this run actually read — B-061.
 
-    The bundle is 34 reference files. A run reads some subset and nothing recorded which,
+    The bundle is 35 reference files. A run reads some subset and nothing recorded which,
     so **a skipped file and a read one were indistinguishable** — the class every guard in
     this repository exists to catch, left standing over the doctrine itself.
 
-    `read:` lines in the run ledger are written by a hook, never by the agent, for the same
-    reason `gate:` is: a claim about what somebody read, written by the party the claim is
-    about, is not evidence.
+    `read:` lines are written by a hook rather than by the agent, for the same reason `gate:`
+    is: a claim about what somebody read, written by the party the claim is about, is not
+    evidence.
+
+    **And that is an intent, not a proof, so every line here is reported as UNATTESTED.**
+    The ledger is `.task-pipeline/run.md` — the file the agent appends to at every stage —
+    so nothing in it distinguishes a hook-written line from one an agent typed. The doctrine
+    said *hook-written, never agent-written*, which is a provenance claim this script cannot
+    check and no format here carries; B-014's class, committed by the mechanism built to
+    close it. Until the ledger can attest a writer, the honest output is the count plus the
+    word: read as *this is what the ledger says, and the ledger cannot say who wrote it*.
 
     **The one rule that matters here: no `read:` lines means UNMEASURED, never «read
     nothing».** Zero would be the reassuring answer to a question nobody asked, and this
@@ -919,7 +966,10 @@ def cmd_doctrine(graph, args):
         return 0
 
     unread = [r for r in refs if r not in read]
-    print(f"doctrine: {len(read)} of {len(refs)} reference files read")
+    print(f"doctrine: {len(read)} of {len(refs)} reference files read — unattested")
+    print("          unattested: the ledger is the file the agent appends to at every stage, "
+          "so nothing in it proves the hook wrote these lines rather than an agent. The "
+          "count is what the ledger says; who wrote it is not recorded.")
     print("          a disclosure: no floor, no direction, never a target. A run that needs "
           "four files and reads four is not worse than one that reads thirty.")
     for r in unread:
@@ -993,14 +1043,17 @@ def cmd_close(graph, args):
         title = str(spec.get("title", "")).strip()
         owner = str(spec.get("owner", "implementer")).strip()
         serves = str(spec.get("serves", node.get("serves"))).strip()
+        check = str(spec.get("check", "")).strip()
         if not title:
             die("replan.add carries an entry with no title — nothing was written")
+        if not check:
+            die("replan.add carries an entry with no check — nothing was written")
         if owner not in ROLES:
             die("replan.add names owner %r, which is not a role this pipeline ships" % owner)
         new_id = next_id({n.get("id") for n in graph["nodes"]})
         graph["nodes"].append({"id": new_id, "title": title, "owner": owner,
                                "status": "pending", "blocked_by": [], "serves": serves,
-                               "evidence": None})
+                               "check": check, "evidence": None})
         revise(graph, "add", new_id, why or ("re-planned by the verdict on " + nid))
         added.append(new_id)
     for pid in rp.get("park") or []:
@@ -1074,6 +1127,10 @@ def main(argv=None):
     p_add.add_argument("--title", required=True)
     p_add.add_argument("--owner", required=True)
     p_add.add_argument("--serves", required=True)
+    p_add.add_argument("--check", required=True,
+                       help="the command that closes this node, or the judge where no "
+                            "command can decide it — the verifier runs it and reports its "
+                            "output as the evidence row")
     p_add.add_argument("--blocked-by", dest="blocked_by", action="append", default=[])
     p_add.add_argument("--carries", action="append", default=[],
                        help="what each --blocked-by hands over; pairs in the order written")

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

@@ -31,7 +31,7 @@ has not fired in the last five run stamps, or in the last sixty days. At eleven
 rows, the oldest never-fired
 row goes — the cap is not negotiable, ranking is.
 
-## Recent log — entries from the last five run stamps (newest first)
+## Recent log — narrative entries, uncapped and queried rather than read (newest first)
 
 Older entries and every retirement **move** to `docs/evidence/retro/YYYY-QN.md`
 at the prune. Moving is not deleting: the archive is append-only and holds the

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

@@ -20,23 +20,35 @@ Run: `<topic>` · started `<YYYY-MM-DD>` · module map: `<path or "none">`
 
 ## `read:` — which doctrine this run actually opened
 
-The bundle is 34 reference files and nothing recorded which of them a run read, so **a
+The bundle is 35 reference files and nothing recorded which of them a run read, so **a
 skipped file and a read one were indistinguishable** — the class every guard in this
 pipeline exists to catch, left standing over the doctrine itself.
 
-`read:` is **hook-written, never agent-written**, for the same reason `gate:` is: a claim
-about what somebody read, written by the party the claim is about, is not evidence. The
+`read:` is **written by a hook rather than by the agent**, for the same reason `gate:` is: a
+claim about what somebody read, written by the party the claim is about, is not evidence. The
 hook is in `hooks.example.json`, matches `Read`, records the path only
 when it is inside the bundle's `references/`, deduplicates, and **always exits 0** — a hook
 that can fail a `Read` would break every turn in every session.
 
+**That is an intent, not a proof, and the line says so.** This file is the one the agent
+appends to at every stage, so nothing in it distinguishes a hook-written line from one an
+agent typed: there is no writer field, and `scripts/graph.py` has no provenance check
+because the format gives it nothing to check. The doctrine here said *hook-written, never
+agent-written* until 2026-08-20 — a provenance claim in the file whose whole subject is that
+a claim by the interested party is not evidence, which is B-014's class committed by the
+mechanism built to close it. So `doctrine` and the `gate:` reader both report **`unattested`**
+beside their counts, and the two claims that survive are the ones the ledger can support:
+*this line is in the ledger*, and *nobody recorded who wrote it*. Attesting a writer needs a
+field this format does not have; inventing one that an agent can also fill would restate the
+same claim one level down.
+
 `scripts/graph.py doctrine` reads these lines and prints one of three things:
 
 | It prints | When | Why not just a number |
 |---|---|---|
 | `unmeasured — no run ledger` | there is no ledger | nothing to read from |
 | `unmeasured — the ledger carries no read: lines` | the hook is absent, **or** the run opened no doctrine | two opposite facts, and the ledger cannot separate them, so neither is claimed |
-| `N of 34 reference files read`, then each unread one | the hook is installed and fired | the count alone says there is a gap, not where |
+| `N of 35 reference files read — unattested`, then each unread one | the hook is installed and fired | the count alone says there is a gap, not where — and `unattested` says the ledger cannot name who wrote the lines |
 
 **It is a disclosure: no floor, no direction, never a target.** A run that needs four files
 and reads four is not worse than one that reads thirty — and the moment the number becomes
@@ -58,15 +70,17 @@ hand:  <N|10> — task "<quoted>" — done <n> — surfaced <n> — decisions <n
 holds: <stage id> — <n> (<class: what, owner>; … or "none") — enumerated <n>/8 classes, <unlooked: classes not enumerable>
 gate:  <stage id> — command "<cmd>" — exit <N> — <ISO-8601>
 event: <compact|session-end|subagent> — <detail> — <ISO-8601>
-read:  references/<file>.md            # hook-written, deduplicated, one per file opened
+read:  references/<file>.md            # hook-appended, deduped, UNATTESTED (no writer field)
 ```
 
 - **`stage:`** — written when a gate **returns**, not when the stage is entered. The
   rail's `✓` is derived from this line and from nothing else; a glyph set from memory
   is a summary that is confidently wrong exactly when it matters.
-- **`gate:`** — written by `hooks/gate-observer.sh`, never by an agent. It is the
-  only line here that records what a command **did** rather than what somebody
-  concluded: the exit code of the stage's declared `gate.command`, observed. The
+- **`gate:`** — appended by `hooks/gate-observer.sh` rather than by an agent, and
+  **unattested** for the reason `read:` is: this file is agent-written at every stage
+  and carries no writer field, so the line's provenance is an intent the format cannot
+  prove. It is the only line here that records what a command **did** rather than what
+  somebody concluded: the exit code of the stage's declared `gate.command`, observed. The
   `stage:` line above it is the agent's claim, and the release gate requires the
   two to agree — without this, a gate reads a claim written by the party it
   constrains and confirms an assertion with itself. Absent where the project

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

@@ -41,6 +41,7 @@ worse than saying nothing.
 ## Contents
 
 - [Staleness — a row is true about the tree it OBSERVED](#staleness--a-row-is-true-about-the-tree-it-observed)
+- [Environment — a proof is only valid where it ran](#environment--a-proof-is-only-valid-where-it-ran)
 - the ledger itself — one row per REQ, appended by stage 8
 - [What `Human` means, and what it does not](#what-human-means-and-what-it-does-not)
 
@@ -71,11 +72,39 @@ one. Four things overtake a row, and naming which one applies is the note's job:
 change in what it covers, a **dependency** change, an **environment** change, and a
 **policy** change — the last being the rule under which the evidence was accepted.
 
-| REQ | What | Run | Shipped in | Observed at | Auto | Human | Note |
-|---|---|---|---|---|---|---|---|
-| REQ-001 | CSV export from a report | `2026-07-28-export` | v1.4.0 | `5f21ac3` | pass | 2026-07-30 | opened the deployed page, exported, opened the file |
-| REQ-004 | XLSX export | `2026-07-28-export` | v1.4.0 | `5f21ac3` | pass | **never** | — |
-| REQ-007 | Export respects active filters | `2026-07-28-export` | v1.4.0 | `5f21ac3` | partial | **never** | CSV path only |
+## Environment — a proof is only valid where it ran
+
+`Observed at` says which tree the check saw. It does not say **where**, and without that a
+smoke test against a preview URL enters the record in a shape indistinguishable from one
+against production, and a suite green on a laptop with accumulated state is
+indistinguishable from one green on a runner that started clean. Those are the two halves
+of the same question, and only one was instrumented.
+
+**`Environment` is a required cell on every row.** Its vocabulary is the project's own,
+declared in the runbook and not invented per row — this file ships with four, and a project
+that deploys differently declares different ones:
+
+| Value | What it means |
+|---|---|
+| `production` | the deployed target real users reach |
+| `preview` | a per-branch or per-PR deployment; proves the build, never the release |
+| `ci` | a clean runner, no accumulated state |
+| `local` | a developer machine, with whatever state it has |
+| `—` | **recorded absence** — a row written before this column existed, or one whose environment nobody recorded. Not a value, and never a default to reach for |
+
+A missing cell is not the same as `—`: the first is a row that forgot the question, and it is
+**refused**. The second is an answer.
+
+**A REQ claiming production behaviour may not be closed on a non-production
+observation.** Stage 8 writes the row and refuses that pairing rather than recording it —
+`pass` in `ci` against a requirement about the deployed product is the exact substitution
+this column exists to make visible.
+
+| REQ | What | Run | Shipped in | Observed at | Environment | Auto | Human | Note |
+|---|---|---|---|---|---|---|---|---|
+| REQ-001 | CSV export from a report | `2026-07-28-export` | v1.4.0 | `5f21ac3` | production | pass | 2026-07-30 | opened the deployed page, exported, opened the file |
+| REQ-004 | XLSX export | `2026-07-28-export` | v1.4.0 | `5f21ac3` | ci | pass | **never** | — |
+| REQ-007 | Export respects active filters | `2026-07-28-export` | v1.4.0 | `5f21ac3` | preview | partial | **never** | CSV path only |
 
 ## Columns
 
@@ -86,6 +115,10 @@ change in what it covers, a **dependency** change, an **environment** change, an
 - **Run** — the brief's topic slug, so the context is one file away.
 - **Shipped in** — the tag or commit that carried it. Where a project does not tag,
   the commit, and the same value every row of that run carries.
+- **Observed at** — the commit the check ran against. `—` where nobody recorded one.
+- **Environment** — where it ran, from the project's declared vocabulary. Required; `—` is
+  the recorded absence and an omitted cell is refused. See *Environment — a proof is only
+  valid where it ran*.
 - **Auto** — what the run's own gate said: `pass` · `partial` · `none`. Copied from the
   coverage table rather than re-derived; where the two disagree the coverage table wins
   and the disagreement is a finding. A coverage verdict of **`review`** — *no check can