gsd-opencode 1.20.3 → 1.22.0

package/get-shit-done/templates/VALIDATION.md

@@ -9,9 +9,7 @@ created: {date}
 
 # Phase {N} — Validation Strategy
 
-> Generated by `gsd-phase-researcher` during `/gsd-plan-phase {N}`.
-> Updated by `gsd-plan-checker` after plan approval.
-> Governs feedback sampling during `/gsd-execute-phase {N}`.
+> Per-phase validation contract for feedback sampling during execution.
 
 ---
 
@@ -20,22 +18,19 @@ created: {date}
 | Property | Value |
 |----------|-------|
 | **Framework** | {pytest 7.x / jest 29.x / vitest / go test / other} |
-| **Config file** | {path/to/pytest.ini or "none — Wave 0 installs"} |
-| **Quick run command** | `{e.g., pytest -x --tb=short}` |
-| **Full suite command** | `{e.g., pytest tests/ --tb=short}` |
+| **Config file** | {path or "none — Wave 0 installs"} |
+| **Quick run command** | `{quick command}` |
+| **Full suite command** | `{full command}` |
 | **Estimated runtime** | ~{N} seconds |
-| **CI pipeline** | {.github/workflows/test.yml — exists / needs creation} |
 
 ---
 
-## Nyquist Sampling Rate
-
-> The minimum feedback frequency required to reliably catch errors in this phase.
+## Sampling Rate
 
 - **After every task commit:** Run `{quick run command}`
 - **After every plan wave:** Run `{full suite command}`
 - **Before `/gsd-verify-work`:** Full suite must be green
-- **Maximum acceptable task feedback latency:** {N} seconds
+- **Max feedback latency:** {N} seconds
 
 ---
 
@@ -43,62 +38,39 @@ created: {date}
 
 | task ID | Plan | Wave | Requirement | Test Type | Automated Command | File Exists | Status |
 |---------|------|------|-------------|-----------|-------------------|-------------|--------|
-| {N}-01-01 | 01 | 1 | REQ-{XX} | unit | `pytest tests/test_{module}.py::test_{name} -x` | ✅ / ❌ W0 | ⬜ pending |
-| {N}-01-02 | 01 | 1 | REQ-{XX} | integration | `pytest tests/test_{flow}.py -x` | ✅ / ❌ W0 | ⬜ pending |
-| {N}-02-01 | 02 | 2 | REQ-{XX} | smoke | `curl -s {endpoint} \| grep {expected}` | ✅ N/A | ⬜ pending |
+| {N}-01-01 | 01 | 1 | REQ-{XX} | unit | `{command}` | ✅ / ❌ W0 | ⬜ pending |
 
-*Status values: ⬜ pending · ✅ green · ❌ red · ⚠️ flaky*
+*Status: ⬜ pending · ✅ green · ❌ red · ⚠️ flaky*
 
 ---
 
 ## Wave 0 Requirements
 
-> Test scaffolding committed BEFORE any implementation task. Executor runs Wave 0 first.
-
-- [ ] `{tests/test_file.py}` — stubs for REQ-{XX}, REQ-{XX}
+- [ ] `{tests/test_file.py}` — stubs for REQ-{XX}
 - [ ] `{tests/conftest.py}` — shared fixtures
 - [ ] `{framework install}` — if no framework detected
 
-*If none required: "Existing infrastructure covers all phase requirements — no Wave 0 test tasks needed."*
+*If none: "Existing infrastructure covers all phase requirements."*
 
 ---
 
 ## Manual-Only Verifications
 
-> Behaviors that genuinely cannot be automated, with justification.
-> These are surfaced during `/gsd-verify-work` UAT.
-
 | Behavior | Requirement | Why Manual | Test Instructions |
 |----------|-------------|------------|-------------------|
-| {behavior} | REQ-{XX} | {reason: visual, third-party auth, physical device...} | {step-by-step} |
+| {behavior} | REQ-{XX} | {reason} | {steps} |
 
-*If none: "All phase behaviors have automated verification coverage."*
+*If none: "All phase behaviors have automated verification."*
 
 ---
 
 ## Validation Sign-Off
 
