task-pipeline-skill 1.99.0 → 1.100.0

package/CHANGELOG.md

@@ -1,3 +1,63 @@
+## v1.100.0 (2026-10-22)
+
+Guards: 530 → **530**; property checks 15 → **15**. No negative was added: the new checks are
+`test/design_gate_test.py` (75 cases) and eight new cases in `test/waves_test.py`.
+
+**The design review is a gate** (operator, 2026-10-22). Every node that changes an interface
+owes it, in a single run, a wave or a release iteration.
+
+- **`design-tester`** (`agents/design-tester.md`) walks the project's ten-portrait test panel
+  (super-ux 0.64.0, `docs/ux/test-panel.md`) through the changed scenarios: pass D over the
+  Figma frames or mockups before build (stage 3), pass B in a real browser over the build after
+  it (stage 6). Every step answers a fixed checklist (frame, primary action, controls, focus,
+  states, text fit, outcome); a `breaks` finding names the item that failed.
+- **`scripts/design_gate.py`** gates the panel (ten portraits, each with basis, features,
+  composite scenarios, activation and retention), the report `design-review/1` (coverage of
+  scope scenario × persona, the checklist, no open `breaks`, one pass of each kind per round,
+  the resource receipt) and the recorded browser (`browser.storageState` outside the repo).
+- **The tester's browser** (`references/browser.md`): asked once per project and recorded in
+  `pipeline.json` → `browser`, WebKit first, a prepared signed-in session, a fallback that is
+  said, never silent.
+- **`scripts/resource_guard.py`**: load, memory pressure and free disk before a run (wait over
+  the line), caps on browsers, pages and dev servers, a ledger of what the run started, and a
+  close that touches only that, verified empty.
+- **The stop, in every run**: stage 10 computes the finish verdict with `waves.py finish` over
+  the run's own ledger, and `run.finish.maxAgents` (default 2) fails a round whose `agents:`
+  line ran more sub-agents at once.
+- `scripts/backlog_sources.py` no longer cites a private repository.
+- **Reviewed under its own budget:** three blind unit readings found 4, then 2, then 2 `breaks`
+  (each fixed with a regression case); the round budget of 3 was reached, so no fourth reading
+  ran.
+
+## v1.99.1 (2026-10-21)
+
+Guards: 530 → **530**; property checks 15 → **15**. No negative was added: the new cases
+are regression tests in `test/audit_regressions/diet_retro_budget.py`.
+
+**`retro_budget.py` reads an older retro's floor and migrates it** (B-149, from sshlg-skills
+B-244). That retro writes its standing instructions as a numbered list and its run stamps as
+`- **date: title** ...` narrative items beside a table. `check` printed `standing 0/10 rows`
+for ten instructions, and `migrate` answered `nothing to move` on a 103,737-byte floor with 89
+stamps, so stage 10's byte budget could never pass there.
+
+- `check` counts numbered-list standing instructions and list stamps, measures each item
+  whole and names it (`standing row #6`, `stamp 2026-09-06 (list)`).
+- `migrate` rotates the oldest stamps past the cap of ten, ordered by their date and never by
+  position, verbatim into the quarter's archive (a table row travels under its table's
+  header); keeps a long list item's bold rule and its `*(Retire ...)*` trigger and moves the
+  rest; keeps a long list stamp's bold title; and, only over budget, moves the Run stamps
+  section's loose prune paragraphs. Every move leaves a `sha256:` pointer that `verify` proves.
+- Edge rules from two review rounds: a lead of several bold spans stays whole and a date-only
+  lead refuses by name; a same-day tie follows its own block's direction; a paragraph holding
+  a heading stays in the floor; the script's own pointer notes never move again, so a floor
+  still over budget is left alone by the next run; a table's header leaves only with the rows
+  this run rotated; a list marker, a quote, a rule or a `*(` note ends an item; a rule still
+  over 600 characters after its story moved is reported, never moved again.
+- On a copy of the sshlg-skills retro: 103,737 bytes to 6,446, every pointer proved, no
+  non-blank line lost, the text outside the floor unchanged.
+- Tests: `test/audit_regressions/diet_retro_budget.py` gains seventeen cases. Each failed on the
+  1.99.0 script (it crashed with no archive to read) or on a reviewed intermediate version.
+
 ## v1.99.0 (2026-10-21)
 
 Guards: 448 → **530**; property checks 15 → **15**. There are 82 new negatives in

