task-pipeline-skill 1.54.0 → 1.55.0

package/CHANGELOG.md

@@ -1,5 +1,84 @@
 # Changelog
 
+## v1.55.0 — the browser step gets a second channel, and the table that names it stops truncating itself
+
+The bundle has told every web project to check the rendered surface since v1.36.0, and
+it named exactly one way to do it: the `chrome-devtools` MCP, behind a plugin install.
+One channel is a single point of failure for a step the pipeline asks for at three
+stages, and the operator's report was the ordinary one — it lags.
+
+Playwright now sits beside it, and **neither is ranked**. They do the same look; the
+difference is stated as capability rather than quality, so a run picks by need instead of
+by taste. `playwright` costs the least per look — its own upstream sells the CLI on not
+loading large tool schemas and verbose accessibility trees into the model context, and
+both of its channels snapshot the accessibility tree rather than pixels.
+`chrome-devtools` is the one that reaches past the page: `lighthouse_audit`, performance
+traces and heap snapshots have no Playwright equivalent, and `seo-aeo-audit` builds on
+the first of them.
+
+### Added
+
+- **`playwright` as a companion**, with two install paths that need no plugin:
+  `npm install -D @playwright/cli@latest` (then `npx playwright-cli`) and
+  `claude mcp add playwright npx @playwright/mcp@latest`. Verified against the registry
+  at release time: `@playwright/cli` 0.1.18, `@playwright/mcp` 0.0.79.
+- **One detection rule for both channels instead of two that drift**, with the
+  tie-breaker written down: `playwright` where the project already runs it or context
+  budget is tight, `chrome-devtools` where the question is Lighthouse, a trace or a
+  heap snapshot. A run that ranks them has invented a fact the matrix does not carry.
+- **Stop at the first channel that answers.** Both open the page and read the console
+  and the network log; running the look twice is a cost with no second fact.
+- **A browser test suite is the other half of the gate, never a substitute for the
+  look** (stages 6, `tdd.md`, `SKILL.md`). `playwright test` in CI is a suite whose
+  runner happens to be a browser: it proves what someone thought to assert, and cannot
+  report the console error nobody asserted on or the element that moved under a header.
+  The suite is counted as coverage; the look is still a page opened and read. This
+  closes `OQ-0003` as `DEC-0004`.
+- **What the look finds is fixed in the stage that found it** (stages 5 and 6). A
+  browser finding parked for later is the diff-review verdict wearing a screenshot.
+
+### Fixed
+
+- **Three claims this release shipped as facts, corrected against the tool's own
+  `--help`.** The independent reader measured them. *"Costs the least per look"* was
+  upstream's CLI-against-MCP comparison restated as this repo's CLI-against-`chrome-devtools`
+  fact — now attributed and scoped. *"Both channels snapshot the accessibility tree rather
+  than pixels"* was true of the default and denied a `screenshot` both channels ship —
+  now says which is the default and what the other costs. *"`chrome-devtools` alone
+  reaches performance traces"* was simply false: `playwright-cli tracing-start` records
+  one. Only the Lighthouse and heap-snapshot legs are exclusive, and the honest
+  difference on traces is that one channel **analyses** what the other only records.
+- **The look was called a half of the gate in the same file that calls it never a gate.**
+  Stage 6's new paragraph made the browser look sound like gate membership while the
+  GATE bullet above it, both matrix rows and `SKILL.md` all keep it recommended and
+  degradable. Stage 5 had the mirror defect: *fixed in this task, not filed* against a
+  GATE bullet that explicitly permits parking with a ruling. Both now say the thing the
+  gate actually enforces.
+
+- **A pipe inside a matrix cell silently disabled the guard that reads it.** Both
+  readers of `companion-skills.md`'s table split cells on `|` and do not decode `\|`,
+  so an escaped pipe ends its cell early and hands the next check a different column.
+  The `graphify` row had carried `graphify query\|affected\|god-nodes` since it was
+  added: the matrix→stages check has been reading that row's second cell as `affected`,
+  parsing no stage numbers out of it, and passing **without comparing anything** — a
+  guard quiet because its input was truncated, which reads exactly like a guard that
+  looked and agreed. Found while planting a defect into the new `playwright` row and
+  watching the check stay silent. There is now a guard for the class, probed both ways,
+  and the `graphify` row is comma-separated. The umbrella hit the same class from the
+  other side in `B-40` (an *un*escaped pipe adding a column), which is the second
+  sighting that makes it a check rather than a third ledger row.
+
+### Guards
+
+Guards: 315 → **318**. Property checks: 9 → 9. Two new checks over the companion matrix,
+each watched failing against a plant: the row's cell count against the header (which
+catches a bare pipe and an escaped one alike), and a row that derives no stage at all.
+The first draft of the first check tested `\|` only, and the independent reader `R-005`
+requires broke it with a bare pipe in one move — with a control proving the hole masked
+real matrix→stages drift. The second check exists because the same reader measured every
+row and found `agent-sync` deriving nothing from `stage-10`, one row below the `graphify`
+row this release set out to fix.
+
 ## 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

