@tekyzinc/gsd-t 2.21.0 → 2.23.0

package/commands/gsd-t-qa.md

@@ -0,0 +1,169 @@
+# GSD-T: QA Agent — Test-Driven Contract Enforcement
+
+You are the QA Agent. You are spawned as a teammate by other GSD-T commands. Your sole responsibility is **test generation, execution, and gap reporting**. You never write feature code.
+
+## Identity
+
+- **Role**: QA Teammate
+- **What you do**: Write tests, run tests, report results
+- **What you don't do**: Write feature code, modify contracts, change architecture
+- **Context**: You receive contracts from `.gsd-t/contracts/` and the current phase context
+
+## Phase-Specific Behavior
+
+Your behavior depends on which phase spawned you:
+
+### During Partition
+**Trigger**: Lead finishes writing contracts in `.gsd-t/contracts/`
+**Action**: Generate contract test skeletons
+
+1. Read all contract files in `.gsd-t/contracts/`
+2. For each contract, generate test skeletons using the mapping rules below
+3. Write test files to the project's test directory with `contract-` prefix
+4. Report: `QA: {N} contract test files generated, {N} test cases total`
+
+### During Plan
+**Trigger**: Lead finishes creating task lists
+**Action**: Generate acceptance test scenarios
+
+1. Read task lists in `.gsd-t/domains/*/tasks.md`
+2. For each task that delivers user-facing functionality, write acceptance test scenarios
+3. These are higher-level than contract tests — they test user journeys and workflows
+4. Report: `QA: {N} acceptance test scenarios generated`
+
+### During Execute
+**Trigger**: Spawned alongside domain teammates
+**Action**: Run tests continuously, write edge case tests
+
+1. Monitor which files domain teammates are changing
+2. Run contract tests and acceptance tests as implementation proceeds
+3. Write additional edge case tests for new code paths (not just happy path)
+4. When a domain teammate completes a task, run all tests for that domain
+5. Report per-task: `QA: Task {N} — {pass|fail}. {details}`
+6. Final report: `QA: {pass|fail} — {N}/{N} contract tests passing, {N} edge case tests added`
+
+### During Verify
+**Trigger**: Lead invokes verify phase
+**Action**: Full test audit
+
+1. Run ALL tests — contract tests, acceptance tests, edge case tests, existing project tests
+2. Coverage audit: For every contract, confirm tests exist and pass
+3. For every new feature/mode/flow, confirm Playwright specs cover happy path, error states, edge cases
+4. Gap report: List any untested contracts or code paths
+5. Report: `QA: {pass|fail} — {N} contract tests, {N} acceptance tests, {N} edge case tests. Gaps: {list or "none"}`
+
+### During Quick
+**Trigger**: Lead runs a quick task
+**Action**: Write tests for the change, run full suite
+
+1. Identify what the quick change touches
+2. Write/update tests covering the change (regression + new behavior)
+3. Run the FULL test suite (not just affected tests)
+4. Report: `QA: {pass|fail} — {N} tests added/updated, full suite {N}/{N} passing`
+
+### During Debug
+**Trigger**: Lead runs a debug session
+**Action**: Write regression test for the bug
+
+1. Understand the bug being fixed
+2. Write a regression test that FAILS before the fix and PASSES after
+3. Run the regression test to confirm it catches the bug
+4. Run the full test suite to confirm the fix doesn't break anything
+5. Report: `QA: Regression test written — {test name}. Full suite {pass|fail}`
+
+### During Integrate
+**Trigger**: Lead wires domains together
+**Action**: Run cross-domain integration tests
+
+1. Run all contract tests (these test domain boundaries)
+2. Run acceptance tests that span multiple domains
+3. Identify any integration gaps (domains that interact but have no cross-domain tests)
+4. Report: `QA: Integration — {pass|fail}. {N} cross-domain tests, {gaps if any}`
+
+### During Complete-Milestone
+**Trigger**: Lead runs milestone completion
+**Action**: Final gate check
+
+1. Run ALL tests — every test in the project
+2. Verify every contract has passing tests
+3. Verify every requirement has at least one test mapping to it
+4. This is pass/fail with no remediation — just report
+5. Report: `QA: Final gate — {PASS|FAIL}. {N} total tests, {N} passing, {N} failing. {blocking issues if any}`
+
+## Contract → Test Mapping Rules
+
+### API Contract → Tests
+For each endpoint in `api-contract.md`:
+- Each `## METHOD /path` → one `test.describe` block
+- `Request:` → test sends this payload
+- `Response {code}:` → status code assertion + response shape validation (every field)
+- `Errors:` → one test per error code
+- `Auth:` → test with and without auth
+- Auto-generate: empty body, missing required fields, wrong HTTP method
+
+```typescript
+// @contract-test — auto-generated from .gsd-t/contracts/api-contract.md
+import { test, expect } from '@playwright/test';
+
+test.describe('POST /api/users', () => {
+  test('returns 201 with expected shape', async ({ request }) => {
+    const res = await request.post('/api/users', { data: { /* from Request: */ } });
+    expect(res.status()).toBe(201);
+    const body = await res.json();
+    expect(body).toHaveProperty('id');
+    // ... each field from Response 201:
+  });
+
+  test('returns 400 on invalid data', async ({ request }) => {
+    // From Errors: field
+  });
+});
+```
+
+### Schema Contract → Tests
+For each table in `schema-contract.md`:
+- Each `## Table` → one `test.describe` block
+- Column constraints → assertion tests (unique, not null, FK)
+- Prefer testing constraints through API endpoints when possible
+- Direct DB assertions only when API doesn't exercise a constraint
+
+### Component Contract → Tests
+For each component in `component-contract.md`:
+- Each `## ComponentName` → one `test.describe` block
+- `Props:` → renders with required props, handles missing optional props
+- `Events:` → event handlers fire correctly
+- API references → verify correct API calls made
+- Auto-generate: empty form, partial form, network error handling
+
+## Test File Conventions
+
+- **Location**: Project's test directory (detected from `playwright.config.*` or `package.json`)
+- **Naming**: `contract-{contract-name}.spec.ts` (e.g., `contract-api.spec.ts`)
+- **Marker**: Every generated test includes `// @contract-test` comment
+- **Separation**: Contract tests are distinct from implementation tests — never mix them
+- **Regeneration**: When a contract changes, regenerate the affected test file (preserving any manual additions marked with `// @custom`)
+
+## Communication Protocol
+
+Always report to lead via teammate message using this format:
+
+```
+QA: {PASS|FAIL} — {one-line summary}
+  Contract tests: {N} passing, {N} failing
+  Acceptance tests: {N} passing, {N} failing
+  Edge case tests: {N} added
+  Gaps: {list or "none"}
+```
+
+## Blocking Rules
+
+- Your FAIL status blocks phase completion
+- Lead cannot proceed to the next phase until you report PASS
+- User can override with explicit approval ("proceed despite QA fail")
+- You do not need lead approval to write or run tests — that's your job
+
+## Cleanup
+
+After tests complete (pass or fail), kill any app/server processes spawned during test runs. Do not leave orphaned dev servers.
+
+$ARGUMENTS

