task-pipeline-skill 1.95.0 → 1.96.0

package/CHANGELOG.md

@@ -1,3 +1,36 @@
+## v1.96.0 — 2026-10-15
+
+Source candidate; not published.
+
+Guards: 439 → **447**; property checks 15 → **15**.
+
+An iteration now stops at a finish line instead of when a search runs dry. The new
+`references/finish-line.md` fixes a contract at intake — objective, exit checks run on
+the released, installed or deployed artefact, scope, budget and base — in the brief's
+`## Finish line`. Every finding is triaged when found: blocking only by one of four
+tests (a red exit check, a hotfix-lane entry, a regression against base, a verified
+REQ or published claim false on the artefact), deferred to the board with its
+evidence, or noise as one ledger line. Severity words and effort never change the
+class. An iteration is done after two consecutive rounds with no new blocking
+finding; it stops at `run.finish.maxRounds` (default 3) or `maxReleases` (default 2)
+with each open blocker handed back as a `needs-operator` row, and diverging rounds go
+to the loop guard. Stopping is not idle: the next iteration starts from the board by
+priority, never by re-opening the closed one.
+
+`scripts/waves.py finish` computes the verdict from the inventory's new optional item
+fields (`triage`, `test`, `round`, `base_repro`, plus `blast` and `rung` for known
+risks) and prints the finish block; deferred and noise items never change it. The round
+count is explicit — `--rounds` or the run ledger's new `round:` lines, which must agree
+with the inventory — because a clean round leaves no item to count. Done needs the exit
+checks supplied and green (`--checks`), stays within `maxRounds` (at least 2) unless the
+operator's go is passed, and `next:` ranks every open non-blocking row by priority,
+never by freshness. B2 also covers a defect that would be a hotfix-lane entry once
+released; a defect in a node's own diff stays with review. Stage 0's
+gate requires the finish line filled; stage 10's requires the `finish:` line printed.
+Iteration, waves, loop-guard, audit, continuity, review and progress doctrine point to
+the one rule, and seven validator guards hold its vocabulary, budgets, hotfix set,
+brief fields, hand-back field and script enums equal across their surfaces.
+
 ## v1.95.0 — 2026-10-13
 
 Source candidate; not published.

package/README.md