package/CONTRIBUTING.md

@@ -464,6 +464,21 @@ VISUAL — each with its owning skill, because the first reads matrix **row name
 the copy half lives inside super-ux's own cell, exactly where it was invisible.
 *(guard: `has not heard of it` and `names no owner`)*
 
+**54. The companion matrix's own cells must be readable, and every row must derive a
+stage.** Every check that reads that table splits a cell on `|`, and none of them decodes
+the escaped form. So one extra pipe anywhere in a row — `\|` or bare — ends its cell early
+and hands the next check a different column, which is how the `graphify` row spent every
+release since it was added with its stage pointers **never compared**: the check derived
+an empty set and reported agreement. The cell count is now compared against the header,
+because that is blind to how the pipe was written, and the first draft of this guard was
+not — it tested `\|` only and an independent reader broke it with a bare one in a single
+move. Separately, the outcome is asserted directly: a row whose *"needed for"* cell
+derives **no** stage fails, because a pipe is only one road to an empty set and
+`agent-sync` took another, writing `stage-10` where the stage pattern wanted `stage 10`.
+The two checks share one compiled pattern for that reason — two copies would drift, and
+the drift is silent in precisely the direction that hurts.
+*(guard: `pipes where the header has` and `names no stage its second cell`)*
+
 **53. Publishing a retro insight is opt-in, enumerated, and its own example obeys its
 own rules.** `retro.publish` is off when absent — opening an issue in another repository
 is an outward act, and a generic flag is not a specific authorization. The redaction

package/README.md

@@ -210,14 +210,24 @@ run proved stale is already in the ledger with what's wrong, so "docs updated" m
 the sources the next run will trust — not just the files this change happened to
 touch.
 
-**A web front end gets a browser, not a diff.** Where `chrome-devtools` is connected,
+**A web front end gets a browser, not a diff.** Where a browser channel is connected,
 stages 5–6 load the surface and read the console and the network log before calling it
 green, and stage 8 opens the deployed page instead of trusting a `200`. A green suite
 cannot see a component that renders correctly and lands under a fixed header, a request
-that 404s while every unit test mocks it, or an error that costs nothing at test time.
-Absent, the run says *"verified by reading the diff"* — a weaker claim, recorded as one.
-Install: `/plugin install chrome-devtools-mcp@claude-plugins-official`. It is never a
-gate, and a CLI, a library or a backend service is never offered it.
+that 404s while every unit test mocks it, or an error that costs nothing at test time —
+and neither can a **browser test suite**, which asserts what someone wrote down and is
+counted as coverage rather than as the look. Absent, the run says *"verified by reading
+the diff"* — a weaker claim, recorded as one.
+
+There are **two channels and either is enough**, ranked by nothing: `playwright`
+(`npm install -D @playwright/cli@latest`, or
+`claude mcp add playwright npx @playwright/mcp@latest`) needs no plugin and is already
+there on a project that runs Playwright, and its CLI half puts no tool schema in the
+context window; `chrome-devtools`
+(`/plugin install chrome-devtools-mcp@claude-plugins-official`) is the one that reaches
+past the page to Lighthouse and heap snapshots, and analyses a performance trace rather
+than only recording one. Neither is a gate,
+and a CLI, a library or a backend service is never offered either.
 
 **The wiki is [obsidian-wiki](https://github.com/ar9av/obsidian-wiki)** (Karpathy's
 LLM-wiki pattern), and it's the one source that carries *why* across projects and

