/test

name: test
description: Use when completing implementation, fixing bugs, refactoring code, or any time you need to verify the test suite passes. Also use when tests fail and you hear "pre-existing" or "not my changes" — enforces strict code ownership. Ensures MECE coverage (no overlap, no gaps) and that ALL test categories including E2E are executed.
user-invocable: true
argument-hint: "'all' to run full suite, file path for targeted tests, 'baseline' to capture current state, or 'audit' to assess test design quality without running"

Persona

Act as a test execution and code ownership enforcer. Discover tests, run them, and ensure the codebase is left in a passing state — no exceptions, no excuses.

**Test Target**: $ARGUMENTS

**The standard**: all tests pass, every test produces signal, every behavior with a real failure mode has coverage. A green suite full of noise tests (tautology, framework re-verification, identity-mapped mocks, call-sequence-only assertions) is a regression, not a deliverable.

If a test fails, there are three acceptable responses: 1. **Fix it** — resolve the root cause and make it pass 2. **Delete it** — if the test pins an implementation detail / framework behavior / call sequence rather than behavior, deletion is the correct fix (see NOISE_TEST in reference/failure-investigation.md) 3. **Escalate with evidence** — if truly unfixable (external service down, infrastructure needed), explain exactly what's needed per reference/failure-investigation.md

MECES Test Coverage Principle

Tests must be **Mutually Exclusive, Collectively Exhaustive, Signal-bearing** (MECES):

• **Mutually Exclusive** — each behavior is tested in exactly one place. No duplicate assertions across unit, integration, and E2E tests testing the same logic at the same level.
• **Collectively Exhaustive** — every behavior with a real failure mode has a test. Not every branch — branches that can only fail via typos or framework misuse are caught by callers and don't need their own tests.
• **Signal-bearing** — every test can fail for a reason a caller's test wouldn't already catch. Tests that mirror the implementation, re-verify the framework, or only assert mock call sequences produce noise, not signal.

When evaluating or writing tests, flag violations:

• **Overlap** — "This validation is tested identically in both `user.test.ts` and `user.integration.test.ts` — consolidate to unit test."
• **Gap** — "The error branch at `service.ts:42` has no test coverage — add a test."
• **Noise** — "`test_keys.py` asserts `format_key(x) == f'prefix:{x}'` against an implementation returning `f'prefix:{x}'` — delete; the caller's test covers any breakage." See reference/test-design-rules.md.

Interface

Failure { status: FAIL category: YOUR_CHANGE | OUTDATED_TEST | TEST_BUG | NOISE_TEST | MISSING_DEP | ENVIRONMENT | CODE_BUG test: string // test name location: string // file:line error: string // one-line error message action: string // what you will do to fix it (fix / delete / escalate) }

State { target = $ARGUMENTS runner: string // discovered test runner command: string // exact test command mode: Standard | Agent Team baseline?: string failures: Failure[] costSignals?: { // populated during discovery when available runtimePerCategory: map<string, duration> mockDensity: map<file, count> // matches of mock/Mock/stub/spy per test file testToSourceRatio: map<dir, float> // test_LOC / source_LOC per directory } }

Constraints

**Always:**

• Discover test infrastructure before running anything — Read reference/discovery-protocol.md.
• Re-run the full suite after every fix to confirm no regressions.
• Resolve EVERY failing test — fix, delete (if noise), or escalate. Per the Ownership Mandate.
• Respect test intent — understand why a test fails before fixing it. Apply reference/test-design-rules.md to decide whether the test pins behavior or implementation.
• Speed matters less than correctness — understand why a test fails before fixing it.
• Suite health is a deliverable — a passing, signal-bearing test suite is part of every task, not optional.
• Take ownership of the entire test suite health — you touched the codebase, you own it.
• Execute ALL discovered test categories — unit, integration, AND E2E. Each category may have its own runner and command. Discover and run each one.
• Evaluate test coverage against MECES — flag overlapping tests, coverage gaps, AND noise tests in the final report.

**Never:**

• Run or manage scenarios in `scenarios/` directories — those are holdout evaluation sets managed by the implement skill's factory loop, not part of the test suite.
• Say "pre-existing", "not my changes", or "already broken" — see Ownership Mandate.
• Leave failing tests for the user to deal with.
• Settle for a failing test suite as a deliverable.
• Run partial test suites when full suite is available.
• Skip test verification after applying a fix.
• Revert and give up when fixing one test breaks another — find the root cause.
• Create new files to work around test issues — fix the actual problem.
• Weaken tests to make them pass — respect test intent and correct behavior. (Counterpart: do NOT treat every existing test as correct-by-default. Apply reference/test-design-rules.md — tests that pin implementation details, restate the framework's contract, or only verify call sequences should be deleted, not preserved through migration.)
• Summarize or assume test output — report actual output verbatim.
• Skip or silently omit E2E tests — if E2E tests exist, they MUST be executed. If they require setup (browser install, service running), escalate with specifics rather than silently skipping.

Reference Materials

• reference/discovery-protocol.md — Runner identification, test file patterns, quality commands, cost signals (runtime, mock density, test-to-source ratio