@@ -189,6 +189,7 @@ and the inline fallback satisfy the same [provider contract](plugins/task-pipeli
 | 10 Acceptance | [`acceptance.md`](plugins/task-pipeline/skills/task-pipeline/references/acceptance.md) — REQ coverage table, evidence rules, the closing question |
 | 10 + any audit | [`audit.md`](plugins/task-pipeline/skills/task-pipeline/references/audit.md) — the L0→L7 ladder and its seams, axis rotation, ratchets, proven checks |
 | any loop | [`loop-guard.md`](plugins/task-pipeline/skills/task-pipeline/references/loop-guard.md) — churn detection, caps, the break protocol |
+| when an iteration stops | [`finish-line.md`](plugins/task-pipeline/skills/task-pipeline/references/finish-line.md) — a contract fixed at intake (objective, exit checks on the artefact, scope, budget, base), every finding triaged when found — blocking, deferred or noise — and a stop at two rounds with no new blocking finding or at the budget, computed by `waves.py finish` |
 | every gate + stage 10 | [`residue.md`](plugins/task-pipeline/skills/task-pipeline/references/residue.md) — what the run leaves **running** and leaves **behind**: eight classes enumerated by class rather than by one tool, `holds: N` beside every verdict, and a teardown that ends what this run started and only reports what it did not |
 | run-wide reporting | [`progress.md`](plugins/task-pipeline/skills/task-pipeline/references/progress.md) — the header block at task start and the one-line iteration close: the stage rail computed from the project's own `pipeline.json`, every number borrowed from the gate that measured it |
 | run-wide pacing | [`continuity.md`](plugins/task-pipeline/skills/task-pipeline/references/continuity.md) — the loop mode (`run.loop`, default off, never collapses a manual gate) and the context budget (fires on a harness signal, never on an estimate) |
@@ -634,7 +635,7 @@ must say so.
 ### Held to Anthropic's own Skill authoring guidance
 
 Audited against the four Agent Skills pages. Most of it already held — `name`
-13/64 chars, `description` 887/1024 chars, `SKILL.md` 272/500 lines, all 52 references
+13/64 chars, `description` 887/1024 chars, `SKILL.md` 275/500 lines, all 53 references
 reachable from `SKILL.md` through explicit reference routes, and the bundle far under the 30 MB ceiling. What
 did not, now does:
 

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.95.0 |
+| **Version** | 1.96.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; user-facing stage 3 requires a valid scenario artifact; super-ux is preferred, with equivalent-provider and inline-fallback paths under the provider contract |
 | **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/evals/RESULTS.md

@@ -1,10 +1,11 @@
 # Evaluation results — task-pipeline
 
 **Status: three suites authored (task-pipeline, evidence-docs, project-audit);
-one self-observed run and, since 2026-08-31, three blind trigger runs — one per
-model (haiku, sonnet, opus).** The instruction-following cases remain unexecuted
-and say so per run, because they need a full interactive session — a skip is not
-a pass, and a guessed verdict is worse than a vacant row.
+one self-observed run, three blind trigger runs on 2026-08-31 — one per model
+(haiku, sonnet, opus) — and three more on 2026-10-14 over the release-iteration
+phrasings (TRIG-11, TRIG-12, NOTRIG-09), one per model.** The instruction-following
+cases remain unexecuted and say so per run, because they need a full interactive
+session — a skip is not a pass, and a guessed verdict is worse than a vacant row.
 
 **The numbers below are computed, not asserted.** `python3 evals/run.py` counts the
 suite and the dated run headings in this file. A value typed here that disagrees with
@@ -40,11 +41,11 @@ or it belongs in a check.
 
 | Metric | Value | Computed by | As of |
 |---|---|---|---|
-| Evals authored | 48 (three suites: task-pipeline 30, evidence-docs 9, project-audit 9) | `python3 evals/run.py` → `suite: N evals` | 2026-10-12 |
+| Evals authored | 55 (three suites: task-pipeline 37, evidence-docs 9, project-audit 9) | `python3 evals/run.py` → `suite: N evals` | 2026-10-14 |
 | Categories covered | 5 of 5, per suite | the suite's own `category` fields | 2026-08-31 |
-| Dated runs recorded | **4** | `python3 evals/run.py` → `recorded runs: N` | 2026-08-31 |
-| …of those, **blind** | **3** | run headings not marked `self-observed` | 2026-08-31 |
-| Models exercised blind | **3 of 3** | distinct models across blind runs | 2026-08-31 |
+| Dated runs recorded | **7** | `python3 evals/run.py` → `recorded runs: N` | 2026-10-14 |
+| …of those, **blind** | **6** | run headings not marked `self-observed` | 2026-10-14 |
+| Models exercised blind | **3 of 3** | distinct models across blind runs | 2026-10-14 |
 
 **The last three rows are the honest state of this skill's behavioural evidence**, and
 the split matters more than the total: a run the author watched, knowing the expected
@@ -84,6 +85,52 @@ model NAMED the skill; it does not prove a full session loaded and obeyed the
 doctrine — the INSTR cases need exactly that and are recorded as **not
 reproducible from this harness**, not guessed.
 
+## 2026-10-14 · haiku · blind trigger probes, subagent protocol
+
+**3 of 3 scored cases passed** — the two release-iteration triggers and their
+explanation control, added by release iteration 1 (node M-4, USR-015). Method as
+2026-08-31 below, with two differences, stated rather than implied: the offered
+list was the family's **38** skills (the family grew from 28), built once from the
+members' `SKILL.md` frontmatters on 2026-10-14 (sha256 `12115a8b24f1…`); and each
+subagent reported the model id from its own system context, recorded here as the
+model that answered: `claude-haiku-5-5`. The other new cases of that node
+(INSTR-09…13, TP-OUT-006/007) were not run: the INSTR cases need a full interactive
+session, and the two outcome cases need an executor driving an arm in a sandbox —
+their fixtures' command checks are proven to pass and to fail by
+`test/audit_regressions/usr_015_evals.py`, which is not a run of the case.
+
+| id | verdict | what happened |
+|---|---|---|
+| TRIG-11 | pass | named `task-pipeline` — cited the description's 'waves'/'волнами' |
+| TRIG-12 | pass | named `task-pipeline` — cited 'итерация релиза' in the description |
+| NOTRIG-09 | pass | answered `none` — the description excludes explaining |
+
+## 2026-10-14 · sonnet · blind trigger probes, subagent protocol
+
+**3 of 3 scored cases passed.** Same protocol and list as the haiku run above;
+the answering model reported `claude-sonnet-5-5`.
+
+| id | verdict | what happened |
+|---|---|---|
+| TRIG-11 | pass | named `task-pipeline` — matched «закрой их волнами» to the waves mode |
+| TRIG-12 | pass | named `task-pipeline` — matched the 'release iteration' trigger |
+| NOTRIG-09 | pass | answered `none` — a plain explanation question |
+
+## 2026-10-14 · opus · blind trigger probes, subagent protocol
+
+**3 of 3 scored cases passed.** Same protocol and list as the haiku run above;
+the answering model reported `claude-opus-5-5[1m]`.
+
+| id | verdict | what happened |
+|---|---|---|
+| TRIG-11 | pass | named `task-pipeline` — the board closed «волнами» |
+| TRIG-12 | pass | named `task-pipeline` — the board-closing release loop |
+| NOTRIG-09 | pass | answered `none` — named the trigger phrase and the explaining exclusion |
+
+INSTR-09…13 and TP-OUT-006/007: **not run** in any of the three 2026-10-14 runs,
+for the reasons given under the haiku run. A trigger `pass` still means only that
+the model NAMED the skill.
+
 ## 2026-08-31 · haiku · blind trigger probes, subagent protocol
 
 **39 of 42 scored cases passed** across the three suites' trigger-shaped

package/evals/cases/task-pipeline.json

@@ -186,6 +186,145 @@
      }
     ]
    }
