task-pipeline-skill 1.70.0 → 1.72.0

package/CHANGELOG.md

@@ -1,5 +1,128 @@
 # Changelog
 
+## 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
+
+> **v1.71.0 is a burned tag.** Its entry was prepended **above** `# Changelog`, so
+> `test/validate.py`'s newest-section parser read the *previous* release while the
+> negative self-test planted its defect in *this* one. The two looked at different
+> sections, the plant proved nothing, and CI failed with *"the release entry claimed a
+> guard count the workflow does not define"* — which is the R-001 failure the plant's
+> own comment describes, reproduced by the release that shipped the doctrine about it.
+
+Four issues, one class: a signal that reports success while checking nothing. All four
+survived at least one release in a real project, and none is visible to inspection — the
+command reads correctly, the test name is accurate, the document's rows look settled.
+
+### The false-success table gains two shapes, and its rules go from two to four (#48, #49)
+
+**Read through a pipe.** GitHub Actions runs `run:` under `bash -e` **without** `pipefail`, so
+`npm test 2>&1 | tee ../test.log` concluded `success` over its own `# fail 55`. Then the same
+author did it by hand hours after fixing it: `check-docs.sh | grep -E '^(OK|FAIL)' | tail && git
+commit` committed over a `FAIL` printed to their own screen. **This is the least visible entry
+in the table because the command reads as diligence** — `check.sh | grep FAIL` looks like
+somebody being careful.
+
+**An absence with no subject.** A viewport suite pinned a responsive rule as a pair: the column
+visible at 1280, absent at 1279. The column had been removed from the product months earlier, so
+the desktop half failed and the compact half **passed at every width**. The test named after the
+compact band proved nothing about it. This is the complement of *watch the green fail against a
+planted defect*: that rule finds a check which **cannot fail**; this one finds a check which
+**cannot succeed meaningfully**.
+
+### A check with a wrong premise can still be the thing that finds the defect (#40)
+
+A new check going red on day one invites one reflex — *the check must be wrong, relax it*.
+A guard asserted two constants for "the price of one unit per year" were equal; the premise was
+wrong, they belong to two different products. Reading further, the disagreement was **visible to
+customers**: both still sell from one page, and the note under the volume table promised a
+discount computed from the header's price while the table's numbers gave roughly half of it.
+
+`gates.md` now says to **separate the premise from the observation before touching either**, and
+to relax the assertion only after what it surfaced has its own record — otherwise the finding
+leaves with the check that found it.
+
+### A hand-corrected document drifts back within one run (#39)
+
+Four boards consolidated into one, every row re-checked; within 24 hours a row settled in code
+that morning read `open` again — in **two** places, because a row in a section table and again
+in a summary has to be closed twice. **A document's claims are never executed**, so nothing
+distinguishes a row that *is* true from one that *was* true, and the audit correcting it is the
+only reader that checks.
+
+`documentation.md` gains the rule: a correction is done not when the rows are right but when
+**something other than the next audit** will notice them going wrong — with the four claim types
+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.
+
+> **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.
+
 ## v1.70.0 — the stemmer cannot conjugate, so the description says the other form
 
 `запиши решение` — the imperative a person actually types — reached no route at all, while

package/CONTRIBUTING.md

