@lovehlmmm/primekit 1.0.0

package/skills/test/SKILL.md

@@ -0,0 +1,200 @@
+---
+name: pk:test
+description: "Run unit, integration, e2e, and UI tests. Use for test execution, coverage analysis, build verification, visual regression, and QA reports."
+user-invocable: true
+when_to_use: "Invoke for running or designing validation suites."
+category: utilities
+keywords: [test, unit, integration, e2e, coverage]
+argument-hint: "[context] OR ui [url] OR create|optimize|audit [scope] [--advice] [--ultra] [--interview]"
+metadata:
+  author: primekit
+  version: "1.1.0"
+  workflow:
+    precedes: [primekit-code-review]
+---
+
+# Testing & Quality Assurance
+
+Comprehensive testing framework covering code-level testing (unit, integration, e2e), UI/visual testing via browser automation, coverage analysis, and structured QA reporting.
+
+## Default (No Arguments)
+
+If invoked with context (test scope), proceed with testing. If invoked WITHOUT arguments, use `ask_user capability` to present available test operations:
+
+| Operation | Description |
+|-----------|-------------|
+| `(default)` | Run unit/integration/e2e tests |
+| `ui` | Run UI tests on a website |
+| `create` | Scout the codebase + docs, then create a covering test suite |
+| `optimize` | Parallel-scout CI/CD, git history, codebase + docs, then cut test cost/time safely |
+| `audit` | Parallel-scout the suite + CI, detect deceptive/weak tests, then repair |
+
+Present as options via `ask_user capability` with header "Test Operation", question "What would you like to do?".
+
+## Core Principle
+
+**NEVER IGNORE FAILING TESTS.** Fix root causes, not symptoms. No mocks/cheats/tricks to pass builds.
+
+## When to Use
+
+- **After implementation**: Validate new features or bug fixes
+- **Coverage checks**: Ensure coverage meets project thresholds (80%+)
+- **UI verification**: Visual regression, responsive layout, accessibility
+- **Build validation**: Verify build process, dependencies, CI/CD compatibility
+- **Pre-commit/push**: Final quality gate
+
+## Workflows
+
+### 1. Code Testing (`references/test-execution-workflow.md`)
+
+Execute test suites, analyze results, generate coverage. Supports JS/TS (Jest/Vitest/Mocha), Python (pytest), Go, Rust, Flutter. Includes working process, quality standards, and tool commands.
+
+**Load when:** Running unit/integration/e2e tests, checking coverage, validating builds
+
+### 2. UI Testing (`references/ui-testing-workflow.md`)
+
+Browser-based visual testing via `pk:agent-browser`, `pk:chrome-profile`, `pk:web-testing`, or project-native Playwright/Vitest/k6 commands. Covers screenshots, responsive checks, accessibility audits, form automation, and console error collection.
+
+**Load when:** Visual regression testing, UI bugs, responsive layout checks, accessibility audits
+
+### 3. Report Format (`references/report-format.md`)
+
+Structured QA report template: test results overview, coverage metrics, failed tests, performance, build status, recommendations.
+
+**Load when:** Generating test summary reports
+
+### 4. Suite Creation (`references/create-suite-workflow.md`)
+
+`create`: activate `pk:scout` over the codebase and docs, map features and
+workflows to a coverage matrix, then design and implement a test suite that
+covers them.
+
+**Load when:** `create` argument — bootstrapping or extending a test suite
+
+### 5. Suite Optimization (`references/optimize-suite-workflow.md`)
+
+`optimize`: multiple parallel `pk:scout` subagents analyze CI/CD workflows, git
+history, codebase, and docs, then restructure tests for speed at equal safety —
+parallel lanes, change-based test selection, docs-only skips. Goal: lower CI
+cost, faster ships, no lost coverage.
+
+**Load when:** `optimize` argument — CI too slow/expensive, suite growth pains
+
+### 6. Suite Audit (`references/audit-suite-workflow.md`)
+
+`audit`: multiple parallel `pk:scout` subagents analyze the test suite and
+CI/CD workflows, detect deceptive or weak tests (tests written only to pass,
+commented-out/skipped tests, unfinished tests, redundant or outdated tests,
+security gaps), then fix and apply the improvements.
+
+**Load when:** `audit` argument — trust or quality concerns about the suite
+
+## Quick Reference
+
+```
+Code tests     → test-execution-workflow.md
+  npm test / pytest / go test / cargo test / flutter test
+  Coverage: npm run test:coverage / pytest --cov
+
+UI tests       → ui-testing-workflow.md
+  Screenshots, responsive, a11y, forms, console errors
+  Auth: chrome-profile for real user login/cookies, or project-native test setup
+
+Reports        → report-format.md
+  Structured QA summary with metrics & recommendations
+```
+
+## Working Process
+
+1. Identify testing scope from recent changes or requirements
+2. Run typecheck/analyze commands to catch syntax errors first
+3. Execute appropriate test suites
+4. Analyze results — focus on failures
+5. Generate coverage reports if applicable
+6. For frontend: run UI tests via `pk:agent-browser`, `pk:chrome-profile`, `pk:web-testing`, or project-native browser tests
+7. Produce structured summary report
+
+## Tools Integration
+
+- **Test runners**: Jest, Vitest, Mocha, pytest, go test, cargo test, flutter test
+- **Coverage**: Istanbul/c8/nyc, pytest-cov, go cover
+- **Browser**: `pk:agent-browser` for live browser interaction without real user cookies; `pk:chrome-profile` for the user's actual Chrome login state, opened with `chrome-profile open --json` and bound by the returned selector; `pk:web-testing` or project-native Playwright/Vitest/k6 for repeatable UI tests
+- **Analysis**: `pk:ai-multimodal` skill for screenshot analysis
+- **Debugging**: `pk:debug` skill when tests reveal bugs requiring investigation
+- **Thinking**: `pk:sequential-thinking` skill for complex test failure analysis
+
+## Quality Standards
+
+- All critical paths must have test coverage
+- Validate happy path AND error scenarios
+- Ensure test isolation — no interdependencies
+- Tests must be deterministic and reproducible
+- Clean up test data after execution
+- Never ignore failing tests to pass the build
+
+## Report Output
+**IMPORTANT:** Invoke "the engineer project-organization skill" skill to organize the outputs.
+
+Use naming pattern from `## Naming` section injected by hooks.
+
+## Team Mode
+
+When operating as teammate:
+1. Discover the live task-management surface and the live team-coordination surface
+2. Claim the assigned or next unblocked item when supported; otherwise read and update the active plan
+3. Read the full work description before starting and wait for implementation prerequisites
+4. Respect file ownership — only create/edit test files assigned
+5. When done, record completion and report results through the live team surface
+
+Plan files are the durable source of truth when runtime task tracking is absent
+or session-scoped.
+
+## Workflow Position
+
+**Typically follows:** `/pk:cook` (test after implementation), `/pk:fix` (test after bug fix)
+**Typically precedes:** `primekit-code-review` (review after tests pass)
+**Related:** `/pk:cook` (implement then test), `/pk:fix` (fix then test)
+
+## Flags (create / optimize / audit)
+
+- `--advice` — run under `kongming` advisory supervision (see below).
+- `--ultra` — run the analysis/design step as a best-of-5 verifier pass (see
+  Ultra Verifier Mode).
+- `--interview` — before applying any change, list every proposed change
+  (tests added/removed/rewritten, CI workflow edits) with a one-line reason and
+  interview the user via `ask_user capability` — one decision per change group;
+  apply only the approved changes. Without `--interview`, apply directly but
+  still report the full change list.
+
+## Advisory supervision (`--advice`)
+
+When `--advice` is present, run this skill under `kongming` supervision.
+`kongming` is an advisory-only supervisor: it returns counsel, never code, and
+the main agent stays responsible for every decision, edit, and gate.
+
+Spawn `kongming` at these checkpoints: after the scout/analysis phase (pass the
+coverage matrix or findings and ask for a go/no-go plus the top risk); before
+applying suite or CI workflow changes (pass the proposed change list); and when
+stuck. Invoke with
+`delegate_agent capability(subagent_type="kongming", prompt="<task, evidence, approaches tried, the exact question>", description="advice: <checkpoint>")`.
+`--advice` never bypasses the failing-test rules or CI safety gates.
+
+## Ultra Verifier Mode (`--ultra`)
+
+When `--ultra` is present with `create`, `optimize`, or `audit`, run the
+analysis/design step as a best-of-5 verifier pass: one immutable evidence
+packet (scout reports, CI timings, git history summary), exactly five
+independent read-only candidates in one parallel wave, one strongest-model
+verifier.
+
+- `create`/`optimize`: the verifier selects the single winning suite design or
+  optimization plan unchanged (or rejects all); implementation runs once from
+  the winner.
+- `audit`: the verifier returns the
+  evidence-validated, deduplicated union of audit findings across the five
+  candidates — a real deceptive test may be caught by only one candidate;
+  repairs run once on the union.
+
+Full mechanics are in `../primekit-brainstorm/references/ultra-verifier-mode.md`. It
+is a best-of-5 verifier mode inspired by LLM-as-a-Verifier, not the full
+framework. `--ultra` composes with `--advice` and `--interview`.