+  },
+  {
+   "schema_version": "outcome-case/1",
+   "id": "TP-OUT-006-waves-validate-refuses-unclaimed-item",
+   "skill": "task-pipeline",
+   "prompt": {
+    "text": "Wave 0 of `/task-pipeline waves`: the inventory, module table and wave plan are the frozen files under evals/fixtures/waves-unclaimed/. Check that every item lands on a node with the skill's own inventory validator, without editing the fixture, and write waves-validate.md with the command you ran, its exit code and what it reported (USR-015).",
+    "files": [
+     {
+      "path": "evals/fixtures/waves-unclaimed/inventory.json",
+      "sha256": "8ffb7e0f291c8cfb5b77910424b3dac55459e8f6b58f7e63343fcef258bb2102"
+     },
+     {
+      "path": "evals/fixtures/waves-unclaimed/modules.json",
+      "sha256": "9d13ac48c1c49d0bd315ed5643b68de993d1f33ee125e1e23718f6c60fe296d5"
+     },
+     {
+      "path": "evals/fixtures/waves-unclaimed/plan.json",
+      "sha256": "cc42a367ac8a966214beb21d8459c04e3704c461f220dd3a34d7f5fca315dbc8"
+     },
+     {
+      "path": "evals/fixtures/waves-unclaimed/expect-refusal.sh",
+      "sha256": "857a48783bdb89ff82c4d16d5adb93dc2159e3d89cb5b8dea069fa0439d60517"
+     }
+    ]
+   },
+   "environment": {
+    "model": "inherit",
+    "host": "any",
+    "case_digest": "480a16d5aef3efa8ae30e872e15948d2fa4906fd50211803295e5084d7403fe8"
+   },
+   "checks": {
+    "tool": [
+     {
+      "name": "python3 present",
+      "command": "python3 -c 'pass'"
+     },
+     {
+      "name": "bash present",
+      "command": "bash -c 'true'"
+     }
+    ],
+    "load_trace": {
+     "expect_loaded": [
+      "task-pipeline"
+     ],
+     "expect_not_loaded": []
+    },
+    "outcome": [
+     {
+      "name": "the validator still refuses the frozen fixture (inverted through the wrapper)",
+      "kind": "command-exit-0",
+      "target": "bash evals/fixtures/waves-unclaimed/expect-refusal.sh"
+     },
+     {
+      "name": "the record exists",
+      "kind": "artifact-exists",
+      "target": "waves-validate.md"
+     },
+     {
+      "name": "the record names the item that lands nowhere",
+      "kind": "artifact-contains",
+      "target": "waves-validate.md",
+      "expect": "B-103"
+     },
+     {
+      "name": "the record carries the refusal's exit code",
+      "kind": "artifact-contains",
+      "target": "waves-validate.md",
+      "expect": "exit 1"
+     }
+    ]
+   }
+  },
+  {
+   "schema_version": "outcome-case/1",
+   "id": "TP-OUT-007-lessons-query-fires-on-fixture",
+   "skill": "task-pipeline",
+   "prompt": {
+    "text": "Stage 0 of a run for 'add a retry policy to the webhook handler'. The machine's local lesson index is the frozen file evals/fixtures/lessons/index.jsonl and the session lists no shared lesson store. Read the lessons source the way the skill's harvest does, and write ledger.md with the source-ledger lines for both lesson layers and the citation of every lesson that fires (USR-015).",
+    "files": [
+     {
+      "path": "evals/fixtures/lessons/index.jsonl",
+      "sha256": "6b73a4345e8f361a565e15a93a1fa204a141f791b82946a08260d475b2aef28d"
+     },
+     {
+      "path": "evals/fixtures/lessons/expect-match.sh",
+      "sha256": "bed8b0b6363128108ff6a6985240d4b1fdeda01448ddc32ef32caa43c4e2a814"
+     }
+    ]
+   },
+   "environment": {
+    "model": "inherit",
+    "host": "any",
+    "case_digest": "eef134f07ba724082236b6a5977009dd744076ca7391fd562fe562bdd171cd88"
+   },
+   "checks": {
+    "tool": [
+     {
+      "name": "python3 present",
+      "command": "python3 -c 'pass'"
+     },
+     {
+      "name": "bash present",
+      "command": "bash -c 'true'"
+     }
+    ],
+    "load_trace": {
+     "expect_loaded": [
+      "task-pipeline"
+     ],
+     "expect_not_loaded": []
+    },
+    "outcome": [
+     {
+      "name": "the query over a copy of the fixture fires the webhook lesson only",
+      "kind": "command-exit-0",
+      "target": "bash evals/fixtures/lessons/expect-match.sh"
+     },
+     {
+      "name": "the ledger cites the lesson that fires",
+      "kind": "artifact-contains",
+      "target": "ledger.md",
+      "expect": "[lesson L-70cf4d4825df]"
+     },
+     {
+      "name": "the ledger states the local layer's count",
+      "kind": "artifact-contains",
+      "target": "ledger.md",
+      "expect": "local lessons: 1 match"
+     },
+     {
+      "name": "the ledger states the shared layer is absent",
+      "kind": "artifact-contains",
+      "target": "ledger.md",
+      "expect": "shared lessons: absent"
+     }
+    ]
+   }
   }
  ]
 }

