task-pipeline-skill 1.40.0 → 1.42.0

package/CHANGELOG.md

@@ -1,5 +1,148 @@
 # Changelog
 
+## v1.42.0 — a probe proves the phrasing its author had in mind
+
+Six times in one session a guard was defeated by **text that was not its subject**, and
+every one of those guards had a probe, and every probe fired. The probes and the guards
+were written in the same hour from the same reading of the same file, so they shared the
+blind spot rather than covering it.
+
+| The check's subject | What answered it instead |
+|---|---|
+| stage 2 names the loop's arming | *"it **arms** the UX track"*, present since v1.7.0 |
+| the section states the authorization floor | the same phrase in a Rationalizations row, and in a section from v1.11.0 |
+| the run stamps have a cap | the **standing instructions'** `max 10` in the same cell — and, once narrowed past it, the same cap on the other side of the `·` |
+| a section read in full stays capped | rows under one heading, while a second heading held forty more |
+
+### The doctrine failed its own first use, and a reader caught that too
+
+R-005's fourth consecutive reader read the three new probes against the section that
+defines them. **`nb03` was not a neighbour probe.** It planted the needles of two
+*retired* predicates — proving the guards that used to exist were neighbour-answerable
+and saying nothing about the one that does. The instruction *"plant the guard's own
+evidence"* reads as *"plant something that used to satisfy it"* unless it says **which
+literal**, and now it does: the one the predicate matches today, read out of the guard.
+
+Seven more, each planted and watched passing, each now replayed and failing:
+
+- **Part 1a's precondition could be replaced by its opposite** and a housekeeping aside in
+  a `###` subsection answered for it — the reading `Default off` exists to forbid, shipping
+  behind a parenthesis;
+- **the stage-2 guard's declared span was false.** Its comment said *"the GATE bullet and
+  nothing else"*; the GATE is the last bullet, so the split handed it everything to the
+  section end and a trailing note satisfied it;
+- `- **GATEways to stage 3:**` was taken as the gate — no word boundary;
+- **a decoy row about the archive answered for the live file**, because the retrospective
+  check scanned every `|` line rather than the row it names;
+- **the scope depended on a `·`** no doctrine requires: replacing it with `, and` restored
+  the v1.41.0 defeat by punctuation;
+- **one disjunct was dead and the live one was a literal** — the source line-wraps, so the
+  check was a false positive on any reword and a false negative on inversion;
+- and **rekeying the stage-2 guard silently lost coverage**: deleting the whole queue
+  bullet began to pass, while its probe kept firing only because it *also* deleted the
+  gate clause. A probe whose stated claim has quietly become another probe's claim.
+
+**A probe that only deletes is not a neighbour probe** — it may be correct, but if it
+leans on copies already next door it must assert they are there, or a later edit demotes
+it to a delete-only test that still passes.
+
+### The neighbour probe
+
+`gates.md` now asks a guard that reads a scoped span for a **second** probe, planting in
+two places at once: break the subject, plant the guard's own evidence **next door**, and
+require it to still fail. A guard that goes green is reading the neighbourhood, and the
+ordinary probe cannot tell the difference — which is why it is a separate probe rather
+than a stricter one.
+
+Three shipped with it, one per guard that fell this way. **The third failed on its first
+run and was right to:** a planted sentence saying *"after-decomposition remains a word in
+the schema"* satisfied the stage-2 guard, proving it neighbour-answerable. The guard is
+now keyed on the stage's **gate** — what it must DO — rather than on prose around it,
+because prose above a gate can say anything.
+
+**Positional narrowing is not scoping**, and three of the six were "fixed" that way
+before falling again to text still inside the cut.
+
+### Half of B-057 was already mechanised, and the row overstated it
+
+`test/negatives.py` runs `differs_from_repo` on every planted copy, so a probe whose
+needle no longer matches fails **loudly** rather than silently — which is what every
+stale literal in this session actually did. The remaining half is the silent one, and it
+is what the neighbour probe is for.
+
+- Guards: 250 → **253**.
+
+## v1.41.0 — one line per run is a slope, not a bound
+
+`retro.md` is read **in full** at stage 0, and its own doctrine called both read sections
+*bounded by construction*. Measured 2026-08-10:
+
+```
+standing instructions   ~1 234 tok   capped at ten
+run stamps              ~2 099 tok   27 rows, capped by nothing
+recent log             ~12 441 tok   queried, not read
+```
+
+The v1.38.0 audit found exactly this shape in the narrative log and moved it out of the
+floor. It left the neighbour in the same file, with the same property, because the
+neighbour's growth is **tidy** — one line per run. A tidy slope is still a slope: at a
+hundred runs the stamp table alone is ~7 800 tokens of a floor the doctrine believes is
+bounded.
+
+**The cap is ten, and the cold trigger is why.** It reads *the last five run stamps*, so
+ten is that with a margin and a rotated row can never be one the trigger needed. Eighteen
+stamps rotated into `docs/superpowers/retro/2026-Q3.md`, whole, append-only. The stamp
+section went **2 099 → 1 088 tok**, the read portion **3 333 → 2 335**, and the stage-0
+floor to roughly **35 300**.
+
+### The reader found six ways past the cap, and one of them was the doctrine's own command
+
+R-005's reader defeated the first cap guard six ways, each planted and watched passing:
+
+- **a second `## Run stamps — …` heading in the same file** held forty more rows and
+  passed. The guard read a *section*; stage 0 reads the **file**;
+- **one leading space** on a row — still a valid table row — hid it from `startswith("|")`;
+- **the stamp command this doctrine ships** (`printf '%s · %s\n' …`) appends prose, not a
+  table row. An agent obeying the shipped instruction literally produced forty stamps the
+  guard could not see, with `unlooked: 0`;
+- **`templates/retro.md`** ships the same table to every host project and was outside the
+  corpus — the fourth hand-written list this repository has caught, against an invariant
+  that says corpora are discovered;
+- **rotation by deletion** passed: a stamp removed from `retro.md` and absent from the
+  archive is history destroyed, and the guard could not tell moving from deleting;
+- and the row check — already narrowed twice — was defeated by **swapping the two items
+  around the `·`**, which is the standing instructions' `max 10` answering for the stamps
+  again, on the other side of the separator.
+
+Both guards are rewritten to count by **predicate over a discovered corpus**: three stamp
+shapes (table row, list item, and the `<date> · <sha>` line the doctrine writes), every
+file carrying a `## Run stamps` section, and the doctrine's cap read from the segment that
+names the stamps rather than from anywhere in the row.
+
+**Four surfaces had never learned the rule** — the live section's own intro, stage 10's
+prune, `templates/retro.md`, and `templates/retro-archive.md`, which had no destination
+section for a rotation the doctrine names. And stage 0 still called *one line per run* a
+bound. All five now say the same thing.
+
+**A hand-written count in this release was wrong.** It said twenty-one stamps rotated;
+computed, it is **eighteen** (28 → 10). In a repository whose loudest canon is *compute,
+never restate*.
+
+### Two predicates that were answered by their neighbours
+
+Both found by their own probes, both the same shape as the defects the last release's
+reader named:
+
+- the first version asked whether the file contained *"one line each"* and *"bounded by
+  construction"*. After the fix both survived **only inside the sentences criticising
+  them**, and the guard fired on its own correction. A predicate that cannot tell a claim
+  from its refutation has a false-positive budget above zero, which `gates.md` sets at
+  zero;
+- scoped to the table row, it was then answered by the **standing instructions' own
+  `max 10`** in the same cell. It now reads only the part of the row after `Run stamps`.
+
+- Guards: 248 → **250**.
+
 ## v1.40.0 — the loop had a cadence and no queue
 
 `run.loop` said how **often** to continue. It never said **what the next item is**, so an

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.40.0 |
+| **Version** | 1.42.0 |
 | **Surface** | Claude Code (filesystem skill + plugin) and the vercel `skills` CLI. **Not** uploaded to the Skills API; custom Skills do not sync across surfaces |
 | **Dependencies** | None required. Optional: `context7` (MCP), `figma` (MCP), super-ux, agent-sync, graphify, obsidian-wiki. Every stage's doctrine ships in-repo; the one conditional requirement is super-ux for the stage-3 UX track on a user-facing task |
 | **Evaluation status** | Suite authored, 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.40.0",