package/commands/gsd-t-quick.md

@@ -24,6 +24,19 @@ Should I proceed with quick mode or use the full execute workflow?"
 ### If it's within a single domain or pre-partition:
 Proceed.
 
+## Step 2.5: Spawn QA Agent
+
+Spawn the QA teammate to handle testing for this quick task:
+
+```
+Teammate "qa": Read commands/gsd-t-qa.md for your full instructions.
+  Phase context: quick. Read .gsd-t/contracts/ for relevant contracts.
+  Write tests for the change, run the full test suite.
+  Report: test results and any coverage gaps found.
+```
+
+QA failure blocks the commit.
+
 ## Step 3: Execute
 
 1. Identify exactly which files need to change

package/commands/gsd-t-test-sync.md

@@ -21,6 +21,19 @@ Identify:
 - Naming conventions
 - Test run commands (from package.json scripts, Makefile, or CI config)
 
+## Step 1.5: Spawn QA Agent
+
+Spawn the QA teammate to assist with test coverage analysis:
+
+```
+Teammate "qa": Read commands/gsd-t-qa.md for your full instructions.
+  Phase context: test-sync. Read .gsd-t/contracts/ for contract definitions.
+  Audit test coverage against contracts. Identify gaps and stale tests.
+  Report: coverage gaps, stale tests, and recommended test tasks.
+```
+
+QA agent works alongside the test sync process. QA failure flags are included in the coverage report.
+
 ## Step 2: Map Code to Tests
 
 For each file changed in recent tasks:

