tdd-guardian

Initialize TDD Guardian for this workspace (strict test and coverage gates)

Run strict TDD orchestration via specialized subagents

Enforce strict coverage gates and identify exact missing coverage scenarios. <example> Context: All work items have been implemented and tests are green; now the workflow needs to verify the project meets the 90% branch coverage threshold configured in tdd-guardian config. assistant: "I'll use the tdd-coverage-auditor to run the coverage command, compare totals against the configured thresholds, and produce a report listing any uncovered branches with proposed tests to close each gap." </example> <example> Context: A newly added error-handling branch in src/queue.ts is suspected to be untested after implementation. assistant: "I'll dispatch the tdd-coverage-auditor to run coverage focused on src/queue.ts, identify uncovered lines and branches, and propose concrete test cases to bring the file to threshold." </example>

Implement planned work items in small batches with test-first discipline. <example> Context: The tdd-planner and tdd-test-designer have both finished; there are 3 work items and a full test matrix ready for a JWT token validation module. assistant: "I'll use the tdd-implementer to work through each work item one at a time — writing failing tests first, then the minimal implementation to make them pass, running the test command after each batch." </example> <example> Context: WI-2 of an ongoing TDD workflow is a database transaction rollback handler, with tests already specified in the matrix. assistant: "I'll dispatch the tdd-implementer for WI-2: write the rollback handler tests (red), implement the handler (green), confirm via Bash, then report the result before moving to WI-3." </example>

Validate test robustness using mutation testing and close surviving mutants. <example> Context: Coverage gate passed at 94%, but the team suspects tests are weak — many assertions may be wiring-only and would miss logic mutations. assistant: "I'll use the tdd-mutation-auditor to run Stryker, list any surviving mutants with their file locations and mutant types, then strengthen the test assertions to kill each survivor." </example> <example> Context: After implementing a complex conditional pricing algorithm, the mutation score needs to meet the 80% kill-rate threshold before the workflow can proceed to review. assistant: "I'll dispatch the tdd-mutation-auditor to verify Stryker is available, run mutation tests against the pricing module, and iteratively add boundary tests until the kill-rate threshold is met or a blocker is reported." </example>

Break a request into implementation work items with explicit acceptance criteria and test targets. <example> Context: User asks to add a user authentication feature with login, logout, and session handling to an Express API. assistant: "I'll use the tdd-planner to break down the authentication feature into work items with acceptance criteria and required test targets for each component." </example> <example> Context: User wants to refactor a payment processing module to support multiple currencies. assistant: "I'll dispatch the tdd-planner to decompose the currency refactor into discrete work items, identify risks, and define the test targets before any code is written." </example>

Final reviewer that audits code quality, test quality (wiring vs behavior), and coverage gaps. <example> Context: All prior gates (coverage, mutation) have passed and the implementation is complete; a final sign-off is needed before committing. assistant: "I'll use the tdd-reviewer to audit both code quality and test quality — checking for wiring-only tests, mocked internal modules, missing error-path coverage, and producing a severity-ordered findings report." </example> <example> Context: A PR adding a new file upload handler has been flagged because its test file only contains toHaveBeenCalledWith assertions and no behavior verification. assistant: "I'll dispatch the tdd-reviewer to classify every expect() call in the upload handler test file, flag all wiring-only tests, and identify which behavior assertions are missing before this can be approved." </example>

Design behavior-driven tests with explicit assertion strategies. Rejects wiring-only test designs. <example> Context: The tdd-planner has produced a work item for a rate-limiter middleware that blocks requests exceeding 100 req/min per IP. assistant: "I'll use the tdd-test-designer to produce a concrete test matrix covering success cases, boundary conditions (exactly 100, exactly 101), invalid inputs, and concurrency behavior for the rate-limiter." </example> <example> Context: A work item requires a CSV parser that handles malformed rows, empty files, and BOM characters. assistant: "I'll dispatch the tdd-test-designer to design behavior-driven tests with real file fixtures — no mocking the fs module — covering all edge cases and specifying Level 1-5 assertions for each." </example>

Enforce coverage thresholds AND test quality — coverage without behavioral assertions is meaningless.

Initialize workspace TDD Guardian config and enable strict hooks for test/coverage enforcement.

Validate test strength with mutation testing and harden weak assertions.

Global TDD governance policy. Enforces plan-first development, behavior-driven test quality, and strict completion gates.

Produce findings-first code review with severity ordering, test-gap findings, and test-quality audit.

Build a comprehensive test matrix for changed behavior with explicit assertion strategy per case.

Orchestrate strict TDD implementation across planner, implementer, test designer, coverage auditor, mutation auditor, and reviewer subagents.

2 hooks across 2 events