package/skills/test/references/audit-suite-workflow.md

@@ -0,0 +1,70 @@
+# Suite Audit Workflow (`audit`)
+
+Find and repair tests that lie. LLM-authored code often optimizes for "done"
+at any cost, so suites accumulate tests written only to pass, disabled tests,
+unfinished tests, and stubs that assert nothing. The audit restores the suite's evidential value.
+
+## 1. Parallel scout pass
+
+Dispatch multiple parallel `pk:scout` subagents with disjoint scopes over the
+test suite and CI/CD workflows:
+
+- test files per area (unit/integration/e2e/UI);
+- CI workflow files, including selection/skip logic and ignored lanes;
+- git history of test files (when tests were weakened, skipped, or deleted —
+  `git log -p` over test paths).
+
+## 2. Detection targets
+
+Hunt for each class with concrete evidence (file:line):
+
+- **Deceptive tests** — tests written only to pass: tautological asserts
+  (`expect(true)`), asserting the mock instead of the behavior, snapshotting
+  whatever the code currently does, catching and swallowing the failure,
+  over-broad mocks that bypass the code under test.
+- **Disabled tests** — commented-out or skipped tests (`skip`, `todo`, `xit`,
+  `t.Skip`, `@pytest.mark.skip`) without a linked reason or issue.
+- **Unfinished tests** — empty bodies, `TODO: implement`, setup without
+  assertions, placeholders left "for later".
+- **Ineffective tests** — pass with the bug present (spot-check by mutating
+  the code under test and watching for a failure), assert implementation
+  details instead of contracts, or duplicate another test's coverage.
+- **Missing edge cases** — boundaries, empty/null inputs, concurrency,
+  error paths, permission failures on covered features.
+- **Redundant tests** — overlapping low-value tests whose removal loses no
+  coverage (prove with a coverage diff before deleting).
+- **Outdated tests** — tests locked to removed features, renamed APIs, or
+  contracts the current code no longer has.
+- **Security gaps in tests** — hardcoded real credentials or tokens in
+  fixtures, tests that print secrets, missing security coverage for authz/authn
+  failure paths, injection-shaped inputs never exercised.
+- **CI blind spots** — lanes that never run, always-green jobs with masked
+  exit codes (`|| true`), result files ignored by the gate.
+
+## 3. Rank and decide
+
+Classify each finding: **Critical** (deceptive/disabled test hides a real
+regression path, secret exposure) → **Important** (ineffective, outdated,
+missing edge case) → **Minor** (redundancy, style). For each, record evidence,
+the proposed repair (rewrite / re-enable with fix / add cases / delete), and
+the risk of the repair itself.
+
+## 4. Repair and apply
+
+- With `--interview`: present the ranked change list and interview the user per
+  group before applying; apply only approved repairs. Otherwise apply directly
+  and report everything.
+- Rewrite deceptive/ineffective tests to assert the observable contract; each
+  repaired test must fail when its target bug is reintroduced.
+- Re-enable disabled tests by fixing the underlying cause — never delete a
+  skip marker without making the test genuinely pass.
+- Add the missing edge cases; delete redundant tests only with a coverage diff
+  proving nothing is lost.
+- Remove real secrets from fixtures; replace with synthetic values.
+- Run the full suite after repairs; everything green, no new skips.
+
+## 5. Report
+
+Per `references/report-format.md`: findings by class and severity with
+evidence, repairs applied vs deferred (and why), coverage before/after,
+suite-trustworthiness assessment, unresolved questions last.

