task-pipeline-skill 1.67.0 → 1.69.0

package/CHANGELOG.md

@@ -1,5 +1,856 @@
 # Changelog
 
+## v1.69.0 — the work graph, and a check that mentions is not a check that binds
+
+**Module 1 of the role-agent programme, complete** — T-1 through T-7, briefed in
+`docs/evidence/specs/2026-08-17-role-agent-graph-brief.md`. The graph is on disk, a script
+walks it, a verifier closes one node at a time against a seven-key verdict, and the loop
+reads a queue rather than its own recollection.
+
+**Counted at the close, not carried from a section above:** 376 guards · 114 graph fixtures · 24 exposure fixtures · 9 verbs on `graph.py` · 35 reference files · `npm run test:all` exits 0 over eight suites. The figures in the sub-sections below are each true at the moment that sub-section landed, which is why this line exists.
+
+
+**`graph.schema.json` and `graph.example.json` ship**, and `test/validate.py` reads
+them. `.task-pipeline/graph.json` is the queue the loop walks — a run artifact, never
+committed by the skill, so what ships is the schema and one example that exercises it.
+
+**The first draft of the check asserted membership in `required` and nothing else,
+and an independent reader defeated every requirement it claimed to enforce.** Standing
+instruction `R-005` exists for exactly that — *your own reading of your own check is
+the reading that missed it* — and this is the first time it has been run on a check
+this repository added. Eight bypasses, all now refused and each watched refusing:
+
+| Bypass | Why it worked |
+|---|---|
+| `nodes` declared an object map, `items` left as decoration | `items` constrains arrays only, so every element check was vacuous — REQ-001, 002 and 003 defeated at once |
+| `owner` in `required`, `minLength` dropped | a node whose owner is `""` satisfies `required` and dispatches to nobody |
+| `owner` typed `["string", "null"]` | the same, with `null` |
+| `edges` requiring `payload` and neither endpoint | an edge is from, to, and what it carries |
+| `items` given as a tuple | binds element 0, frees the rest — and crashed the check rather than failing it |
+| a name in `required` that `properties` never declares | constrains nothing at all |
+| a two-hop `$ref` | reported five fields missing that were not missing |
+| an example of `{"nodes": [], "edges": []}` | validates against any schema and demonstrates none of it |
+
+**And one claim in the schema's own prose was false.** It said `done` implying
+evidence was beyond JSON Schema. Draft-07 `if`/`then` states it exactly, and now does
+— so a node called done by assertion is refused **by the format**, before any script
+runs. The line between "the schema's job" and "the script's job" moved to where the
+format actually puts it: what remains for `graph.py` is cross-document — whether an
+owner names a role that exists, whether `serves` resolves, whether the edges cycle.
+
+**A NameError, found by the reader and not by the author.** The skip path appended to
+`_skips`, which exists in a **sibling repository's** validator and not in this one. On
+any machine without `jsonschema` the run died on a bare traceback and the ~250 checks
+below it never ran; CI could not see it, because CI installs `jsonschema` first. The
+accumulator here is `_UNLOOKED`, and the one-line fix that defines `_skips` would have
+been worse — a silent skip, which `test/validate.py:395` forbids by name.
+
+### T-2 — the walk, and the promise it exists to keep
+
+`scripts/graph.py` ships: `validate`, `next`, `goal`. Stdlib only, verified by
+parsing its own imports — `references/portability.md` makes `scripts/` the one
+Claude-Code capability that travels, and a dependency here would have made the
+graph Claude-Code-shaped.
+
+**The design's central claim is now a measurement.** A 400-node graph is 51 KB on
+disk and produces a **27-byte** frontier; a 4-node graph produces the same 27
+bytes. Context cost is **flat in graph size**, which is the property every other
+part of this programme rests on — and it is why `next` prints the frontier and
+nothing else. That line enters a context on every iteration of every loop.
+
+It checks the three things a schema cannot reach, and only those: whether `owner`
+names a role that **exists** (with the misspelt near-miss caught separately from
+the absent one, per `R-008`'s enumerate-the-shapes rule), whether `blocked_by` and
+the edges name nodes that exist, and whether the edges **cycle** — the one failure
+of this design that looks exactly like slow progress.
+
+Exit codes are the contract per `R-004`: `3` is *nothing left to do* and `4` is
+*nothing runnable*, because a finished graph and a stalled one are different facts
+and a caller that cannot tell them apart will wait on the wrong one.
+
+`test/graph_test.py`, **14 cases**, joins `npm test`. This is also the first
+`scripts/` in this repository, so `CLAUDE.md`'s sentence about the only executable
+code being two installers and the validator was false the moment it landed, and is
+corrected in the same change.
+
+Guards: 351 → **376**. Twenty-three plants across the module, structurally distinct rather than variations,
+each asserting it landed before the validator runs.
+
+### Stage 9 — the third artifact, and one false alarm I raised myself
+
+The code graph was **33 commits behind** and its report described a *different* graph: 1787
+nodes and 1847 edges in `GRAPH_REPORT.md` against 1535 nodes in the `graph.json` beside it,
+with the report the older of the two. `graphify update .` re-extracts without an LLM call, so
+the refresh cost nothing but time: **1866 nodes · 1983 edges · 231 communities**, stamped at
+`26ac6dd`, and the report now agrees with the graph exactly.
+
+**The hubs are seven doctrine sections and three test helpers, and no undocumented code
+seam.** `project()`, `exposure()` and `row()` are hubs because twenty-four fixtures call them
+— scaffolding, not architecture. That `graph.py`'s own functions are *not* hubs is the
+informative part: nine verbs with little internal coupling is what the design intended.
+
+**And I raised a false alarm on the way, which is worth recording because of how it read.**
+The first measurement said *1535 nodes and zero edges* — a graph that answers no reach
+question at all, which is exactly the failure `references/knowledge-graph.md` warns of, since
+a wrong graph carries the authority of a machine. It was wrong: edges live under `links` in
+this format, and there were 1585 of them. A check that reads the wrong field reports the most
+alarming possible state with total confidence — the same shape as a check that reads the
+wrong subject, one axis over, and the reason the second measurement was taken before anything
+was filed.
+
+**Disclosed rather than skipped in silence:** 231 communities now carry 156 saved labels, 154
+of them renamed by their hub. Refreshing the names needs an LLM call and was not made, so the
+community names in the report are hub-derived and not semantic.
+
+### Stage 6 — the full suite, and the thing it found was the suite itself
+
+`npm run test:all` ran six suites and **`graph_test.py` was not one of them.** 114 fixtures —
+the whole of module 1 — lived in `npm test` and outside the command named *all*. Every command
+in `test:all` passed, so *the full suite is green* had been a true sentence about a smaller set
+than it names. `exposure_test.py` was worse off: **24 fixtures in no script at all**, testing
+the very file this release extended with the staleness section.
+
+Both are in now, and a guard **discovers** the suites rather than listing them — every
+`test/*_test.py` and `negatives.py` must be reachable from `test:all`, resolving one level of
+`npm run`. A list there would drift exactly the way the thing it checks drifted.
+
+**Its own first run was wrong, and said so.** Substituting script names in declaration order
+made `npm run test` a prefix of `npm run test:probe`, so four suites were reported absent that
+the chain reaches. Longest name first.
+
+**Then the full suite found two rotted CI plants — both rotted by edits made in this release.**
+
+- *coverage stops refusing a requirement nothing serves* replaced the first
+  `return 1 if bad else 0`, and that line **stopped being unique** the day `cmd_close` landed:
+  the plant disarmed `cmd_validate` instead and the guard, correctly, stayed green. This is a
+  new shape of an old class — a plant pinned to a literal usually rots because the literal
+  disappears; this one rotted because the literal **multiplied**. It anchors inside
+  `cmd_coverage` now.
+- *a worked GATE verdict that prints no disclosures* matched a sentence that B-064 appended
+  `· holds: 0` to, hours earlier. It matches the line's **shape** now.
+
+Both were watched landing and firing before the suite was re-run. `test:all` → **exit 0**
+across eight suites: 376 guards, 114 graph fixtures, 24 exposure fixtures, 9 property checks,
+7 + 7 artifact fixtures, the release-gate harness and the documentation gate.
+
+### T-7 — the doctrine that names the graph, and module 1 closes
+
+`scripts/graph.py`, `graph.schema.json` and `.task-pipeline/graph.json` had shipped and **no
+doctrine file named any of them.** The schema disclosed it about itself: its `queue`
+description said `continuity.md` did not yet know about `work-graph`. A capability with no
+doctrine is one an agent meets by accident, and the run that meets it by accident is the run
+that reads the graph itself — which is the one thing the design exists to prevent.
+
+`references/work-graph.md` ships: what each field is for and the failure it prevents, the
+nine verbs with their exit codes, the three invariants a schema cannot state and the fourth
+reason `violations()` restates the ones it can (**the schema is never applied to a live
+graph** — `graph.py` is stdlib by design, so a rule checked only against the shipped example
+is a rule the run does not have), and what the graph deliberately does not do.
+
+**Stage 2 now writes it and its gate reads it.** The queue was already declared there — *the
+queue exists here, so the loop arms here* — and the graph is where that declaration becomes
+walkable: the frozen REQ ids so `serves` resolves, one node per unit of work with its owner
+and what it touches, an edge per dependency **naming what it hands over**, then
+`graph.py validate`. A graph that does not validate is not a queue, and `next` refuses to
+walk one. `continuity.md` prefers it over the module map and the task list for a measured
+reason rather than a taste: 400 nodes and 4 produce the same 27-byte frontier.
+
+**The verb list is discovered from the script, not typed into the doctrine.** Two homes for
+one list is the class B-084 recorded twice in a day, and the plant is a tenth verb shipped
+without a doctrine row — refused.
+
+**And the position hole appeared a third time.** `graph.py validate` is named in stage 2's
+body and in stage 2's gate, so a file-wide search was satisfied by either: removing it from
+the body left the gate to cover for it. Body and gate are checked separately now, as are
+`SKILL.md`'s stage-table row and `stages.md`'s prose — the stage list is compared across
+three surfaces, so a criterion on one is a criterion the others quietly drop.
+
+Six planted defects watched refused. **Module 1 of the role-agent programme is complete:
+T-1 through T-7.**
+
+### T-5 — `close` consumes a verdict, and the verdict grew its seventh key
+
+`verdict_violations()` had **no CLI verb**: the gate this module's own docstring calls *the
+thing `close` consumes* was reachable only from the test suite, while `agents/verifier.md`
+told an agent to run `graph.py close`. Shipped doctrine pointing at an absence — the class
+B-080 is about, in the file that names it.
+
+`close <id> --verdict <path>` checks the verdict, closes the node, applies `replan.add` and
+`replan.park`, records a revision, and prints the goal with the new frontier count.
+
+**A stop closes the node and refuses the next step.** `replan.possible: false` means the run
+cannot continue around what it found — not that the work just verified did not happen.
+Exiting 0 there would let the loop carry on past a stop; discarding the close would throw
+away a verdict somebody earned. Both directions are fixtured, and the CI plant is the first
+of them.
+
+**`close` stamps the commit; the verifier never supplies it.** Evidence is prose, and a
+verdict written after the tree moved is evidence about a different tree. An agent cannot name
+the wrong commit if it is never the one naming one. Outside a checkout the stamp says
+`unavailable` and why — canon 9a.
+
+**The seventh key is `not_verified`, and it is the one people collapse into `not_done`.**
+`not_done` is *asked for and absent*; `not_verified` is *present and unchecked* — the second
+ships and the first does not. `npm test` has printed `unlooked: N` for releases, so the
+pipeline named the concept everywhere except in the verdict that closes work with it. An
+empty list is a valid answer; silence is not.
+
+**And it walked straight into B-084's class again.** `close` wrote `verb: "close"` into the
+revision log while the schema enumerated only `add` and `park` — so the first `close` wrote a
+graph its own shipped schema rejects. The fixture asserting *the graph after a close still
+validates* **passed**, because `violations()` never reaches an enum; a `jsonschema` probe
+caught it. Both ends now agree from one place, the runtime enforces the set, and a fixture
+compares the two homes directly rather than trusting either.
+
+`test/graph_test.py` → **114 cases**.
+
+### B-092 — the report an operator actually reads
+
+Every gate computes exactly what a not-verified field needs: `abstained` for claims the run
+declined to make, `unlooked` for checks that did not look. **None of it reached the
+hand-back** — four sections and two counters, none of which said what the claim covers or
+what was never checked. So a run could hand back a report honest sentence by sentence and
+still be **indistinguishable from a run whose checks never looked**, which is the failure
+`references/progress.md` names three separate times about other things.
+
+`SCOPE` and `NOT VERIFIED` are in the block now, and in the `hand:` ledger shape beside it —
+the block is transient and the ledger is what survives a compaction, so a field in one and
+not the other is lost exactly when it is needed.
+
+`NOT VERIFIED` is **populated from the disclosures rather than composed**: the `abstained`
+and `unlooked` sets in words, plus anything built this iteration that no check touched.
+Composed by hand it becomes a summary of the parts somebody remembered. And the literal
+`none within the stated scope` is required for the empty case, because an empty field and
+*nothing inside what SCOPE names is unverified* read the same and are not the same — canon
+9a, one artifact over.
+
+**Three of the five plants defeated the guard first, all by the same hole: either side
+satisfying a check meant for both.** A search for the words anywhere in `progress.md` passed
+a block that carried neither, since the doctrine discusses them in prose throughout — it
+reads **inside the block** now. And a search for `scope` among `run.md`'s `hand:` lines was
+satisfied by the *example* while the *shape* had lost it, and vice versa — each `hand:` line
+is now checked against its own continuation, shape and worked example alike, because an
+example that omits what the shape mandates teaches the omission.
+
+One miss was mine rather than the guard's: the plant harness filtered failures for `B-092`
+while that check cited only canon 9a, so a working guard read as a hole. The attribution now
+names both.
+
+### Canon 9a — a measured zero and an unmeasured quantity may not print the same
+
+This arrived **three times under three names** in one programme before anyone named it:
+*State zero out loud* for the code graph, `unanchored`/`unresolvable` for the verification
+ledger, and `unmeasured` for `graph.py doctrine` — joined this release by `next` reporting
+how many runnable nodes declared no `touches`. Four sites, one rule, and
+`references/audit.md` is explicit that a class seen twice becomes a mechanism rather than
+another paragraph.
+
+Canon 9 already said *carry the absence*. 9a says **refuse the number**: `0 of 34 files
+read` and *the recorder was never installed* are opposite facts, and a `0` claims the first
+while meaning the second — the most reassuring answer available, derived from an instrument
+nobody switched on.
+
+**The check is over the shape, not the four sites.** Any verb of `graph.py` that prints a
+count must carry, in the same function, a word for the case where nothing measured it. A
+list of the four would not catch the fifth, which is the whole reason the rule is written
+down — and the plant is exactly that fifth: a new counting verb, added and refused.
+
+**It also caught the difference between a word being present and a word being said.** The
+first version searched the whole function body, so a site that kept its `undeclared`
+variable and printed `note:` instead passed. It reads **printed text only** now — the same
+lesson as four substring failures earlier in this release, arriving once more in a new
+costume.
+
+Measured before writing, and it changed the work: `templates/stage-coverage.sh` prints three
+counts and no absence word, which looked like a fourth instance — and is not. It
+**enumerates** every unaccounted stage by name, so its `accounted for 0` is a measurement
+rather than a claim. The check was scoped to what actually has the defect.
+
+### B-093 — two runnable nodes, one mutable target
+
+`references/planning.md` states the rule with the right teeth — *distinct is not the same as
+independent, and the check is what they touch, never what they are called* — and it lived
+**entirely in the markdown plan**. The role-agent design replaced that plan with
+`graph.json` as the thing deciding what runs next, and the node had no field for what it
+mutates. So `frontier()` ranked by `blocked_by` alone and could hand two agents two runnable
+nodes that write the same file, with nothing able to report it.
+
+`touches` ships on the node — paths, register names, remote resource ids — and `next` reports
+a pair of **simultaneously-runnable** nodes sharing one. Only simultaneously: a pair where
+one waits on the other never holds the target at once, and reporting it would be a warning
+nobody can act on, which is how a warning becomes noise.
+
+**Both reports go to stderr, and that is a contract rather than a preference.** The frontier
+rows are parsed one per node and are the one line paid for on every iteration of every loop
+— a warning among them reads as a node.
+
+**And the third state is the one that matters: nobody declared anything.** A frontier whose
+nodes carry no `touches` produces no pairs, which looks exactly like a frontier that was
+checked and found clean. So `next` prints how many runnable nodes said nothing — the same
+shape `doctrine` refuses to print `0` for, one axis over.
+
+**Three existing fixtures went red, and they were right to.** They asserted *the frontier
+and nothing else* by reading stdout and stderr merged, so a disclosure written to stderr
+looked like a violation of the width contract. The contract is about stdout; the helpers
+`run_out` and `run_at_out` read that stream alone, and a helper that merges the two cannot
+tell the contract from its breach. Six planted defects watched refused, including both
+disclosures relocated to stdout.
+
+`test/graph_test.py` → **101 cases**.
+
+### B-065 — what the invariants bind together, coordination must guard together
+
+Two halves of this row had gone stale and the third could not be mechanised, so it was
+closed by measuring all three rather than by taking the easy one.
+
+**Stale, and the measurement says so.** *«six registers under lease»* — `idRegisters` is
+deliberately **empty**: the `fs` backend cannot reserve an id safely, and a declaration that
+cannot be served reads as a capability nobody then writes the procedure for. *«the same
+config in the other projects»* — measured: **all eight** family repositories carry one.
+
+**Genuinely open, and now closed.** The version-sync invariant names **five** surfaces that
+must move together; four were lease-guarded. The fifth is `SKILL-CARD.md` — whose omission
+had already surfaced once on a release bump, from the validator rather than from a reader.
+Two agents bumping a version collided there with no lease, which is not hypothetical: this
+project lost four version numbers and a `files[]` entry to exactly that. `SKILL-CARD.md` and
+the carry-over ledgers are guarded now.
+
+**The surfaces are discovered, not listed.** A file *declaring* the current version — JSON
+`"version": "x"` or the card's `| **Version** | x |` row — is a surface a bump touches, and
+each must match a `guardedFiles` glob. A list here would drift from the invariant exactly
+the way the last one did; watched catching a `registry.json` created for the test and never
+mentioned to the check.
+
+**And the habit was promoted rather than left as a row nobody can close.** *Take the lease
+before the edit, not after the collision* is `R-009` now, with the retirement condition the
+doctrine requires. It is a standing instruction and not a mechanism because whether a write
+is *about to* happen is not a state a script can read — the guard refuses an unleased edit
+*at* the edit, which is already too late to have avoided the race. B-75 is the evidence: a
+second session committed to the umbrella with no leases and **invisible to `agent_sync
+status`**, so the config being present is not the habit being held.
+
+Five planted defects watched refused.
+
+### B-061 — which doctrine a run actually read, and the one number it must refuse to print
+
+The bundle is **34 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.
+
+A `PostToolUse` hook on `Read` now appends `read: references/<file>.md` to the run ledger,
+deduplicated, and **always exits 0**: a hook that can fail a `Read` breaks every turn in
+every session, including sessions of packs that never asked for this one. It is
+hook-written for the same reason `gate:` is — a claim about what somebody read, written by
+the party the claim is about, is not evidence.
+
+`scripts/graph.py doctrine` reports it, and **the state that matters is the one where it
+must not print a number.** No ledger, or a ledger with no `read:` lines, prints
+`unmeasured` and says why: the hook being absent and the run having opened no doctrine are
+**opposite facts**, the ledger cannot separate them, so neither is claimed. `0 of 34` there
+would be the reassuring answer to a question nobody asked, over 34 files nobody checked —
+and that is precisely the shape that went unnoticed for a whole bundle.
+
+Where the hook did fire, it prints the count **and every unread file**, because a number
+says there is a gap and not where. 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 something to raise, a run will open files to raise it.
+
+**No per-file reading floor was invented.** Stage 0's mandatory items are the floor that
+exists and they are not per-file; declaring one inside a measurement would be a doctrine
+decision smuggled in as a count.
+
+Two existing guards caught this change as it landed, both correctly: a relative link in a
+seeded template (which resolves from `templates/` and nowhere it is seeded to), and **a
+ledger shape with no reader** — `read:` had to be named in the doctrine that consumes it
+before the template could declare it. Seven planted defects watched refused.
+
+### B-064 — a worked example is the executable half of doctrine, and now something checks one
+
+Three times in one release a rule moved and its own example did not. An agent copies the
+example literally and paraphrases the prose, so **the example is what ships** — and nothing
+compared one against the rule it illustrates.
+
+Now something does. Every `GATE <n> <name>: PASS|FAIL` block across `references/` and
+`templates/` is read and required to carry the `holds:` line `gates.md` says every gate
+prints. Three of the seven did not; they do now. And the page that **states** a mandate must
+carry a conforming example of its own — the prose gets paraphrased and the example gets
+copied, so the page stating a rule is the page that most needs one.
+
+**The unit is the block, and that is not a detail — it is the whole finding.** A verdict is
+its `GATE …` line plus the indented continuation beneath it. Measuring by *line* said five
+examples lacked `holds:`. Measuring by *block* says three did: two carried it on a
+continuation line all along.
+
+**So the first version of this fix was wrong, and this check caught it ten minutes later.**
+Reading line-wise, `holds: 0` was appended to two blocks that already said
+`holds: 10 — none — enumerated 8/8 classes`. Two values for one disclosure in one verdict is
+**worse than none**, because a reader picks one and copies whichever they picked. Both
+duplicates are reverted, and the guard now refuses a repeated disclosure as well as a
+missing one — a rule it learned from being broken by the change that introduced it.
+
+Six planted defects watched refused: a continuation-line disclosure removed, an inline one
+removed, the disclosure renamed inside an example, a **new** example added without it, a
+second contradicting value, and the stating page losing its own example.
+
+### B-076 — a ruling is not a measurement
+
+Gate types were `auto` and `manual`, and that was one short. A reviewer's ruling, a check
+that the scenarios are coherent, a verdict that a mockup is good — none has a complete
+deterministic check, and all three rode in `auto`, **indistinguishable from an exit code**.
+A coverage table then cannot tell a measured row from an opinion, and the role-agent
+programme multiplies it: `reviewer`, `ux`, `ui` and `market-analyst` produce judgement by
+design.
+
+`judgment` ships. `auto` now means only what a machine established, and a judgment gate
+**must name its `judge`** — the schema refuses it otherwise. That obligation is not
+bookkeeping: a ruling with no author cannot be weighed for independence, and independence
+is not a property of *having* a reviewer. This pipeline's own `R-005` reader shares a
+model, instructions and repository with the author it reviews, differing only in context.
+It is a real second reading and it is **not** a deterministic runner, a contract at another
+boundary, or an external system. Naming the judge is what makes that difference visible
+instead of assumed.
+
+**It generalises a rule this repository already had in one place.**
+`templates/verification.md` turns a coverage verdict of `review` into `none` in the `Auto`
+column, because that column records what a machine established. That is the `judgment` type
+applied to one column, and it has been sitting there being right.
+
+**Which of this pipeline's own gates are judgement is deliberately not decided.**
+`references/gates.md` says gate assignment is the operator's call and the framework fixes
+none — so shipping a reclassified stage list would contradict the sentence above it.
+
+**Eight planted defects, all refused on the first attempt — including the two shapes that
+defeated every guard before this one.** Renaming the doctrine row to `judgement` and the
+section to *About judgment gates* both fail now, because the checks anchor on a line's
+opening cell rather than searching for a word. That was the session's repeated lesson —
+four guards had been beaten by a substring — and this is the first one written with it in
+hand.
+
+### B-081 — proof expires, and the ledger had only one end of it
+
+The verification ledger tracked rows nobody had **ever** confirmed and had no notion of a
+row whose confirmation the tree has since **overtaken**. A row verified at commit A read
+`verified` after commit B, forever. Those are the same failure from two ends, and only one
+end was instrumented — so a ledger could read fully green over a tree where every check ran
+against code that has since moved.
+
+**This is a port, not a design.** `references/knowledge-graph.md` already gives the code
+graph a stamp, a distance, three states, and a marker on every non-current one. The same
+contract, applied to the ledger: `Observed at` is the commit the check ran against, and
+`exposure.sh` reports **current · behind · unresolvable · unanchored** — a disclosure with
+no floor, no direction and never a target, exactly like the `never` column beside it.
+
+`behind` means **unproven for this tree, never wrong.** The section knows the distance and
+does not know whether the commits between touched anything the row covers; claiming more
+would be the estimate-printed-as-measurement this pipeline refuses elsewhere. And
+**invalidation is not deletion** — an overtaken row is true about the tree it observed and
+stays; re-observing appends.
+
+**Where it prints turned out to matter as much as what it prints.** The first placement put
+the section after the check-list, and `exposure.sh` exits early when nothing is unverified
+— so the counts were invisible in exactly the state where they matter most. `0 unverified`
+is the sentence most likely to be read as *nothing to look at*.
+
+**Three of the eight plants defeated the guard on the first attempt, and one of them for the
+fourth time this session.** Checking `"staleness" not in output` passed a section renamed to
+`was-staleness`, because the old string is a substring of the new one; the guard anchors on a
+line *beginning* `staleness —` now. Checking `"not trusted" not in output` passed a plant
+that stripped the marker from the `behind` row only, because the unresolvable row still
+carried one — it is checked **per state** now. And nothing asserted the **shipped** template
+carried the column at all, so every project seeding it would have got a section dormant
+forever, and dormant is green. All eight refused now.
+
+### B-087 — the pointer is not the path
+
+Stage 10 already required `git submodule status` with no `+` and every repository clean
+and pushed. That is a statement about **commits**: the parent points at the child's newest
+one. It proves nothing about whether the two versions work *together*. A parent can point
+at a green submodule whose contract the parent's own code calls with the previous
+signature, and every check passes — the child's suite ran against the child, the parent's
+against the parent, and no check ran across the pointer. Neither repository looks wrong
+alone, which is how this survived being written down twice.
+
+`templates/convergence.sh` ships, and the criterion fires **only where a component
+pointer moved in the range being accepted** — a range that crossed no boundary has no seam
+to prove, and demanding a record for it is how a gate becomes noise. Where one moved, the
+acceptance owes a named cross-component path, the exact versions it observed, and the
+observation to the same standard a single REQ meets.
+
+It also checks the thing `git submodule status` **cannot see: whether the pinned commit is
+published at all.** Measured here on 2026-08-16 — a release tag failed CI at checkout
+because the parent pinned a commit that existed only on one machine, and `submodule
+status` showed no `+` because the pointer matched the *local* head.
+
+**Two things happened on its first live run, and both are the point.** It found a real,
+current defect in the umbrella: the parent's pointer and the child's HEAD disagree, so a
+clone would get a different tree than the one tested. And it found a defect **in itself** —
+the published-pin section read `git -C <c> rev-parse HEAD`, the *child's* HEAD, where it
+needed `git rev-parse HEAD:<path>`, the parent's pointer. Those are the same fact only
+while they agree, and they disagree in precisely the case the section exists for. So its
+first live run reported about a commit the parent does not pin.
+
+**The gate does not read the script; it runs it over four shapes built from real git
+repositories** — a repository pinning nothing (dormant and green, because a gate that
+starts red teaches its project the gate is noise), a range touching no component, a moved
+pointer with no record, and a record that names no version. Five planted defects watched
+refused, including a verdict block that prints FAIL and returns 0.
+
+### B-086 — what produced the proof
+
+Every artifact here recorded what was done, what proved it, and whether a person looked.
+None recorded what **produced** it. Two runs six months apart, one under v1.40 doctrine
+and one under v1.69, leave indistinguishable coverage tables — so a defect traced to a
+doctrine change cannot be scoped to the runs that carried it.
+
+`graph.py producer` prints seven fields, and **needs no graph**, because it is wanted
+beside an acceptance artifact rather than inside a run. Three resolve from the tree —
+the skill version from the plugin manifest, a digest of the project's `pipeline.json`,
+and `git rev-parse HEAD`. Four belong to the harness (`actor`, `model`, `runtime`,
+`trace`) and are read from named environment variables a project wires once.
+
+**A field that cannot be resolved prints anyway and says why.** An omitted field is
+indistinguishable from one that was checked and found empty — the rule every disclosure
+in this pipeline already follows, applied to the one artifact that had no disclosures at
+all. And `model` is deliberately **not inferred**: naming a vendor id in a shipped skill
+is forbidden here, and inferring the wrong one is worse than saying nothing.
+
+`templates/verification.md` carries the block above its rows, with the command that
+computes it, so it is pasted rather than typed.
+
+**Two harness defects surfaced while building this, and both were worth more than the
+feature.** A fixture raising anything but `AssertionError` used to abort the whole suite —
+one `KeyError` hid every case after it, and a harness that stops at the first crash
+reports fewer failures than exist. It reports a `CRASH` line now and keeps going: the
+count went from 1 visible failure to 4. And the guard could not observe the
+no-manifest branch, because this repository always has a manifest — so a version *guessed*
+as `task-pipeline@unknown` passed. That branch has its own fixture now, copying the bundle
+alone, which is exactly what a plain-skill install is; watched failing against the guess.
+
+`test/graph_test.py` → **93 cases**.
+
+### B-085 and B-077 — the one edge between intent and execution, and the relation over it
+
+`serves` was a non-empty string and nothing more, so `serves: "REQ-999"` and
+`serves: "asdf"` passed every gate identically — and that field is the **only** edge
+joining the intent graph to the execution graph. T-2's own DoD claimed *«every `serves`
+resolves»* and nothing did.
+
+The graph now carries `requirements`: the REQ ids the brief froze, **required and
+non-empty**, plus optional `goal_clauses` for release work no requirement names.
+Enumerated rather than substring-matched against the goal's prose, because matching a
+sentence is the kind of check that produces confidence without correctness. A `serves`
+resolving to neither is refused, with a near-miss hint.
+
+**And `add` refuses to invent a requirement.** The REQ table is frozen at stage 0 —
+adding to it is free and the *brief* does it, not a node. The refusal says so and lists
+what is available, because an agent told only «no» will try a synonym.
+
+**`graph.py coverage` computes the relation, and says which quarter of it it cannot
+see.** `references/acceptance.md` defines the path a requirement takes and an agent
+walked it from a checklist, one REQ at a time — the pipeline's own definition of a rule
+that should have been a mechanism. Three directions are now computed: a requirement no
+node serves, a requirement whose every node is **parked** (covered on paper and by
+nothing that will run), and each requirement with the nodes and statuses serving it. The
+fourth — an evidence row closing no requirement — lives in `docs/evidence/verification.md`,
+which this script does not read, and **the report says that out loud**, because a report
+silent about its own blind spot reads as the whole relation.
+
+**Two of the guards for this were defeated on their first attempt, and both by shapes
+this file has now met three times.** A source scan for `cmd_coverage` passed a
+renamed-and-unwired `_cmd_coverage_disabled`, because the old name is a substring of the
+new one. And the guard ran `coverage` only against the shipped example, which is fully
+covered on paper — so a `return 0` that had stopped refusing anything passed. Both are
+behavioural now: the example supplies the **failing** control (it has a parked-only
+requirement, and refusing it is correct), a copy with the parked node removed supplies
+the passing one, and the subparsers are **built from the dispatch table**, so a verb
+argparse accepts and the dispatch lacks cannot exist — it used to raise `KeyError`, which
+is a traceback where a named refusal belongs. Seven planted defects watched refused.
+
+`test/graph_test.py` → **85 cases**.
+
+### B-084 — the mutation verb was drawing chronology
+
+The graph stored one fact in two unlinked places. `blocked_by` is what `frontier()`
+obeys; `edges` carries the `payload` the schema requires — and nothing read it past a
+from/to existence check. So `references/planning.md`'s fake-edge test, stated for the
+markdown plan, was **unenforceable on the artifact that replaced the plan**, and
+`graph.py add` wrote the first field and never the second. Every node added mid-run
+therefore created a dependency whose payload was unnamed *by construction*. Measured by
+the four-way manifesto audit: adding a node to the shipped example gave 5 nodes, 2
+edges, `validate` exit 0.
+
+Four things move together, because separately each leaves a hole the others cover:
+
+- **`violations()` refuses an edge whose `payload` is missing or blank**, and refuses a
+  `blocked_by` with no payload-bearing edge **in the blocker→blocked direction** — a
+  backwards edge no longer satisfies a dependency.
+- **`title` and `serves` must be non-empty at runtime.** Both were schema-only, and the
+  schema has never run against a live graph, so `serves: ""` passed the gate while the
+  format forbade it.
+- **`add` takes `--carries`**, one per `--blocked-by`, pairing in the order written, and
+  writes the edge **with** the node. A count mismatch is refused and names both counts.
+- **`add` takes `--why`, and there is now a revision log.** `park` demanded a reason
+  from the start and `add` demanded nothing, which left half the graph's revision
+  surface silent — and a graph that changed for reasons nobody recorded can always
+  explain its own completion by appealing to a plan that existed only at the end. Both
+  verbs append `{verb, node, why}`; the schema requires all three and requires `why` to
+  hold a non-whitespace character; `next` never prints the log, because the frontier's
+  width is what a loop pays for on every iteration and this grows.
+
+**Tightening the rule invalidated the fixtures that had relied on it being loose**,
+which is the clearest evidence it bites: the test helper now *derives* an edge for every
+`blocked_by` it builds, and the one fixture that needs a dependency with no edge asks
+for it explicitly. Four planted defects were watched being refused, including a
+`why` pattern of `^.*$` and a nullable `why` — the two shapes that defeated this file
+twice already today.
+
+`test/graph_test.py` → **75 cases**.
+
+### The npx install path lost the verifier without saying so
+
+`agents/` is a Claude Code plugin capability, and `install.sh` and
+`bin/task-pipeline.js` copy the skill directory and the command and nothing else. That
+absence is the **design** — the brief chose plugin agents with honest degradation. It
+was silent, which is the part that was not: an operator on the npx path reads doctrine
+naming `task-pipeline:verifier`, finds a name that resolves to nothing, and nothing they
+ran ever mentioned it.
+
+Both paths now print what they are not installing, how many files it is, that **every
+role still runs** — on the main thread rather than in its own context, which costs
+context and speed and not doctrine — and the two commands that get the agent-backed
+version.
+
+**The guard RUNS the installers against a throwaway `HOME` rather than reading them**,
+and that decision was forced twice. The first version scanned the source for the printed
+string — and the first draft of this very fix defined `discloseAgents()` and never
+called it, which satisfies a source scan exactly. The second was defeated by a
+substring: `bin/task-pipeline.js` already prints *"Any agent (70+): npx skills add…"*,
+about the seventy agent products this skill installs into, and a check for the word
+`agent` passed it while the real gap stood untouched. It matches `agents/` with the
+slash, in output, from a real run. Three planted defects watched being refused, the
+dead-code one included.
+
+### The R-005 read of T-3 — fourteen findings, and two of them were critical
+
+The reader that standing instruction `R-005` requires was given the wave and told to
+defeat it. It did, and the two worst were in checks written that same hour:
+
+**The new schema check read the rule's shape and never its behaviour.** It asserted
+that `parked_reason` carried a `pattern` — and `"^.*$"` is a pattern. Swap it in, drop
+`minLength`, and the whole gate stays green over a schema that accepts `parked_reason:
+""`. This is the fourth time this file has been defeated by the same class: a name in
+`required` constraining nothing, a nullable type, a decorative `items`, and now a
+pattern that matches everything. **The check now RUNS the regex** — it must reject
+`""` and `"   "` and accept ordinary text — because presence has never once been
+behaviour here.
+
+**And the same field was left nullable.** `pattern` and `minLength` are string-only
+assertions, so `type: ["string", "null"]` satisfies both vacuously and `parked_reason:
+null` sailed through. The check three screens above tests `owner`'s type for exactly
+this reason; the new field did not inherit it. It does now, at both ends of the rule.
+
+**The third was worse than either, because it disarmed both rules at once.** Add one
+impossible name to each `if.required` and, under `additionalProperties: false`, no node
+can ever match — `done → evidence` and `parked → reason` both go inert while every key
+the check reads is still in place, and `npm test` exits 0. A conditional is now accepted
+only when its `if` constrains the status and **nothing else**.
+
+**Then the finding that made a claim in this repository false.** Nothing ever validated
+a *live* `.task-pipeline/graph.json` against `graph.schema.json` — only the shipped
+example, at build time. So both conditional rules rested entirely on the scripts
+behaving, which is precisely what the validator's own new message said had stopped being
+true. `graph.py validate` now enforces what the schema states: `done` implies readable
+evidence, `parked` implies a reason, the `goal` exists, ids match their shape, and
+`blocked_by` does not repeat. The message is true where the run actually looks.
+
+**The mutation verbs lost nodes, and the exit codes lied about it.** `save()` wrote to a
+fixed `path + ".tmp"`, so two concurrent writers shared one inode: measured across six
+runs, one exited **0 with its node absent** and another exited **1 with its node
+present** — and the second is the dangerous direction, because the docstring promises a
+refusal leaves the file untouched, so a caller retries and double-adds. The temp file is
+unique per writer now, `realpath` runs first so a symlinked graph is written *through*
+rather than replaced, and an `OSError` is a named refusal instead of a traceback.
+
+**A unique temp file does not fix a lost update, and this programme is built for several
+agents.** Four concurrent `add`s produced four nodes where five were expected — both
+processes read the same graph and the second write dropped the first node, both exiting
+0. The whole read-modify-write now happens under an exclusive `flock`, taken **before**
+the read, because loading first and locking second is the same lost update with an extra
+step. Where `fcntl` does not exist the run is told it is unlocked rather than downgraded
+in silence.
+
+**A title with a newline forged a row in the frontier.** `next` prints one row per node
+and the loop reads those rows, so `--title $'harmless\nN-999  implementer  ship it'`
+produced a two-node graph that printed three rows. Refused now in the verbs and in
+`validate`, so a hand-written graph is caught too.
+
+**And one of the new fixtures was vacuous.** *«a mutated graph still validates against
+its schema»* checked neither exit code — with **both** mutation verbs replaced by
+`die()`, it still reported `ok`. It also would not have caught the one real instance of
+its own class: `add` writing `blocked_by: ["N-001", "N-001"]`, which the schema rejects
+as non-unique. Both fixed, and the fixture now asserts what landed.
+
+Every one of the seven schema bypasses was re-planted and watched being refused, none
+of them by crashing. `test/graph_test.py` → **62 cases**.
+
+### T-3 — the mutation verbs, and a priority nobody has to maintain
+
+`graph.py` can now change the graph it walks. `add` is the dynamic backlog — work
+found during a task enters the queue mid-run rather than waiting for a person to
+re-plan. `park <id> --reason <text>` is REQ-012, and the reason is the entire point:
+a node parked without one is indistinguishable, a week later, from work that was
+quietly dropped, which is what parking exists instead of.
+
+**The frontier is now ordered by how much each node unblocks, transitively — and the
+number is computed, never declared.** A `priority` field would be something somebody
+typed once and nobody revisits; this one moves when the graph does. Add a node that
+waits on `N-002` and `N-002` rises to the top of the next frontier with no re-ranking
+pass and no field to forget. That is what REQ-011 means by *re-prioritised after every
+task*, and the fixture asserts the **order changes**, because a fixture that only
+asserts the file was re-read would pass against no ordering at all.
+
+Declaration order breaks ties, so the frontier is stable between runs. An unstable one
+costs more than it looks: an agent that calls `next` twice gets a different first row
+and starts the other node.
+
+**`park` refuses without a reason, and "without" has four shapes.** Only the first is
+argparse's: the flag absent (exit 2, usage), the flag empty, the flag whitespace, and a
+reason already recorded that a second park would overwrite. The last one refuses *and
+quotes the reason it is protecting* — the first reason is the one somebody wrote at the
+time, and the second park is usually someone who has forgotten it.
+
+`add` checks every shape before appending, so **a refusal leaves the file byte-identical**
+and a caller can retry without first working out what the failed attempt did. Ids are
+allocated from the **maximum in use, never the count** — ids stop being contiguous the
+first time anything is renumbered, and from that moment counting hands out one that
+already exists. Both verbs refuse outright on a graph that was *already* invalid and say
+so in those words: a mutation that reports pre-existing damage as though the caller
+caused it sends the next fix to the wrong place.
+
+`save()` writes to a temp file beside the graph and `os.replace`s it. A crash mid-write
+now loses the mutation instead of the queue. This repository has destroyed a file by
+writing it in place twice, and both times what saved it was a copy somebody had made by
+hand.
+
+**REQ-012 moved from the script into the format.** The reason used to live in `note` —
+a free-text field with no description and no rule, which made a park carrying a reason
+and a park carrying an unrelated remark the same shape to every reader and every check.
+It is `parked_reason` now, **required by the schema when the status is `parked`**,
+exactly as `evidence` is required when the status is `done`, with the same
+non-whitespace `pattern` the wave-2 convergence check taught this file to write.
+
+**And that broke a guard, which is the guard working.** draft-07 allows one `if`/`then`
+per schema object, so the second rule went into an `allOf` beside the first — and
+`test/validate.py` read `node["if"]` literally and went red immediately. It walks `allOf`
+recursively now, so a schema stating both rules inline, both in `allOf`, or one of each
+reads the same. Six planted defects were watched refusing, including the inverse: the
+old inline shape is still accepted, which is what a widening has to prove it did not
+break. Two of the six are now CI plants; the section's running count is at the top.
+
+`test/graph_test.py` → **52 cases**.
+
+### Wave 2 — T-4 and T-6, and the check `build.md` puts over a fan-out
+
+`agents/verifier.md` ships — the first agent this plugin has. It closes one node and
+returns a six-key verdict, and `graph.py`'s `verdict_violations()` refuses one that
+omits a key or claims `done` with no evidence. The agent file says what it cannot do
+and why that matters: **it cannot ask the operator anything**, so a verdict meaning
+*«I need a decision»* has to say so in `replan.why` rather than end in a question
+nobody will see.
+
+`pipeline.json` moves to `mode: dynamic` — `interval` dropped, because the schema
+calls it meaningless there — and records `release.goal`.
+
+**Then the convergence check `references/build.md` §4.2a requires over a fanned-out
+group, and it earned its place.** Nine contradictions, every one of them invisible to
+the three per-task reviews that had already passed:
+
+| Found | Between |
+|---|---|
+| the verdict gate accepted `evidence: ["", "  "]` that the **schema refuses** — `close` would write a node its own shipped schema rejects | `graph.py` ↔ `graph.schema.json` |
+| `release.goal` was undeclared in the schema, so the guard T-6 shipped **could not see the field T-6 shipped** — `additionalProperties` is true, and renaming it away kept every gate green | `pipeline.json` ↔ `pipeline.schema.json` |
+| `ROLES` held ten of the brief's thirteen — and its own refusal message **named the manager while the set rejected it** | `graph.py` ↔ the brief |
+| `verifier.md` told an agent to run `graph.py close`, which is T-5 and does not exist | the agent ↔ the script |
+| `_goal_note` claimed the goal is *"printed above the frontier every iteration"*; nothing prints them together | the config ↔ the script |
+| the schema's `queue` cited `continuity.md`, which still describes a two-item queue set that does not include `work-graph` | the schema ↔ the doctrine |
+| the brief's REQ-005 required `plugin.json` to **declare** `agents`, and declaring it fails `--strict` | the brief ↔ the platform |
+| *«five keys»* over a six-key object, in five places | everywhere at once |
+| T-6's new guard shipped with **no negative self-test**, against this repo's own stage-6 gate | the change ↔ the gate |
+
+Every one is fixed. Two are worth naming for the shape rather than the fix:
+
+**`ROLES` conflated two different axes.** Whether a role ships as a subagent and
+whether it may **own a node** are separate questions, and the first draft answered
+the second with the first. `manager` and `business-analyst` are main-thread doctrine
+*because* their job is asking the operator — that is precisely why they cannot be
+agents, and it says nothing about whether work can belong to them. Both own nodes
+now; `project` still cannot, because the brief defers it for having no stated job,
+and a role that cannot say what it does cannot own work either.
+
+**And the fix for the evidence bug was itself incomplete.** A cross-check fixture —
+asking the gate and the schema the same question and requiring the same answer —
+caught `["  "]` surviving one and not the other: the gate strips, and `minLength: 1`
+counts a space. The schema now requires a non-whitespace character, and the fixture
+that found it is in the suite.
+
+`test/graph_test.py` → **29 cases**. Two of them were added here.
+## v1.68.0 — the worst body in the family, and the rule that was wrong about it
+
+**6685 tokens against a 5000 budget → 4735**, under the 4750 working limit, by
+splitting rather than trimming. This was the largest `SKILL.md` body in the
+ssheleg family and the furthest over — 34% — and the body loads on every turn of
+every session that resolves the skill.
+
+Most of the overrun sat in the **stage table's Gate column**, which restated
+`references/stages.md` under a heading that literally says *(detail in
+`references/stages.md`)*. The table is the index and the run order now; the
+reference is what you read while standing in the stage. Nothing was deleted:
+
+| Moved | To | Why there |
+|---|---|---|
+| Stage 10 in a project of several repositories | `references/acceptance.md` | it owns stage-10 close-out |
+| Step 5's cross-cutting rules | `references/gates.md` | they fire at any stage, not inside step 5 |
+
+and five *Prerequisites* paragraphs that restated a reference in full were cut to
+the rule plus the failure it prevents — which is what a body is for — with the
+procedure left in the file that owns it.
+
+**All 38 routed trigger phrases across both skills survive verbatim**
+(`node test/advertised_check.js`), and the stage list still matches across the
+three surfaces the validator compares mechanically.
+
+### The description rule was wrong, and this repository was already right
+
+The family's shared auditor demands a description **start** with `Use when …`.
+This repository's own validator refuses exactly that, and its comment says why:
+Anthropic's guidance asks for **both** halves — what the skill does and when to
+use it — and their own example leads with the capability (*"Extracts text and
+tables from PDF files… Use when working with PDF files."*). Demanding `Use when`
+at position 0 enforces the WHEN half and leaves the WHAT half optional.
+
+So the 2026-08-16 audit's finding that this description *"does not open with Use
+when, against the house rule its sibling obeys"* is **withdrawn — the house rule
+is the one that is wrong**, and this repository had corrected its own copy of it
+already. Applying the corrected rule to the family measures **22 of 24 skills**
+opening with the trigger, so flipping it rewrites 22 descriptions that carry live
+routing phrases. That is a family decision rather than a member's, and it is
+filed as umbrella `B-76` rather than taken here.
+
+### Fixed
+
+- A negative self-test was pinned to a literal containing a **line break**, so it
+  stopped landing the moment the paragraph reflowed — the guard then read green
+  while proving nothing. Matched by regex now. Same class as the two that refused
+  `seo-aeo-audit`'s release earlier the same day, and the reason the local gate
+  there learned to catch it before the tag.
+
+Guards: 351 → **351**. No guard was added or removed — one plant was repaired, and
+the suite that reports `all 351 guards provably reject their planted defect` was
+red until it was, which is the whole point of counting them.
+
+Found by the nine-repository audit of 2026-08-16 (umbrella `B-66`;
+`F-task-pipeline-01`, and `F-task-pipeline-02` withdrawn).
+
 ## v1.67.0 — a ledger records two different things, and most record only one
 
 **A ledger records two different things, and most record only one.** *What confirmed it*
@@ -4175,6 +5026,11 @@ this class of defect surfaces:
 
 ## v1.5.0 — 2026-08-01
 
+> **Never released on its own.** There is no `v1.5.0` tag and no `1.5.0` on npm,
+> so `npm install task-pipeline-skill@1.5.0` and `git checkout v1.5.0` both fail. This section
+> describes work that shipped inside a later version. The note is here because
+> the section reads as a release (2026-08-17, umbrella `B-71`).
+
 ### `references/knowledge-graph.md` — the code graph as a source, and as a second opinion
 
 A grep finds a **name**. The questions that actually stop a run are *what calls this*