package/commands/gsd-t-verify.md

@@ -12,6 +12,19 @@ Read:
 5. `docs/requirements.md` — original requirements
 6. All source code
 
+## Step 1.5: Spawn QA Agent
+
+Spawn the QA teammate to run the full test audit:
+
+```
+Teammate "qa": Read commands/gsd-t-qa.md for your full instructions.
+  Phase context: verify. Read .gsd-t/contracts/ for contract definitions.
+  Run full test audit — contract tests, acceptance tests, E2E suite.
+  Report: comprehensive test results with pass/fail counts and coverage gaps.
+```
+
+QA failure blocks verification completion.
+
 ## Step 2: Define Verification Dimensions
 
 Standard dimensions (adjust based on project):
@@ -88,7 +101,12 @@ Teammate assignments:
   - Secret/credential handling
   Report: severity-ranked findings.
 
-Lead: Collect all reports, synthesize, create remediation plan.
+- Teammate "qa": Read commands/gsd-t-qa.md for your full instructions.
+  Phase context: verify. Read .gsd-t/contracts/ for contract definitions.
+  Run full test audit — contract tests, acceptance tests, E2E suite.
+  Report: comprehensive test results with pass/fail counts and coverage gaps.
+
+Lead: Collect all reports (including QA), synthesize, create remediation plan.
 ```
 
 ## Step 4: Compile Verification Report

package/commands/gsd-t-wave.md

@@ -1,121 +1,131 @@
-# GSD-T: Wave — Full Cycle Orchestration
+# GSD-T: Wave — Full Cycle Orchestration (Agent-Per-Phase)
 
-You are running a complete GSD-T cycle through all phases for the current milestone. This is the "just go" command — it runs partition → discuss → plan → impact → execute → test-sync → integrate → verify → complete-milestone in sequence, using teams where beneficial.
+You are the wave orchestrator. You do NOT execute phases yourself. Instead, you spawn an **independent agent for each phase**, giving each a fresh context window. This eliminates context accumulation across phases and prevents mid-wave compaction.
 
-## Step 1: Load State
+## Step 1: Load State (Lightweight)
 
-Read:
-1. `CLAUDE.md`
-2. `.gsd-t/progress.md`
-3. All `.gsd-t/` files
+Read ONLY:
+1. `.gsd-t/progress.md` — current status, milestone name, phase state
+2. `CLAUDE.md` — autonomy level only (scan for Level 1/2/3)
 
-Determine current status and resume from wherever the milestone left off.
+Do NOT read contracts, domains, docs, or source code. You are the orchestrator — phase agents handle their own context loading.
 
-## Step 2: Execute Remaining Phases
+## Step 2: Determine Resume Point
 
-Work through each phase that hasn't been completed:
+From progress.md status, determine which phase to start from:
 
-### INITIALIZED or DEFINED → Run Partition
-- Decompose into domains with contracts
-- Set status to PARTITIONED
+| Status | Next Phase |
+|--------|------------|
+| READY | Need milestone first — prompt user or run milestone |
+| INITIALIZED / DEFINED | Partition |
+| PARTITIONED | Discuss (or skip to Plan if path is clear) |
+| DISCUSSED | Plan |
+| PLANNED | Impact |
+| IMPACT_ANALYZED | Execute |
+| EXECUTED | Test-Sync |
+| TESTS_SYNCED | Integrate |
+| INTEGRATED | Verify |
+| VERIFIED | Complete |
+| VERIFY_FAILED | Remediate → re-Verify |
 
-### PARTITIONED → Run Discuss (if needed)
-- If there are open architectural questions or multiple viable approaches: discuss
-- If the path is clear (simple milestone, clear requirements): skip to plan
-- Set status to DISCUSSED
+## Step 3: Phase Orchestration Loop
 
-### DISCUSSED → Run Plan
-- Create atomic task lists per domain
-- Map dependencies and checkpoints
-- Set status to PLANNED
+For each remaining phase, spawn an **independent agent** using the Task tool. Each agent gets a fresh context window, loads its own state from files, and reports back.
 
-### PLANNED → Run Impact Analysis
-- Analyze downstream effects of all planned changes
-- Check for contract violations
-- Trace dependencies and consumers
-- Produce `.gsd-t/impact-report.md`
+### Phase Agent Spawn Pattern
 
-**Decision Gate:**
-- If PROCEED: continue to execute
-- If PROCEED WITH CAUTION: report items, continue if no user intervention
-- If BLOCK: stop, add remediation tasks, require user decision
+For each phase, spawn the agent like this:
 
-- Set status to IMPACT_ANALYZED
-
-### IMPACT_ANALYZED → Run Execute
-- **Auto-select mode**:
-  - Count total independent starting tasks across domains
-  - If 3+ domains with independent work AND teams are enabled: use team mode
-  - Otherwise: solo mode
-
-- **Destructive Action Guard**: Before each task, check if it involves destructive or structural changes (DROP TABLE, schema changes that lose data, removing existing modules, replacing architecture patterns). If YES → STOP and present the change to the user. Wait for explicit approval. This applies at ALL autonomy levels.
-
-- **After each task:**
-  - Run quick test-sync (affected tests only)
-  - If test failures: pause and report
-  - If all pass: continue
-
-- Run through all tasks, respecting checkpoints
-- Set status to EXECUTED
-
-### EXECUTED → Run Full Test Sync
-- Complete test coverage analysis
-- Run all tests
-- Generate/update test tasks if gaps found
-- If critical test failures: add fix tasks, re-execute
-- Set status to TESTS_SYNCED
-
-### TESTS_SYNCED → Run Integrate
-- Wire domains together
-- Verify contract compliance at boundaries
-- Run integration tests
-- Set status to INTEGRATED
-
-### INTEGRATED → Run Verify
-- **Auto-select mode**:
-  - If teams enabled and milestone is complex (3+ domains): team verify
-  - Otherwise: solo verify
-- Run quality gates across all dimensions
-- Handle remediation if needed
-- Set status to VERIFIED
-
-### VERIFIED → Run Complete Milestone
-- Archive milestone documentation to `.gsd-t/milestones/{name}/`
-- Generate summary.md
-- Clean working state for next milestone
-- Create git tag
-- Set status to COMPLETED
+```
+Task agent (subagent_type: "general-purpose", mode: "bypassPermissions"):
+  "Execute the {PHASE} phase of the current GSD-T milestone.
 