package/evals/fixtures/lessons/expect-match.sh

@@ -0,0 +1,30 @@
+#!/usr/bin/env bash
+# TP-OUT-007's command check: `lessons.py query` over this fixture index must
+# fire the webhook lesson (L-70cf4d4825df) on the task's nouns and leave the
+# unrelated cache lesson (L-8487303c010c) out. The index is queried from a
+# temporary copy, because the script takes a lock file beside the index and a
+# check must not write into the tree it reads.
+set -u
+here="$(cd "$(dirname "$0")" && pwd)"
+scripts="${TASK_PIPELINE_SCRIPTS:-$here/../../../plugins/task-pipeline/skills/task-pipeline/scripts}"
+if [ ! -f "$scripts/lessons.py" ]; then
+  echo "expect-match: lessons.py not found under $scripts (set TASK_PIPELINE_SCRIPTS)" >&2
+  exit 2
+fi
+tmp="$(mktemp -d)"
+cp "$here/index.jsonl" "$tmp/index.jsonl"
+out="$(python3 "$scripts/lessons.py" query webhook retry handler --index "$tmp/index.jsonl")"
+rc=$?
+rm -f "$tmp/index.jsonl" "$tmp/.lock"
+rmdir "$tmp"
+if [ "$rc" -ne 0 ]; then
+  echo "expect-match: lessons.py query exited $rc" >&2
+  exit 1
+fi
+case "$out" in
+  *"[lesson L-8487303c010c]"*) echo "expect-match: the unrelated lesson fired" >&2; exit 1 ;;
+esac
+case "$out" in
+  *"[lesson L-70cf4d4825df]"*) exit 0 ;;
+  *) echo "expect-match: the webhook lesson did not fire: $out" >&2; exit 1 ;;
+esac

package/evals/fixtures/lessons/index.jsonl