package/README.md

@@ -186,6 +186,7 @@ and the inline fallback satisfy the same [provider contract](plugins/task-pipeli
 | 5 Build | [`build.md`](plugins/task-pipeline/skills/task-pipeline/references/build.md) + [`review.md`](plugins/task-pipeline/skills/task-pipeline/references/review.md) — isolation, ledger, subagent loop, review rubric, fix loop |
 | 5–6 TDD | [`tdd.md`](plugins/task-pipeline/skills/task-pipeline/references/tdd.md) — the iron law, red/green/refactor, the suite gate |
 | 5, 6, 8 The browser | [`browser.md`](plugins/task-pipeline/skills/task-pipeline/references/browser.md) — the ref model both channels share, the four commands the look is made of, sessions, and the three different things *"tested in a browser"* means |
+| 3, 6 The design review | [`design-review.md`](plugins/task-pipeline/skills/task-pipeline/references/design-review.md): the `design-tester` agent walks the ten-portrait test panel through the changed scenarios over the Figma frames or mockups before build and in the recorded browser after it, judges every step on a fixed checklist, and closes everything it started (`scripts/design_gate.py`, `scripts/resource_guard.py`) |
 | 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 |
@@ -641,7 +642,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` 386/1024 chars, `SKILL.md` 207/500 lines, all 53 references
+13/64 chars, `description` 386/1024 chars, `SKILL.md` 207/500 lines, all 54 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.99.0 |
+| **Version** | 1.100.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. The engine is WebKit (Safari) first; `chrome-devtools` is Chrome-only, a stated exception. 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/package.json

@@ -1,13 +1,13 @@
 {
   "name": "task-pipeline-skill",
-  "version": "1.99.0",
+  "version": "1.100.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"
   },
   "scripts": {
-    "test": "python3 test/validate.py && python3 test/graph_test.py && python3 test/project_audit_test.py && python3 test/packet_schema_test.py && python3 test/browser_claims_test.py && python3 test/visual_gate_test.py && python3 test/stage_checkpoint_test.py && python3 test/backlog_sources_test.py && python3 test/release_approval_test.py && python3 test/memory_nudge_test.py && python3 test/lessons_test.py && python3 test/waves_test.py && python3 test/continuity_doc_test.py && bash test/install_test.sh && npm run test:audit-regressions",
-    "test:all": "python3 test/validate.py && python3 test/graph_test.py && python3 test/project_audit_test.py && python3 test/packet_schema_test.py && python3 test/browser_claims_test.py && python3 test/visual_gate_test.py && python3 test/stage_checkpoint_test.py && python3 test/backlog_sources_test.py && python3 test/release_approval_test.py && python3 test/memory_nudge_test.py && python3 test/lessons_test.py && python3 test/waves_test.py && python3 test/continuity_doc_test.py && bash test/install_test.sh && python3 test/negatives.py && npm run test:certify && npm run test:exposure && npm run test:probe && npm run test:anchors && npm run test:runner && npm run test:hooks && npm run test:artifacts && npm run test:docs && npm run test:audit-regressions",
+    "test": "python3 test/validate.py && python3 test/graph_test.py && python3 test/project_audit_test.py && python3 test/packet_schema_test.py && python3 test/browser_claims_test.py && python3 test/visual_gate_test.py && python3 test/stage_checkpoint_test.py && python3 test/backlog_sources_test.py && python3 test/release_approval_test.py && python3 test/memory_nudge_test.py && python3 test/lessons_test.py && python3 test/waves_test.py && python3 test/design_gate_test.py && python3 test/continuity_doc_test.py && bash test/install_test.sh && npm run test:audit-regressions",
+    "test:all": "python3 test/validate.py && python3 test/graph_test.py && python3 test/project_audit_test.py && python3 test/packet_schema_test.py && python3 test/browser_claims_test.py && python3 test/visual_gate_test.py && python3 test/stage_checkpoint_test.py && python3 test/backlog_sources_test.py && python3 test/release_approval_test.py && python3 test/memory_nudge_test.py && python3 test/lessons_test.py && python3 test/waves_test.py && python3 test/design_gate_test.py && python3 test/continuity_doc_test.py && bash test/install_test.sh && python3 test/negatives.py && npm run test:certify && npm run test:exposure && npm run test:probe && npm run test:anchors && npm run test:runner && npm run test:hooks && npm run test:artifacts && npm run test:docs && npm run test:audit-regressions",
     "test:negatives": "python3 test/negatives.py",
     "test:exposure": "python3 test/exposure_test.py",
     "test:probe": "python3 test/probe.py --self-test",

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 proportional short path for small changes, a loop guard whose ceilings stop and record a blocker, 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.99.0",
+  "version": "1.100.0",
   "author": {
     "name": "ssheleg",
     "url": "https://x.com/sshlg93"

package/plugins/task-pipeline/agents/design-tester.md

@@ -0,0 +1,80 @@
+---
+name: design-tester
+description: The design-review gate, owed by every node that changes an interface. Walks the project's test panel of ten personas through the changed scenarios, first over the Figma frames or mockups (pass D), then in a real browser over the build (pass B), judges every step on a fixed checklist, watches the machine's load and closes everything it started. Writes design-review/1. Use when a task-pipeline node with a surface_class other than none reaches stage 3 or stage 6. Not for code review (the unit tier) or the pixel diff of a contact sheet (verifier-visual).
+model: inherit
+tools: Read, Grep, Glob, Bash
+---
+
+# Design tester: the interface, walked by the people it is for
+
+You test what a user meets, not how it was built. The builder and the designer will never see
+your reasoning, only your report, and you never see theirs: a tester who has read *the screen
+is finished* sees a finished screen.
+
+Your inputs, and nothing else is yours:
+
+- the **test panel**, `docs/ux/test-panel.md`: ten portraits, each with its features, composite
+  scenarios (`SCR-` ids), activation funnel, retention loop and needs, and a basis line that
+  says evidence or hypothesis. Run `python3 scripts/design_gate.py panel docs/ux/test-panel.md`
+  first; a FAIL or NOT_RUN there stops you and goes back to super-ux `ux-foundation`;
+- the **scenarios**, `docs/ux/scenarios.md`, and the node's scope: the `SCR-` ids it changes;
+- the **design**: the Figma frames each step names (through the Figma MCP when connected:
+  `get_metadata`, `get_screenshot`) or, without Figma, the mockups the scenario links;
+- the **build**: the URL or app the node runs, reached in the browser the project recorded
+  (`pipeline.json` → `browser`).
+
+## What you do
+
+1. **Bound the work before starting.** The scope's scenarios × the panel personas that use
+   them (`design_gate.py` computes it): that is the matrix, and the whole of it. One pass D
+   and one pass B per round; a re-review reads only the steps the fix touched. Findings
+   outside the scope are board rows, not your next task.
+2. **Pass D, design, before build.** For each scenario step and each persona: open its frame.
+   Is the step's screen there? Is the primary action present and visible without hunting? Is
+   every control the scenario needs on it? Does anything compete with the step's goal? Are the
+   empty, loading and error states designed? Does the text fit? Does the persona's funnel stage
+   or retention trigger land where the scenario says? Each answer is pass, fail, na or NOT_RUN
+   with its reason. The designer fixes; you re-read only what changed.
+3. **Pass B, build, after build.** Check the machine first:
+   `python3 scripts/resource_guard.py check`; exit 4 means wait, then run with fewer pages.
+   Start the browser the project chose (`references/browser.md` → *The tester's browser*),
+   record every process you start with `resource_guard.py record`, and drive each step as the
+   persona would: the same checklist, a capture per step, the engine named, the business
+   outcome read back (the order exists, the setting persisted, the message arrived). Compare
+   each capture with its Figma frame or mockup.
+4. **Sign-in walls are a human gate, said once.** Use the prepared session (Safari's signed-in
+   profile through `safaridriver`, or the `storageState` file outside the repository). A
+   missing sign-in, a one-time code or a consent is named in the report, the steps behind it
+   are NOT_RUN with that reason, and the rest of the matrix runs.
+5. **Close what you opened.** `resource_guard.py close` then `resource_guard.py verify --json`;
+   its output is the report's `resources` block. A live process is a failed gate, not a note.
+6. **Gate yourself.** `python3 scripts/design_gate.py report <report> --class <surface_class>
+   --panel docs/ux/test-panel.md --scope <ids> --require design|build`. Quote its output as
+   your first evidence. NOT_RUN is said as NOT_RUN.
+
+## The report, `design-review/1`
+
+```json
+{"schema": "design-review/1", "surface": "<surface>", "panel_revision": "<sha>",
+ "rows": [{"scenario": "SCR-03", "step": 2, "persona": "P-04", "pass": "build", "round": 1,
+           "frame": "<figma node or mockup>", "capture": "<path>", "engine": "webkit",
+           "outcome": "order #… created, visible in history",
+           "checks": {"frame": "pass", "primary_action": "pass", "controls": "fail",
+                      "focus": "pass", "states": "na", "text_fit": "pass", "outcome": "pass"},
+           "findings": [{"severity": "breaks", "what": "no way back from the summary",
+                         "where": "summary screen", "status": "open"}]}],
+ "resources": {"started": [], "live": [], "closed": true}}
+```
+
+`breaks` stops the user in a scenario step or contradicts the scenario's outcome. `risk` makes a
+step slower, unclear or easy to get wrong. `nit` is polish. Taste is none of them: a finding
+names the step, the persona and the checklist item it failed.
+
+## Three ways this goes wrong
+
+- **The panel decided the product.** A hypothesis portrait chooses what to test, never what to
+  build. Say so when a finding rests only on a hypothesis.
+- **The run kept going.** A fourth round, or steps outside the scope, is the loop the finish
+  line exists to stop (`references/finish-line.md`). Stop and hand back with the numbers.
+- **The machine paid.** A browser left open, a dev server still listening, or a run started at
+  a load the guard said to wait on. The receipt is the proof, and it is checked.

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

@@ -81,6 +81,70 @@
           "description": "The resume point that survives context loss."
         }
       }
+    },
+    "browser": {
+      "type": "object",
+      "additionalProperties": false,
+      "description": "The browser the design-tester and every look use (since 1.100.0). Asked once per project at stage 0 when absent, then recorded here. WebKit first (references/browser.md). Doctrine: references/browser.md, The tester's browser.",
+      "required": [
+        "primary"
+      ],
+      "properties": {
+        "primary": {
+          "type": "string",
+          "enum": [
+            "safari",
+            "playwright-webkit",
+            "chrome-dev",
+            "playwright-chromium"
+          ],
+          "description": "The engine and driver tried first."
+        },
+        "fallback": {
+          "type": "array",
+          "items": {
+            "type": "string",
+            "enum": [
+              "safari",
+              "playwright-webkit",
+              "chrome-dev",
+              "playwright-chromium"
+            ]
+          },
+          "description": "Tried in order when the primary fails to start or attach twice; a fallback is said in every receipt, never silent."
+        },
+        "storageState": {
+          "type": "string",
+          "description": "Path of the Playwright signed-in state file. A credential: it must sit outside the repository (design_gate.py browser refuses a path inside it)."
+        },
+        "limits": {
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "maxBrowsers": {
+              "type": "integer",
+              "minimum": 1,
+              "default": 2
+            },
+            "maxPages": {
+              "type": "integer",
+              "minimum": 1,
+              "default": 4
+            },
+            "maxServers": {
+              "type": "integer",
+              "minimum": 1,
+              "default": 1
+            },
+            "maxLoadRatio": {
+              "type": "number",
+              "minimum": 0.1,
+              "default": 1.0
+            }
+          },
+          "description": "What resource_guard.py enforces: browsers, pages and dev servers at once, and the load average per core over which a run waits."
+        }
+      }
     }
   },
   "definitions": {
@@ -180,6 +244,12 @@
               "minimum": 1,
               "default": 2,
               "description": "Releases per iteration, the first included; every corrective release after a post-release failure counts against it."
+            },
+            "maxAgents": {
+              "type": "integer",
+              "minimum": 1,
+              "default": 2,
+              "description": "Sub-agents running at once in one round (since 1.100.0). Each round's ledger carries `agents: <round> — <n>`, the most that ran together; waves.py finish fails a round over it. Two is the energy-saving default the operator set on 2026-10-22."
             }
           }
         }
@@ -235,7 +305,9 @@
           "type": "string",
           "minLength": 1,
           "pattern": "\\S",
-          "not": {"pattern": "[\\r\\n]"},
+          "not": {
+            "pattern": "[\\r\\n]"
+          },
           "description": "Optional single-line source locator (for example docs/DECISIONS.md:42) for the standing authorization covering the tag and its publication. A locator, not a grant: how it is read and verified lives in references/deploy-targets.md, When the release waits for an approval."
         },
         "approval": {

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

@@ -32,6 +32,7 @@ which is how a run says *I checked the browser* and means *I ran the unit tests*
 - Reading a look vs gating on one
 - "Tested in a browser" is three different claims
 - The visual half — pixels against intent, under a contract
+- The tester's browser: asked once, prepared, bounded, closed
 - Getting past a login, and past a backend
 - When the look finds something: debugging the spec that missed it
 - Evidence a reader can open
@@ -292,6 +293,33 @@ native screen's frames come from a simulator or a device (XCUITest snapshots, Co
 screenshot tests) and its accessibility from the platform's own audit; with neither, the
 native rows stay `NOT_RUN`, said in words.
 
+## The tester's browser: asked once, prepared, bounded, closed
+
+The design-tester ([`design-review.md`](design-review.md)) and every look use the browser the
+project recorded in `pipeline.json` → `browser`. When the block is absent, stage 0 asks the
+operator once: which browser the tests use (`safari` through `safaridriver`,
+`playwright-webkit`, `chrome-dev`, `playwright-chromium`) and the fallback order, WebKit first
+as above. The answer is recorded and never asked again in that project.
+
+- **Prepared session.** Safari reuses the operator's signed-in Safari through `safaridriver`
+  (Remote Automation enabled once: `sudo safaridriver --enable`, a human gate). Playwright
+  reuses `browser.storageState`, a file outside the repository (below). A sign-in, a one-time
+  code or a consent is named once; the steps behind it are NOT_RUN and the rest run.
+- **Fallback, said.** A driver that fails to start or attach twice yields to the next in
+  `browser.fallback`; every capture names its engine.
+- **Load.** `python3 scripts/resource_guard.py check` before starting and between scenarios:
+  exit 4 (load over cores × `limits.maxLoadRatio`, memory pressure, low disk) means wait, then
+  run with fewer pages.
+- **Caps and close.** Every process the run starts (browser, driver, dev server) is recorded
+  with `resource_guard.py record`, which refuses past `limits.maxBrowsers`, `maxPages`,
+  `maxServers`; at the end `resource_guard.py close` then `verify` prove nothing is left. The
+  operator's own windows are never recorded, so they are never touched.
+- **Where the ledger lives, and what to record.** `.task-pipeline/resources.json`, outside the
+  tracked tree. Record the process that stays alive (the browser, the server), not a launcher
+  that exits after starting it: a child reparented after its launcher died is not a
+  descendant any more, and `close` cannot find it. `record` refuses its own process, its
+  ancestors and pid 1; `close` never signals them.
+
 ## Getting past a login, and past a backend
 
 A surface behind auth is the usual reason a run skips the look. Both channels solve it,

package/plugins/task-pipeline/skills/task-pipeline/references/design-review.md

@@ -0,0 +1,64 @@
+# Design review: the interface, walked by its users, as a gate
+
+Load this when a node's brief names a `surface_class` other than `none`, at stage 3 (before
+build) and at stage 6 (after build), in a single run, a wave or a release iteration. The agent
+is [`../../../agents/design-tester.md`](../../../agents/design-tester.md); its gate is
+`scripts/design_gate.py`; its machine discipline is `scripts/resource_guard.py`; its browser is
+[`browser.md`](browser.md) → *The tester's browser*.
+
+## Contents
+
+- When it is owed
+- The test panel
+- The two passes and their gates
+- The budget, and where findings go
+- Degradation
+
+## When it is owed
+
+Every node that changes what a user sees or does. On `flagship`, `product` and `ad` it is a
+gate; on `internal` it is recommended and its report is checked for honesty, its coverage
+reported. A recorded refusal (`Design review: declined: <reason>` in the brief) passes; an
+unmentioned one does not. Waves and iterations owe it per UI node, never once per wave.
+
+## The test panel
+
+`docs/ux/test-panel.md`, owned by super-ux (`ux-foundation` → *The test panel*): ten portraits,
+each with **basis** (`evidence RE-NN` or `hypothesis`), **situation**, **goals**, **features**,
+**scenarios** (composite chains by `SCR-` id), **activation** (steps to first value, and where
+it drops), **retention** (trigger → action → reward → what brings it back) and **needs**
+(device, engine, locale, accessibility). The operator confirms it once; a later change of the
+product revises it. `python3 scripts/design_gate.py panel docs/ux/test-panel.md` gates it.
+
+A portrait marked `hypothesis` chooses what to test, never what to build: the super-ux rule
+that a synthetic persona is never evidence still holds.
+
+## The two passes and their gates
+
+| Stage | Pass | Reads | Gate |
+|---|---|---|---|
+| 3, before build | D, design | Figma frames (Figma MCP) or, without Figma, the scenario's mockups | `design_gate.py report <r> --class <c> --panel docs/ux/test-panel.md --scope <ids> --require design` exits 0 |
+| 6, after build | B, build | the running build in the recorded browser, each step captured, compared with its frame or mockup, the outcome read back | the same command with `--require build` exits 0, and `resource_guard.py verify` is clean |
+
+The checklist every step answers: `frame`, `primary_action`, `controls`, `focus`, `states`,
+`text_fit`, `outcome`: pass, fail, na or NOT_RUN with its reason. A failed item names its
+finding; a `breaks` finding names its failed item. NOT_RUN is never PASS.
+
+With Figma, pass D judges what the designer drew and pass B how it was built against it.
+Without Figma, pass D judges the mockups and pass B the build against them.
+
+## The budget, and where findings go
+
+One pass D and one pass B per surface per round; a re-review reads only the steps the fix
+touched; at most `run.finish.maxRounds` rounds ([`finish-line.md`](finish-line.md)). A finding
+in the scope goes to the builder (pass D: the designer); outside it, to the board with its
+evidence. The review never widens the iteration.
+
+## Degradation
+
+- **No panel**: NOT_RUN, and super-ux `ux-foundation` builds it; the gate does not pass on a
+  missing panel.
+- **No Figma and no mockup**: pass D reads the scenario text alone and says so in every row's
+  `frame` (`scenario text only`); a gated class owes a mockup next round.
+- **No browser channel**: pass B is NOT_RUN, the weaker claim recorded, never "tested".
+- **A sign-in wall**: the human gate is named once, the steps behind it NOT_RUN, the rest run.

package/plugins/task-pipeline/skills/task-pipeline/references/doctrine-map.md

@@ -60,6 +60,7 @@ Custom profiles use their own declared stages and doctrine, with the kernel inta
 | **first run · the entry audit** (offered once) | `references/setup.md` |
 | **what travels with the bundle vs stays in a project** | `references/portability.md` |
 | 0–10 · when an iteration stops — the contract fixed at intake, triage at discovery, the round budget | `references/finish-line.md` |
+| 3, 6 · the design review: the test panel walked over the design, then the build, in the recorded browser, bounded and closed | `references/design-review.md` |
 | any repeating loop | `references/loop-guard.md` |
 | run-wide · what the run **leaves running and leaves behind** — every gate, and stage 10 | `references/residue.md` |
 | run-wide · what the run **prints about itself** — the rail, the iteration line | `references/progress.md` |

package/plugins/task-pipeline/skills/task-pipeline/references/finish-line.md

@@ -24,9 +24,10 @@ fields, written at stage 0 and confirmed with the brief:
 - **Exit checks** — REQ ids, each with its command, run on the artefact the operator uses:
   released, installed or deployed. A branch is not that artefact.
 - **Scope** — the modules, paths and REQ ids this iteration may change, as a list.
-- **Budget** — `run.finish.maxRounds` (default 3) and `run.finish.maxReleases` (default 2),
-  from `pipeline.json` ([`../pipeline.schema.json`](../pipeline.schema.json)), and
-  `run.finish.cleanRounds`: 1, or 2 when the iteration carries an R3 or flagship node.
+- **Budget** — `run.finish.maxRounds` (default 3), `run.finish.maxReleases` (default 2) and
+  `run.finish.maxAgents` (sub-agents at once, default 2, since 1.100.0), from `pipeline.json`
+  ([`../pipeline.schema.json`](../pipeline.schema.json)), and `run.finish.cleanRounds`: 1,
+  or 2 when the iteration carries an R3 or flagship node.
 - **Base** — the commit the iteration started from.
 
 Widening the scope is a recorded revision of the brief, with the operator's go. A finding is
@@ -92,8 +93,13 @@ finding to count:
 
 ```
 round: <N> — <reading> — new blocking <k>
+agents: <N> — <most sub-agents running at once in round N>
 ```
 
+Every run computes its verdict, not only a wave: a single run's inventory is its one node
+(`waves.py finish --inventory`), and a person checks the same three numbers the script read:
+rounds n/max, agents n/max, exit checks k/m on the named artefact.
+
 ## Computing the verdict
 
 ```

package/plugins/task-pipeline/skills/task-pipeline/references/loop-guard.md

@@ -43,6 +43,11 @@ One line per file per pass. The reason must name **what forced the edit** — a
 finding id, a failed gate item, an operator instruction. "Cleanup", "polish" and
 "while I was there" are not reasons; they are churn with better manners.
 
+Fan-out is bookkept too (since 1.100.0): each round writes `agents: <N> — <k>`, the most
+sub-agents that ran at once in it. `waves.py finish` charges the peak against
+`run.finish.maxAgents` (2 by default), so a loop that tries to escape its round budget by
+spawning wider is stopped by the same verdict ([`finish-line.md`](finish-line.md)).
+
 **This ledger was required here from the day the file shipped and written by no run
 until 2026-08-10.** The detection below calls itself mechanical; with no ledger it had
 no input at all, so the guard sat on rung 1 while every reader took it for rung 3

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

@@ -96,6 +96,7 @@ a row pointing outside the bundle is the defect this file exists to catch.
 | **Effect verification** — the `verified-by:` contract and the rubric item that blocks | `references/build.md`, `references/review.md` |
 | The TDD iron law and the suite gate | `references/tdd.md` |
 | How the browser look is taken, and how a spec suite sits beside it | `references/browser.md` |
+| How the design review walks the test panel over the design, then the build, bounded and closed | `references/design-review.md` |
 | The REQ coverage table, evidence rules, the closing question | `references/acceptance.md` |
 | How the host project's own conventions are read | `references/conventions.md` |
 | Which companions exist, what is required, self-currency | `references/companion-skills.md` |

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

@@ -205,6 +205,10 @@ narrative are how a capped list grows anyway.
   `Because`) **verbatim** into the quarter's archive, each block carrying the sha256 of
   its text, and leaves a pointer; `retro_budget.py verify` proves every pointer. An
   instruction still over 600 characters after its story moved is rewritten by hand.