package/skills/test/references/create-suite-workflow.md

@@ -0,0 +1,60 @@
+# Suite Creation Workflow (`create`)
+
+Create a test suite that covers the project's features and workflows, grounded
+in what the code and docs actually do — never in guessed behavior.
+
+## 1. Scout the codebase and docs
+
+Activate `pk:scout` (parallel Explore subagents when the runtime permits) over:
+
+- entry points, public APIs, exported modules, CLI commands, HTTP routes;
+- business workflows described in `docs/` and the README;
+- existing tests (framework, layout, helpers, fixtures, naming conventions);
+- configuration and environment surfaces that change behavior;
+- error paths and boundary conditions visible in the code.
+
+Output: a scout report listing features, workflows, and their owning files.
+
+## 2. Build the coverage matrix
+
+Map every discovered feature/workflow to its intended coverage:
+
+| Feature / workflow | Owner files | Level (unit/integration/e2e) | Exists? | Priority |
+| --- | --- | --- | --- | --- |
+
+Rules:
+
+- Prefer the lowest level that can prove the behavior (unit > integration > e2e).
+- Every critical path gets happy-path AND error-path coverage.
+- Reuse the project's existing framework and conventions — never introduce a
+  second test framework beside a working one.
+- Skip trivial plumbing (getters, pass-throughs); test behavior, boundaries,
+  invariants, transitions, and real error handling.
+
+## 3. Design before writing
+
+For each matrix row without coverage, define: the observable contract under
+test, the failure a plausible bug would cause, fixtures needed, and isolation
+requirements (no cross-test dependencies, deterministic, full-suite-safe).
+
+With `--interview`: present the matrix and the planned test list; interview the
+user per group before writing. With `--ultra`: fan this design step per the
+skill's Ultra Verifier Mode. With `--advice`: checkpoint the matrix with
+`kongming` before implementation.
+
+## 4. Implement
+
+- Write tests group by group; run each group as it lands.
+- Each test MUST fail on a plausible bug — spot-check by mutating the code
+  under test once, watching the test fail, then reverting.
+- Wire coverage tooling when the project already defines it; target the
+  project's threshold (default 80% on critical paths).
+- Never write a test that asserts nothing, mirrors the implementation line by
+  line, or locks in buggy behavior to pass.
+
+## 5. Verify and report
+
+- Run the full new suite plus the pre-existing suite; both must be green.
+- Report per `references/report-format.md`: matrix coverage before/after,
+  tests added per level, gaps intentionally left (with reasons), and unresolved
+  questions last.