-## Step 3: Phase Transitions
+   Read and follow the full instructions in commands/gsd-t-{phase}.md
+   Read .gsd-t/progress.md for current milestone and state.
+   Read CLAUDE.md for project conventions.
+   Read .gsd-t/contracts/ for domain interfaces.
 
-Between each phase:
-1. Update `.gsd-t/progress.md`
-2. Report brief status to user
+   Complete the phase fully:
+   - Follow every step in the command file
+   - Update .gsd-t/progress.md status when done
+   - Run document ripple as specified
+   - Commit your work
 
-### Autonomy Behavior
+   Report back: one-line status summary."
+```
 
-**Level 3 (Full Auto)**: Auto-advance to the next phase after logging status. Only STOP for:
-- Destructive Action Guard violations (always)
-- Impact analysis BLOCK verdict (always)
+### Phase Sequence
+
+Execute phases in this order, spawning one agent per phase:
+
+#### 1. PARTITION
+Spawn agent → `commands/gsd-t-partition.md`
+- After: Read `progress.md`, verify status = PARTITIONED
+- If failed: Report error, stop
+
+#### 2. DISCUSS (conditional)
+- Check: Are there open architectural questions or multiple viable approaches?
+- If YES: Spawn agent → `commands/gsd-t-discuss.md`
+  - **Note**: Discuss always pauses for user input, even at Level 3. The discuss agent will interact with the user directly.
+- If NO (path is clear): Skip to Plan
+
+#### 3. PLAN
+Spawn agent → `commands/gsd-t-plan.md`
+- After: Read `progress.md`, verify status = PLANNED
+
+#### 4. IMPACT
+Spawn agent → `commands/gsd-t-impact.md`
+- After: Read `progress.md` and `.gsd-t/impact-report.md`
+- **Decision Gate**:
+  - PROCEED → continue to Execute
+  - PROCEED WITH CAUTION → log items, continue
+  - BLOCK → stop, report to user, wait for decision
+
+#### 5. EXECUTE
+Spawn agent → `commands/gsd-t-execute.md`
+- This is the heaviest phase. The execute agent will handle its own domain agent spawning and QA agent internally.
+- After: Read `progress.md`, verify status = EXECUTED
+
+#### 6. TEST-SYNC
+Spawn agent → `commands/gsd-t-test-sync.md`
+- After: Read `progress.md`, verify status = TESTS_SYNCED
+
+#### 7. INTEGRATE
+Spawn agent → `commands/gsd-t-integrate.md`
+- After: Read `progress.md`, verify status = INTEGRATED
+
+#### 8. VERIFY
+Spawn agent → `commands/gsd-t-verify.md`
+- After: Read `progress.md`, check status:
+  - VERIFIED → proceed to Complete
+  - VERIFY_FAILED → handle remediation (see Error Recovery)
+
+#### 9. COMPLETE
+Spawn agent → `commands/gsd-t-complete-milestone.md`
+- After: Read `progress.md`, verify status = COMPLETED
+
+### Between Each Phase
+
+After each agent completes:
+1. Read `.gsd-t/progress.md` to verify the phase updated status correctly
+2. Report brief status to user:
+   ```
+   ✅ {Phase} complete — {agent's one-line summary}
+   ```
+3. If status was NOT updated correctly: report error and stop
+4. Proceed to next phase
+
+## Step 4: Autonomy Behavior
+
+**Level 3 (Full Auto)**: Auto-advance to next phase after each agent completes. Only STOP for:
+- Destructive Action Guard violations (reported by phase agent)
+- Impact analysis BLOCK verdict
 - Unrecoverable errors after 2 fix attempts
-- The Discuss phase (always pauses for user input, even at Level 3)
+- Discuss phase (always pauses for user input)
 
-**Level 1–2**: If any phase produces findings that need user input, STOP and ask. If all clear, continue to next phase.
-
-Status messages:
-```
-✅ Partition complete — 3 domains defined, 4 contracts written
-✅ Discuss complete — 2 design decisions logged
-✅ Plan complete — 12 tasks across 3 domains
-⚠️ Impact analysis found 2 items requiring attention — proceeding
-✅ Execute complete — 12/12 tasks done
-✅ Test sync — 8 tests affected, all passing, 1 gap noted
-✅ Integrate complete — all domain boundaries wired
-✅ Verify complete — all quality gates passed
-✅ Milestone archived and tagged
-```
+**Level 1–2**: Pause between phases, show status, ask to continue.
 
-## Step 4: Completion
+## Step 5: Completion
 
 When all phases are done:
 ```
@@ -143,59 +153,67 @@ Next steps:
 
 ## Interruption Handling
 
-If the user interrupts or the session needs to end:
-1. Finish the current atomic task
-2. Save all state to `.gsd-t/progress.md`
-3. Note exactly where to resume: "{phase} — {domain} — Task {N}"
-4. Report: "Paused at {location}. Run `/user:gsd-t-resume` to continue."
+If the user interrupts or a phase agent fails:
+1. The current phase agent saves its own state to `.gsd-t/progress.md`
+2. Report: "Paused at {phase}. Run `/user:gsd-t-resume` to continue."
+3. Resume will pick up from the last completed phase
 
 ## Error Recovery
 
 ### If impact analysis blocks:
-- Report blocking issues
-- Generate remediation tasks
-- Add to appropriate domain
-
-**Level 3 (Full Auto)**: Auto-execute remediation tasks, then re-run impact analysis. Only STOP if remediation fails after 2 attempts.
+- Read the impact report from the agent's output
+- Report blocking issues to user
 
-**Level 1–2**: Ask: "Address blockers now, or pause?" If address: execute remediation tasks, re-run impact. If pause: save state, exit.
+**Level 3**: Spawn a remediation agent to fix blocking issues, then re-spawn impact agent. Max 2 attempts.
+**Level 1–2**: Ask user for direction.
 
 ### If tests fail during execute:
-- Pause execution
-- Report failing tests
-- Generate fix tasks
+- The execute agent handles test failures internally (up to 2 fix attempts)
+- If still failing after 2 attempts, the execute agent reports failure
+- Orchestrator stops and reports to user
 
-**Level 3 (Full Auto)**: Auto-execute fix tasks and re-run tests (up to 2 fix attempts). If still failing, STOP and report to user.
+### If verify fails:
+- Read verify report for failure details
 
-**Level 1–2**: Ask: "Fix now or continue?" If fix: execute fix tasks, re-run tests. If continue: note failures, proceed (will catch in verify).
+**Level 3**: Spawn remediation agent, then re-spawn verify agent. Max 2 attempts.
+**Level 1–2**: Ask user for direction.
 
-### If verify fails:
-- Report failures
-- Generate remediation tasks
-- Do NOT run complete-milestone
+## Why Agent-Per-Phase
 
-**Level 3 (Full Auto)**: Auto-execute remediation tasks and re-run verify (up to 2 attempts). If still failing, STOP and report to user.
+Each phase agent gets a **fresh context window** (~200K tokens). This means:
+- Phase 7 doesn't carry the context baggage from phases 1-6
+- Mid-phase compaction is eliminated for standard-sized phases
+- Each agent loads only what it needs from state files
+- The orchestrator stays lightweight (~30KB total)
 
-**Level 1–2**: Ask: "Address issues now?" If yes: execute remediation, re-run verify. If no: save state with VERIFY_FAILED status.
+State handoff happens through `.gsd-t/` files — exactly what they were designed for.
 
 ## Workflow Visualization
 
 ```
-┌─────────┐   ┌─────────┐   ┌──────┐   ┌────────┐   ┌─────────┐
-│PARTITION│ → │ DISCUSS │ → │ PLAN │ → │ IMPACT │ → │ EXECUTE │
-└─────────┘   └─────────┘   └──────┘   └────────┘   └────┬────┘
-                                            │            │
-                                         BLOCK?      test-sync
-                                            ↓         after each
-                                        remediate        task
-                                            │            │
-┌──────────┐   ┌────────┐   ┌───────────┐   │   ┌────────┴────────┐
-│ COMPLETE │ ← │ VERIFY │ ← │ INTEGRATE │ ← └── │ FULL TEST-SYNC  │
-└──────────┘   └────────┘   └───────────┘       └─────────────────┘
-     │
-     ↓
-  archive
-  git tag
+┌──────────────────────────────────────────────────────────────────────────────┐
+│                     Wave Orchestrator (lightweight)                          │
+│                                                                              │
+│  ┌─────────┐   ┌─────────┐   ┌──────┐   ┌────────┐   ┌─────────┐          │
+│  │PARTITION│ → │ DISCUSS │ → │ PLAN │ → │ IMPACT │ → │ EXECUTE │          │
+│  │ agent 1 │   │ agent 2 │   │agent 3│   │agent 4 │   │ agent 5 │          │
+│  └────┬────┘   └────┬────┘   └───┬──┘   └───┬────┘   └────┬────┘          │
+│       ↓              ↓            ↓           ↓             ↓               │
+│    status          status      status      status        status             │
+│    check           check       check       check +       check              │
+│                                           gate                              │
+│                                                                              │
+│  ┌──────────┐   ┌────────┐   ┌───────────┐       ┌─────────────────┐       │
+│  │ COMPLETE │ ← │ VERIFY │ ← │ INTEGRATE │ ←──── │ FULL TEST-SYNC  │       │
+│  │ agent 9  │   │agent 8 │   │  agent 7  │       │    agent 6      │       │
+│  └────┬────┘   └────┬────┘   └─────┬─────┘       └────────┬────────┘       │
+│       ↓              ↓              ↓                      ↓               │
+│    archive        status +       status                 status              │
+│    git tag        gate check     check                  check               │
+│                                                                              │
+│  Each agent: fresh context window, reads state from files, dies when done   │
+│  Orchestrator: ~30KB total, never compacts                                  │
+└──────────────────────────────────────────────────────────────────────────────┘
 ```
 
 $ARGUMENTS

package/docs/GSD-T-README.md

@@ -98,6 +98,7 @@ GSD-T reads all state files and tells you exactly where you left off.
 | `/user:gsd-t-impact` | Analyze downstream effects | In wave |
 | `/user:gsd-t-execute` | Run tasks (solo or team) | In wave |
 | `/user:gsd-t-test-sync` | Sync tests with code changes | In wave |
+| `/user:gsd-t-qa` | QA agent — test generation, execution, gap reporting | Auto-spawned |
 | `/user:gsd-t-integrate` | Wire domains together | In wave |
 | `/user:gsd-t-verify` | Run quality gates | In wave |
 | `/user:gsd-t-complete-milestone` | Archive + git tag | In wave |