+  An older retro whose standing instructions are a numbered list and whose stamps are
+  `- **date: title**` items is read the same way: the item keeps its bold rule and its
+  `*(Retire ...)*` trigger, a stamp keeps its title, stamps past the cap rotate out by date,
+  and, over budget, the Run stamps section's loose prune paragraphs move.
 - **A prune that retires nothing writes its count into the stamp row**, as
   `prune: 0 retired`, and no paragraph. Repeated "nothing to prune" notes were a
   measured share of the floor.

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

@@ -110,7 +110,9 @@ never that the work was skipped quietly.
   harvested source has a recorded resolution** (which governs, and whether the doc
   is now stale), no open contradictions, **every
   autonomy-sweep row is answered or explicitly marked "stop and ask here"**, **a
-  user-facing task's brief names its `surface_class`**, the
+  user-facing task's brief names its `surface_class`**, and on any class but `none`
+  **the project's test browser is recorded** (`pipeline.json` → `browser`, asked once,
+  [`browser.md`](browser.md) → *The tester's browser*), the
   **REQ table is written and every row names its check**, **the brief's `## Finish line`
   is filled — objective, exit checks on the artefact the operator uses, scope, budget and
   base** ([`finish-line.md`](finish-line.md)), the carry-over ledger is
@@ -192,6 +194,11 @@ never that the work was skipped quietly.
   validator reads **NOT_RUN** beside the verdict — never PASS — and the gate stands on
   the floor, said so. A record saying `Mode: declined` with its reason is the refusal,
   and it passes.