-Updated by `gsd-plan-checker` when plans are approved:
-
-- [ ] All tasks have `<automated>` verify commands or Wave 0 dependencies
-- [ ] No 3 consecutive implementation tasks without automated verify (sampling continuity)
-- [ ] Wave 0 test files cover all MISSING references
-- [ ] No watch-mode flags in any automated command
-- [ ] Feedback latency per task: < {N}s ✅
+- [ ] All tasks have `<automated>` verify or Wave 0 dependencies
+- [ ] Sampling continuity: no 3 consecutive tasks without automated verify
+- [ ] Wave 0 covers all MISSING references
+- [ ] No watch-mode flags
+- [ ] Feedback latency < {N}s
 - [ ] `nyquist_compliant: true` set in frontmatter
 
-**Plan-checker approval:** {pending / approved on YYYY-MM-DD}
-
----
-
-## Execution Tracking
-
-Updated during `/gsd-execute-phase {N}`:
-
-| Wave | Tasks | Tests Run | Pass | Fail | Sampling Status |
-|------|-------|-----------|------|------|-----------------|
-| 0 | {N} | — | — | — | scaffold |
-| 1 | {N} | {command} | {N} | {N} | ✅ sampled |
-| 2 | {N} | {command} | {N} | {N} | ✅ sampled |
-
-**Phase validation complete:** {pending / YYYY-MM-DD HH:MM}
+**Approval:** {pending / approved YYYY-MM-DD}

package/get-shit-done/templates/codebase/structure.md

@@ -216,7 +216,7 @@ get-shit-done/
 
 **New Workflow:**
 - Implementation: `get-shit-done/workflows/{name}.md`
-- Usage: Reference from command with `@~/.config/opencode/get-shit-done/workflows/{name}.md`
+- Usage: Reference from command with `@$HOME/.config/opencode/get-shit-done/workflows/{name}.md`
 
 **New Reference Document:**
 - Implementation: `get-shit-done/references/{name}.md`