package/skills/test/references/optimize-suite-workflow.md

@@ -0,0 +1,61 @@
+# Suite Optimization Workflow (`optimize`)
+
+Make the test suite and its CI cheaper and faster while keeping every safety
+case covered. Optimize execution, never assertions: dropping real coverage to
+save minutes is failure.
+
+## 1. Parallel scout pass
+
+Dispatch multiple parallel `pk:scout` subagents (one per area, disjoint scopes):
+
+- **CI/CD workflows** — every pipeline file (`.github/workflows/`, etc.): job
+  graph, triggers, matrices, caches, artifact flows, wall-clock and billable
+  minutes per job (use `gh run list`/`gh run view` timings when available).
+- **Git history** — mine the git history for which paths change together, change frequency per area,
+  which tests fail most, which never fail (candidates for slimmer lanes).
+- **Codebase** — module boundaries and the dependency edges that map source
+  paths to the tests that exercise them.
+- **Docs** — documented workflows whose coverage must never be dropped, plus
+  pure-docs surfaces eligible for test skips.
+
+Merge into one evidence report: cost per job, slowest tests, path→test-group
+mapping, and safety-critical groups that must always run.
+
+## 2. Optimization levers (apply in this order)
+
+1. **Change-based test selection** — run only the test groups whose mapped
+   source paths changed (derive the mapping from the dependency scout; keep a
+   conservative fallback: unmapped changes run the full suite).
+2. **Docs-only skip** — when a diff is docs-only (touches only documentation/prose surfaces),
+   skip test execution in preflight/CI via path filters or a classifier gate;
+   changes that touch both docs and code always run the code lanes.
+3. **Parallel lanes** — split slow suites into balanced parallel jobs/shards;
+   keep shards deterministic and isolation-safe.
+4. **Cache and setup cost** — cache dependency stores and build outputs;
+   hoist repeated setup into fixtures or shared jobs.
+5. **Tiering** — fast smoke lane on every push; full suite on merge queues,
+   protected branches, and risk-labeled diffs.
+6. **Kill duplicate work** — deduplicate overlapping jobs, cancel superseded
+   runs (concurrency groups), stop re-running unchanged matrices.
+
+## 3. Safety gates (non-negotiable)
+
+- Safety-critical groups (from the scout report) run on every code-touching
+  diff regardless of change-based test selection.
+- Selection/skip logic must fail open: classifier errors → run the full suite.
+- Never weaken, delete, or skip an assertion to save time — that is `audit`
+  territory, and only with evidence the test is worthless.
+- Merge-blocking gates keep their trigger conditions; only their internal
+  parallelism and selection change.
+
+## 4. Apply and prove
+
+- With `--interview`: list every proposed change (per workflow file, per test
+  group) with expected savings and risk; interview the user per group; apply
+  only approved changes. Otherwise apply directly and report the list.
+- Prove no lost coverage: run the full suite once after restructuring; compare
+  pass/fail sets and coverage totals before/after.
+- Prove the savings: compare pipeline wall-clock/billable minutes on a real run
+  (or a dry-run estimate per job) before/after.
+- Report: levers applied, measured savings, safety groups preserved, fallback
+  behavior, unresolved questions last.