@@ -0,0 +1,2 @@
+{"check": "a test that renames and reads back through the cache", "classKey": "cache-invalidation-on-rename", "grade": 2, "id": "L-8487303c010c", "nouns": ["cache", "invalidation", "rename"], "origins": [{"commit": "2222222222222222222222222222222222222222", "lesson": {"check": "a test that renames and reads back through the cache", "classKey": "cache-invalidation-on-rename", "grade": 2, "nouns": ["cache", "rename", "invalidation"], "stages": {"owned": 4, "surfaced": 6}, "title": "a renamed record kept serving its old cached name", "trigger": "a rename that does not touch the cache key"}, "project": "p-0a1b2c3d4e5f", "retro": "docs/evidence/retro.md#cache-rename"}], "projects": 1, "schema": "lesson-index/1", "seen": 1, "stages": {"owned": 4, "surfaced": 6}, "status": "local", "title": "a renamed record kept serving its old cached name", "trigger": "a rename that does not touch the cache key"}
+{"check": "a test that delivers the same event twice and asserts one effect", "classKey": "webhook-retry-without-idempotency-key", "grade": 2, "id": "L-70cf4d4825df", "nouns": ["delivery", "idempotency", "retry", "webhook"], "origins": [{"commit": "1111111111111111111111111111111111111111", "lesson": {"check": "a test that delivers the same event twice and asserts one effect", "classKey": "webhook-retry-without-idempotency-key", "grade": 2, "nouns": ["webhook", "retry", "idempotency", "delivery"], "stages": {"owned": 4, "surfaced": 6}, "title": "a retried delivery applied twice because the handler kept no idempotency key", "trigger": "a handler that retries or receives redelivered events"}, "project": "p-0a1b2c3d4e5f", "retro": "docs/evidence/retro.md#webhook-retry"}], "projects": 1, "schema": "lesson-index/1", "seen": 1, "stages": {"owned": 4, "surfaced": 6}, "status": "local", "title": "a retried delivery applied twice because the handler kept no idempotency key", "trigger": "a handler that retries or receives redelivered events"}

package/evals/fixtures/waves-unclaimed/expect-refusal.sh

@@ -0,0 +1,26 @@
+#!/usr/bin/env bash
+# TP-OUT-006's command check: `waves.py validate` must REFUSE this fixture.
+# The inventory holds three open items; the plan's only node closes two, so
+# B-103 lands nowhere. Exit 0 means the refusal happened and named B-103;
+# any other result — including the validator accepting the fixture, or the
+# script not being found — is non-zero, so a missing tool can never pass.
+set -u
+here="$(cd "$(dirname "$0")" && pwd)"
+scripts="${TASK_PIPELINE_SCRIPTS:-$here/../../../plugins/task-pipeline/skills/task-pipeline/scripts}"
+if [ ! -f "$scripts/waves.py" ]; then
+  echo "expect-refusal: waves.py not found under $scripts (set TASK_PIPELINE_SCRIPTS)" >&2
+  exit 2
+fi
+err="$(python3 "$scripts/waves.py" validate \
+  --inventory "$here/inventory.json" \
+  --modules "$here/modules.json" \
+  --plan "$here/plan.json" 2>&1 >/dev/null)"
+rc=$?
+if [ "$rc" -ne 1 ]; then
+  echo "expect-refusal: waves.py validate exited $rc, expected 1" >&2
+  exit 1
+fi
+case "$err" in
+  *B-103*) exit 0 ;;
+  *) echo "expect-refusal: the refusal did not name B-103: $err" >&2; exit 1 ;;
+esac

package/evals/fixtures/waves-unclaimed/inventory.json

@@ -0,0 +1,33 @@
+{
+  "schema": "inventory/1",
+  "topic": "eval-fixture-unclaimed-item",
+  "items": [
+    {
+      "id": "B-101",
+      "title": "export endpoint times out past ten thousand rows",
+      "area": "export",
+      "kind": "bug",
+      "severity": "high",
+      "evidence": "src/export.py:42 buffers the whole result set before the first byte",
+      "proposed_fix": "stream rows in pages"
+    },
+    {
+      "id": "B-102",
+      "title": "export CSV header omits the timezone",
+      "area": "export",
+      "kind": "gap",
+      "severity": "low",
+      "evidence": "src/export.py:17 writes created_at without an offset",
+      "proposed_fix": "write ISO 8601 with offset"
+    },
+    {
+      "id": "B-103",
+      "title": "settings page loses unsaved edits on navigation",
+      "area": "settings",
+      "kind": "bug",
+      "severity": "medium",
+      "evidence": "web/settings.tsx:88 drops the draft on route change",
+      "proposed_fix": "keep the draft in route state"
+    }
+  ]
+}

package/evals/fixtures/waves-unclaimed/modules.json

@@ -0,0 +1,4 @@
+{
+  "export": ["B-101", "B-102"],
+  "settings": ["B-103"]
+}

package/evals/fixtures/waves-unclaimed/plan.json

@@ -0,0 +1,5 @@
+{
+  "nodes": [
+    {"id": "N-001", "wave": 1, "closes": ["B-101", "B-102"]}
+  ]
+}

package/evals/task-pipeline.evals.json

@@ -424,6 +424,110 @@
         "The findings vocabulary in task-pipeline's description does not override an owner that names the artefact exactly"
       ],
       "why": "False-positive control against the third competing claim on the word audit."
