wicked-garden 12.33.0 → 12.34.0

package/.claude-plugin/marketplace.json

@@ -1 +1 @@
-{"name": "wicked-garden", "owner": {"name": "Mike Parcewski"}, "plugins": [{"name": "wicked-garden", "source": "./", "description": "Your coding agent already plans and swarms \u2014 Wicked Garden is the curated toolkit for what it can't: proof-not-claims gates, code links grep can't see, deterministic refactor, cross-session memory, real multi-model second opinions. Don't fight the harness; fill its gaps. The gate needs wicked-vault (a self-contained infra peer, installed directly) and re-derives through garden's built-in engine; estate/bus are opt-in layers (wicked-testing and wicked-brain are retired \u2014 QE ships in-catalog as the qe domain, memory lives in wicked-estate).", "version": "12.33.0"}], "version": "12.33.0"}
+{"name": "wicked-garden", "owner": {"name": "Mike Parcewski"}, "plugins": [{"name": "wicked-garden", "source": "./", "description": "Your coding agent already plans and swarms \u2014 Wicked Garden is the curated toolkit for what it can't: proof-not-claims gates, code links grep can't see, deterministic refactor, cross-session memory, real multi-model second opinions. Don't fight the harness; fill its gaps. The gate needs wicked-vault (a self-contained infra peer, installed directly) and re-derives through garden's built-in engine; estate/bus are opt-in layers (wicked-testing and wicked-brain are retired \u2014 QE ships in-catalog as the qe domain, memory lives in wicked-estate).", "version": "12.34.0"}], "version": "12.34.0"}

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "wicked-garden",
-  "version": "12.33.0",
+  "version": "12.34.0",
   "description": "Your coding agent's harness already plans and swarms; Wicked Garden is the curated toolkit for what it can't do alone. Proof, not claims \u2014 gates re-derive 'done' through the internal loom engine (fail-closed, independently attested via wicked-vault), so a self-asserted pass can't lie its way green. Relationships grep can't see \u2014 the wicked-estate code graph + injected bus/dispatch/capability/archetype edges power blast-radius & lineage. Plus deterministic multi-file refactor (wicked-patch), cross-session memory + knowledge (the mem domain over wicked-estate), real multi-model second opinions (jam:council), portable expertise as on-demand skill-refs, and evidence-gated testing (the in-catalog qe domain). It reads the shape of your work to apply the right rigor \u2014 steering, not a pipeline \u2014 then gets out of the way. The compiler stamps a self-contained evidence gate into any repo that runs with no wicked-garden installed. Don't fight the harness; fill its gaps. The evidence gate requires wicked-vault, a self-contained infra peer wicked-garden installs directly; wicked-bus is an opt-in layer \u2014 install what you'll use, the toolkit works without the rest.",
   "wicked_vault_version": "^0.5.0",
   "wicked_ledger_version": "^0.4.0",

package/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 ## [Unreleased]
 