package/skills/test/references/report-format.md

@@ -0,0 +1,58 @@
+# Test Report Format
+
+Structured QA report template. Sacrifice grammar for concision.
+
+## Template
+
+```markdown
+# Test Report — {date} — {scope}
+
+## Test Results Overview
+- **Total**: X tests
+- **Passed**: X | **Failed**: X | **Skipped**: X
+- **Duration**: Xs
+
+## Coverage Metrics
+| Metric   | Value | Threshold | Status |
+|----------|-------|-----------|--------|
+| Lines    | X%    | 80%       | PASS/FAIL |
+| Branches | X%    | 70%       | PASS/FAIL |
+| Functions| X%    | 80%       | PASS/FAIL |
+
+## Failed Tests
+### `test/path/file.test.ts` — TestName
+- **Error**: Error message
+- **Stack**: Relevant stack trace (truncated)
+- **Cause**: Brief root cause analysis
+- **Fix**: Suggested resolution
+
+## UI Test Results (if applicable)
+- **Pages tested**: X
+- **Screenshots**: ./screenshots/
+- **Console errors**: none | [list]
+- **Responsive**: checked at [viewports] | skipped
+- **Performance**: LCP Xs, FID Xms, CLS X
+
+## Build Status
+- **Build**: PASS/FAIL
+- **Warnings**: none | [list]
+- **Dependencies**: all resolved | [issues]
+
+## Critical Issues
+1. [Blocking issue description + impact]
+
+## Recommendations
+1. [Actionable improvement with priority]
+
+## Unresolved Questions
+- [Any open questions, if any]
+```
+
+## Guidelines
+
+- Include ALL failed tests with error messages — don't summarize away details
+- Coverage: highlight specific uncovered files/functions, not just percentages
+- Screenshots: embed paths directly in report for easy access
+- Recommendations: prioritize by impact (critical > high > medium > low)
+- Keep report under 200 lines — split into sections if larger scope needed
+- Save report using naming pattern from `## Naming` section injected by hooks

package/skills/test/references/test-execution-workflow.md

