task-pipeline-skill 1.53.0 → 1.54.0

package/CHANGELOG.md

@@ -1,5 +1,35 @@
 # Changelog
 
+## v1.54.0 — a run cannot reach acceptance with a stage it never stamped
+
+The 2026-08-13 artifact-root run closed at stage 10 with `0,1,2,5,6,7,8,9,10` recorded
+and **3 (spec) and 4 (plan) never stamped**. The status line printed `3· 4·` and 73% and
+was exactly right; nothing read it. Detection existed — `lib/runledger.js` renders that
+rail — and no gate refused on it, which is the difference between a display and a check.
+
+Stage 7's release gate could not have caught it either: it fires before 8, 9 and 10
+exist, and it asks only about the tests stage.
+
+### Added
+
+- **`templates/stage-coverage.sh`**, seeded at stage 0 and run at stage 10 before the
+  coverage table. It reads the stage ids `pipeline.json` declares and the `stage: <id>
+  … verdict` lines the ledger holds, and names every declared stage with no verdict.
+  Last verdict per id wins — a stage re-entered after a fix has the outcome of the
+  re-entry, not of the failure that caused it.
+- **Both remedies are legitimate, and the refusal says so.** Stamp what happened,
+  because a merged stage still has an outcome; or stop declaring in `pipeline.json` a
+  stage this project folds into another. What is not legitimate is a flow that declares
+  eleven stages against a ledger that accounts for nine.
+- **Exit 2 when it cannot look** — no config, no ledger — and that is not a pass.
+  Standing instruction #1: a component that never received its input refuses rather than
+  approves. It has its own negative self-test, because "no input" is the state in which
+  a checker most easily agrees with everything.
+
+Guards: 313 → **315**. Property checks: 9 → 9. The first new one plants the incident
+itself — a five-stage flow whose ledger stamps four — and requires the refusal to name
+stage 3.
+
 ## v1.53.0 — the artifact root stops carrying another pack's name
 
 The paperwork directory was called `docs/superpowers/`. The name came from an unrelated

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.53.0 |
+| **Version** | 1.54.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.53.0",
+  "version": "1.54.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.53.0",
+  "version": "1.54.0",
   "author": {
     "name": "ssheleg",
     "url": "https://x.com/sshlg93"

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

@@ -12,6 +12,7 @@ requirement.** It is what turns the pipeline from a funnel into a circle.
 - Why a stage and not a gate
 - First, the ladder walk — what the list itself is missing
 - Inputs
+- Every declared stage is accounted for
 - Output — the coverage table
 - Evidence, not assertion
 - Several repositories — a submodule is finished when its parent says so
@@ -68,6 +69,31 @@ Read all of them before writing anything:
 - stage 8's post-deploy notes; stage 9's doc/wiki changes
 - for UI tasks: `docs/ux/scenarios.md` statuses and the `/ux-lint` result
 
+## Every declared stage is accounted for
+
+Before the coverage table, one cheaper question: **does the ledger account for every
+stage the flow declares?**
+
+A run can reach acceptance with stages that never happened and never said so. On
+2026-08-13 one closed with `0,1,2,5,6,7,8,9,10` recorded and **3 (spec) and 4 (plan)
+never stamped** — the artifacts existed, folded into the brief, but their verdicts did
+not. The status line printed `3· 4·` and 73% and was right; nothing read it. Stage 7's
+release gate could not have caught it: that gate fires before 8, 9 and 10 exist, and it
+asks only about the tests stage.
+
+```bash
+bash scripts/stage-coverage.sh
+```
+
+Exit 1 names each declared stage with no verdict. **Both remedies are legitimate** —
+stamp what actually happened, because a merged stage still has an outcome; or stop
+declaring a stage this project folds into another, in `pipeline.json`, where the flow
+describes itself. What is not legitimate is a flow that declares eleven stages and a
+ledger that accounts for nine.
+
+Exit 2 means it could not look — no config, or no ledger. That is **not** a pass: a
+check that cannot run says so rather than agreeing.
+
 ## Output — the coverage table
 
 Write `<artifacts>/specs/YYYY-MM-DD-<topic>-acceptance.md`:

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

@@ -21,6 +21,7 @@ from `super-ux`.
 | `open-questions.md` | `docs/OPEN_QUESTIONS.md` | 0 seeds it, the Doc Loop resolves rows |
 | `docgate.sh` | `scripts/check-docs.sh` | 0 seeds it · 9 runs it · 10 proves it |
 | `hygiene.sh` | `scripts/check-hygiene.sh` | 0 seeds it · **5 runs it after every task** · 6 and 9 run it · 10 proves it |
+| `stage-coverage.sh` | `scripts/stage-coverage.sh` | 0 seeds it · **10 runs it before the coverage table** — every stage the flow declares must carry a verdict, or the flow stops declaring one it merges |
 | `hooks.example.json` | the project's `.claude/settings.json` | 0 — offered, never installed silently |
 | `routing-rule.md` | the operator's `CLAUDE.md` — **offered by `setup`, never written silently** | 0 / `setup` |
 | `retro.md` | `docs/evidence/retro.md` — **one per project, not per run** | 10 writes (stamp → prune → entry), 0 reads it in full |

package/plugins/task-pipeline/skills/task-pipeline/templates/stage-coverage.sh

@@ -0,0 +1,77 @@
+#!/usr/bin/env bash
+# Stage 10: does the ledger account for every stage the flow declares?
+#
+# A run can reach acceptance with stages that never happened and never said so. On
+# 2026-08-13 one closed with 0,1,2,5,6,7,8,9,10 recorded and **3 (spec) and 4 (plan)
+# never stamped** — the artifacts existed, folded into the brief, but their verdicts did
+# not. The status line printed `3· 4·` and 73% and was right; nothing read it. Stage 7's
+# release gate could not have caught this: it fires before 8, 9 and 10 exist, and it asks
+# only for the tests stage.
+#
+# So this is the check stage 10 owes: every declared stage carries a verdict, or the flow
+# stops declaring a stage it merges. Both are legitimate — a project whose spec and plan
+# genuinely live inside the brief should say so in `pipeline.json` rather than record a
+# verdict nobody produced. What is not legitimate is a flow that declares eleven stages
+# and a ledger that accounts for nine.
+#
+#     bash scripts/stage-coverage.sh            # the project's own flow and ledger
+#     bash scripts/stage-coverage.sh --ledger X --config Y
+#
+# Exit 0 = every declared stage has a verdict. Exit 1 = it does not, and each missing one
+# is named. Exit 2 = it could not look (no config, no ledger) — which is NOT a pass:
+# a check that cannot run must say so rather than agree.
+set -euo pipefail
+
+LEDGER=".task-pipeline/run.md"
+CONFIG="pipeline.json"
+while [ $# -gt 0 ]; do
+  case "$1" in
+    --ledger) LEDGER="$2"; shift 2 ;;
+    --config) CONFIG="$2"; shift 2 ;;
+    *) echo "unknown argument: $1" >&2; exit 2 ;;
+  esac
+done
+
+[ -f "$CONFIG" ] || { echo "STAGE COVERAGE CANNOT RUN: no $CONFIG — the flow does not say what it declares" >&2; exit 2; }
+[ -f "$LEDGER" ] || { echo "STAGE COVERAGE CANNOT RUN: no $LEDGER — there is no run to account for" >&2; exit 2; }
+
+python3 - "$CONFIG" "$LEDGER" <<'PY'
+import json, re, sys
+
+cfg_p, led_p = sys.argv[1], sys.argv[2]
+cfg = json.load(open(cfg_p, encoding="utf-8"))
+declared = [s["id"] for s in cfg.get("stages", []) if "id" in s]
+names = {s["id"]: s.get("name", "") for s in cfg.get("stages", [])}
+if not declared:
+    print(f"STAGE COVERAGE CANNOT RUN: {cfg_p} declares no stages", file=sys.stderr)
+    raise SystemExit(2)
+
+led = open(led_p, encoding="utf-8").read()
+# `stage: <id> <name> — gate <type> — verdict <v> — <when>`; the LAST verdict for an id
+# wins, because a stage re-entered after a fix is the stage's real outcome.
+seen = {}
+for m in re.finditer(r"^stage:\s*(\d+)\b[^\n]*?verdict\s+(\w+)", led, re.M):
+    seen[int(m.group(1))] = m.group(2)
+
+missing = [i for i in declared if i not in seen]
+unpassed = [(i, v) for i, v in sorted(seen.items()) if v not in ("pass", "skip")]
+
+for i in missing:
+    print(f"  stage {i} ({names.get(i,'')}) — DECLARED BY {cfg_p}, NO VERDICT IN THE LEDGER")
+for i, v in unpassed:
+    print(f"  stage {i} ({names.get(i,'')}) — last verdict is '{v}'")
+
+covered = len(declared) - len(missing)
+print(f"\nstages declared {len(declared)} · accounted for {covered} · "
+      f"{round(100*covered/len(declared))}%")
+
+if missing:
+    print("\nA run that reaches acceptance with a stage unaccounted for is a run whose own\n"
+          "record disagrees with its flow. Either stamp what actually happened — a merged\n"
+          "stage still has an outcome — or stop declaring a stage this project folds into\n"
+          "another, in pipeline.json, where the flow describes itself.")
+    raise SystemExit(1)
+if unpassed:
+    raise SystemExit(1)
+print("every declared stage carries a verdict")
+PY