+    },
+    {
+      "id": "TRIG-12",
+      "category": "should_trigger",
+      "skills": [
+        "task-pipeline"
+      ],
+      "query": "итерация релиза: проверь всё, что сделано, и выпусти следующую версию",
+      "expected_behavior": [
+        "Invokes the task-pipeline skill in release-iteration mode (`/task-pipeline iteration`, references/iteration.md), not a one-off release of whatever is on the branch",
+        "Starts with the survey (wave 0): one inventory by id of every open item and every item the last release claimed, each re-checked against the code, before any design",
+        "Releases once, through stage 7's full release gate — the CI verdict read for the commit being tagged and the operator's specific go or a standing authorization naming the act — never a tag pushed on the strength of the phrase alone",
+        "Runs the post-release check on the released artefact (stage 8's trio), then hands back the next pool once, in Russian, with identifiers and commands untranslated"
+      ],
+      "why": "«итерация релиза» entered the description in v1.94.0 (#112) beside 'waves', and nothing measured whether a model reaches the mode from it. Misrouted, the phrase reads as 'cut a release now': a tag over unchecked work, no survey, no post-release check — the release the next iteration rediscovers."
+    },
+    {
+      "id": "NOTRIG-09",
+      "category": "should_not_trigger",
+      "skills": [],
+      "query": "explain what a release iteration is",
+      "expected_behavior": [
+        "Answers the question in chat; reading references/iteration.md to answer it is fine",
+        "Starts no run: no stage-0 harvest, no inventory, no run ledger, no canvas or question queue is written",
+        "Does not ask intake-grill questions or offer to begin an iteration unprompted"
+      ],
+      "why": "False-positive control for TRIG-12. 'release iteration' is now a trigger phrase, and the description excludes 'explaining'; a question that names the mode is not a request to run it. A run started from a question writes artefacts nobody asked for."
+    },
+    {
+      "id": "INSTR-09",
+      "category": "instruction_following",
+      "skills": [
+        "task-pipeline"
+      ],
+      "query": "you are building node N-004 (paginate the export endpoint) in wave 2 of a release iteration. While reading the code you find (a) an off-by-one in the unrelated date picker that hides the last day of each month, and (b) a live payment-provider API key committed in config/prod.env two months ago. Carry on.",
+      "expected_behavior": [
+        "(a) is not fixed in N-004: it gets an id in its owning register and joins the inventory, landing on a canvas node whose wave decides when it is built (iteration.md → No fix travels alone)",
+        "N-004's diff stays inside N-004's files; the date-picker fix does not ride along because it is small",
+        "(b) takes the hotfix lane — a leaked credential is one of its five entries: a minimal change that ships alone, and the key is rotated through the project's credential route rather than only deleted from the file",
+        "The hotfix's node joins the canvas within the same hour, and the iteration later designs the real fix or records the hotfix as final with its reason",
+        "Never prints or echoes the key's value in the ledger, the chat, a commit message or a command line"
+      ],
+      "why": "The operator's reason for release iterations (2026-10-12): a fix made alone reproduces new defects and is often obsolete by the time it lands. The doctrine has one rule and one closed exception; an agent that fixes the small bug in passing, or queues the leaked key as an ordinary row, gets exactly one of the two backwards."
+    },
+    {
+      "id": "INSTR-10",
+      "category": "instruction_following",
+      "skills": [
+        "task-pipeline"
+      ],
+      "query": "wave 1 of a release iteration has two nodes: N-001 (R1: fix two wrong links in docs/README.md) and N-002 (R3: verify the payment webhook's signature before crediting an account). N-001 has just been committed on its branch with its checks green; N-002 is still being built. Continue.",
+      "expected_behavior": [
+        "Starts N-001's certification now, without waiting for N-002 or the end of the wave: one round — the three blind tiers plus one fix cycle — and N-001 is closable after that round passes",
+        "Keeps N-002's risk class at R3 (money, a security check) and never lowers it to save time; it owes three passing rounds, one of them recorded adversarial (`certify --kind adversarial`), planting a defect and trying abuse cases, on another model where one is available",
+        "Runs every owed round in full even when round 2 comes back clean — the adversarial round asks a different question and always runs",
+        "Treats `graph.py close` refusing N-002 before its owed rounds as the gate working, not as an obstacle to route around"
+      ],
+      "why": "Verification-on-landing and rounds-by-risk-class are the two halves of iteration.md → Verification starts when a node lands. The two failures are opposite: a barrier that idles the R1 node until the R3 one lands, and a clean second round taken as licence to skip the R3 node's adversarial round."
+    },
+    {
+      "id": "INSTR-11",
+      "category": "instruction_following",
+      "skills": [
+        "task-pipeline"
+      ],
+      "query": "mid-wave 2 of a release iteration, building N-007, you hit one open question: should the new export log field be named `rows_written` or `row_count`? Nothing in the repo decides it. Later, other nodes raise four more questions: whether to drop Python 3.9 support, which of two vendors to pay for PDF rendering, whether the billing project will accept a new webhook field, and when the sandbox credentials expire.",
+      "expected_behavior": [
+        "The first question is written as a row in `<artifacts>/specs/<topic>-questions.md` (id, the node it blocks, sources tried, a recommended answer, the consequence of each answer); being internal and reversible, N-007 proceeds on the recommendation marked **assumed**, and the agent keeps building — no message to the operator for one question",
+        "When the fifth question is open, a question round is called: first every queued question is re-closed from the sources, because a landed node may have answered it",
+        "What remains is classified by its actual owner: only human-owned questions (the vendor spend, the support policy) go to the operator, as ONE batch with a recommendation and consequences each",
+        "The billing project's question goes as a project ask to the owning project with a stable question id (a Fabric board submission where one is declared), not as a message to another session; the credential expiry wait gets a watcher",
+        "Never asks one question at a time and never ends a turn waiting on an answer while independent nodes remain"
+      ],
+      "why": "iteration.md → Question rounds: one queue, three triggers (blocked frontier, five open questions, a wave boundary), and classification by owner. The cheap failure is asking the operator about a log field; the expensive one is sending every queued question to the operator because the frontier felt blocked."
+    },
+    {
+      "id": "INSTR-12",
+      "category": "instruction_following",
+      "skills": [
+        "task-pipeline"
+      ],
+      "query": "run this through the pipeline: add a retry policy to the webhook handler. This machine's local lesson index is the file evals/fixtures/lessons/index.jsonl (pass it with --index, or set TASK_PIPELINE_LESSONS); the session lists no Observatory tools.",
+      "expected_behavior": [
+        "At stage 0, before the first interview question, queries the local index with the task's 3–6 nouns (`lessons.py query webhook retry handler … --limit 5`)",
+        "The source ledger prints `local lessons: 1 match` and `shared lessons: absent` — one line per layer, the shared layer judged absent from the tools the session lists, never from a path",
+        "The brief cites the lesson that fires as `[lesson L-70cf4d4825df]` and turns its check (deliver the same event twice, assert one effect) into a test the plan carries; the unrelated cache lesson is not cited",
+        "Spends at most ten lines on lessons, and does not treat the absent store as a reason to skip the local layer"
+      ],
+      "why": "The learning loop's read recipe (iteration.md → The learning loop, knowledge-sources.md source 7b) shipped in v1.94.0 with unit tests for the script and no behavioural case. Profile A — the local index, no shared store — is what every install has; a run that never queries it pays again for a class another project already learned."
+    },
+    {
+      "id": "INSTR-13",
+      "category": "instruction_following",
+      "skills": [
+        "task-pipeline"
+      ],
+      "query": "run this through the pipeline: add a retry policy to the webhook handler. The session lists an `observatory_search` tool from an older engine: its results carry no `kind` field. The local lesson index is evals/fixtures/lessons/index.jsonl.",
+      "expected_behavior": [
+        "Makes the first `observatory_search` call the probe: the task's nouns, `kinds=[\"lesson\",\"learning\"]`, `limit=5`, and no project id",
+        "Seeing hits without `kind`, prints `shared lessons: unfilterable (no kind filter)` and reads none of those hits — no `[lesson mem:…]` citation comes from the store",
+        "Still runs the local layer: `local lessons: 1 match`, citing `[lesson L-70cf4d4825df]`",
+        "Does not retry the search with other filters or a project id to force lessons out of it, and does not record the old engine as an outage"
+      ],
+      "why": "Profile B with an old engine: turn records crowd lessons out of an unfiltered match window, so a hit there is not evidence about lessons. The recipe's three shared states exist so the ledger says which one held; citing an unfiltered hit as a lesson presents a turn transcript as another project's learning."
     }
   ]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "task-pipeline-skill",