@@ -0,0 +1,103 @@
+# Test Execution Workflow
+
+## Step 1: Identify Scope
+
+Determine what to test based on recent changes:
+- New feature → full test suite + new test cases
+- Bug fix → regression tests + targeted fix validation
+- Refactor → existing test suite (no new tests unless gaps found)
+- Coverage check → full suite with coverage flags
+
+## Step 2: Pre-flight Checks
+
+Run syntax/type checks before tests to catch compile errors early:
+
+```bash
+# JavaScript/TypeScript
+npx tsc --noEmit          # TypeScript check
+npx eslint .              # Lint check
+
+# Python
+python -m py_compile file.py
+flake8 .
+
+# Flutter
+flutter analyze
+
+# Go
+go vet ./...
+
+# Rust
+cargo check
+```
+
+## Step 3: Execute Tests
+
+### JavaScript/TypeScript
+```bash
+npm test                    # or yarn test / pnpm test / bun test
+npm run test:coverage       # with coverage
+npx vitest run              # Vitest
+npx jest --coverage         # Jest with coverage
+```
+
+### Python
+```bash
+pytest                      # basic
+pytest --cov=src --cov-report=term-missing  # with coverage
+python -m unittest discover # unittest
+```
+
+### Go / Rust / Flutter
+```bash
+go test ./... -cover        # Go with coverage
+cargo test                  # Rust
+flutter test --coverage     # Flutter
+```
+
+## Step 4: Analyze Results
+
+Focus on:
+1. **Failing tests** — read error messages and stack traces carefully
+2. **Flaky tests** — tests that pass/fail intermittently indicate race conditions or state leaks
+3. **Slow tests** — identify bottlenecks (>5s per test is suspicious)
+4. **Skipped tests** — ensure skips are intentional, not hiding failures
+
+## Step 5: Coverage Analysis
+
+Thresholds:
+- **80%+** line coverage — standard minimum
+- **70%+** branch coverage — acceptable for most projects
+- Focus on critical paths: auth, payment, data mutations
+
+Identify gaps:
+- Uncovered error handlers
+- Missing edge case branches
+- Untested utility functions
+
+## Step 6: Build Verification
+
+```bash
+npm run build               # JS/TS production build
+python setup.py build       # Python
+go build ./...              # Go
+cargo build --release       # Rust
+flutter build               # Flutter
+```
+
+Check for:
+- Build warnings or deprecation notices
+- Unresolved dependencies
+- Production config correctness
+
+## Quality Checklist
+
+- [ ] All tests pass (zero failures)
+- [ ] Coverage meets project threshold
+- [ ] No flaky tests detected
+- [ ] Build completes without errors
+- [ ] Error scenarios tested
+- [ ] Test isolation verified (no shared state)
+- [ ] Test data cleaned up after execution
+- [ ] Mocks/stubs properly configured
+- [ ] Environment variables correctly set

package/skills/test/references/ui-testing-workflow.md

@@ -0,0 +1,64 @@
+# UI Testing Workflow
+
+Use `pk:agent-browser` for live browser interaction when a fresh/tool-managed browser is enough. Use `pk:chrome-profile` only when the test needs the user's real Chrome profile, cookies, or already-logged-in state. Use `pk:web-testing` or project-native Playwright/Vitest/k6 commands for repeatable test runs.
+
+## Purpose
+Run comprehensive UI tests on a website and generate a detailed report.
+
+## Arguments
+- $1: URL - The URL of the website to test
+- $2: OPTIONS - Optional test configuration (e.g., --headless, --mobile, --auth)
+
+## Testing Protected Routes (Authentication)
+
+### Step 1: User Manual Login
+Instruct the user to:
+1. Open the target site in their browser
+2. Log in manually with their credentials
+3. Open browser DevTools (F12) → Application tab → Cookies/Storage
+
+### Step 2: Persist Auth State Or Select The Chrome Profile
+Prefer project-native auth helpers for repeatable tests. For ad-hoc browser driving with real user auth/cookies, invoke `pk:chrome-profile` and run:
+
+```bash
+chrome-profile doctor
+chrome-profile setup
+chrome-profile list
+```
+
+If real user Chrome state is not needed, use `agent-browser` state commands after manual login when available.
+
+### Step 3: Run Tests
+After auth is available, run tests normally. If real user Chrome state is not needed:
+```bash
+agent-browser open https://example.com/dashboard
+agent-browser screenshot -o profile.png
+```
+
+If real user Chrome state is needed:
+
+```bash
+chrome-profile open --json work https://example.com/dashboard
+```
+
+Then select the MCP page whose URL contains the returned `bind_selector` such as `cdp-open=<token>`, verify it also contains `cdp-profile=work`, and capture screenshots or snapshots through the active bridge.
+
+This restriction applies only when real user Chrome state is required. For profile-scoped testing, do not use raw Chrome MCP `new_page` or `navigate_page` as the opening path. Those tools use whichever profile/page the bridge currently targets.
+
+## Workflow
+- Use `pk:plan` skill to organize the test plan & report
+- All screenshots saved in the same report directory
+- Browse URL, discover all pages, components, endpoints
+- Create test plan based on discovered structure
+- Use multiple `tester` subagents in parallel for: pages, forms, navigation, user flows, accessibility, responsive layouts, performance, security, seo
+- Use `pk:ai-multimodal` to analyze all screenshots
+- Generate comprehensive Markdown report
+- Ask user if they want to preview with `/pk:preview`
+
+## Output Requirements
+- Clear, structured Markdown with headers, lists, code blocks
+- Include test results summary, key findings, screenshot references
+- Ensure token efficiency while maintaining high quality
+- Sacrifice grammar for concision
+
+**Do not** start implementing fixes.