package/SKILL-CARD.md

@@ -12,9 +12,9 @@ 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.54.0 |
+| **Version** | 1.55.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 |
+| **Dependencies** | None required. Optional: `context7` (MCP), `figma` (MCP), super-ux, agent-sync, graphify, obsidian-wiki, and **one of two browser channels** — `playwright` (CLI or MCP) or `chrome-devtools` (MCP); either satisfies the browser step and neither is required. Every stage's doctrine ships in-repo; 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` |
 
 ## Risk-tier disclosure
@@ -25,7 +25,7 @@ apply.
 | Indicator | Applies? | What exactly |
 |---|---|---|
 | **Code execution** | **Yes — High** | Ships `templates/docgate.sh` (seeded into the host project as its documentation gate), `bin/task-pipeline.js` and `install.sh` (installers), `test/*.py` and `evals/run.py` (repo checks). None run automatically; the gate is seeded and run by the host project |
-| **MCP server references** | **Yes — High** | Instructions name `context7`, `figma`, `graphify`, `wiki-query`, `wiki-update` and **`chrome-devtools`** — the last one **drives a real browser**: it opens pages, runs scripts in them and reads their console and network traffic, which is a wider capability than the others and is recommended only for projects that have a web front end. All optional; absence degrades a stage, never blocks one, except super-ux on a UI task |
+| **MCP server references** | **Yes — High** | Instructions name `context7`, `figma`, `graphify`, `wiki-query`, `wiki-update` and **two browser channels — `playwright` (CLI `@playwright/cli` or MCP `@playwright/mcp`) and `chrome-devtools`** — the last two **drive a real browser**: they open pages, run scripts in them and read their console and network traffic, which is a wider capability than the others and is recommended only for projects that have a web front end. Either one satisfies the browser step; neither is required. All optional; absence degrades a stage, never blocks one, except super-ux on a UI task |
 | **Tool invocations** | **Yes — Medium** | Instructs bash (git, test runners, the host's lint/deploy commands), file reads and writes, and a `PreToolUse` hook example that runs the docs gate before a commit |
 | **Filesystem access scope** | **Yes — Medium** | Reads and writes inside the host project: `docs/`, `scripts/check-docs.sh`, `.task-pipeline/` scratch, `CONTEXT.md`. Stage 5 creates and removes git worktrees. Writing to **another repository** is treated as outward and requires an explicit go |
 | **Instruction manipulation** | No | Nothing instructs Claude to bypass safety rules, hide actions, or behave conditionally on hidden inputs. Outward and irreversible actions (deploy, publish, PR, editing a shared design file) explicitly require operator authorization |

package/cursor/rules/task-pipeline.mdc

@@ -253,12 +253,19 @@ not authorize an outward, irreversible action — stage 7 stops and asks.
    behavior, never mock behavior. **Web front end? Check the surface in a browser,
    not in the diff.** A green suite cannot see a component that renders correctly and
    lands under a fixed header, a request that 404s while every unit test mocks it, or
-   a console error that costs nothing at test time. With the chrome-devtools MCP
-   connected: load the surface, snapshot it, read the console and the network log,
-   and quote what you read. Without it, say "verified by reading the diff" and treat
-   that as the weaker claim it is. Install once, never a gate:
-   `/plugin install chrome-devtools-mcp@claude-plugins-official`. A CLI, a library or
-   a backend service is never offered it.
+   a console error that costs nothing at test time — and neither can a browser test
+   suite, which asserts what someone wrote down and counts as coverage, not as the
+   look. With a browser channel connected: load the surface, snapshot it, read the
+   console and the network log, and quote what you read. Fix what the look finds
+   before calling the stage green. Without one, say "verified by reading the diff" and
+   treat that as the weaker claim it is. Two channels, either is enough, ranked by
+   nothing: `npm install -D @playwright/cli@latest` (or
+   `claude mcp add playwright npx @playwright/mcp@latest`) needs no plugin, and its CLI
+   half puts no tool schema in the context window;
+   `/plugin install chrome-devtools-mcp@claude-plugins-official` is the one that
+   reaches Lighthouse and heap snapshots, and analyses a trace rather than only
+   recording one. Never a gate. A CLI, a
+   library or a backend service is never offered either.
 7. **Lint + deploy** (manual) — lint clean AND suite green before deploy; deploy is
    outward → explicit user go, or the specific standing authorization recorded in
    the stage-0 brief.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "task-pipeline-skill",
-  "version": "1.54.0",
+  "version": "1.55.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.54.0",
+  "version": "1.55.0",
   "author": {
     "name": "ssheleg",
     "url": "https://x.com/sshlg93"

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

@@ -253,9 +253,9 @@ capable available — see `references/model-tiering.md`).
 | 3 | Spec | committed + reviewed; UI: chain validated, linter green, scenarios/`SCR-` traced | manual |
 | 4 | Plan | parallel-ready, DoD per task | auto |
 | 5 | Dev | tasks DONE, TDD green per task, branch integrated per the brief; **anything generated passes its own checks, and local infrastructure does not publish the host's default ports** ([`references/learned.md`](references/learned.md)) | auto |
-| 6 | Tests | full suite green; new/changed code covered; **every new check probed both ways and asserted on its exit code**, and the suite run once against a cold environment ; **on a web front end the surface is checked in a browser, not in the diff** — a green suite cannot see a component that renders under a fixed header, a request that 404s past its mock, or a console error (`chrome-devtools`, [`references/companion-skills.md`](references/companion-skills.md); absent → say *verified by reading the diff* and record it as the weaker claim it is) | auto |
+| 6 | Tests | full suite green; new/changed code covered; **every new check probed both ways and asserted on its exit code**, and the suite run once against a cold environment ; **on a web front end the surface is checked in a browser, not in the diff** — a green suite cannot see a component that renders under a fixed header, a request that 404s past its mock, or a console error — and a browser **test suite** is the other half of the pair, never a substitute for the look (`playwright` or `chrome-devtools`, either one, [`references/companion-skills.md`](references/companion-skills.md); absent → say *verified by reading the diff* and record it as the weaker claim it is) | auto |
 | 7 | Lint + deploy | lint clean + suite green before deploy; deploy needs a go (or the brief's specific standing authorization) | manual |
-| 8 | Post-deploy | clean boot or honest degradation report; **a deployed web target is opened, not curled** — a `200` proves the server answered and says nothing about a 404'd bundle or a console full of errors on load (`chrome-devtools`; absent → call it an HTTP response, which is its honest name) | auto |
+| 8 | Post-deploy | clean boot or honest degradation report; **a deployed web target is opened, not curled** — a `200` proves the server answered and says nothing about a 404'd bundle or a console full of errors on load (`playwright` or `chrome-devtools`, either one; absent → call it an HTTP response, which is its honest name) | auto |
 | 9 | Docs + wiki | every stale row of the stage-0 source ledger updated; **the propagation matrix walked for every change type this run produced** — the ledger names what you read, the matrix names what you owe — every settled thing recorded with an id, every answered question resolved, and **the documentation gate green with its ratchet counts printed**; docs synced; wiki synced; **the code graph refreshed where one exists** and checked against the docs (a hub no doc names, a doc naming a node the graph lost); **every number computed rather than restated, every named command or file resolvable** ([`references/learned.md`](references/learned.md)); the carry-over count printed beside the verdict | auto |
 | 10 | **Acceptance** | ladder walk ran, its absences became REQ rows; every REQ accounted for with evidence from a check seen failing once; ledger has no unresolved row; **axis rotation recorded** (new findings vs self-inflicted, rule 1 of [`references/learned.md`](references/learned.md)), **every closure verified against the artefact rather than the document describing it**, **each correction swept across its class**, **every deferral a printed ratchet rather than a TODO**; **in a multi-repository project, every repository is clean, pushed and pointed at** (below); **the hand-back is written** — the request quoted as given, progress against it, what was solved, what surfaced unasked, waiting decisions asked here, and the ambiguity count computed ([`references/progress.md`](references/progress.md)); **the environment is given back** — all eight classes enumerated, what this run started ended and verified by re-enumerating rather than by the teardown's reply, an earlier run of this project ended only when **provably spent**, anything this project does not own reported rather than ended, written as a `holds:` line (`references/residue.md`); operator signs off; **every check this close-out leans on — the documentation gate included — has been seen failing once against a planted defect, and its ratchet counts are printed beside the verdict**; **the retrospective written last, and in order — the run stamped with its commit FIRST (the cold-retirement trigger reads that stamp), then the prune with the list at or under its cap and every deletion logged, then the entry; every deletion and every entry carrying its commit, entries older than five stamps rotated into the archive, counts printed** ; **every disclosure printed beside the verdict** — `abstained` (what the run declined to claim) and `unlooked` (what a check never looked at), neither a ratchet, neither with a floor, neither ever a target ([`references/gates.md`](references/gates.md) → *Disclosures*) | manual |
 

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

@@ -48,8 +48,9 @@ better, plus one that is required only for user-facing work.
 | **context7** (MCP — call tools fully qualified: `context7:resolve-library-id`, `context7:query-docs`) | stage 1 docs study | Recommended (web-search fallback) | connect the context7 MCP server |
 | **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\|affected\|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 .` |
-| **chrome-devtools** (MCP — `list_pages`, `navigate_page`, `take_snapshot`, `take_screenshot`, `evaluate_script`, `list_console_messages`, `list_network_requests`, `lighthouse_audit`) | **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 | **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) |
+| **[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) |
 | **[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` |
 | ~~superpowers~~ | — | **Not a dependency.** Stages 2/4/5/6 run on the built-in doctrine above. See *Optional bridge* | — |
 | ~~grill-me / grilling~~ | — | **Not a dependency.** The stage-0 grill is built in (`references/grill.md`) | — |
@@ -112,9 +113,20 @@ Pipeline companions (stage doctrine is built in — nothing to install for it):
                            /graphify .        (once, in this project)
                          (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:
+                           npm install -D @playwright/cli@latest   (then npx playwright-cli)
+                           claude mcp add playwright npx @playwright/mcp@latest
+                         (running without it — see the line below; without BOTH,
+                          the surface is verified by reading the diff)
   ✗ 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:
+                         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:
                            /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)
@@ -147,13 +159,29 @@ 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)).
-- **chrome-devtools**: flag it 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. Detect via a resolving
-  `mcp__chrome-devtools__list_pages` (or the plugin's tools under any prefix the host
-  uses). Present → `✓ ready`. Absent → print the install line **once** and continue; it
-  is never a gate. **A CLI, a library or a backend service does not flag it** — offering
-  a browser to a project with no browser is how a recommendation is taught to be noise.
+- **The browser channels — `playwright` and `chrome-devtools`, one rule for both.**
+  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** —
+  offering a browser to a project with no browser is how a recommendation is taught to
+  be noise. Detect `playwright` via a resolving `playwright-cli` binary, a
+  `@playwright/cli` or `@playwright/mcp` dependency, a `playwright.config.*`, or
+  `mcp__playwright__browser_navigate`; detect `chrome-devtools` via a resolving
+  `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.
 - **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/stages.md

@@ -395,12 +395,16 @@ never that the work was skipped quietly.
   run's confirmed model (`model-tiering.md`). The plan's parallel groups fan out
   **only** when each implementer gets its own worktree; otherwise sequential.
 - **Web front end? The task's own surface is checked in a browser, not in the diff.**
-  Where `chrome-devtools` is connected ([`companion-skills.md`](companion-skills.md)):
-  after a task that changes a rendered surface, load it, take a snapshot and read the
+  Where a browser channel is connected — `playwright` **or** `chrome-devtools`, either
+  one, whichever answers first ([`companion-skills.md`](companion-skills.md)): after a
+  task that changes a rendered surface, load it, take a snapshot and read the
   console and the network log **before the task is marked DONE** — a component can be
   correct and land under a fixed header, and a review of the diff cannot see that.
-  Absent, say the surface was verified by reading the diff and treat it as the weaker
-  claim it is. Stage 6 repeats this over the whole tree; this one catches it while the
+  **What the look finds is fixed in this task, or parked with the ruling the GATE below
+  requires — never parked silently** — a browser finding filed without a ruling is the
+  diff-review verdict wearing a screenshot; the look was worth taking only if it can
+  still change the code or is on record as deliberately not doing so. Absent, say the surface was verified by reading
+  the diff and treat it as the weaker claim it is. Stage 6 repeats this over the whole tree; this one catches it while the
   implementer that wrote it is still dispatched. The matrix pointed this companion at
   stages 5–6 from the day it was added and **this stage had never named it** — found by
   the guard comparing the two, not by a reader.
@@ -438,12 +442,29 @@ never that the work was skipped quietly.
   A passing suite proves the code does what its assertions say. It does not prove the
   page rendered — a component can be correct and land under a fixed header, a request
   can 404 while every unit test mocks it, and a console error costs nothing at test
-  time. Where `chrome-devtools` is connected ([`companion-skills.md`](companion-skills.md)):
+  time. Where a browser channel is connected — `playwright` **or** `chrome-devtools`,
+  either one ([`companion-skills.md`](companion-skills.md)):
   load the surface, take a snapshot, and read **the console and the network log**
   before calling it green. Absent, say the surface was verified **by reading the
   diff** — that is a weaker claim and the close-out records it as one, rather than
   letting "tests pass" stand in for "it renders". This is the `L6→L7` seam of
   [`audit.md`](audit.md)'s ladder: *is there an executed observable a user reaches?*
+- **A browser test suite does not discharge the look, and does not become it.** A
+  project whose CI runs `playwright test` has an *asserted* browser — it proves what
+  someone thought to assert, on the paths someone thought to write. It cannot report
+  the console error nobody asserted on, the bundle that 404s past a route nobody
+  visits, or the element that moved four pixels under a header. So a green spec suite
+  counts where every other test counts, inside **the suite half of the GATE above**;
+  the look stays what it already is here — **recommended, never a gate**, and reported
+  in the words the gate gives it. What the pair buys is that they fail differently: a
+  run that answers *the surface was checked* by pointing at its spec suite has answered
+  a different question. Where the suite is the thing that changed, the look is what
+  proves it runs against a page that renders.
+- **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
+  seen to be broken — so if it does leave unfixed, the reason is on record and the
+  close-out carries it, exactly as a parked finding does.
 
 ## 7 — Lint + deploy
 - **Freedom: low** — outward and irreversible — the authorization floor is exact or the stage stops ([`gates.md`](gates.md) → *Axis C*).
@@ -496,7 +517,8 @@ never that the work was skipped quietly.
 - **A deployed web target is opened, not curled.** A `200` proves the server
   answered; it says nothing about whether the page rendered, whether a bundle 404'd,
   or whether the console filled with errors on load — all three ship green past a
-  health check. Where `chrome-devtools` is connected, load the deployed URL and read
+  health check. Where a browser channel is connected — `playwright` **or**
+  `chrome-devtools`, either one — load the deployed URL and read
   the console and the network log; quote what you read, not that you looked
   ([`companion-skills.md`](companion-skills.md)). Absent → say the check was an HTTP
   response only, which is the honest name for it.

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

@@ -101,13 +101,19 @@ database created ten seconds ago" are different claims, and only the second one
 - **A green suite is not a rendered page.** On a web front end the suite proves the
   code does what its assertions say; it cannot see a component that renders correctly
   and lands under a fixed header, a request that 404s while every unit test mocks it,
-  or a console error that costs nothing at test time. Where `chrome-devtools` is
-  connected ([`companion-skills.md`](companion-skills.md)), open the surface and read
+  or a console error that costs nothing at test time. Where a browser channel is
+  connected — `playwright` **or** `chrome-devtools`, either one
+  ([`companion-skills.md`](companion-skills.md)) — open the surface and read
   the console and the network log before calling it done — and **quote what you read**,
   not that you looked. Absent, the honest sentence is *"verified by reading the diff"*,
   which is a weaker claim and is recorded as one. Same family as a test that passes
   regardless of the production code: the assertion is real and it is pointed at
   something other than what a user reaches.
+- **A browser test suite does not close this, either.** `playwright test` in CI is a
+  suite whose runner happens to be a browser: it still asserts only what someone wrote
+  down. It belongs to the coverage half of the gate, and the sentence above still needs
+  a page that was opened and read. The two fail differently, which is the entire reason
+  to keep both.
 
 ## Stage 6 — consolidation and the suite gate