+  **And the design review's pass D ran over the design before build** (since 1.100.0):
+  the `design-tester` walked the test panel through the changed scenarios over the Figma
+  frames or mockups, and `python3 scripts/design_gate.py report <design-review.json>
+  --class <surface_class> --panel docs/ux/test-panel.md --scope <SCR ids> --require design`
+  exits 0 ([`design-review.md`](design-review.md)).
   **Where both tracks ran, their convergence check is recorded** — findings with the
   ruling, or `Tracks converge: clean`; a screen where each track is right alone and they
   disagree together is the defect neither track's own review can see.
@@ -298,6 +305,10 @@ never that the work was skipped quietly.
   **one, two at most**, then `unresolved` to the person — never round three — and only
   external, specific feedback starts a round. The procedure and the order of the checks:
   [`browser.md`](browser.md) → *The visual half*.
+  **On any class but `none` the design review's pass B ran over the build** (since
+  1.100.0): the same `design_gate.py report` with `--require build` exits 0, every capture
+  names its engine, and `python3 scripts/resource_guard.py verify <ledger>` is clean
+  ([`design-review.md`](design-review.md)).
 - **What the look finds is fixed here.** A rendering defect found at stage 6 is a
   stage-6 finding: fix it, look again, then call the stage green. Filing it to the
   board and advancing is how a run reports *checked in a browser* for a page it has