+## [12.34.0] — 2026-09-11
+
+### Changed
+- **qe `author` / `review`: run what you claim, cite what you cover, deliver through the run (wave 6 — R4-r2, F-7R2-015/016).** The wave-6 acceptance review of a governed "New test" run found the worker had shipped a Playwright suite it never executed (it failed on its first check when run independently — 0 of 12 assertions reached), sold 22 pre-existing tests as a "29-scenario suite" without a single `file:line`, described wait-gating it had not written, and opened the PR itself with `gh pr create` from its shell — while seven default-allow gates passed it. The `wicked-garden-qe` router's `author` and `review` actions now carry the contract that makes that impossible to do honestly. **author** (`skills/qe/refs/author.md` § Verified-test contract, copied into every code-producing dispatch's args — a fork worker sees only its args): detect the repo's harness first (`package.json` scripts, `vitest`/`jest`/`playwright` configs, `pyproject.toml` pytest, an existing `e2e/` rig) and name the exact command; write BEHAVIOUR tests (observable outcome, never a mock asserting on a mock; know the source change that would fail each test); RUN every produced file with the harness's real command before claiming it and record file · exact command · result in the PLAN's execution table — a test not executed is `unverified`, never `covered`, never "passes"; claim pre-existing coverage only with `path:line` and report new vs pre-existing counts separately; label fixture-bound e2e `needs-fixture` with how to start it and run it against that fixture (selectors/test ids/text verified against the source); carry `not covered` rows for every intent gap; and NEVER `git push` / `gh pr create` / `gh pr merge` — the run's deliver phase opens the PR (standalone, the human does). The PLAN's status vocabulary is closed: `covered` · `unverified` · `needs-fixture` · `failing` · `not covered`. **review** (`skills/qe/refs/review.md` § Reviewing produced tests, dispatched to `wicked-garden-qe-test-code-quality-auditor` §9, which grades in a dedicated produced-test mode where `PASS` is reachable — every claim verified at `path:line`, every produced test executed and green, no `unverified`; P1/P2-only → `CONDITIONAL`; any P0 → `FAIL` — with a guarded source-mutation restore that never `git checkout`s over the author's uncommitted edit): open every `covered` claim at its `file:line` and reclassify unsupported ones; require an execution record for every produced file and FAIL the plan (`[unexecuted-test]`) when one is missing or a `needs-fixture` e2e was never run against its fixture; mutate-or-reason about at least two tested behaviours (apply a source mutation, confirm the test fails, restore — or name the mutation and the catching assertion when the harness cannot run); flag implementation-shaped tests; check every e2e oracle against the source on the visited route; check scope honesty; and never open, edit, merge or push the PR — the verdict goes back to the run. The same rules land in the workers the dispatches reach: `wicked-garden-qe-test-automation-engineer` ("Run what you write"), `wicked-garden-qe-e2e-orchestrator` (fixture named + started, oracles checked against the source, wait for the state you assert), `wicked-garden-qe-ui-component-test-engineer`, and — as one shared run-before-claim / cite / never-ship block pointing at the contract by skill name — the ten code-producing Tier-2 specialists (`test-data-manager`, `contract-testing-engineer`, `integration-test-engineer`, `visual-regression-engineer`, `a11y-test-engineer`, `load-performance-engineer`, `fuzz-property-engineer`, `localization-test-engineer`, `observability-test-engineer`, `data-quality-tester`), so a direct invocation on the flat Codex/Pi/OpenCode layout is bound the same way as a router dispatch. Cross-CLI wording throughout (the 12.33 portability convention — no CLI-specific delivery mechanics; "the run's deliver phase opens the PR"); `tests/test_skill_portability.py` stays at 0 violations and the router stays at the 200-line cap.
+
+### Fixed
+- **Domain schema bundle re-vendored at `1.2.0`.** `skills/domain/vendor/VERSION` was still `1.1.0` while the live owner (wicked-core `crates/wicked-governance/schemas/`) had moved to `1.2.0` with the STEERING unification's optional fields on `conformance-rules.schema.json`, so `tests/domain/test_schema_vendor_pin.py::test_vendored_bundle_version_matches_owner_when_present` failed whenever a sibling `wicked-core` checkout was present (CI, with no sibling, skipped it). Re-vendored from wicked-core `main` @ `e421e87` per the vendor README's procedure: `domain-model.schema.json` is confirmed byte-identical to the owner copy (same git blob), only `VERSION` and the README's bundle-history prose moved; the document contract stays `domain-model@1.0.0`.
+- **`pyproject.toml` `version` documented as not a release anchor.** It had sat at `1.33.0` since the plugin was 1.x; the release train (`release.yml` → `npm version` → `.github/scripts/sync-plugin-version.mjs`) bumps package.json + `.claude-plugin/{plugin,marketplace}.json` only, this Python project is never built or published, and nothing reads the field — so instead of inventing a fourth anchor it is pinned to the `0.0.0` placeholder with the convention written above it (mirrored in `uv.lock`).
+
 ## [12.33.0] — 2026-09-11
 
 ### Added

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wicked-garden",
-  "version": "12.33.0",
+  "version": "12.34.0",
   "type": "module",
   "description": "Curated toolkit for what AI coding agents can't do alone: evidence-gated work, codegraph relationships, deterministic multi-file refactor, multi-model second opinions, and cross-session memory. Installs as a Claude Code plugin.",
   "keywords": [

package/pyproject.toml

@@ -1,6 +1,11 @@
 [project]
 name = "wicked-garden"
-version = "1.33.0"
+# NOT a release anchor. The plugin's version lives in package.json and is synced into
+# .claude-plugin/{plugin,marketplace}.json by `npm version` -> .github/scripts/sync-plugin-version.mjs
+# when the vX.Y.Z tag runs release.yml. This Python project is never built or published (the hatch
+# target exists only so uv can manage deps), nothing reads this field, and the release train does
+# not bump it — PEP 621 requires a value, so it is pinned to the placeholder 0.0.0 (mirrored in uv.lock).
+version = "0.0.0"
 description = "AI-Native SDLC delivered as a single Claude Code plugin"
 requires-python = ">=3.10"
 dependencies = [

package/scripts/domain/validate_domain_model.py

@@ -53,7 +53,8 @@ def pinned_version() -> str:
     own ``metadata.schema_version`` const (== its ``$id`` version segment).
     Deliberately NOT the vendored bundle ``VERSION`` file — that tracks the
     owner's whole 4-schema bundle and moves when ANY sibling schema changes
-    (1.0.0→1.1.0 added conformance-rules.schema.json; this schema stayed 1.0.0)."""
+    (1.0.0→1.1.0 added conformance-rules.schema.json, 1.1.0→1.2.0 changed only
+    that sibling's steering fields; this schema stayed 1.0.0 throughout)."""
     schema = load_schema()
     return schema["properties"]["metadata"]["properties"]["schema_version"]["const"]
 

package/skills/domain/vendor/README.md

@@ -15,7 +15,7 @@ is history, not the contract.
 
 | | |
 |---|---|
-| Bundle version (`VERSION`) | `1.1.0` — mirrors the owner's `schemas/VERSION` |
+| Bundle version (`VERSION`) | `1.2.0` — mirrors the owner's `schemas/VERSION` (re-vendored 2026-09-11 from wicked-core `main` @ `e421e87`) |
 | Schema contract version (`$id` / `metadata.schema_version`) | `1.0.0` |
 | Schema `$id` | `https://wickedagile.com/schemas/domain-model/1.0.0` |
 | Canonical source | `wicked-core/crates/wicked-governance/schemas/domain-model.schema.json` |
@@ -25,7 +25,9 @@ is history, not the contract.
 
 The **bundle** `VERSION` bumps when ANY schema in the owner's 4-file bundle
 changes (the 1.0.0→1.1.0 bump added `conformance-rules.schema.json` to the
-bundle — this file was untouched). The **contract version** a document carries (`metadata.schema_version`,
+bundle; the 1.1.0→1.2.0 bump was the STEERING unification's optional fields on
+`conformance-rules.schema.json` — this file was byte-untouched both times). The
+**contract version** a document carries (`metadata.schema_version`,
 const-pinned by the schema, matching the `$id` segment) is independent — the
 schemas document that independence themselves. Documents emitted here still carry
 `schema_version: "1.0.0"`.

package/skills/domain/vendor/VERSION

@@ -1 +1 @@
-1.1.0
+1.2.0

package/skills/qe/SKILL.md

@@ -69,8 +69,7 @@ action; multi-model deliberation is `jam` council; in-run crew review is
 { test -f ".wicked-qe/config.json" || test -f ".wicked-testing/config.json"; } || echo "ERR_NO_CONFIG"
 ```
 
-On `ERR_NO_CONFIG`, run § setup first (it is safe to auto-run: it only
-scaffolds `.wicked-qe/` and registers a project record).
+On `ERR_NO_CONFIG`, run § setup first (safe to auto-run: it only scaffolds `.wicked-qe/` and registers a project record).
 
 ## setup — per-project initialization
 
@@ -87,10 +86,15 @@ scaffolds `.wicked-qe/` and registers a project record).
 
 ## author — scenarios, test code, fixtures
 
-1. Read `refs/author.md` — full playbook.
+1. Read `refs/author.md` — full playbook, incl. § Verified-test contract.
 2. Scenario authoring and/or framework test code via
    `wicked-garden-qe-{test-automation-engineer | acceptance-test-writer |
    test-data-manager | contract-testing-engineer}` per the playbook's table.
+3. Contract (binding for every produced test): detect the repo's harness; write
+   BEHAVIOUR tests against it; RUN every produced test and record command + result
+   in the PLAN — not executed = `unverified`, never `covered`; cite `file:line` for
+   any pre-existing coverage; label fixture-bound e2e `needs-fixture` with how to
+   start it. Never `gh pr create`/`git push` — the run's deliver phase opens the PR.
 
 ## campaign — repo recon + generated scenario ladder
 
@@ -122,10 +126,14 @@ scaffolds `.wicked-qe/` and registers a project record).
 
 ## review — independent verdicts
 
-1. Read `refs/review.md` — full playbook.
+1. Read `refs/review.md` — full playbook, incl. § Reviewing produced tests.
 2. Evidence manifests → `wicked-garden-qe-acceptance-test-reviewer`;
    spec-vs-code → `wicked-garden-qe-semantic-reviewer`; suite quality →
    `wicked-garden-qe-code-analyzer` + the matching tier-2 specialist.
+3. A PLAN + produced tests (the `author` output): verify every `covered` claim at
+   its `file:line`, mutate-or-reason about ≥ 2 tested behaviours, and FAIL a plan
+   whose e2e (or any produced test) has no execution record. The reviewer never
+   opens or merges the PR — the verdict goes back to the run.
 
 ## insight — read-only ledger lens
 
@@ -156,21 +164,16 @@ Pipeline: `wicked-garden-qe-acceptance-test-{writer, executor, reviewer}` · `wi
 
 Planning: `wicked-garden-qe-{test-strategist, risk-assessor, testability-reviewer, requirements-quality-analyst}`.
 
-Review/insight: `wicked-garden-qe-{semantic-reviewer, code-analyzer,
-test-oracle, production-quality-engineer, release-readiness-engineer,
-flaky-test-hunter, coverage-archaeologist, exploratory-tester,
-test-code-quality-auditor, snapshot-hygiene-auditor, test-impact-analyzer,
-mutation-test-engineer}`.
-
-Domain specialists (all prefixed `wicked-garden-qe-`): `a11y-test-engineer` ·
-`security-test-engineer` · `compliance-test-engineer` ·
-`ai-feature-test-engineer` · `chaos-test-engineer` · `iac-test-engineer` ·
-`integration-test-engineer` · `localization-test-engineer` ·
-`observability-test-engineer` · `ui-component-test-engineer` ·
-`load-performance-engineer` · `visual-regression-engineer` ·
-`fuzz-property-engineer` · `data-quality-tester` · `e2e-orchestrator` ·
-`contract-testing-engineer` · `test-automation-engineer` ·
-`test-data-manager` · `incident-to-scenario-synthesizer`.
+Review/insight: `wicked-garden-qe-{semantic-reviewer, code-analyzer, test-oracle,
+production-quality-engineer, release-readiness-engineer, flaky-test-hunter, coverage-archaeologist,
+exploratory-tester, test-code-quality-auditor, snapshot-hygiene-auditor, test-impact-analyzer, mutation-test-engineer}`.
+
+Domain specialists (all prefixed `wicked-garden-qe-`): `a11y-test-engineer` · `security-test-engineer` ·
+`compliance-test-engineer` · `ai-feature-test-engineer` · `chaos-test-engineer` · `iac-test-engineer` ·
+`integration-test-engineer` · `localization-test-engineer` · `observability-test-engineer` ·
+`ui-component-test-engineer` · `load-performance-engineer` · `visual-regression-engineer` ·
+`fuzz-property-engineer` · `data-quality-tester` · `e2e-orchestrator` · `contract-testing-engineer` ·
+`test-automation-engineer` · `test-data-manager` · `incident-to-scenario-synthesizer`.
 
 **Executor-vs-advisor twins** (reciprocal NOT-THIS-WHEN contracts): qe specialists RUN tools and
 write evidence + ledger verdict rows; their garden twins advise. a11y ↔ `product-a11y-expert`;
@@ -182,19 +185,16 @@ AC quality ↔ `product-requirements-analyst`; AI-feature probes ↔ `agentic-sa
 - **Evidence + config contract (shared with crew/ledger — do not rename):**
   `.wicked-qe/config.json`, `.wicked-qe/evidence/<run-id>/`,
   `.wicked-qe/wicked-qe.db`.
-- **wicked-ledger** (npm, pinned via `wicked_ledger_version` in plugin.json):
-  DomainStore CRUD, fixed-SQL oracle queries, `buildManifest`. Import-style
-  snippets need the package resolvable from the project
-  (`npm i --no-save wicked-ledger`).
-- **`{WT_LIB}` helpers**: specialist playbooks reference helper modules that
-  ship in-catalog at `scripts/qe/lib/` (ported from the
-  retired wicked-testing package in Phase 6c) — resolve <!-- historical -->
+- **wicked-ledger** (npm, pinned via `wicked_ledger_version` in plugin.json): DomainStore CRUD,
+  fixed-SQL oracle queries, `buildManifest`. Import-style snippets need the package resolvable
+  from the project (`npm i --no-save wicked-ledger`).
+- **`{WT_LIB}` helpers**: specialist playbooks reference helper modules that ship in-catalog at
+  `scripts/qe/lib/` (ported from the retired wicked-testing package in Phase 6c) — resolve <!-- historical -->
   `WT_LIB="$(wicked-garden path scripts/qe/lib)"`.
 
 ## Integration with wicked-crew
 
-Engaged during **build** (author + execute), **test/review** phases
-(execute + accept + review), and **ship** gates (release-readiness via
-insight/review). Crew routes the `qe` specialist per `specialist.json`;
-gates read verdict rows from the ledger — the pipeline never self-declares
-a crew gate passed.
+Engaged during **build** (author + execute), **test/review** phases (execute + accept + review),
+and **ship** gates (release-readiness via insight/review). Crew routes the `qe` specialist per
+`specialist.json`; gates read verdict rows from the ledger — the pipeline never self-declares a
+crew gate passed, and no qe action pushes or opens a PR — the run's deliver phase delivers.

package/skills/qe/refs/author.md

@@ -66,27 +66,113 @@ framework.
 - Framework: {jest | pytest | playwright | vitest | go test | ... | detect from project}
 
 ## Instructions
-1. Detect the project's test framework if not specified (presence of
-   `vitest.config.*`, `jest.config.*`, `pyproject.toml` with pytest, etc.).
-2. For every public function / endpoint / component in scope, produce a test
-   that exercises a happy path AND at least one negative / edge case.
+1. Detect the project's test harness if not specified (`package.json`
+   `scripts.test` / `test:e2e`, `vitest.config.*`, `jest.config.*`,
+   `playwright.config.*`, `pyproject.toml` with pytest, an existing `e2e/`
+   rig) and name the exact run command. Match what is there — never add a runner.
+2. For every public function / endpoint / component in scope, produce a
+   BEHAVIOUR test that exercises a happy path AND at least one negative /
+   edge case — assert on what the caller observes, not on internal structure.
 3. Use existing fixtures where present; don't hand-roll test data if the
    project has factories.
 4. Follow the project's file-layout convention (co-located vs `tests/`).
-
-Return the path(s) written and a one-line per-file summary."""
+5. RUN every file you produced with the harness's real command and record
+   file · exact command · result (`N passed / N failed`) in the PLAN's
+   execution table. A file you did not run is `unverified` — never `covered`,
+   never "passes". Pre-existing coverage is claimed only with `path:line`.
+   A test that needs a server, seed data or a build is `needs-fixture` with
+   how to start it — run it against that fixture before you claim it.
+6. Do NOT `git push`, `gh pr create` or merge — the run's deliver phase
+   opens the PR; leave the files on the working tree and report the paths.
+
+Return the path(s) written, the execution table, the `unverified` and
+`not covered` rows, and a one-line per-file summary."""
 )
 ```
 
 Specialized dispatches swap the `skill` id for the right worker (see the
 table above). For an OpenAPI spec, use `wicked-garden-qe-contract-testing-engineer`; for the
 3-role acceptance pipeline's test-plan phase, use `wicked-garden-qe-acceptance-test-writer`.
+Instructions 1, 5 and 6 travel with EVERY code-producing dispatch (not the
+acceptance writer — its plans are run by the executor) — a fork worker sees only
+its args, so the contract below is copied into them, not assumed.
+
+## Verified-test contract (binding for every produced test)
+
+Written after the wave-6 acceptance review of a governed "New test" run (R4-r2 /
+F-7R2-015): the worker shipped a Playwright suite it never executed (it failed on
+its first line when run independently), sold 22 pre-existing tests as a
+"29-scenario suite", described waits it had not written, and opened the PR
+itself. None of that is authoring. Every dispatch in this playbook carries the
+rules below, and the `review` action (`refs/review.md` § Reviewing produced
+tests) re-derives each one.
+
+1. **Detect the harness before writing a line.** Read `package.json` `scripts`
+   (`test`, `test:e2e`, `typecheck`), `vitest.config.*` / `jest.config.*` /
+   `playwright.config.*`, `pyproject.toml` `[tool.pytest.ini_options]` /
+   `pytest.ini` / `conftest.py`, an `e2e/` or `tests/e2e/` directory and how its
+   existing rigs start their fixture, `Cargo.toml`, `go.mod`. Name the harness
+   and the exact command in the PLAN. Match what is there; never add a runner.
+2. **Behaviour, not implementation.** Assert what a user or caller observes —
+   rendered DOM, response status/body, file contents, exit code, the arguments a
+   mocked boundary received. Not internal structure, not "the mock was called",
+   never a snapshot of a mock. For each test, know the change to the source that
+   would make it fail; a test with no such change is tautological — drop it.
+3. **Run what you write — before you claim it.** Execute every produced test
+   file with the harness's real command (`npx vitest run <file>`,
+   `python -m pytest <file>`, `npx playwright test <file>`, the rig's own
+   `python3 e2e/<rig>.py`). Record in the PLAN's execution table: file, exact
+   command, result (`N passed / N failed`, duration), commit or timestamp. A
+   test you did not execute is `unverified` — never `covered`, never "passes".
+   A failing test is fixed and re-run, or shipped as `failing` with the reason
+   — never described as green. "All tests pass" without the table is a claim,
+   not evidence.
+4. **Cite pre-existing coverage or don't claim it.** A `covered` row for a
+   test you did not write carries `path:line` of the `it` / `test` /
+   `def test_` and what it asserts. No citation → `unverified`. Report
+   "N new" and "M pre-existing (cited)" as separate counts — never a padded
+   total.
+5. **Fixture-bound e2e is labelled and started.** A browser or API test that
+   needs a server, seed data or a build is `needs-fixture`; the PLAN says how
+   to start it (build step, command, port, env) — copy the repo's own rig
+   convention. Run it against that fixture before claiming; verify every
+   selector, test id and text against the source (`grep` the `data-testid`,
+   read the render rule that produces the text). If the fixture cannot start
+   here, the row is `unverified — fixture unavailable: <reason>` and the reply
+   says so.
+6. **Say what you did not cover.** The PLAN carries `not covered` rows for
+   every part of the intent without a test — no UI control exists, out of
+   scope, blocked — with the reason. Silence is a false claim.
+7. **Delivery belongs to the run, not to you.** Leave the tests on the working
+   tree / run branch and report the paths. Never `git push`, `gh pr create`,
+   `gh pr merge`, or any remote-writing command — inside a wicked-crew run the
+   run's deliver phase opens the PR (evaluator ≠ creator: the acceptance gate
+   reads the evidence the deliver phase records); standalone, the human opens
+   it.
+
+### PLAN execution table (required shape)
+
+| Row | Status | Evidence the row must carry |
+|---|---|---|
+| a test you wrote | `covered` | `<file>` · `<exact command>` · `<N passed / N failed>` · `<sha or time>` |
+| a pre-existing test | `covered` | `<path:line>` · what it asserts |
+| written, not executed | `unverified` | why (not run / `fixture unavailable: <reason>`) |
+| needs a server / build / seed | `needs-fixture` | how to start it · then its execution row |
+| executed and red | `failing` | the failure and why it ships red |
+| an intent gap | `not covered` | why (no control exists / out of scope / blocked) |
+
+The status vocabulary is closed. `covered` requires an execution row (new) or a
+`path:line` citation (pre-existing); the reviewer FAILS a PLAN that breaks it,
+and FAILS any PLAN whose e2e has no execution row.
 
 ## Tier-2 specialists this skill routes to
 