@@ -518,6 +518,19 @@ 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`)*
+
 ## 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.70.0 |
+| **Version** | 1.72.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.70.0",
+  "version": "1.72.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.70.0",
+  "version": "1.72.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",
@@ -139,6 +148,32 @@
         }
       },
       "allOf": [
+        {
+          "if": {
+            "properties": {
+              "status": {
+                "not": {
+                  "const": "parked"
+                }
+              }
+            },
+            "required": [
+              "status"
+            ]
+          },
+          "then": {
+            "required": [
+              "check"
+            ],
+            "properties": {
+              "check": {
+                "type": "string",
+                "minLength": 1,
+                "pattern": "\\S"
+              }
+            }
+          }
+        },
         {
           "if": {
             "properties": {

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

@@ -22,6 +22,7 @@ being written twice; write it once, here.
 - The inventory — four questions, answered before the first line of work
 - Registers and ids
 - Single source of truth
+- A hand-corrected document drifts back within one run
 - The Doc Loop
 - Changing your mind
 - The propagation matrix
@@ -214,6 +215,42 @@ doc to its own view is the failure this paragraph exists to prevent.
 
 ---
 
+## A hand-corrected document drifts back within one run
+
+A board, backlog or status document gets corrected during an audit; the same
+contradictions are back inside a day. **Correcting it again is the same
+intervention at the same cost, not a fix.**
+
+Measured: four contradictory boards were consolidated into one, every row
+re-checked against its source. Within 24 hours a row settled in code that morning
+read `open` again — in **two** places, because a row listed in a section table and
+again in a summary has to be closed twice. Another called two files missing while
+one had been written five hours earlier. A count quoted from a generated ledger had
+moved and the row had not.
+
+**Why the manual pass cannot hold.** A document's claims are never executed. Nothing
+distinguishes a row that **is** true from one that **was** true, so the audit that
+corrects it is the only reader that checks — and it runs once. Between audits the
+document is a set of assertions with no mechanism behind any of them, ageing at the
+speed of the work it describes.
+
+So a correction is not done when the rows are right. It is done when **something
+other than the next audit** will notice them going wrong:
+
+| The claim | What makes it self-checking |
+|---|---|
+| a row's status | derived from the artefact that settles it, or a gate that fails when the two disagree |
+| a count | computed at check time and printed beside its command — never transcribed |
+| "these files are missing" | resolved against the filesystem by the check that prints it |
+| a row in two tables | one table, or a guard asserting the pair agrees |
+
+Where a claim genuinely cannot be derived, **say that in the row** — an assertion
+marked as unverifiable is honest, and the next reader stops treating it as measured.
+Silently correcting it a second time is how a document teaches its readers that
+somebody else is checking.
+
+---
+
 ## The Doc Loop
 
 **Fires whenever something is settled — at any stage.** Scope, a contract, a name,

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

@@ -186,6 +186,22 @@ Four preconditions. Skipping any of them turns a run into a claim.
 4. **You have read the ratchet floors.** A pass with a floor that was quietly
    raised is a pass over the thing the floor was hiding.
 
+**And one rule for the moment after.** A new check that goes red on the day it is
+written invites one reflex — *the check must be wrong, relax it*. Sometimes the
+check **is** wrong, **and the red is still the finding.** A guard asserted two
+constants describing "the price of one unit per year" were equal; they belong to
+two different products, so the premise was wrong and the obvious move was to
+delete the assertion. Reading further showed the disagreement was **visible to
+customers**: both products still sell from one page, and the note under the volume
+table promised a discount computed from the header's price while the table's own
+numbers gave roughly half of it. Nothing miscalculated — only the claim on the page
+was false.
+
+So: **separate the premise from the observation before touching either.** Ask what
+the check *saw*, not whether it was entitled to look. Relax or delete the assertion
+only after the thing it surfaced has its own record — otherwise the finding leaves
+with the check that found it, and nothing remembers it was ever seen.
+
 ---
 
 ## False success — when a mechanism reports a win it never checked
@@ -206,19 +222,34 @@ at least one release in this repository:
 | Presence instead of absence | a counter asserted the new number was present, not that the old one was gone | four surfaces still printed the old number, green for three releases |
 | Half-applied batch | a batch of edits reported done while one edit never applied (R-002) | the file was unchanged |
 | Silence read as a pass | a section with no input printed nothing, and the caller counted it as checked | nothing was looked at |
+| **Read through a pipe** | the caller read the **formatter's** exit code, not the gate's | `npm test 2>&1 \| tee ../test.log` under `bash -e` without `pipefail` concluded `success` over its own `# fail 55`; `check-docs.sh \| grep FAIL \| tail && git commit` committed over a `FAIL` printed to the author's screen |
+| **An absence with no subject** | an assertion that a thing is gone, about a thing that exists nowhere | a viewport test asserting a column leaves the tree at 1279px passed at **every** width — the column had been deleted from the product months earlier |
 
 **The test.** For any mechanism you are about to trust, ask:
 *what does it print when it did not look?* If that is indistinguishable from what
 it prints when it looked and found nothing wrong, it is not evidence — give it a distinct `dormant`
 or `skip` state (→ *Progressive arming*), or verify the effect independently.
 
-Two rules follow. Elsewhere in this bundle they are **cited, never restated**:
+Four rules follow. Elsewhere in this bundle they are **cited, never restated**:
 
 1. **Verify by re-reading, not by the reply.** After a teardown, cancel, delete,
    disable, publish or migrate: query the authoritative state and assert the item's
    new condition.
 2. **Assert the absence of the old, not the presence of the new.** A check that only
    proves the new value exists stays green while the old one is still shipping.
+3. **Read a gate's own exit code, never a pipeline's.** `set -o pipefail`, or
+   `${PIPESTATUS[0]}`, or do not pipe. GitHub Actions runs `run:` under `bash -e`
+   **without** `pipefail`, so `gate | tee` reports `tee`. This is the least visible
+   entry in the table because the command reads as diligence: `check.sh | grep FAIL`
+   looks like someone being careful, and it is the shape that reports success while
+   printing failure to the screen of the person who wrote it.
+4. **An absence assertion needs a subject that exists somewhere.** Before pinning
+   "X must not appear here", prove X appears *somewhere* — otherwise the assertion is
+   true for a reason unrelated to what it claims, and the complement of *watch the
+   green fail against a planted defect* is what catches it: that rule finds a check
+   that **cannot fail**, this one finds a check that **cannot succeed meaningfully**.
+   Both are invisible to every mechanical signal — the test is green, its name is
+   accurate, its code reads correctly.
 
 ---
 

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/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
@@ -993,14 +1032,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 +1116,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")