@@ -229,12 +229,12 @@ get-shit-done/
 ## Special Directories
 
 **get-shit-done/**
-- Purpose: Resources installed to ~/.config/opencode/
+- Purpose: Resources installed to $HOME/.config/opencode/
 - Source: Copied by bin/install.js during installation
 - Committed: Yes (source of truth)
 
 **commands/**
-- Purpose: Slash commands installed to ~/.config/opencode/commands/
+- Purpose: Slash commands installed to $HOME/.config/opencode/commands/
 - Source: Copied by bin/install.js during installation
 - Committed: Yes (source of truth)
 

package/get-shit-done/templates/config.json

@@ -1,12 +1,12 @@
 {
   "mode": "interactive",
-  "depth": "standard",
+  "granularity": "standard",
   "workflow": {
     "research": true,
     "plan_check": true,
     "verifier": true,
     "auto_advance": false,
-    "nyquist_validation": false
+    "nyquist_validation": true
   },
   "planning": {
     "commit_docs": true,

package/get-shit-done/templates/context.md

@@ -54,6 +54,20 @@ Template for `.planning/phases/XX-name/{phase_num}-CONTEXT.md` - captures implem
 
 </specifics>
 
+<code_context>
+## Existing Code Insights
+
+### Reusable Assets
+- [Component/hook/utility]: [How it could be used in this phase]
+
+### Established Patterns
+- [Pattern]: [How it constrains/enables this phase]
+
+### Integration Points
+- [Where new code connects to existing system]
+
+</code_context>
+
 <deferred>
 ## Deferred Ideas
 

package/get-shit-done/templates/phase-prompt.md

@@ -38,10 +38,10 @@ Output: [What artifacts will be created]
 </objective>
 
 <execution_context>
-@~/.config/opencode/get-shit-done/workflows/execute-plan.md
-@~/.config/opencode/get-shit-done/templates/summary.md
+@$HOME/.config/opencode/get-shit-done/workflows/execute-plan.md
+@$HOME/.config/opencode/get-shit-done/templates/summary.md
 [If plan contains checkpoint tasks (type="checkpoint:*"), add:]
-@~/.config/opencode/get-shit-done/references/checkpoints.md
+@$HOME/.config/opencode/get-shit-done/references/checkpoints.md
 </execution_context>
 
 <context>
@@ -76,7 +76,7 @@ Output: [What artifacts will be created]
   <done>[Acceptance criteria]</done>
 </task>
 
-<!-- For checkpoint task examples and patterns, see @~/.config/opencode/get-shit-done/references/checkpoints.md -->
+<!-- For checkpoint task examples and patterns, see @$HOME/.config/opencode/get-shit-done/references/checkpoints.md -->
 <!-- Key rule: OpenCode starts dev server BEFORE human-verify checkpoints. User only visits URLs. -->
 
 <task type="checkpoint:decision" gate="blocking">
@@ -270,7 +270,7 @@ TDD features get dedicated plans with `type: tdd`.
 → Yes: Create a TDD plan
 → No: Standard task in standard plan
 
-See `~/.config/opencode/get-shit-done/references/tdd.md` for TDD plan structure.
+See `$HOME/.config/opencode/get-shit-done/references/tdd.md` for TDD plan structure.
 
 ---
 
@@ -374,9 +374,9 @@ Output: Working dashboard component.
 </objective>
 
 <execution_context>
-@~/.config/opencode/get-shit-done/workflows/execute-plan.md
-@~/.config/opencode/get-shit-done/templates/summary.md
-@~/.config/opencode/get-shit-done/references/checkpoints.md
+@$HOME/.config/opencode/get-shit-done/workflows/execute-plan.md
+@$HOME/.config/opencode/get-shit-done/templates/summary.md
+@$HOME/.config/opencode/get-shit-done/references/checkpoints.md
 </execution_context>
 
 <context>
@@ -499,7 +499,7 @@ user_setup:
 
 **Result:** Execute-plan generates `{phase}-USER-SETUP.md` with checklist for the user.
 
-See `~/.config/opencode/get-shit-done/templates/user-setup.md` for full schema and examples
+See `$HOME/.config/opencode/get-shit-done/templates/user-setup.md` for full schema and examples
 
 ---
 
@@ -566,4 +566,4 @@ task completion ≠ Goal achievement. A task "create chat component" can complet
 5. Gaps found → fix plans created → execute → re-verify
 6. All must_haves pass → phase complete
 
-See `~/.config/opencode/get-shit-done/workflows/verify-phase.md` for verification logic.
+See `$HOME/.config/opencode/get-shit-done/workflows/verify-phase.md` for verification logic.

package/get-shit-done/templates/retrospective.md

@@ -0,0 +1,54 @@
+# Project Retrospective
+
+*A living document updated after each milestone. Lessons feed forward into future planning.*
+
+## Milestone: v{version} — {name}
+
+**Shipped:** {date}
+**Phases:** {count} | **Plans:** {count} | **Sessions:** {count}
+
+### What Was Built
+- {Key deliverable 1}
+- {Key deliverable 2}
+- {Key deliverable 3}
+
+### What Worked
+- {Efficiency win or successful pattern}
+- {What went smoothly}
+
+### What Was Inefficient
+- {Missed opportunity}
+- {What took longer than expected}
+
+### Patterns Established
+- {New pattern or convention that should persist}
+
+### Key Lessons
+1. {Specific, actionable lesson}
+2. {Another lesson}
+
+### Cost Observations
+- Model mix: {X}% opus, {Y}% sonnet, {Z}% haiku
+- Sessions: {count}
+- Notable: {efficiency observation}
+
+---
+
+## Cross-Milestone Trends
+
+### Process Evolution
+
+| Milestone | Sessions | Phases | Key Change |
+|-----------|----------|--------|------------|
+| v{X} | {N} | {M} | {What changed in process} |
+
+### Cumulative Quality
+
+| Milestone | Tests | Coverage | Zero-Dep Additions |
+|-----------|-------|----------|-------------------|
+| v{X} | {N} | {Y}% | {count} |
+
+### Top Lessons (Verified Across Milestones)
+
+1. {Lesson verified by multiple milestones}
+2. {Another cross-validated lesson}

package/get-shit-done/templates/roadmap.md

@@ -105,7 +105,7 @@ Phases execute in numeric order: 2 → 2.1 → 2.2 → 3 → 3.1 → 4
 
 <guidelines>
 **Initial planning (v1.0):**
-- Phase count depends on depth setting (quick: 3-5, standard: 5-8, comprehensive: 8-12)
+- Phase count depends on granularity setting (coarse: 3-5, standard: 5-8, fine: 8-12)
 - Each phase delivers something coherent
 - Phases can have 1+ plans (split if >3 tasks or multiple subsystems)
 - Plans use naming: {phase}-{plan}-PLAN.md (e.g., 01-02-PLAN.md)

package/get-shit-done/workflows/add-phase.md

@@ -29,7 +29,8 @@ Exit.
 Load phase operation context:
 
 ```bash
-INIT=$(node ~/.config/opencode/get-shit-done/bin/gsd-tools.cjs init phase-op "0")
+INIT=$(node "$HOME/.config/opencode/get-shit-done/bin/gsd-tools.cjs" init phase-op "0")
+if [[ "$INIT" == @file:* ]]; then INIT=$(cat "${INIT#@file:}"); fi
 ```
 
 Check `roadmap_exists` from init JSON. If false:
@@ -44,7 +45,7 @@ Exit.
 **Delegate the phase addition to gsd-tools:**
 
 ```bash
-RESULT=$(node ~/.config/opencode/get-shit-done/bin/gsd-tools.cjs phase add "${description}")
+RESULT=$(node "$HOME/.config/opencode/get-shit-done/bin/gsd-tools.cjs" phase add "${description}")
 ```
 
 The CLI handles:

package/get-shit-done/workflows/add-tests.md

@@ -0,0 +1,351 @@
+<purpose>
+Generate unit and E2E tests for a completed phase based on its SUMMARY.md, CONTEXT.md, and implementation. Classifies each changed file into TDD (unit), E2E (browser), or Skip categories, presents a test plan for user approval, then generates tests following RED-GREEN conventions.
+
+Users currently hand-craft `/gsd-quick` prompts for test generation after each phase. This workflow standardizes the process with proper classification, quality gates, and gap reporting.
+</purpose>
+
+<required_reading>
+read all files referenced by the invoking prompt's execution_context before starting.
+</required_reading>
+
+<process>
+
+<step name="parse_arguments">
+Parse `$ARGUMENTS` for:
+- Phase number (integer, decimal, or letter-suffix) → store as `$PHASE_ARG`
+- Remaining text after phase number → store as `$EXTRA_INSTRUCTIONS` (optional)
+
+Example: `/gsd-add-tests 12 focus on edge cases` → `$PHASE_ARG=12`, `$EXTRA_INSTRUCTIONS="focus on edge cases"`
+
+If no phase argument provided:
+
+```
+ERROR: Phase number required
+Usage: /gsd-add-tests <phase> [additional instructions]
+Example: /gsd-add-tests 12
+Example: /gsd-add-tests 12 focus on edge cases in the pricing module
+```
+
+Exit.
+</step>
+
+<step name="init_context">
+Load phase operation context:
+
+```bash
+INIT=$(node "$HOME/.config/opencode/get-shit-done/bin/gsd-tools.cjs" init phase-op "${PHASE_ARG}")
+if [[ "$INIT" == @file:* ]]; then INIT=$(cat "${INIT#@file:}"); fi
+```
+
+Extract from init JSON: `phase_dir`, `phase_number`, `phase_name`.
+
+Verify the phase directory exists. If not:
+```
+ERROR: Phase directory not found for phase ${PHASE_ARG}
+Ensure the phase exists in .planning/phases/
+```
+Exit.
+
+read the phase artifacts (in order of priority):
+1. `${phase_dir}/*-SUMMARY.md` — what was implemented, files changed
+2. `${phase_dir}/CONTEXT.md` — acceptance criteria, decisions
+3. `${phase_dir}/*-VERIFICATION.md` — user-verified scenarios (if UAT was done)
+
+If no SUMMARY.md exists:
+```
+ERROR: No SUMMARY.md found for phase ${PHASE_ARG}
+This command works on completed phases. Run /gsd-execute-phase first.
+```
+Exit.
+
+Present banner:
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ GSD ► ADD TESTS — Phase ${phase_number}: ${phase_name}
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+</step>
+
+<step name="analyze_implementation">
+Extract the list of files modified by the phase from SUMMARY.md ("Files Changed" or equivalent section).
+
+For each file, classify into one of three categories:
+
+| Category | Criteria | Test Type |
+|----------|----------|-----------|
+| **TDD** | Pure functions where `expect(fn(input)).toBe(output)` is writable | Unit tests |
+| **E2E** | UI behavior verifiable by browser automation | Playwright/E2E tests |
+| **Skip** | Not meaningfully testable or already covered | None |
+
+**TDD classification — apply when:**
+- Business logic: calculations, pricing, tax rules, validation
+- Data transformations: mapping, filtering, aggregation, formatting
+- Parsers: CSV, JSON, XML, custom format parsing
+- Validators: input validation, schema validation, business rules
+- State machines: status transitions, workflow steps
+- Utilities: string manipulation, date handling, number formatting
+
+**E2E classification — apply when:**
+- Keyboard shortcuts: key bindings, modifier keys, chord sequences
+- Navigation: page transitions, routing, breadcrumbs, back/forward
+- Form interactions: submit, validation errors, field focus, autocomplete
+- Selection: row selection, multi-select, shift-click ranges
+- Drag and drop: reordering, moving between containers
+- Modal dialogs: open, close, confirm, cancel
+- Data grids: sorting, filtering, inline editing, column resize
+
+**Skip classification — apply when:**
+- UI layout/styling: CSS classes, visual appearance, responsive breakpoints
+- Configuration: config files, environment variables, feature flags
+- Glue code: dependency injection setup, middleware registration, routing tables
+- Migrations: database migrations, schema changes
+- Simple CRUD: basic create/read/update/delete with no business logic
+- Type definitions: records, DTOs, interfaces with no logic
+
+read each file to verify classification. Don't classify based on filename alone.
+</step>
+
+<step name="present_classification">
+Present the classification to the user for confirmation before proceeding:
+
+```
+question(
+  header: "Test Classification",
+  question: |
+    ## Files classified for testing
+
+    ### TDD (Unit Tests) — {N} files
+    {list of files with brief reason}
+
+    ### E2E (Browser Tests) — {M} files
+    {list of files with brief reason}
+
+    ### Skip — {K} files
+    {list of files with brief reason}
+
+    {if $EXTRA_INSTRUCTIONS: "Additional instructions: ${EXTRA_INSTRUCTIONS}"}
+
+    How would you like to proceed?
+  options:
+    - "Approve and generate test plan"
+    - "Adjust classification (I'll specify changes)"
+    - "Cancel"
+)
+```
+
+If user selects "Adjust classification": apply their changes and re-present.
+If user selects "Cancel": exit gracefully.
+</step>
+
+<step name="discover_test_structure">
+Before generating the test plan, discover the project's existing test structure:
+
+```bash
+# Find existing test directories
+find . -type d -name "*test*" -o -name "*spec*" -o -name "*__tests__*" 2>/dev/null | head -20
+# Find existing test files for convention matching
+find . -type f \( -name "*.test.*" -o -name "*.spec.*" -o -name "*Tests.fs" -o -name "*Test.fs" \) 2>/dev/null | head -20
+# Check for test runners
+ls package.json *.sln 2>/dev/null
+```
+
+Identify:
+- Test directory structure (where unit tests live, where E2E tests live)
+- Naming conventions (`.test.ts`, `.spec.ts`, `*Tests.fs`, etc.)
+- Test runner commands (how to execute unit tests, how to execute E2E tests)
+- Test framework (xUnit, NUnit, Jest, Playwright, etc.)
+
+If test structure is ambiguous, ask the user:
+```
+question(
+  header: "Test Structure",
+  question: "I found multiple test locations. Where should I create tests?",
+  options: [list discovered locations]
+)
+```
+</step>
+
+<step name="generate_test_plan">
+For each approved file, create a detailed test plan.
+
+**For TDD files**, plan tests following RED-GREEN-REFACTOR:
+1. Identify testable functions/methods in the file
+2. For each function: list input scenarios, expected outputs, edge cases
+3. Note: since code already exists, tests may pass immediately — that's OK, but verify they test the RIGHT behavior
+
+**For E2E files**, plan tests following RED-GREEN gates:
+1. Identify user scenarios from CONTEXT.md/VERIFICATION.md
+2. For each scenario: describe the user action, expected outcome, assertions
+3. Note: RED gate means confirming the test would fail if the feature were broken
+
+Present the complete test plan:
+
+```
+question(
+  header: "Test Plan",
+  question: |
+    ## Test Generation Plan
+
+    ### Unit Tests ({N} tests across {M} files)
+    {for each file: test file path, list of test cases}
+
+    ### E2E Tests ({P} tests across {Q} files)
+    {for each file: test file path, list of test scenarios}
+
+    ### Test Commands
+    - Unit: {discovered test command}
+    - E2E: {discovered e2e command}
+
+    Ready to generate?
+  options:
+    - "Generate all"
+    - "Cherry-pick (I'll specify which)"
+    - "Adjust plan"
+)
+```
+
+If "Cherry-pick": ask user which tests to include.
+If "Adjust plan": apply changes and re-present.
+</step>
+
+<step name="execute_tdd_generation">
+For each approved TDD test:
+
+1. **Create test file** following discovered project conventions (directory, naming, imports)
+
+2. **write test** with clear arrange/act/assert structure:
+   ```
+   // Arrange — set up inputs and expected outputs
+   // Act — call the function under test
+   // Assert — verify the output matches expectations
+   ```
+
+3. **Run the test**:
+   ```bash
+   {discovered test command}
+   ```
+
+4. **Evaluate result:**
+   - **Test passes**: Good — the implementation satisfies the test. Verify the test checks meaningful behavior (not just that it compiles).
+   - **Test fails with assertion error**: This may be a genuine bug discovered by the test. Flag it:
+     ```
+     ⚠️ Potential bug found: {test name}
+     Expected: {expected}
+     Actual: {actual}
+     File: {implementation file}
+     ```
+     Do NOT fix the implementation — this is a test-generation command, not a fix command. Record the finding.
+   - **Test fails with error (import, syntax, etc.)**: This is a test error. Fix the test and re-run.
+</step>
+
+<step name="execute_e2e_generation">
+For each approved E2E test:
+
+1. **Check for existing tests** covering the same scenario:
+   ```bash
+   grep -r "{scenario keyword}" {e2e test directory} 2>/dev/null
+   ```
+   If found, extend rather than duplicate.
+
+2. **Create test file** targeting the user scenario from CONTEXT.md/VERIFICATION.md
+
+3. **Run the E2E test**:
+   ```bash
+   {discovered e2e command}
+   ```
+
+4. **Evaluate result:**
+   - **GREEN (passes)**: Record success
+   - **RED (fails)**: Determine if it's a test issue or a genuine application bug. Flag bugs:
+     ```
+     ⚠️ E2E failure: {test name}
+     Scenario: {description}
+     Error: {error message}
+     ```
+   - **Cannot run**: Report blocker. Do NOT mark as complete.
+     ```
+     🛑 E2E blocker: {reason tests cannot run}
+     ```
+
+**No-skip rule:** If E2E tests cannot execute (missing dependencies, environment issues), report the blocker and mark the test as incomplete. Never mark success without actually running the test.
+</step>
+
+<step name="summary_and_commit">
+Create a test coverage report and present to user:
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ GSD ► TEST GENERATION COMPLETE
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+## Results
+
+| Category | Generated | Passing | Failing | Blocked |
+|----------|-----------|---------|---------|---------|
+| Unit     | {N}       | {n1}    | {n2}    | {n3}    |
+| E2E      | {M}       | {m1}    | {m2}    | {m3}    |
+
+## Files Created/Modified
+{list of test files with paths}
+
+## Coverage Gaps
+{areas that couldn't be tested and why}
+
+## Bugs Discovered
+{any assertion failures that indicate implementation bugs}
+```
+
+Record test generation in project state:
+```bash
+node "$HOME/.config/opencode/get-shit-done/bin/gsd-tools.cjs" state-snapshot
+```
+
+If there are passing tests to commit:
+
+```bash
+git add {test files}
+git commit -m "test(phase-${phase_number}): add unit and E2E tests from add-tests command"
+```
+
+Present next steps:
+
+```
+---
+
+## ▶ Next Up
+
+{if bugs discovered:}
+**Fix discovered bugs:** `/gsd-quick fix the {N} test failures discovered in phase ${phase_number}`
+
+{if blocked tests:}
+**Resolve test blockers:** {description of what's needed}
+
+{otherwise:}
+**All tests passing!** Phase ${phase_number} is fully tested.
+
+---
+
+**Also available:**
+- `/gsd-add-tests {next_phase}` — test another phase
+- `/gsd-verify-work {phase_number}` — run UAT verification
+
+---
+```
+</step>
+
+</process>
+
+<success_criteria>
+- [ ] Phase artifacts loaded (SUMMARY.md, CONTEXT.md, optionally VERIFICATION.md)
+- [ ] All changed files classified into TDD/E2E/Skip categories
+- [ ] Classification presented to user and approved
+- [ ] Project test structure discovered (directories, conventions, runners)
+- [ ] Test plan presented to user and approved
+- [ ] TDD tests generated with arrange/act/assert structure
+- [ ] E2E tests generated targeting user scenarios
+- [ ] All tests executed — no untested tests marked as passing
+- [ ] Bugs discovered by tests flagged (not fixed)
+- [ ] Test files committed with proper message
+- [ ] Coverage gaps documented
+- [ ] Next steps presented to user
+</success_criteria>