-For domain-specific test authoring, dispatch the matching specialist. Each
-returns test code and/or scenarios in its domain — do not merge their output
-verbatim; fold it into the authoring reply:
+For domain-specific test authoring, dispatch the matching specialist with the
+block above — instructions 1, 5 and 6 included. Each specialist's own SKILL.md
+also carries the contract's run-before-claim / cite / never-ship block, so a
+direct invocation on any CLI is bound the same way. Each returns test code
+and/or scenarios in its domain — do not merge their output verbatim; fold it
+into the authoring reply:
 
 | Trigger                                              | Specialist                                  |
 |------------------------------------------------------|---------------------------------------------|
@@ -109,9 +195,14 @@ Scenario files use the format in [refs/scenario-format.md](refs/scenario-format.
 - Test code in the project's test directory matching the project's framework,
   OR
 - Both, when authoring scenarios that have automated companions
+- For test code, ALWAYS a PLAN carrying the execution table above — harness +
+  command, per-file results, `unverified` / `needs-fixture` / `not covered`
+  rows — in the run's deliverable, or where the repo already keeps test prose
+  (`docs/`, `.product/`); inside the test tree only if the repo already does that
 
 Emits `wicked.qe.scenario.authored` and/or `wicked.test.strategy.generated` on the
-bus when present.
+bus when present. The authoring reply never says a test passes without its
+execution row, and never opens or pushes a PR — the run's deliver phase does.
 
 ## Legacy invocations (absorbed in 0.4.0)
 

package/skills/qe/refs/review.md

@@ -45,6 +45,7 @@ Arguments map onto the dispatch table below:
 | A run's evidence manifest                                  | `wicked-garden-qe-acceptance-test-reviewer`    |
 | Spec + implementation (post-code divergence)               | `wicked-garden-qe-semantic-reviewer`           |
 | Test suite path                                            | `wicked-garden-qe-code-analyzer` + Tier-2      |
+| A PLAN + the produced tests it claims (the `author` output) | `wicked-garden-qe-test-code-quality-auditor` — § Reviewing produced tests |
 | Production metrics, post-deploy                            | `wicked-garden-qe-production-quality-engineer` |
 
 ### Dispatch block (executable)
@@ -95,6 +96,105 @@ Reviewers work from evidence and spec, not from the executor's story.
 forked invocation, scrubbed `context.md` via `{WT_LIB}/context-md-validator.mjs`)
 to keep its verdict honest. Do not pre-narrate what it should find.
 