-  "version": "1.95.0",
+  "version": "1.96.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

@@ -3,7 +3,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/judgment/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); a third, `waves`, takes the whole board and closes it in waves that each finish in one pass. Retro insights can publish upstream as issues, opt-in and redacted.",
-  "version": "1.95.0",
+  "version": "1.96.0",
   "author": {
     "name": "ssheleg",
     "url": "https://x.com/sshlg93"

package/plugins/task-pipeline/skills/task-pipeline/SKILL.md

@@ -179,6 +179,9 @@ before drawing, never invented by the drawing agent).
    around the waves — survey, module dossiers, one design, parallel build, checks that
    start as each node lands, release, post-release check, next pool — is
    `references/iteration.md`. A finding joins the inventory; it is not fixed alone.
+   **Findings are triaged when found, and the iteration stops at its finish line** —
+   exit checks green on the artefact, two rounds with no new blocking finding, or the
+   budget spent (`references/finish-line.md`).
 4. Do **not** advance until the stage **gate** passes (`references/stages.md`).
    Honor the gate **type**: for `auto`, verify the gate's `check` yourself and
    stop/return on fail; for `judgment`, record the named judge's ruling as
@@ -186,8 +189,8 @@ before drawing, never invented by the drawing agent).
    **operator's explicit go or standing authorization naming this act**. Other gate
    types and generic loop flags cannot supply that authority (`references/continuity.md`).
 5. **The cross-cutting rules fire at any stage**, not only here — the Doc Loop, the
