task-pipeline-skill 1.96.0 → 1.98.0

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

@@ -160,13 +160,20 @@
         "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.",
+          "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 a 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,
+              "minimum": 1,
               "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."
+              "description": "Finish-line rounds per iteration, at least cleanRounds: done needs that many consecutive rounds with no new blocking finding. Rotating the audit axis happens inside this budget and never adds a round."
+            },
+            "cleanRounds": {
+              "type": "integer",
+              "minimum": 1,
+              "maximum": 2,
+              "default": 1,
+              "description": "Consecutive rounds with no new blocking finding that end the iteration: 1, or 2 when it carries an R3 or flagship node (since 1.98.0; two for every iteration was the default before). Passed to waves.py finish as --clean-rounds."
             },
             "maxReleases": {
               "type": "integer",

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

@@ -20,7 +20,7 @@ requirement.** It is what turns the pipeline from a funnel into a circle.
 - The retrospective — the run's last act
 - A `verified by` name is a claim until it resolves
 - A seam is not a deliverable, and REQ rows are written against deliverables
-- GATE (manual)
+- GATE (auto)
 - When the answer is "something's missing"
 - A project of several repositories
 
@@ -329,7 +329,7 @@ client write on the other — the table says so under `unlooked` rather than sho
 green rows. Two green halves reporting a working whole is exactly the shape this file
 spends its length refusing.
 
-## GATE (manual)
+## GATE (auto)
 
 > **Acceptance policy `AP-1` · owner: the operator of the project running this pipeline ·
 > in force since 2026-08-20 · supersedes: the unversioned ladder that stood before it.**

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

@@ -22,7 +22,7 @@ approved design — not at code.
 - UI detection — a required output
 - The approved design is a set of decisions — record them
 - User paths are a design output, not a spec detail
-- GATE (manual)
+- GATE (auto)
 - Rationalizations
 
 ## The hard gate
@@ -139,9 +139,9 @@ Feed them into [`spec.md`](spec.md)'s UX track — super-ux turns them into flow
 screens and traced scenarios. **Do not draft scenario IDs here**; that is the
 chain's job, and two sources for one scenario is worse than one.
 
-## GATE (manual)
+## GATE (auto)
 
-The operator approves the design, **the UI verdict is recorded**, and — where that verdict is *yes* — **the paths, the states and the error paths are named** (above) rather than deferred to the spec. **Every REQ in the brief is answered by the design** — a requirement the design doesn't address
+The design is approved (the operator's go, or the standing authorization recorded in the brief; `auto` by default since 1.98.0), **the UI verdict is recorded**, and — where that verdict is *yes* — **the paths, the states and the error paths are named** (above) rather than deferred to the spec. **Every REQ in the brief is answered by the design** — a requirement the design doesn't address
 is either covered now or explicitly dropped by the operator, with the drop written
 into the carry-over ledger. For a platform, the module map
 ([`decomposition.md`](decomposition.md)) is committed and approved as part of this

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

@@ -12,7 +12,9 @@ which is how a run says *I checked the browser* and means *I ran the unit tests*
 > **Every command and flag below was read from the tool's own `--help`**, not from a
 > vendor page. Where the two disagreed, `--help` won and the page was wrong — see
 > *Rationalizations*. Re-derive before quoting:
-> `npx @playwright/cli@latest --help` and `npx @playwright/mcp@latest --help`.
+> `npx @playwright/cli@latest --help` and `npx @playwright/mcp@latest --help`. The
+> `--browser webkit` flag on both was last read from `@playwright/cli` 0.1.22 (`open
+> --help`) and `@playwright/mcp` 0.0.83 on 2026-10-16.
 >
 > **Use the scoped name with `npx`.** `npx playwright-cli --help` fails outside a project
 > that has already installed it (`could not determine executable to run`), and the bare
@@ -23,6 +25,7 @@ which is how a run says *I checked the browser* and means *I ran the unit tests*
 
 ## Contents
 
+- Engine order — WebKit (Safari) first
 - The one model: a tree, and a ref
 - The look, as commands you can run
 - Sessions, and why an agent needs them
@@ -35,6 +38,35 @@ which is how a run says *I checked the browser* and means *I ran the unit tests*
 - What the channel can reach — the part a recommendation owes you
 - Rationalizations
 
+## Engine order — WebKit (Safari) first
+
+**Check a rendered surface in WebKit first** (`DEC-0007`). The channel is how a look
+arrives; the engine is what renders it, and the two are separate choices:
+
+| Need | WebKit route — the default |
+|---|---|
+| A real browser | Safari itself, through `safaridriver` (WebDriver; enable it once with `sudo safaridriver --enable`) |
+| Automation, the look | Playwright's `webkit`: `playwright-cli open --browser webkit <url>`, the MCP started with `--browser webkit`, a `webkit` project in `playwright.config.*`. Install the engine with `playwright-cli install-browser webkit` or `npx playwright install webkit` |
+| Debugging | Safari Web Inspector |
+| A page for a person, on macOS | `open -a Safari <url>` — never bare `open <url>`, which hands the page to the system default browser, and the default may be another browser |
+| An automation library (browser-use and the like) | its WebKit or Safari backend, where it has one |
+
+Name the engine every time. Without `--browser`, the CLI falls back to a Chromium-family
+browser (read from its own bundle, 0.1.22, not from `--help`) — so a recipe that leaves
+the flag off has chosen Chromium without saying so. Playwright's `webkit` is the engine,
+not Safari itself: a question about Safari's own behaviour goes to `safaridriver`.
+
+**Chromium is a stated fallback, never the default.** Use it only when the task needs
+Chrome itself — a Chrome-only API, Lighthouse, a CDP performance trace, a heap snapshot,
+the `chrome-devtools` MCP — and say which and why in the verdict. Prefer the Chrome Dev
+build for that. When you launch your own Chrome or Chromium for a UI run, give it a
+temporary profile (never the user's), record what you started, and close every process
+you started before you finish ([`residue.md`](residue.md)).
+
+**A surface checked only in Chromium is reported as exactly that** — *"checked in
+Chromium (`chrome-devtools`, for `lighthouse_audit`)"*, never *"tested in a browser"*.
+The engine is part of the claim, the same way the command is.
+
 ## The one model: a tree, and a ref
 
 **Both channels drive the page through its accessibility tree, not its pixels.** You ask
@@ -68,14 +100,15 @@ The pipeline asks for the same four things every time: **open it, snapshot it, r
 console, read the network.** In the CLI that is literally four commands:
 
 ```bash
-playwright-cli open http://localhost:3000/checkout
+playwright-cli open --browser webkit http://localhost:3000/checkout
 playwright-cli snapshot
 playwright-cli console warning     # min-level: only warnings and errors
 playwright-cli requests            # then: request <n> for headers, body, response
 ```
 
 The MCP is the same four moves under different names: `browser_navigate`,
-`browser_snapshot`, `browser_console_messages`, `browser_network_requests`.
+`browser_snapshot`, `browser_console_messages`, `browser_network_requests` — on WebKit
+when the server was started with `--browser webkit`.
 
 **Quote what you read, not that you looked.** *"Console clean, all requests fine"* is a
 claim. *"`console warning` → empty; `requests` → no status ≥ 400"* is the same claim with
@@ -87,8 +120,9 @@ resources by default and says so in its own footer (*"N static request(s) not sh
 appears without the flag — so *no status ≥ 400* is a safe claim and *14 requests* is not.
 
 `chrome-devtools` takes the identical four moves — `navigate_page`, `take_snapshot`,
-`list_console_messages`, `list_network_requests` — which is why the matrix ranks neither:
-the look is the same look.
+`list_console_messages`, `list_network_requests` — but only in Chrome. The moves are the
+same look; the engine is not, so for the look it is the **stated Chromium exception**,
+reached for when the question needs Chrome (*Engine order*, above).
 
 ## Sessions, and why an agent needs them
 
@@ -130,17 +164,17 @@ commonest way a run reports a green it does not have.
 |---|---|---|---|
 | **The look** | an agent driving a page: open, snapshot, console, network | that this surface renders, right now, and what the browser said while it did | the **functional look**, stage 6 — recommended, never a gate. Its **visual half** is a gate on a `flagship`, `product` or `ad` surface — *The visual half*, below |
 | **The spec suite** | `playwright test` — the **test runner** | that the assertions someone wrote still hold, on the paths someone thought to write | the **suite** half of the stage-6 gate, counted with every other test |
-| **The library** | `require('playwright')` — `chromium`/`firefox`/`webkit`, `devices`, `request`, `selectors` | whatever your own script asserts; it is an automation API, not a test framework | wherever the project already runs it |
+| **The library** | `require('playwright')` — `webkit`/`chromium`/`firefox`, `devices`, `request`, `selectors` | whatever your own script asserts; it is an automation API, not a test framework | wherever the project already runs it |
 
-The library and the runner are **separate APIs** — a script built on `chromium.launch()`
+The library and the runner are **separate APIs** — a script built on `webkit.launch()`
 has no `expect`, no fixtures, no reporter, and no retry. Choosing the library where a
 runner was wanted is how a project ends up with a bespoke half-runner nobody trusts.
 
 The minimal library shape, for reading a script that already exists:
 
 ```js
-const { chromium } = require('playwright');
-const browser = await chromium.launch();
+const { webkit } = require('playwright');
+const browser = await webkit.launch();
 const page = await browser.newPage();
 await page.goto('http://example.com');
 await browser.close();
@@ -186,7 +220,8 @@ the close-out — the same rule as every other refusal in the pipeline.
 
 1. **Deterministic.** The project linter — `python3 scripts/visual_gate.py lint <dir>`,
    which runs sheleg-design's `--lint` where it is installed and answers **NOT_RUN (exit 3)**
-   where it is not — plus axe or Lighthouse, the token check, the type checker. An S1
+   where it is not — plus axe or Lighthouse (the stated Chromium exception), the token
+   check, the type checker. An S1
    finding blocks, whatever anyone says about the picture later. **With Figma on, the
    token check includes the drift probe**: `python3 scripts/visual_gate.py tokens
    --figma <variables.json> --css <tokens.css>` compares the variable names exported
@@ -266,7 +301,7 @@ and neither needs a password in a transcript.
 
 ```bash
 mkdir -p .auth                                  # state-save does not create it
-playwright-cli open https://app.example.com/login
+playwright-cli open --browser webkit https://app.example.com/login
 #  … sign in by hand, or drive the form …
 playwright-cli state-save .auth/state.json      # cookies + localStorage
 playwright-cli state-load .auth/state.json      # every later look starts signed in
@@ -387,4 +422,6 @@ On a CI box, headed is the failure you will spend an hour on.
 | *"The tool list is in the docs."* | The page listed tools this version does not ship, and omitted that tracing, video and PDF need `--caps`. Ask the server: 24 tools default, 42 with all caps. |
 | *"It's behind a login, so the look isn't possible."* | `state-save` / `state-load`, or `--storage-state`. Auth is a solved step, not an exemption. |
 | *"No browser channel is installed, so the step doesn't apply."* | The step still applies; the claim weakens. Say *verified by reading the diff* and let the close-out record it as the weaker claim it is. |
+| *"Tested in a browser."* | Which engine? A look taken only in Chromium is reported as *checked in Chromium*, with the reason Chrome was needed. WebKit is the default (*Engine order*). |
+| *"I opened it with `open <url>`."* | That is the system default browser, which may not be Safari. `open -a Safari <url>` for a person; `--browser webkit` for automation. |
 | *"I closed the browser."* | `list` is the evidence. The command you typed is not the state you left ([`residue.md`](residue.md)). |

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

@@ -176,7 +176,7 @@ overall.
 - **The final whole-branch review.** If the run is on a tier below the most capable
   one available, say so and offer to run this one review there; if the operator
   declines or the tier doesn't exist, run it on the confirmed model and note it.
-- **Fix-loop rounds 4–5.** One tier above the implementer that got stuck, when the
+- **Fix-loop round 3.** One tier above the implementer that got stuck, when the
   environment has one and the override map or the operator allows it; otherwise
   say so and rely on fresh eyes alone.
 
@@ -407,7 +407,7 @@ may say what the reviewer actually saw, and a syntax lint recorded as a blind
 review is refused by `certify` by name.
 
 **The boundary with certification:** this review closes a **prose-plan task** —
-one reviewer, the five-round cap of §4.5. A **work-graph node** is closed by the
+one reviewer, the three-round cap of §4.5. A **work-graph node** is closed by the
 three blind tiers and `graph.py certify` instead
 ([`certification.md`](certification.md), ceiling 3); the artifact the queue is —
 plan or graph — decides which protocol closes the work, never whichever is
@@ -444,7 +444,7 @@ Two routes leave before the loop starts:
   without asking.
 
 Everything else loops. One round = one fix dispatch + one scoped re-review.
-**Five rounds maximum per task.**
+**Three rounds maximum per task**, then the open findings become blocker rows and the run moves on.
 
 **The loop guard runs alongside the counter** ([`loop-guard.md`](loop-guard.md)):
 log every repeat touch (`touch: <file> — round N — reason: <finding id>`) and trip
@@ -453,13 +453,13 @@ the same reason, or when a finding already ADDRESSED reappears. A tripped guard
 not another round: stop, name the two shapes, escalate to the layer that owns the
 conflict, then re-check in a planned order.
 
-- **Rounds 1–3:** resume the original implementer with the open findings verbatim —
+- **Rounds 1–2:** resume the original implementer with the open findings verbatim —
   its context is intact. If the harness can't message a live subagent, dispatch a
   fresh one with the brief path, the report path and the findings; the report file
   is the persistent memory either way.
-- **Rounds 4–5:** fresh implementer, one tier up if available, framed as: "a prior
+- **Round 3:** fresh implementer, one tier up if available, framed as: "a prior
   implementer attempted this task N times; you own it now — read the report file
-  for what was tried." A loop that survives three resumes usually means the
+  for what was tried." A loop that survives two resumes usually means the
   implementer can't see its own problem.
 - **Every round:** the implementer fixes, re-runs the tests covering the amended
   code, appends its fix report to the same report file, returns the short contract.
@@ -471,7 +471,7 @@ conflict, then re-check in a planned order.
   breakage joins the open list; out-of-scope observations go to the ledger as
   deferred minors — they never extend the loop.
 - **Ledger, every round:**
-  `Task <N>: fix round <R>/5 (<X> addressed, <Y> open — <one-liners>; commits <a7>..<b7>)`
+  `Task <N>: fix round <R>/3 (<X> addressed, <Y> open — <one-liners>; commits <a7>..<b7>)`
 
 **In a subagent run, never fix findings yourself in the controller session** —
 controller fixes skip review and pollute the context you need for coordination. In a

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

@@ -2,12 +2,15 @@
 
 A node is not closed by one agent's opinion. It is closed by **three independent
 readings at escalating visibility**, and the run may not advance until all three
-pass.
+pass. **The cost follows the risk** (since 1.98.0): an **R1** node certifies with **one**
+blind tier (`unit` by default; `graph.py certify` accepts any one of the three), and a
+clean round ends a node unless it is **R3 or a flagship surface** (*Rounds owed by risk
+class*, below).
 
 **The boundary: this closes a node of the work graph.** Where the queue is a
 prose plan rather than a graph, a task closes through the per-task review instead
 ([`build.md`](build.md) §4.4 and [`review.md`](review.md) — one reviewer, a
-five-round fix loop with an explicit breaker). Two closure protocols with no
+three-round fix loop with an explicit breaker). Two closure protocols with no
 boundary sentence were how a run picked whichever was cheaper; the artifact the
 queue is — graph or plan — is what decides, not the mood of the closer.
 
@@ -208,14 +211,18 @@ erase the only evidence that a node is churning.
 
 The cycle is: `certify` → fail → the `breaks` findings become nodes (each already
 carrying its `check`) → fix → `certify` again, round `N+1`. Same three tiers, same
-blind dispatch. A tier that passed in an earlier round is **re-run**, because the
-fix is a new change and the level it passed on is not the level it now faces.
-
-**At the ceiling the gate measures rather than stops** —
-[`loop-guard.md`](loop-guard.md). `--ceiling` defaults to 3. At or over it, `certify`
-still runs and still reports the tiers; what it adds is the name of the tier that
-has failed **every** round. A run spinning on one level needs the operator to see
-*which* level:
+blind dispatch. A tier that passed in an earlier round is **re-run** after a fix,
+because the fix is a new change. **It is never re-run on unchanged input:** `certify`
+records the tree each round read and refuses a round of the same kind on the same
+tree, before writing anything. A tier's second answer about a tree it already read is
+its first answer again, and asking twice is the loop.
+
+**At the ceiling the gate STOPS** ([`loop-guard.md`](loop-guard.md), since 1.98.0).
+`--ceiling` defaults to 3 failing rounds. The round that reaches it still reports the
+tiers, names the tier that has failed **every** round, and then **parks the node** with
+the evidence (failing tiers, the first break and its check) as its reason, exit `7`.
+The run records a blocker row with that evidence and moves on to the next node. It
+used to measure only, and a loop that is measured is still a loop:
 
 - the same tier every round → the level is being misread, or the node is the wrong
   shape. Not one fix away. Re-plan the node, do not attempt another failing round. (An R3
@@ -227,30 +234,29 @@ has failed **every** round. A run spinning on one level needs the operator to se
 
 In a release iteration a node carries `risk` (R1–R3, [`work-graph.md`](work-graph.md);
 [`iteration.md`](iteration.md) → *Verification starts when a node lands*), and the class
-decides how many **passing** rounds the node owes before `close` accepts it: **R1 one, R2
-two, R3 three, of which one is adversarial.** A round is the three blind tiers (four on a
-flagship or product surface) plus one fix cycle. `graph.py certify` prints `round N: k of M
-owed passing rounds — not closable yet` until the count is met (`k of M owed passing rounds —
-closable` once it is), and `graph.py close` refuses
-the verdict until then. **Only passing rounds count** — a round passes when every tier
-passes, read from `certification.history` — and, for R3, one of the passing rounds must be
-one recorded with `--kind adversarial`
-(`certification.kinds`, one entry per round). A node with a `risk` and no certification at
-all is refused by `close` too: its class owes at least one round.
+decides how many **passing** rounds the node owes before `close` accepts it: **R1 one
+(with one blind tier), R2 one, R3 two, of which one is adversarial.** A node on a
+**flagship** surface owes two as well, one of them adversarial, whatever its class. A
+round is the blind tiers the class owes (three; four on a flagship or product surface;
+one on R1) plus one fix cycle. `graph.py certify` prints `round N: k of M owed passing
+rounds — not closable yet` until the count is met (`k of M owed passing rounds —
+closable` once it is), and `graph.py close` refuses the verdict until then. **Only
+passing rounds count**, read from `certification.history`, and for R3 or a flagship one
+of them must be recorded with `--kind adversarial` (`certification.kinds`). A node with
+a `risk` and no certification at all is refused by `close` too. R2 owed two blind
+rounds until 1.98.0, and a clean round did not cancel the next: the second reading of
+an unchanged diff found nothing it had not already been asked.
 
 **What a round after a clean round reads.** The node's **whole diff at the new HEAD** — not
-the fix diff alone, and not the previous round's reports. A clean round proves the tree it
-read; the next owed round asks the same three distances again of the whole change as it
-stands, so a defect the first reading accepted has a second chance to be seen from a fresh
-context.
-
-**Owed rounds and the ceiling are different counts.** `--ceiling` measures churn: how many
-rounds a node has *failed*, and which tier keeps failing. An R3 node that owes three rounds
-and passes them is not "at round four" of anything; its owed rounds are the plan, and the
-ceiling's warning is about failing rounds beyond what the class owes. Read the ceiling's
-output only when rounds fail.
-
-**The adversarial round** (one of R3's three, on another model where one is available):
+the fix diff alone, and not the previous round's reports. On an unchanged tree the only
+round that may follow a clean one is the other kind: the adversarial round asks a
+different question of the same change.
+
+**Owed rounds and the ceiling are different counts.** `--ceiling` counts *failing*
+rounds and stops the node at the limit; owed rounds count *passing* ones. An R3 node
+that passes its two is not near any ceiling.
+
+**The adversarial round** (one of R3's two, on another model where one is available):
 1. **Plant defects in the change** — off-by-one in a limit, an inverted check, a dropped
    error path — and require the node's own checks to fail on each. A plant that passes is a
    finding against the check, not against the plant.
@@ -261,19 +267,18 @@ output only when rounds fail.
 3. **Try the abuse cases** a caller outside the trust boundary would: inputs at and past
    every bound, replays, a revoked identity, an out-of-order sequence.
 
-It is a different question, not a stricter reading: on 2026-10-12 one iteration's third
-round on a spend-limits node found three breaks of a money invariant that two blind rounds
-had passed. Record it with `certify --kind adversarial`.
+It is a different question, not a stricter reading: on 2026-10-12 one iteration's
+adversarial round on a spend-limits node found three breaks of a money invariant that two
+blind rounds had passed. That is why R3 keeps it and drops the second blind round. Record it with `certify --kind adversarial`.
 
 ## What this costs, said out loud
 
-Three agents per node instead of one — four on a flagship or product surface. That is
-the price of the visibility, and it is paid per node rather than per run. The three are dispatched in parallel, so the
-wall-clock cost is roughly one reading; the token cost is three. A node whose
-`check` is mechanical and whose blast radius is genuinely nil still pays it — and a
-tier with nothing to find says so in `scope` and `not_examined` rather than being
-skipped, because **a skipped level and a clean level are indistinguishable
-afterwards**, and only one of them is evidence.
+Three agents per node instead of one, four on a flagship or product surface, one on R1.
+The tiers are dispatched in parallel, so the wall-clock cost is roughly one reading and
+the token cost is the tier count. Where a tier runs and finds nothing it says so in
+`scope` and `not_examined`, because **a skipped level and a clean level are
+indistinguishable afterwards**. What the class does not owe is not run: an R1 node's
+second and third tiers are not skipped levels, they are levels its risk never reached.
 
 ## Rationalizations
 
@@ -281,5 +286,5 @@ afterwards**, and only one of them is evidence.
 |---|---|
 | «All three would say the same thing» | Then all three say it, at a cost you already know, and the run has three signatures instead of one guess about what the other two would have found |
 | «The seam tier can read the unit report first — it saves tokens» | It saves tokens by removing the second opinion. The reports are cheap; the independence is the product |
-| «Tier 3 passed last round, skip it» | The fix is a new change. A tier's pass is about the tree it read, and that tree moved |
-| «Round 4 will get it» | Read the ceiling's output. The same tier failing three times is a planning defect wearing a verification failure's clothes |
+| «Tier 3 passed last round, skip it» | The fix is a new change. A tier's pass is about the tree it read, and that tree moved. On an unchanged tree the round is refused instead |
+| «Round 4 will get it» | There is no round 4: the ceiling parks the node with its evidence. The same tier failing three times is a planning defect wearing a verification failure's clothes |

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

@@ -27,6 +27,10 @@ one must never look alike.
 > **`DEC-0006`** scopes that to the functional look: the **visual half** is a gate on a
 > `flagship`, `product` or `ad` surface, and its absent tool reads NOT_RUN and stops to
 > ask rather than passing ([`browser.md`](browser.md) → *The visual half*).
+> **`DEC-0007`** ranks the **engine**, not the channel's quality: WebKit (Safari) first,
+> Chromium a stated exception. `playwright` reaches WebKit and `chrome-devtools` does
+> not, so `playwright` on WebKit is the default look and `chrome-devtools` is reached for
+> when the question needs Chrome ([`browser.md`](browser.md) → *Engine order*).
 
 ## Contents
 
@@ -70,8 +74,8 @@ one must never look alike.
 | **Figma** (MCP) | stage 3 UX track, when the project designs visually — super-ux mirrors each `SCR-` screen/state into a frame | Optional, **UI + Figma-on only**. Absent → super-ux degrades to text-only *by itself and never blocks*, so shipping a UI feature with no mockups becomes a silent scope call — which is why the stage-0 sweep decides it | connect the Figma MCP server (`/mcp`, or your claude.ai connectors) |
 | **[obsidian-wiki](https://github.com/ar9av/obsidian-wiki)** (`wiki-query`, `wiki-update`) | **stage 0 harvest** (query what's already known) **+ stage 9 sync** | **Recommended** — never a gate; absent → harvest runs on repo docs alone | `pip install obsidian-wiki` → `obsidian-wiki setup --vault /path/to/your/vault` |
 | **[graphify](https://github.com/Graphify-Labs/graphify)** (`/graphify`, `graphify query`, `graphify affected`, `graphify god-nodes`) | **stage 0 harvest** (reach: what calls this, what breaks if it moves) **+ stage 9 refresh + the graph↔docs divergence check** ([`knowledge-graph.md`](knowledge-graph.md)) | **Recommended** — never a gate; absent → the harvest greps instead, and the divergence axis is unavailable | `uv tool install graphifyy` → `graphify install` → `/graphify .` |
-| **playwright** (CLI — `playwright-cli open`, `snapshot`, `click`, `type`, and the two this pipeline actually asks for: `console` and `requests`; or MCP — `browser_navigate`, `browser_snapshot`, `browser_click`, `browser_console_messages`, `browser_network_requests`) | **stages 5–6 on any project with a web front end**, and **stage 8** on a deployed target — the same job as the row below: open the surface, snapshot it, read the console and the network log. Its own difference is **the channel a look arrives on**: the CLI is a shell command, so it does not put a tool schema in the context window the way an MCP channel does — that is upstream's own comparison and it is *CLI against MCP*, which makes it a claim about this row's own two halves before it is a claim about the row below. Both channels default to an **accessibility-tree snapshot rather than pixels**, so the ordinary look costs a page of text and no vision model; `screenshot` exists in both and costs one when you ask for it | **Recommended** — never a gate; absent → say the surface was verified **by reading the diff** and treat that as the weaker claim it is | CLI: `npm install -D @playwright/cli@latest` → `npx playwright-cli --help` (or `npm i -g` for the global binary; `playwright-cli install --skills` adds its agent skills, `--global` to the home directory). MCP: `claude mcp add playwright npx @playwright/mcp@latest` |
-| **chrome-devtools** (MCP — `list_pages`, `navigate_page`, `take_snapshot`, `take_screenshot`, `evaluate_script`, `list_console_messages`, `list_network_requests`, `lighthouse_audit`, `performance_start_trace`, `take_heapsnapshot`) | **stages 5–6 on any project with a web front end** — verify the **rendered** surface rather than the diff: computed layout, console errors, failed requests. **Stage 8** on a deployed web target: load the page and read what the browser did, not what the deploy said. Its own difference is **reach past the page**: a Lighthouse category (`lighthouse_audit`, which `seo-aeo-audit` builds on) and a heap snapshot have no equivalent in the row above. A performance trace has one — `playwright-cli tracing-start` records one — but only this row's arrives with `performance_analyze_insight` over it | **Recommended** — never a gate; absent → say the surface was verified **by reading the diff** and treat that as the weaker claim it is | `/plugin install chrome-devtools-mcp@claude-plugins-official` (or connect the MCP server directly) |
+| **playwright** (CLI — `playwright-cli open`, `snapshot`, `click`, `type`, and the two this pipeline actually asks for: `console` and `requests`; or MCP — `browser_navigate`, `browser_snapshot`, `browser_click`, `browser_console_messages`, `browser_network_requests`) | **The default route — WebKit first** (`DEC-0007`): `playwright-cli open --browser webkit`, or the MCP started with `--browser webkit`; on macOS, Safari itself through `safaridriver` and Safari Web Inspector to debug ([`browser.md`](browser.md) → *Engine order*). **Stages 5–6 on any project with a web front end**, and **stage 8** on a deployed target — the same job as the row below: open the surface, snapshot it, read the console and the network log. Its own difference is **the channel a look arrives on**: the CLI is a shell command, so it does not put a tool schema in the context window the way an MCP channel does — that is upstream's own comparison and it is *CLI against MCP*, which makes it a claim about this row's own two halves before it is a claim about the row below. Both channels default to an **accessibility-tree snapshot rather than pixels**, so the ordinary look costs a page of text and no vision model; `screenshot` exists in both and costs one when you ask for it | **Recommended** — never a gate; absent → say the surface was verified **by reading the diff** and treat that as the weaker claim it is | CLI: `npm install -D @playwright/cli@latest` → `npx playwright-cli --help` (or `npm i -g` for the global binary; `playwright-cli install --skills` adds its agent skills, `--global` to the home directory), then `playwright-cli install-browser webkit`. MCP: `claude mcp add playwright -- npx @playwright/mcp@latest --browser webkit` |
+| **chrome-devtools** (MCP — `list_pages`, `navigate_page`, `take_snapshot`, `take_screenshot`, `evaluate_script`, `list_console_messages`, `list_network_requests`, `lighthouse_audit`, `performance_start_trace`, `take_heapsnapshot`) | **The stated Chromium exception** — it drives Chrome only, so it is reached for when the question needs Chrome, said with the reason, and a look taken only here is reported as *checked in Chromium*. **Stages 5–6 on any project with a web front end** — verify the **rendered** surface rather than the diff: computed layout, console errors, failed requests. **Stage 8** on a deployed web target: load the page and read what the browser did, not what the deploy said. Its own difference is **reach past the page**: a Lighthouse category (`lighthouse_audit`, which `seo-aeo-audit` builds on) and a heap snapshot have no equivalent in the row above. A performance trace has one — `playwright-cli tracing-start` records one — but only this row's arrives with `performance_analyze_insight` over it | **Recommended** — never a gate; absent → say the surface was verified **by reading the diff** and treat that as the weaker claim it is | `/plugin install chrome-devtools-mcp@claude-plugins-official` (or connect the MCP server directly) |
 | **[agent-sync](https://github.com/ssheleg/agent-sync)** (`/agent-sync`, **≥ 1.3.0** — `finish` did not exist before it, so an older install turns the stage-10 close-out into a command that is not there) | **guarded registers** — a lease before writing one, `reserve` before minting an id, `reconcile`/`record` for intent vs as-built, and `finish` for the stage-10 multi-repository close-out ([`documentation.md`](documentation.md)) | **Recommended** — never a gate. Absent → the run is **`ungated`** and must say so out loud; the discipline still applies, only the arbitration is missing | `npx sshlg-skills install` |
 | **sheleg-dev** (`stripe-billing`, `crypto-payments`, `error-tracking`, `ad-tracking`, `google-signin`, `google-auth`, `frontend-performance`) | **stage 5 when the task wires money, tracking, sign-in or page speed** — the seams a generated integration gets wrong in ways no screen shows: the webhook is the payment, a thank-you-page event cannot know the charge cleared, a duplicated `event_id` counts revenue twice | **Recommended** — never a gate; absent → the integration ships on the host's own doctrine and the close-out names the seam nobody checked | `/plugin marketplace add ssheleg/sheleg-dev` → `/plugin install sheleg-dev@sheleg-dev` |
 | **agent-stack** (`agent-orchestrator`, `agent-evals`, `agent-interop`, `agent-harness`) | **stage 5 when the thing being BUILT is an agent system** — the orchestrator's loop, evals that say whether it got better, the protocols it speaks (MCP/A2A), the wallet under LLM resale. Not for coordinating the agents editing this repository (that is agent-sync, above) | **Recommended** — never a gate; absent → the agent layer ships unevaluated and the close-out says so | `/plugin marketplace add ssheleg/agent-stack` → `/plugin install agent-stack@agent-stack` |
@@ -94,11 +98,11 @@ required; an absent one is a check recorded as NOT_RUN with its reason.
 | `review-animations`, `improve-animations` | reviews motion against its intent: timing, easing, interruption, reduced-motion fallback | stage 6, on a surface with motion; findings as triples |
 | `mobile-native` | the mobile-web surface: viewport, safe areas, touch targets, keyboard-up states | stages 5–6, mobile-web frames of the matrix |
 | `animate-expo` | React Native and Expo motion, built and reviewed on the platform's own primitives | stage 5, an RN or Expo surface |
-| `webapp-testing`, `chrome-devtools` (`take_screenshot`, `lighthouse_audit`) | the frames of the matrix at each viewport and theme, and a Lighthouse pass as the deterministic floor | stage 6, the capture and the floor; stage 8 on a deployed target |
+| `playwright-cli open --browser webkit` + `screenshot`, `webapp-testing`; `chrome-devtools` (`lighthouse_audit`, the stated Chromium exception) | the frames of the matrix at each viewport and theme, captured in WebKit first, and a Lighthouse pass as the deterministic floor | stage 6, the capture and the floor; stage 8 on a deployed target |
 | `accessibility-review`, `a11y-debugging` | accessibility review of the rendered surface and debugging what it finds | stage 6, beside axe or Lighthouse |
 | XCUITest `performAccessibilityAudit` | the iOS platform's own accessibility audit, run in UI tests | stage 6, a native iOS surface |
 | Compose `enableAccessibilityChecks` | Android's accessibility checks in Compose UI tests | stage 6, a native Android surface |
-| Playwright `toHaveScreenshot` | screenshot regression against the approved baseline, per state and theme | stage 6 (regression), and the nightly or release baseline after |
+| Playwright `toHaveScreenshot` | screenshot regression against the approved baseline, per state and theme — the `webkit` project first | stage 6 (regression), and the nightly or release baseline after |
 | axe-core | the deterministic accessibility floor of a web surface | stage 6, first in the cheap-first order |
 | `figma-code-connect` (Figma's public plugin skill) | maps a design-system component in the file to its code component, so `get_design_context` hands the agent the real import instead of approximated markup | stage 5, **offered** for a core component the file draws and nothing maps — publishes to the file, so it needs a go ([`build.md`](build.md) → *Code Connect, kept*) |
 
@@ -164,11 +168,12 @@ Pipeline companions (stage doctrine is built in — nothing to install for it):
                          (running without it — no reach queries, no graph↔docs
                           divergence check)
   ✗ playwright         — recommended when this project has a web front end.
-                         One of TWO channels that do the same look; either is
-                         enough, and a project that already runs Playwright has
-                         this one for free:
+                         The default look: it reaches WebKit (Safari's engine),
+                         which is checked first; a project that already runs
+                         Playwright has this one for free:
                            npm install -D @playwright/cli@latest   (then npx playwright-cli)
-                           claude mcp add playwright npx @playwright/mcp@latest
+                           playwright-cli install-browser webkit
+                           claude mcp add playwright -- npx @playwright/mcp@latest --browser webkit
                          (running without it — see the line below; without BOTH,
                           the surface is verified by reading the diff)
   ✗ sheleg-dev         — this task wires money, tracking, sign-in or page speed;
@@ -191,9 +196,9 @@ Pipeline companions (stage doctrine is built in — nothing to install for it):
   ✗ chrome-devtools    — recommended when this project has a web front end:
                          stages 5-6 check the RENDERED surface instead of the
                          diff, stage 8 reads what the browser did after a deploy.
-                         The other channel; it alone reaches lighthouse_audit
-                         and heap snapshots, and analyses a trace rather than
-                         only recording one:
+                         The stated Chromium exception: Chrome only, and it
+                         alone reaches lighthouse_audit and heap snapshots, and
+                         analyses a trace rather than only recording one:
                            /plugin install chrome-devtools-mcp@claude-plugins-official
                          (running without it — the surface is verified by reading
                           the diff, and the close-out says so in those words)
@@ -226,7 +231,8 @@ Rules:
   `wiki-query`/`wiki-update`. Present → say `✓ ready` and use it in the harvest.
   Absent → print the two install lines **once** and continue; never ask twice in a
   run and never block a stage on it ([`knowledge-sources.md`](knowledge-sources.md)).
-- **The browser channels — `playwright` and `chrome-devtools`, one rule for both.**
+- **The browser channels — `playwright` and `chrome-devtools`, one rule for both, WebKit
+  first.**
   Flag them only when the project **has a web front end** — an `index.html`, a
   `package.json` naming a browser framework, a `docs/ux/screens.md`, or a deploy target
   that serves pages. **A CLI, a library or a backend service does not flag either** —
@@ -237,18 +243,20 @@ Rules:
   `mcp__chrome-devtools__list_pages` (either one under whatever prefix the host uses).
   Present → `✓ ready`. Absent → print its install lines **once** and continue; neither
   is a gate.
-- **They are two channels for one look, and the run needs one of them, not both.**
-  Both open the page, snapshot it and read the console and the network log, so **stop
-  at the first one that answers** — running the same look twice is a cost with no
-  second fact. Where neither is present, say the surface was verified **by reading the
-  diff**; where both are, the tie-breakers are stated rather than left to taste:
-  **`playwright` when the project already runs it**, or when context budget is tight —
-  its own upstream sells the CLI on not loading large tool schemas and verbose
-  accessibility trees into the model context. **`chrome-devtools` when the question is
-  past the page** — a Lighthouse category or a heap snapshot, neither of which the
-  Playwright channel has, or a performance trace you want *analysed* rather than only
-  recorded. Neither is *the better
-  browser*, and a run that ranks them has invented a fact this matrix does not carry.
+- **They are two channels for one look, and the run needs one of them, not both —
+  on WebKit first** (`DEC-0007`, [`browser.md`](browser.md) → *Engine order*). Both open
+  the page, snapshot it and read the console and the network log, so the look is taken
+  once: **`playwright` with `--browser webkit`** (on macOS, Safari itself through
+  `safaridriver` is the same engine) — running the same look twice is a cost with no
+  second fact. **`chrome-devtools` is the stated Chromium exception**: it drives Chrome
+  only, so it is reached for when the question needs Chrome — a Lighthouse category or a
+  heap snapshot, neither of which the Playwright channel has, a performance trace you
+  want *analysed* rather than only recorded, or a Chrome-only API — and the verdict says
+  which and why. Where only `chrome-devtools` is present, the look is reported as
+  *checked in Chromium*, never as *tested in a browser*; where neither is, say the
+  surface was verified **by reading the diff**. The rank is of the **engine**, not of the
+  tools' quality: neither channel is *the better browser*, and a run that claims one is
+  has invented a fact this matrix does not carry.
 - **graphify**: detect via `graphify-out/graph.json` (built → `✓ ready`, query it in
   the harvest) or a resolving `graphify` binary with no `graphify-out/` (installed,
   not built → offer the one-line `/graphify .`). Absent → print the install lines

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

@@ -49,7 +49,7 @@ Custom profiles use their own declared stages and doctrine, with the kernel inta
 | 3 Spec | `references/spec.md` |
 | 4 Plan | `references/planning.md` |
 | the queue the loop walks | `references/work-graph.md` |
-| 5–8 · how a **work-graph node** is CLOSED — three blind readings at three distances, all three required, plus a fourth `visual` reading on a flagship or product surface (ceiling 3); a **prose-plan task** closes through `review.md` instead — one reviewer, five-round cap | `references/certification.md` |
+| 5–8 · how a **work-graph node** is CLOSED — three blind readings at three distances, all three required, plus a fourth `visual` reading on a flagship or product surface (ceiling 3); a **prose-plan task** closes through `review.md` instead — one reviewer, three-round cap | `references/certification.md` |
 | 5 Build (worktree, subagents, fix loop) | `references/build.md` + `references/review.md` |
 | 5–6 TDD + suite gate | `references/tdd.md` |
 | 5, 6, 8 The browser — the look, the spec suite, and the difference | `references/browser.md` |

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

@@ -25,7 +25,8 @@ fields, written at stage 0 and confirmed with the brief:
   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)).
+  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
@@ -71,12 +72,15 @@ A **round** is every exit check run once, plus one independent reading over the
 audit axis, an observer, or the post-release readback. Rotating the axis
 ([`audit.md`](audit.md)) never adds a round. Only new blocking findings count.
 
-- **Done** — every exit check green on the artefact, and two consecutive rounds with no new
-  blocking finding. The second of them may read only the last fix's diff.
+- **Done** — every exit check green on the artefact, and one round with no new blocking
+  finding; two consecutive ones when the iteration carries an R3 or flagship node, the
+  second of which may read only the last fix's diff. Two for every iteration was the
+  default until 1.98.0, and a clean round that changed nothing bought a second reading
+  of the same tree.
 - **Diverging** — new blocking findings did not fall from one round to the next, or
   self-inflicted ≥ new. Run [`loop-guard.md`](loop-guard.md)'s break protocol.
 - **Budget spent** — `maxRounds` or `maxReleases` reached before done: a blocker open, or the
-  second clean round still owed. Stop and hand the iteration back: each open blocker becomes a
+  clean round still owed. Stop and hand the iteration back: each open blocker becomes a
   top board row marked `needs-operator`. No round runs past the budget without the operator's
   go, given with the numbers; a done reached past it without that go is still `budget`.
 
@@ -94,15 +98,16 @@ round: <N> — <reading> — new blocking <k>
 
 ```
 python3 scripts/waves.py finish --inventory <inventory.json> --ledger .task-pipeline/run.md \
-  --max-rounds 3 --max-releases 2 --releases <n> --checks <k>/<m> --artefact <name>@<sha>
+  --max-rounds 3 --max-releases 2 --releases <n> --checks <k>/<m> --artefact <name>@<sha> \
+  [--clean-rounds 2]
 ```
 
 `--rounds N` may stand in for `--ledger`; with neither the count is unknown and the script
 refuses. Exit codes:
 
-- `0` — done: the last two rounds found no new blocking item, none is open, and every exit
-  check is green on the artefact.
-- `3` — continue: a blocker open, a second clean round owed, or no `--checks` given.
+- `0` — done: the last `--clean-rounds` rounds (1 by default) found no new blocking item,
+  none is open, and every exit check is green on the artefact.
+- `3` — continue: a blocker open, a clean round owed, or no `--checks` given.
 - `5` — budget: reached before done, or done past it without `--operator-go`.
 - `6` — blocked: diverging; run the loop guard's break protocol.
 - `1` — malformed: the inventory, the ledger or the arguments, each reason named.