+  "version": "1.42.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.40.0",
+  "version": "1.42.0",
   "author": {
     "name": "ssheleg",
     "url": "https://x.com/sshlg93"

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

@@ -30,6 +30,7 @@ elsewhere and is not restated here:
 - Anatomy of a project gate
 - Writing the check itself
 - Probing — plant, run, restore
+- The neighbour probe — plant the evidence outside the subject
 - The false-positive budget
 - Ratchets
 - Disclosures — counted like a ratchet, and deliberately not monotone
@@ -295,6 +296,57 @@ Otherwise the next reader has to redo it to know whether it was ever done.
 
 ---
 
+## The neighbour probe — plant the evidence outside the subject
+
+A probe proves a guard rejects **the phrasing its author had in mind**. That is less than
+it looks, and the gap has one shape: **a check answered by text that is not its subject.**
+
+Measured on one project in one session, six times, each found by a reader planting a
+defect and watching `PASS`:
+
+| The check's subject | The text that answered it instead |
+|---|---|
+| stage 2 names the loop's arming | *"it **arms** the UX track"*, present since an earlier release |
+| the section states the authorization floor | the same phrase in a Rationalizations row, and in a section written twenty-nine releases before |
+| the run stamps have a cap | the **standing instructions'** `max 10`, in the same table cell — and, once the check was narrowed past it, the same cap moved to the other side of the `·` |
+| a section read in full stays capped | rows under **one** heading, while a second heading in the same file held forty more |
+
+Every one of those guards had a probe. Every probe fired. The probes and the guards were
+written in the same hour from the same reading, so they shared the same blind spot.
+
+**So a guard that reads a scoped span owes a second probe, and it plants in two places at
+once:**
+
+1. **break the subject** — remove the thing the guard is about;
+2. **plant the guard's own evidence next door** — in a sibling section, an adjacent table
+   cell, a rationalizations row, the other side of a separator;
+3. require the guard to **still fail**.
+
+A guard that passes step 3 is reading its subject. A guard that goes green is reading the
+neighbourhood, and the ordinary probe cannot tell the difference — which is why this one
+is separate rather than a stricter version of it.
+
+**Step 2 means the literal the predicate matches *today*, read out of the guard.** The
+first three neighbour probes written against this section got that wrong on their first
+run: one planted the needles of two **retired** predicates, which proves the guards that
+used to exist were neighbour-answerable and says nothing about the one that does. A
+neighbour probe keyed to a needle the guard no longer reads is the same defect it was
+written to catch, one level up.
+
+**A probe that only deletes is not a neighbour probe.** It may still be a correct probe —
+but if it relies on copies that already sit next door, it must **assert they are there**.
+Otherwise a later edit removes them and the probe quietly becomes a delete-only test that
+still passes, having stopped testing the thing it is named for.
+
+**Positional narrowing is not scoping.** Three of the six were "fixed" by cutting the
+search down to a row, then to everything after a phrase, and fell each time to text that
+was still inside the cut. Scope by *what the span is about*: split to the cell, then to
+the item, then match on flattened text so an emphasis marker cannot hide the boundary.
+
+**And state the span in the guard.** One line above the predicate — *what it reads, and
+where that ends*. It costs nothing and it is the only part of a check a later reader can
+disagree with before the defect arrives.
+
 ## The false-positive budget
 
 Run a new heuristic over the **real corpus** before shipping it and count the false

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

@@ -18,7 +18,7 @@ justifies reading it protects one section while the file below it doubles.
 
 | Artifact | Parts | How it is read |
 |---|---|---|
-| `docs/superpowers/retro.md` — **one per project** | **Standing instructions** (max **10**) · **Run stamps** (one line each) | stage 0, **in full** — both are bounded by construction |
+| `docs/superpowers/retro.md` — **one per project** | **Standing instructions** (max **10**) · **Run stamps** (max **10**, oldest rotate out) | stage 0, **in full** — both are bounded by a **cap**, which *one line each* never was |
 | the same file's **Recent log** | entries from the last five run stamps — narrative, and capped by nothing | stage 0, **queried** by the task's nouns. It said *in full* until 2026-08-10, when it measured **74%** of the file: an uncapped section inside a binding source is what makes the capped part get skimmed |
 | `docs/superpowers/retro/YYYY-QN.md` — the archive | every entry and every retirement ever written, append-only | **queried** by the task's nouns; never read end to end |
 
@@ -32,6 +32,7 @@ file exists to stop.
 
 - Write the entry only for a divergence — and name the layer that owned it
 - Every lesson carries its commit
+- The stamp table is capped at ten, and *one line per run* was never a cap
 - Rotation — the archive is how pruning stops losing things
 - Three grades of fix — take the highest one that can work
 - Stamp first, then prune, then write
@@ -79,6 +80,26 @@ mechanical: the project's documentation gate runs `git rev-parse --verify --quie
 <sha>^{commit}` over every backticked SHA in the retro and its archive
 ([`gates.md`](gates.md)).
 
+## The stamp table is capped at ten, and *one line per run* was never a cap
+
+Measured 2026-08-10: standing instructions **~1 234 tok** behind a cap of ten, run stamps
+**~2 099 tok over 27 rows** behind nothing. Both are read in full at stage 0 and both
+were described as *bounded by construction*. One line per run is a **slope**: at a
+hundred runs the stamp table alone is ~7 800 tokens of a floor the doctrine believes is
+bounded.
+
+This is the same shape the 2026-08-10 audit found in the narrative log and moved out of
+the floor — and it left the neighbour in the same file, with the same property, because
+the neighbour's growth is *tidy*. A tidy slope is still a slope.
+
+**The cap is ten and the trigger is why.** The cold rule reads *the last five run
+stamps*; ten is that with a margin, so a stamp rotating out can never be one the trigger
+needed. At the eleventh, the oldest row moves — whole, with its verdict and its retro
+column — into `docs/superpowers/retro/YYYY-QN.md` under `## Run stamps`, append-only,
+like every other rotation. **The count is printed at the prune**, beside the standing
+instructions' own count, so a table that stops rotating is visible rather than merely
+large.
+
 ## Rotation — the archive is how pruning stops losing things
 
 At the prune, entries older than the last five run stamps **move** to

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

@@ -102,7 +102,7 @@ never that the work was skipped quietly.
   `affected` / `god-nodes` answer *reach*, which is what grep cannot), `CLAUDE.md`,
   `CONTEXT.md`/ADRs, `docs/` + `docs/ux/`, past pipeline briefs and carry-over
   ledgers, **the retro's standing instructions and run stamps** (`docs/superpowers/retro.md`,