+## Reviewing produced tests (the `author` output: a PLAN + test files)
+
+When the input is a PLAN with an execution table plus the test files it claims
+— the `review` phase of a governed test-authoring run, or any "are these new
+tests any good" — the reviewer re-derives every claim; it never takes the
+author's word. Written after the wave-6 acceptance review (R4-r2 / F-7R2-015),
+where seven default-allow gates passed a Playwright suite nobody had run.
+Dispatch `wicked-garden-qe-test-code-quality-auditor` with the block below;
+where the harness is runnable it re-runs the produced files itself.
+
+1. **Every `covered` claim is opened at its `file:line`.** Confirm the test
+   exists, that its assertion is the behaviour the row names, and that the
+   count of `it` / `test` / `def test_` blocks matches the PLAN's numbers (new
+   vs pre-existing reported separately). A `covered` row without a citation,
+   or whose citation does not hold, is reclassified `unverified` and is a
+   finding; a padded total is a finding.
+2. **Every produced file has an execution record** — file · exact command ·
+   result. Re-run at least the produced files when the harness is available
+   and compare with the record. A produced file with no record, a record with
+   no result, or a `needs-fixture` e2e that was never run against its fixture
+   → **the plan FAILS** (`[unexecuted-test]`), whatever else holds. The
+   "evidence-gated" label is decided here, not by the author.
+3. **Mutate or reason — at least two behaviours.** For ≥ 2 tested behaviours
+   either apply a deliberate source mutation (swallow the error, invert the
+   guard, drop the branch), re-run the test, confirm it FAILS, and restore the
+   source — guarded: `git status --porcelain -- <file>` must be empty before
+   you mutate (otherwise copy the file aside and restore from the copy — never
+   `git checkout`, which would also discard the author's uncommitted edit), and
+   `git diff --quiet -- <file>` afterwards proves the tree is byte-identical;
+   or — when you cannot run — write the specific mutation and the assertion
+   line that would catch it. A test for which no failing mutation can be named
+   is tautological → that row FAILS.
+4. **Behaviour vs implementation.** Flag tests that assert internal structure,
+   a mock asserting on a mock, a snapshot of a fixture, or that would still
+   pass with the implementation deleted.
+5. **e2e oracles are checked against the source.** For every selector, test id
+   and text an e2e waits on, confirm it is rendered on the route the test
+   visits under the fixture the PLAN names (read the component; `grep` the
+   `data-testid`). An oracle that can never match is `[scenario-defect]`.
+6. **Scope honesty.** The PLAN's `not covered` rows must name what the intent
+   asked for and why it is absent; an intent area with no row and no test is
+   a finding.
+7. **The verdict goes back to the run.** The reviewer never opens, edits or
+   merges the PR and never pushes — the run's deliver phase (or the human)
+   does; a reviewer that ships is a creator grading itself.
+
+Verdict vocabulary (`MODE=produced-test`): **`PASS`** only when 1–7 hold with
+zero findings — every `covered` claim verified at its `path:line`, every
+produced test executed and green (your re-run reproduces the record), no
+`unverified` or `failing` row; **`CONDITIONAL`** with the fixes listed when only
+P1/P2 rows fail (implementation-shaped test, padded total, silent scope gap,
+style); **`FAIL`** on any `[unexecuted-test]`, red produced test, tautological
+test, unsupported-`covered` claim, or `[scenario-defect]` oracle. Cite
+`file:line` for every finding. The auditor's §9 carries the same rule.
+
+Dispatch fallback as in § Dispatch block above: without a Skill tool, open the
+named skill's `SKILL.md` and carry the args out inline.
+
+```
+Skill(
+  skill="wicked-garden-qe-test-code-quality-auditor",
+  args="""Review the produced tests named in the PLAN below against the qe
+`review` playbook's "Reviewing produced tests" rules. Re-derive every claim.
+
+## Mode
+MODE: produced-test — grade per the auditor's §9 produced-test verdict
+(`PASS` reachable), not its §5 audit.
+
+## PLAN
+{path to the PLAN carrying the execution table}
+
+## Produced files
+{paths}
+
+## Instructions
+1. Open every `covered` row at its file:line; reclassify unsupported rows
+   `unverified`; recount new vs pre-existing tests.
+2. Confirm every produced file has an execution record (file · command ·
+   result). None — or a `needs-fixture` e2e never run against its fixture —
+   is VERDICT=FAIL `[unexecuted-test]`.
+3. Re-run the produced files when the harness is available; compare with
+   the record.
+4. Mutate-or-reason about at least two tested behaviours; name the failing
+   mutation and the assertion that catches it; restore any mutated source
+   (guarded: clean `git status` on the file first, `git diff --quiet` after).
+5. Check every e2e selector / test id / text against the source on the
+   visited route under the named fixture.
+6. Check the PLAN's `not covered` rows against the intent.
+7. Flag implementation-shaped tests: internal structure, a mock asserting on
+   a mock, a snapshot of a fixture, or one that would pass with the
+   implementation deleted.
+
+Return `VERDICT={PASS|CONDITIONAL|FAIL} MODE=produced-test` — PASS only with
+every claim verified at path:line, every produced test executed and green, no
+`unverified` — and per-row findings with file:line. Do NOT push, open, edit or
+merge a PR — the run's deliver phase delivers."""
+)
+```
+
 ## Tier-2 specialists this skill routes to
 
 For domain-specific reviews, dispatch the specialist. Each returns a verdict
@@ -117,7 +217,9 @@ or a list of findings the skill folds into the review output:
 ## Verdict semantics
 
 - `PASS` — evidence + spec agree, tests exercise what was changed
-- `FAIL` — assertion unsatisfied, evidence contradicts, or spec-code divergence
+- `FAIL` — assertion unsatisfied, evidence contradicts, spec-code divergence, or
+  a produced test with no execution record (`[unexecuted-test]` — an e2e nobody
+  ran is a FAIL, never a PASS on paper)
 - `N-A` — reviewable item doesn't apply (must be justified)
 - `SKIP` — applicable but deferred (ticket required)
 - `CONDITIONAL` — approve with listed fixes before ship

package/skills/qe-a11y-test-engineer/SKILL.md

@@ -239,6 +239,22 @@ refuse a verdict — a11y is a gate.
   large text (≥18pt regular or ≥14pt bold). Flag any ratio the scenario's
   context.md tightens beyond that.
 
+## Run what you write — never ship
+
+The `wicked-garden-qe` skill's `refs/author.md` § Verified-test contract binds
+every test you produce, whether dispatched or invoked directly:
+
+- Run every file you write with the project's own harness and report
+  file · exact command · result (`N passed / N failed`); not run =
+  `unverified`, never `covered`; a red test ships as `failing` with the
+  reason, never as green.
+- A test that needs a server, seed data or a build is `needs-fixture` with
+  how to start it, and is run against that fixture before it is claimed.
+- Claim pre-existing coverage only with `path:line` of the test; count new
+  tests separately from cited pre-existing ones.
+- Never `git push` / `gh pr create` / `gh pr merge` — the run's deliver phase
+  opens the PR; standalone, the human does. Leave the files on the working tree.
+
 ## 7. Output format
 
 Print a compact summary to stdout; the full detail lives in the evidence

package/skills/qe-contract-testing-engineer/SKILL.md

@@ -47,6 +47,22 @@ not E2E — specifically the agreement on request/response shape.
 - Changing error shape
 - New required request fields
 
+## Run what you write — never ship
+
+The `wicked-garden-qe` skill's `refs/author.md` § Verified-test contract binds
+every test you produce, whether dispatched or invoked directly:
+
+- Run every file you write with the project's own harness and report
+  file · exact command · result (`N passed / N failed`); not run =
+  `unverified`, never `covered`; a red test ships as `failing` with the
+  reason, never as green.
+- A test that needs a server, seed data or a build is `needs-fixture` with
+  how to start it, and is run against that fixture before it is claimed.
+- Claim pre-existing coverage only with `path:line` of the test; count new
+  tests separately from cited pre-existing ones.
+- Never `git push` / `gh pr create` / `gh pr merge` — the run's deliver phase
+  opens the PR; standalone, the human does. Leave the files on the working tree.
+
 ## Output
 
 - A contract-diff report

package/skills/qe-data-quality-tester/SKILL.md

@@ -47,6 +47,22 @@ You verify the data itself, not just the code that touches it.
 - **SQL-based custom checks** — `EXCEPT` queries, cardinality ratios
 - **Soda** for streaming / operational data
 
+## Run what you write — never ship
+
+The `wicked-garden-qe` skill's `refs/author.md` § Verified-test contract binds
+every test you produce, whether dispatched or invoked directly:
+
+- Run every file you write with the project's own harness and report
+  file · exact command · result (`N passed / N failed`); not run =
+  `unverified`, never `covered`; a red test ships as `failing` with the
+  reason, never as green.
+- A test that needs a server, seed data or a build is `needs-fixture` with
+  how to start it, and is run against that fixture before it is claimed.
+- Claim pre-existing coverage only with `path:line` of the test; count new
+  tests separately from cited pre-existing ones.
+- Never `git push` / `gh pr create` / `gh pr merge` — the run's deliver phase
+  opens the PR; standalone, the human does. Leave the files on the working tree.
+
 ## Output
 
 Assertion suite + a freshness / drift report. On failure, show the

package/skills/qe-e2e-orchestrator/SKILL.md

@@ -46,8 +46,14 @@ point to the business outcome.
 - **Console errors fail the run** — monitor the browser console throughout; any unhandled JS exception or console error is an automatic FAIL
 - **Headless by default** — run browsers headless (`headless: true`) unless a scenario explicitly requires headed mode
 - **No fixed sleeps** — never `sleep N`; always wait for an explicit condition (selector visible, network idle, application state)
+- **Wait for the state you assert** — an assertion after an action is gated on the locator or state it checks, never on a comment that the framework "re-renders synchronously"
+- **Fixture named and started** — the suite is `needs-fixture`: record the build step, start command, port and env (copy the repo's own rig convention) and RUN the journey against it before you claim it. Not run = `unverified`, never "passes"; when the fixture cannot start here, say so with the reason
+- **Oracles checked against the source** — every selector, test id and text you wait on is confirmed rendered on the visited route under that fixture (`grep` the `data-testid`, read the title/render rule); never copy an id shape from a unit test
+- **You never ship** — report file · exact command · result; never `git push` / `gh pr create` / `gh pr merge` — the run's deliver phase opens the PR
+- **Contract** — the `wicked-garden-qe` skill's `refs/author.md` § Verified-test contract is the full text; it binds whether you are dispatched or invoked directly
 
 ## Output
 
-E2E test files + a journey diagram (ASCII or mermaid) showing the path.
+E2E test files + a journey diagram (ASCII or mermaid) showing the path, plus
+the execution record per file (command, result, fixture used).
 Integrates with `wicked-garden-qe execute` for evidence capture.

package/skills/qe-fuzz-property-engineer/SKILL.md

@@ -54,6 +54,22 @@ Target: parsers, deserializers, crypto code, sanitizers.
 - Minimize discovered crashes before filing
 - Integrate into CI as a nightly job — not every PR
 
+## Run what you write — never ship
+
+The `wicked-garden-qe` skill's `refs/author.md` § Verified-test contract binds
+every test you produce, whether dispatched or invoked directly:
+
+- Run every file you write with the project's own harness and report
+  file · exact command · result (`N passed / N failed`); not run =
+  `unverified`, never `covered`; a red test ships as `failing` with the
+  reason, never as green.
+- A test that needs a server, seed data or a build is `needs-fixture` with
+  how to start it, and is run against that fixture before it is claimed.
+- Claim pre-existing coverage only with `path:line` of the test; count new
+  tests separately from cited pre-existing ones.
+- Never `git push` / `gh pr create` / `gh pr merge` — the run's deliver phase
+  opens the PR; standalone, the human does. Leave the files on the working tree.
+
 ## Output
 
 Property test files (checked in) + any crash-inducing inputs (filed as

package/skills/qe-integration-test-engineer/SKILL.md

@@ -42,6 +42,22 @@ test, not your problem. Your tests stand up actual dependencies.
 - Assert the observable outcome, not the internal call sequence
 - Test the error paths: dependency down, slow, returns garbage
 
+## Run what you write — never ship
+
+The `wicked-garden-qe` skill's `refs/author.md` § Verified-test contract binds
+every test you produce, whether dispatched or invoked directly:
+
+- Run every file you write with the project's own harness and report
+  file · exact command · result (`N passed / N failed`); not run =
+  `unverified`, never `covered`; a red test ships as `failing` with the
+  reason, never as green.
+- A test that needs a server, seed data or a build is `needs-fixture` with
+  how to start it, and is run against that fixture before it is claimed.
+- Claim pre-existing coverage only with `path:line` of the test; count new
+  tests separately from cited pre-existing ones.
+- Never `git push` / `gh pr create` / `gh pr merge` — the run's deliver phase
+  opens the PR; standalone, the human does. Leave the files on the working tree.
+
 ## Output
 
 Test code + a one-paragraph note on what gets spun up, teardown strategy,

package/skills/qe-load-performance-engineer/SKILL.md

@@ -52,6 +52,22 @@ refuse to run and record SKIP with reason `trust-level-insufficient`.
 (Same contract as chaos / security-DAST specialists — see
 the `wicked-garden-qe` skill's `refs/execute.md`.)
 
+## Run what you write — never ship
+
+The `wicked-garden-qe` skill's `refs/author.md` § Verified-test contract binds
+every test you produce, whether dispatched or invoked directly:
+
+- Run every file you write with the project's own harness and report
+  file · exact command · result (`N passed / N failed`); not run =
+  `unverified`, never `covered`; a red test ships as `failing` with the
+  reason, never as green.
+- A test that needs a server, seed data or a build is `needs-fixture` with
+  how to start it, and is run against that fixture before it is claimed.
+- Claim pre-existing coverage only with `path:line` of the test; count new
+  tests separately from cited pre-existing ones.
+- Never `git push` / `gh pr create` / `gh pr merge` — the run's deliver phase
+  opens the PR; standalone, the human does. Leave the files on the working tree.
+
 ## Output
 
 A report with:

package/skills/qe-localization-test-engineer/SKILL.md

@@ -45,6 +45,22 @@ hold up.
 - Input validation must accept locale-appropriate formats (thousands separators,
   decimal commas, etc.)
 
+## Run what you write — never ship
+
+The `wicked-garden-qe` skill's `refs/author.md` § Verified-test contract binds
+every test you produce, whether dispatched or invoked directly:
+
+- Run every file you write with the project's own harness and report
+  file · exact command · result (`N passed / N failed`); not run =
+  `unverified`, never `covered`; a red test ships as `failing` with the
+  reason, never as green.
+- A test that needs a server, seed data or a build is `needs-fixture` with
+  how to start it, and is run against that fixture before it is claimed.
+- Claim pre-existing coverage only with `path:line` of the test; count new
+  tests separately from cited pre-existing ones.
+- Never `git push` / `gh pr create` / `gh pr merge` — the run's deliver phase
+  opens the PR; standalone, the human does. Leave the files on the working tree.
+
 ## Output
 
 Findings per locale: missing strings, formatting violations, layout bugs.

package/skills/qe-observability-test-engineer/SKILL.md

@@ -41,6 +41,22 @@ Your tests make sure the system tells its operators what it did.
 - Catch cardinality hazards: user_id as a label, unbounded route paths
 - Verify PII is NOT in logs / traces (names, tokens, payloads)
 
+## Run what you write — never ship
+
+The `wicked-garden-qe` skill's `refs/author.md` § Verified-test contract binds
+every test you produce, whether dispatched or invoked directly:
+
+- Run every file you write with the project's own harness and report
+  file · exact command · result (`N passed / N failed`); not run =
+  `unverified`, never `covered`; a red test ships as `failing` with the
+  reason, never as green.
+- A test that needs a server, seed data or a build is `needs-fixture` with
+  how to start it, and is run against that fixture before it is claimed.
+- Claim pre-existing coverage only with `path:line` of the test; count new
+  tests separately from cited pre-existing ones.
+- Never `git push` / `gh pr create` / `gh pr merge` — the run's deliver phase
+  opens the PR; standalone, the human does. Leave the files on the working tree.
+
 ## Output
 
 Assertion suite. One paragraph per signal category with pass/fail and

package/skills/qe-test-automation-engineer/SKILL.md

@@ -50,6 +50,28 @@ Match what's there. Do not introduce a new framework unless asked.
 - Deterministic: no wall-clock, no random, no network unless explicitly needed
 - Assertion messages explain WHY, not WHAT
 
+## Run what you write — before you claim it
+
+The `wicked-garden-qe` skill's `refs/author.md` § Verified-test contract is the
+full text; the rules below bind whether you are dispatched or invoked directly.
+
+- Name the harness and its exact command in your reply (from `package.json`
+  `scripts`, `vitest.config.*` / `jest.config.*` / `playwright.config.*`,
+  `pyproject.toml` pytest config, an existing `e2e/` rig).
+- Execute every file you produced with that command and report
+  file · command · result (`N passed / N failed`). A file you did not run is
+  `unverified` — never `covered`, never "passes". A red test ships as
+  `failing` with the reason, or not at all — never as green.
+- Behaviour tests: assert what the caller observes (output, status, DOM, file,
+  the arguments a boundary received), never internal structure or a mock
+  asserting on a mock; for each test know the source change that would fail it.
+- Pre-existing coverage is claimed only with `path:line` of the test and what
+  it asserts; report new and pre-existing counts separately — never padded.
+- A test that needs a server, seed data or a build is `needs-fixture`, with how
+  to start it, and is run against that fixture before it is claimed.
+- Never `git push`, `gh pr create` or `gh pr merge` — the run's deliver phase
+  opens the PR; standalone, the human does. Leave the files on the working tree.
+
 ## Infrastructure
 
 - Configure the runner config (jest.config, pytest.ini, etc.) only if missing
@@ -59,6 +81,8 @@ Match what's there. Do not introduce a new framework unless asked.
 ## Output
 
 - Test files in the project's conventional location
+- The execution table: file · exact command · result for every produced file,
+  plus the `unverified`, `needs-fixture` and `not covered` rows
 - One paragraph in the reply summarizing what was added, what's still missing,
   and the next command to run tests
 

package/skills/qe-test-code-quality-auditor/SKILL.md

@@ -3,7 +3,7 @@ name: wicked-garden-qe-test-code-quality-auditor
 context: fork
 model: sonnet
 effort: medium
-max-turns: 10
+max-turns: 15
 allowed-tools: Read, Write, Bash, Grep, Glob
 description: |
   Audits the TEST code itself — not the SUT. Detects assertion-free tests,
@@ -56,6 +56,12 @@ Relative paths in this skill are relative to the directory that contains this SK
     `P0`, `P1`, `P2`; default `P2` (include everything).
   - `top_n:` findings in the remediation list; default 30.
 - **`run_id`** — UUID of the current `runs` row; defines `EVIDENCE_DIR`.
+- **`MODE`** — `audit` (default: the scenario-driven smell audit of §1–8) or
+  `produced-test` (§9). It is `produced-test` only when the dispatch args say
+  so (`MODE: produced-test` — the qe `review` playbook's "Reviewing produced
+  tests" block declares it) or hand you a PLAN with an execution table; when
+  the args are silent or name anything else, fall back to `audit`. The `PASS`
+  branch in §5 exists only in `produced-test` mode.
 - **`.wicked-qe/config.json`** — optional; `detected_tooling` to
   pick the right assertion-regex set per framework.
 - **`.wicked-qe/evidence/<run_id>/context.md`** — optional rules,
@@ -211,7 +217,15 @@ top-n.csv` columns: `file,line,rule,severity,snippet,fix_hint`.
 const p0 = findings.filter(f => f.severity === "P0");
 const p1 = findings.filter(f => f.severity === "P1");
 const p2 = findings.filter(f => f.severity === "P2");
-const verdict = p0.length > 0 ? "FAIL" : (p1.length > 0 ? "CONDITIONAL" : "CONDITIONAL");
+// MODE (§1 Inputs): "produced-test" only when the dispatch args declare `MODE: produced-test`
+// or hand over a PLAN with an execution table; silent or anything else → "audit".
+const MODE = (ARGS_MODE === "produced-test" || PLAN_HAS_EXECUTION_TABLE) ? "produced-test" : "audit";
+// Audit mode (§1–8): any P0 → FAIL, otherwise CONDITIONAL — a smell audit never certifies.
+// Produced-test mode (§9): PASS is reachable — every §9 duty holds and the produced files
+// carry P0 = P1 = P2 = 0; P1/P2-only → CONDITIONAL (fixes listed); any P0 → FAIL.
+const verdict = p0.length > 0 ? "FAIL"
+  : MODE === "produced-test" ? ((p1.length + p2.length) > 0 ? "CONDITIONAL" : "PASS")
+  : "CONDITIONAL";
 
 store.create("verdicts", {
   run_id: RUN_ID,
@@ -254,8 +268,9 @@ narrative so the reviewer knows the coverage is partial.
 
 ## 7. Non-negotiable rules
 
-- **Do not mutate test code.** This is a read-only auditor. Remediation
-  is a human action.
+- **Do not mutate test code.** This is a read-only auditor toward the
+  tests; remediation is a human action. The one exception is §9.3's mutation
+  of the SOURCE under test — temporary, guarded, and restored byte-for-byte.
 - **P0 findings block the verdict.** A single assertion-free test is
   a FAIL — that test is coverage theatre.
 - **Never flag a legitimate `expect.assertions(N)` / `assert_called`
@@ -295,6 +310,72 @@ top-5 (full list in test-quality-top-n.csv):
 VERDICT={CONDITIONAL|FAIL} REVIEWER=wicked-garden-qe-test-code-quality-auditor RUN_ID={RUN_ID}
 ```
 
+## 9. Produced-test review (a PLAN + the tests it claims)
+
+When the qe `review` action dispatches you in `produced-test` mode (`MODE:
+produced-test` in the args — §1) with a PLAN that carries an execution table
+(the `author` output — the review phase of a governed test-authoring run), the
+detectors above run on the produced files AND these duties apply. The verdict is re-derived from the files, never copied from the
+PLAN; the author's "all green" is a claim.
+
+1. **`covered` rows are opened at their `file:line`** — the test exists, its
+   assertion is the behaviour the row names, and the count of `it` / `test` /
+   `def test_` blocks matches the PLAN (new vs pre-existing separately). A
+   `covered` claim with no citation, or one that does not hold, is an
+   unsupported coverage claim (P0) — reclassify the row `unverified`; a padded
+   total is a P1 finding.
+2. **Every produced file has an execution record** — file · exact command ·
+   result. Re-run the produced files with that command when the harness is
+   available and compare. A produced file with no record, an `unverified`
+   produced file, or a `needs-fixture` e2e never run against its fixture →
+   **`[unexecuted-test]`** (P0), whatever else holds; a red produced test
+   (`failing`, or red on your re-run) is P0 too.
+3. **Mutate or reason about ≥ 2 tested behaviours** — apply a deliberate
+   mutation to the SOURCE under test (invert a guard, swallow an error, drop a
+   branch), re-run, confirm the test FAILS, then restore. Guard the restore:
+   before mutating, `git status --porcelain -- <file>` must be empty — if it
+   is not (the author phase touched that file and the run has not committed
+   it), copy the file aside and restore from the copy, never with
+   `git checkout`, which would also discard the author's edit; afterwards
+   `git diff --quiet -- <file>` (or a checksum) proves the tree is
+   byte-identical. §7's "do not mutate test code" stands — this touches the
+   SUT and is reverted. When you cannot run, name the mutation and the
+   assertion line that would catch it. No nameable failing mutation →
+   tautological (P0).
+4. **Behaviour vs implementation** — a test that asserts internal structure,
+   a mock asserting on a mock, a snapshot of a fixture, or that would still
+   pass with the implementation deleted is implementation-shaped (P1); the
+   detectors in §2 do not catch this — read the assertions.
+5. **e2e oracles against the source** — every selector, test id and text the
+   e2e waits on is rendered on the visited route under the named fixture
+   (`grep` the `data-testid`, read the render rule); an oracle that can never
+   match is `[scenario-defect]` (P0).
+6. **Scope honesty** — the PLAN's `not covered` rows name each intent area
+   without a test and why; a silent gap is a P1 finding.
+7. **You never ship** — no `git push`, `gh pr create`, `gh pr merge`; the
+   verdict returns to the run, whose deliver phase (or the human) opens the PR.
+
+### Produced-test verdict (`PASS` is reachable here, unlike the audit in §5)
+
+- **`PASS`** — all of: every `covered` claim verified at its `path:line`
+  (duty 1); every produced file executed with its recorded command and green,
+  and your re-run — when the harness is available — reproduces it (duty 2); no
+  `unverified` and no `failing` row among the produced files; ≥ 2 behaviours
+  mutated-or-reasoned with a nameable failing mutation each (duty 3); e2e
+  oracles verified (duty 5); `not covered` rows account for the intent
+  (duty 6); and the §2 detectors report P0 = P1 = P2 = 0 on the produced files.
+- **`CONDITIONAL`** — no P0, but any P1/P2 (implementation-shaped test, padded
+  total, silent scope gap, style smells): approve with the fixes listed.
+- **`FAIL`** — any P0: `[unexecuted-test]`, a red produced test, an
+  unsupported `covered` claim, a tautological test, or an impossible oracle
+  `[scenario-defect]`.
+
+Report line for this mode (the §8 line stays for the audit):
+
+```
+VERDICT={PASS|CONDITIONAL|FAIL} MODE=produced-test REVIEWER=wicked-garden-qe-test-code-quality-auditor RUN_ID={RUN_ID}
+```
+
 ## Helper resolution (`{WT_LIB}`)
 
 `{WT_LIB}` is the plugin's own qe helper directory — the helper modules ship

package/skills/qe-test-data-manager/SKILL.md

@@ -54,6 +54,22 @@ Before any production-derived snapshot:
 - Fixtures are versioned; a schema change updates fixtures as part of
   the migration
 
+## Run what you write — never ship
+
+The `wicked-garden-qe` skill's `refs/author.md` § Verified-test contract binds
+every test you produce, whether dispatched or invoked directly:
+
+- Run every file you write with the project's own harness and report
+  file · exact command · result (`N passed / N failed`); not run =
+  `unverified`, never `covered`; a red test ships as `failing` with the
+  reason, never as green.
+- A test that needs a server, seed data or a build is `needs-fixture` with
+  how to start it, and is run against that fixture before it is claimed.
+- Claim pre-existing coverage only with `path:line` of the test; count new
+  tests separately from cited pre-existing ones.
+- Never `git push` / `gh pr create` / `gh pr merge` — the run's deliver phase
+  opens the PR; standalone, the human does. Leave the files on the working tree.
+
 ## Output
 
 Factory / fixture files + a one-paragraph note on coverage (what domain

package/skills/qe-ui-component-test-engineer/SKILL.md

@@ -43,8 +43,17 @@ backend — just this component with fake props and a DOM.
 - Interact via user-event (not fireEvent) where possible
 - Query by role / label — avoid test-ids unless there's no semantic anchor
 - Assert what a user would notice, not implementation details
+- Run every file you write with the project's runner (`npx vitest run <file>`,
+  jest) and report file · command · result; not run = `unverified`, never
+  `covered`; a red test ships as `failing` with the reason, never as green
+- Claim pre-existing coverage only with `path:line` of the test; count new
+  tests separately from cited pre-existing ones
+- Never `git push` / `gh pr create` — the run's deliver phase opens the PR
+- The `wicked-garden-qe` skill's `refs/author.md` § Verified-test contract is the
+  full text; it binds whether you are dispatched or invoked directly
 
 ## Output
 
 Tests in the project's conventional test location. One file per component,
-one test per behavior variant. Note coverage gains.
+one test per behavior variant. Note coverage gains with the execution record
+(file · command · result) — never a pass claim without it.

package/skills/qe-visual-regression-engineer/SKILL.md

@@ -262,6 +262,22 @@ a different browser. A missing webkit run is not a chromium run.
   motion-sensitive regions, run the visual pass with both default and
   reduced-motion media queries, and keep both sets of screenshots.
 
+## Run what you write — never ship
+
+The `wicked-garden-qe` skill's `refs/author.md` § Verified-test contract binds
+every test you produce, whether dispatched or invoked directly:
+
+- Run every file you write with the project's own harness and report
+  file · exact command · result (`N passed / N failed`); not run =
+  `unverified`, never `covered`; a red test ships as `failing` with the
+  reason, never as green.
+- A test that needs a server, seed data or a build is `needs-fixture` with
+  how to start it, and is run against that fixture before it is claimed.
+- Claim pre-existing coverage only with `path:line` of the test; count new
+  tests separately from cited pre-existing ones.
+- Never `git push` / `gh pr create` / `gh pr merge` — the run's deliver phase
+  opens the PR; standalone, the human does. Leave the files on the working tree.
+
 ## 9. Output
 
 ```

package/uv.lock

@@ -691,7 +691,7 @@ wheels = [
 
 [[package]]
 name = "wicked-garden"
-version = "1.33.0"
+version = "0.0.0"
 source = { editable = "." }
 dependencies = [
     { name = "aiofiles" },