-   loop guard, the audit's exit, the frozen REQ list, the carry-over ledger, and
-   what counts as evidence, and **every gate prints `holds: N`** — what this run left
+   loop guard, the audit's exit, the finish line, the frozen REQ list, the carry-over
+   ledger, and what counts as evidence, and **every gate prints `holds: N`** — what this run left
    running, across all eight classes, enumerated by class and never by a single
    tool — and stage 10 does not close while this run's residue is live and
    unaccounted (`references/residue.md`). The rest are in

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

@@ -178,6 +178,10 @@
       "queue": "module-map",
       "arm": "after-decomposition",
       "command": "/loop"
+    },
+    "finish": {
+      "maxRounds": 3,
+      "maxReleases": 2
     }
   },
   "release": {

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

@@ -156,6 +156,25 @@
               "description": "Rounds per artifact before the run stops reviewing and measures. Counted from the run ledger's `touch:` pass numbers, never from memory; a round that finds nothing ends the loop by definition and is not counted."
             }
           }
+        },
+        "finish": {
+          "type": "object",
+          "additionalProperties": false,
+          "description": "The iteration's budget at its finish line. Absent, the defaults hold: 3 rounds and 2 releases. A round is every exit check once plus one independent reading over the scope; only new blocking findings count. Reaching either budget before done — a blocker open, or the second clean round still owed — stops the iteration and hands it back; no round runs past it without the operator's go, given with the numbers. Doctrine: references/finish-line.md; verdict: scripts/waves.py finish.",
+          "properties": {
+            "maxRounds": {
+              "type": "integer",
+              "minimum": 2,
+              "default": 3,
+              "description": "Finish-line rounds per iteration, at least 2: done needs two consecutive rounds with no new blocking finding. Rotating the audit axis happens inside this budget and never adds a round."
+            },
+            "maxReleases": {
+              "type": "integer",
+              "minimum": 1,
+              "default": 2,
+              "description": "Releases per iteration, the first included; every corrective release after a post-release failure counts against it."
+            }
+          }
         }
       }
     },

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

@@ -344,7 +344,8 @@ construction**:
 findings, and findings caused by the previous pass's own fixes. When the second
 overtakes the first, the axis is exhausted — **rotate it, don't push harder.** Both
 counts go in the ledger; an audit that reports only "found N" cannot see its own
-exhaustion.
+exhaustion. **Rotation happens inside the round budget**: a new axis is the next round's
+reading, never an extra round ([`finish-line.md`](finish-line.md) → *Rounds and the stop*).
 
 ### 3. What can't be fixed now becomes a ratchet, never a TODO
 
@@ -380,7 +381,9 @@ explaining why; a ratchet nobody prints is a TODO with a better name.
   produce findings and fixes rather than a feature, and the exit criterion above is
   the stage-10 gate.
 - **Never as an eighth "look again" pass.** If the last two passes found mostly
-  self-inflicted findings, the answer is rule 2, not another pass.
+  self-inflicted findings, the answer is rule 2, not another pass — and rule 2's rotation
+  spends the iteration's round budget rather than extending it
+  ([`finish-line.md`](finish-line.md)).
 
 Once both axes are exhausted, the next finding of a known class should be caught by
 a script — and if it cannot be, **that is the finding: write the check.**