@@ -390,7 +401,9 @@ never that the work was skipped quietly.
   options rather than listed**, and the ambiguity count computed from the four
   registers with its ids ([`progress.md`](progress.md) → *The hand-back*) — a run
   that cannot say what happened has not finished, it has stopped; **the `finish:` line is
-  printed beside this verdict — `done`, `budget` or `blocked`, with its block**
+  printed beside this verdict — `done`, `budget` or `blocked`, with its block** and
+  computed, in every run and not only in waves, by `scripts/waves.py finish` over this
+  run's ledger, which also fails a round whose `agents:` line exceeds `maxAgents`
   ([`finish-line.md`](finish-line.md) → *The finish block*); **the environment is
   given back** — all eight classes enumerated, everything this run started ended and
   verified by re-enumerating rather than by the teardown's reply, an earlier run of

package/plugins/task-pipeline/skills/task-pipeline/scripts/backlog_sources.py

@@ -12,9 +12,8 @@ the list the harvest works from.
 The rule a user of this skill reads is the shipped schema template,
 `templates/backlog-sources.schema.json` (backlog-sources/1), with `references/backlog.md` →
 *A declared source list*; this checker enforces it, plus the two rules a schema cannot state
-(a regular file reached through no symlink, no duplicate declaration). The Fabric workspace's
-`knowledge/backlog.md` (section *Source contract*; read at fabric-workspace d49b6f58,
-2026-10-08) is its provenance: the template is compatible with it, with one deliberate
+(a regular file reached through no symlink, no duplicate declaration). Fabric's
+`knowledge/backlog.md` (its *Source contract* section, read on 2026-10-08) is its provenance: the template is compatible with it, with one deliberate
 widening — `repository` may be any `https://github.com/<owner>/<repo>`, because this skill runs
 outside one organisation.