-  read **in full** — ten rows and one line per run, both bounded, and they bind this
+  read **in full** — ten standing rows and ten stamps, both bounded **by a cap**, and they bind this
   run; stamp each instruction as it fires. Its *Recent log* is **queried** by the
   task's nouns, not read: uncapped narrative inside a binding source is what makes the
   capped part get skimmed, [`retrospective.md`](retrospective.md)), the **knowledge wiki** if one is
@@ -656,7 +656,10 @@ never that the work was skipped quietly.
   with a floor, neither ever a target ([`gates.md`](gates.md) → *Disclosures*); **the
   retrospective is written — stamped first, then pruned, then the entry; the
   list at or under its cap, every deletion logged in the archive with its commit,
-  entries older than five run stamps rotated into `docs/superpowers/retro/`, the run
+  entries older than five run stamps rotated into `docs/superpowers/retro/` **and the
+  stamp table itself held to ten — at the eleventh the oldest stamp rotates whole into
+  the same archive, and both counts print beside the verdict** (the stamp table is read
+  in full at stage 0, so *one line per run* is a slope the prune has to stop), the run
   stamped with its commit, every SHA in either file resolvable, and the
   counts printed beside this verdict**; **where `pipeline.json` → `retro.publish` is
   set, the skill-level insight is published as an issue on the skill's repository —

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

@@ -39,3 +39,13 @@ history attached**, which is what this section is for.
 | Date | id | Instruction | Trigger that retired it | Commit |
 |---|---|---|---|---|
 | <YYYY-MM-DD> | R-000 | … | became a check (`npm run lint:paths`) | `<sha>` |
+
+## Run stamps
+
+Rotated out of `retro.md` when its live table passes ten. Append-only, whole rows —
+the cold trigger reads the last five in the live file, so a stamp here is one it no
+longer needs. Moving is not deleting: a stamp that leaves `retro.md` and appears
+nowhere is history destroyed, not archived.
+
+| Date | Topic | Commit | Verdict | Retro |
+|---|---|---|---|---|

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

@@ -61,8 +61,9 @@ shape the hygiene gate's check 6 exists to find.
 
 ## Run stamps
 
-One line per run, appended at stage 10. This is what makes "five runs" countable
-— without it the cold-rule is a guess and the prune becomes a mood.
+One line per run, appended at stage 10, **capped at ten** — at the eleventh the
+oldest rotates whole into the archive. One line per run is a slope, not a bound:
+this section is read in full at stage 0.
 
 | Date | Topic | Commit | Verdict | Retro |
 |---|---|---|---|---|