@tekyzinc/gsd-t 2.20.7 → 2.22.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-triage-and-merge.md

@@ -0,0 +1,167 @@
+# GSD-T: Triage and Merge — Auto-Review, Merge, and Publish GitHub Branches
+
+You are triaging unmerged GitHub branches for safety, then auto-merging, committing, and publishing those that pass all safety checks.
+
+## Step 1: Publish Gate
+
+Check the project's autonomy level in `CLAUDE.md`:
+
+- **Level 3 (Full Auto / "yolo")**: Auto-publish is ON. Skip the prompt and proceed.
+- **Level 1 or 2**: Ask the user before starting:
+  ```
+  Auto-publish after merge? This will version bump, npm publish, and deploy.
+  (yes/no)
+  ```
+  If **no**: triage and merge only — skip version bump, npm publish, and deploy (Steps 7-8).
+  If **yes**: full pipeline including publish.
+
+Store the decision for use in Step 7.
+
+## Step 2: Load Context
+
+Read:
+1. `CLAUDE.md` — project conventions, pre-commit gate, autonomy level
+2. `.gsd-t/progress.md` — current version and state
+3. `package.json` — current version number
+
+## Step 3: Fetch and Identify Branches
+
+```bash
+git fetch --all
+git branch -r --no-merged main
+```
+
+If no unmerged branches exist, report "No unmerged branches found" and stop.
+
+## Step 4: Triage Each Branch
+
+For each unmerged branch, collect:
+
+1. **Commit log**: `git log main..origin/{branch} --oneline`
+2. **Files changed**: `git diff main...origin/{branch} --stat`
+3. **Full diff**: `git diff main...origin/{branch}` (for impact scoring)
+4. **Conflict check**: `git merge --no-commit --no-ff origin/{branch}` then `git merge --abort`
+
+### Impact Scoring
+
+Score each branch on a 3-tier scale:
+
+| Tier | Criteria | Action |
+|------|----------|--------|
+| **Auto-merge** | Docs-only, contracts-only, templates with no behavior change, < 100 lines changed, no merge conflicts, no command file behavior changes | Merge automatically |
+| **Review** | Command file changes, CLI behavior changes, new files in `commands/`, template behavior changes, > 100 lines, wave/phase sequence changes | Show summary, ask user to confirm |
+| **Skip** | Merge conflicts, version-sensitive changes (package.json version), breaking changes to existing interfaces | Report why, do not merge |
+
+### Sensitive File Patterns (trigger Review tier)
+
+- `commands/*.md` — command behavior
+- `bin/gsd-t.js` — CLI installer
+- `templates/CLAUDE-global.md` — global config template
+- `scripts/*.js` — hook scripts
+- `package.json` — version/dependencies
+
+### Safe File Patterns (stay in Auto-merge tier)
+
+- `.gsd-t/contracts/*.md` — contract definitions
+- `.gsd-t/techdebt.md` — debt tracking
+- `docs/*.md` — documentation
+- `examples/**` — example files
+- `*.md` in root (except README.md with structural changes)
+
+## Step 5: Report Triage Results
+
+Display a summary table:
+
+```
+╔══════════════════════════════════════════════════════════════════════════════╗
+║                         Branch Triage Results                               ║
+╠══════════════════════════════════════════════════════════════════════════════╣
+
+  AUTO-MERGE
+  ──────────
+  ✓ {branch-name} — {commit count} commits, {lines} lines, {description}
+
+  NEEDS REVIEW
+  ────────────
+  ? {branch-name} — {commit count} commits, {lines} lines, {reason for review}
+
+  SKIPPED
+  ───────
+  ✗ {branch-name} — {reason} (conflicts / breaking changes)
+
+╚══════════════════════════════════════════════════════════════════════════════╝
+```
+
+## Step 6: Merge Safe Branches
+
+For each Auto-merge branch:
+1. `git merge origin/{branch} --no-edit`
+2. Verify merge succeeded
+3. Log the merge
+
+For each Review branch:
+1. Show the diff summary and reason it needs review
+2. Ask: "Merge {branch}? (yes/no)"
+3. If yes, merge it
+
+If ALL branches were skipped (none merged), report why and stop.
+
+## Step 7: Version Bump and Publish
+
+**If publish gate is OFF** (user declined in Step 1): Skip this step entirely. Report merged branches and stop.
+
+After all merges complete:
+
+1. **Determine version bump**:
+   - If any merged branch adds new commands → bump minor
+   - If merged branches are docs/contracts/fixes only → bump patch
+   - If any merged branch has breaking changes → bump minor (breaking = major, but those should be in Review tier)
+
+2. **Update files**:
+   - `package.json` — bump version
+   - `.gsd-t/progress.md` — update version + add Decision Log entry summarizing all merged branches
+   - `CHANGELOG.md` — add release entry listing what each branch contributed
+
+3. **Pre-Commit Gate**: Run the project-specific pre-commit checklist:
+   - If any merged branch changed command files → update GSD-T-README.md, README.md, CLAUDE-global template, gsd-t-help
+   - If any merged branch changed CLI → verify install/update/status/doctor work
+   - If any merged branch changed templates → verify gsd-t-init output
+
+4. **Commit**: `git add` changed files and commit:
+   ```
+   chore: version bump to v{version} for merged branch(es)
+   ```
+
+5. **Push**: `git push`
+
+6. **Publish**: `npm publish --access public`
+
+7. **Deploy**: Install globally and propagate:
+   ```bash
+   npm install -g @tekyzinc/gsd-t@{version}
+   gsd-t update-all
+   ```
+
+## Step 8: Report
+
+Display final summary:
+
+```
+Triage complete:
+  Merged:    {N} branches
+  Skipped:   {N} branches
+  Published: v{new-version}    (or "Skipped — publish gate off")
+```
+
+## Document Ripple
+
+After completing triage-and-merge, check if any of these need updating based on what was merged:
+
+1. **`.gsd-t/progress.md`** — Decision Log entry (always)
+2. **`CHANGELOG.md`** — Release notes (always, if publishing)
+3. **`README.md`** — If merged branches changed commands or structure
+4. **`docs/GSD-T-README.md`** — If merged branches changed commands or workflow
+5. **`templates/CLAUDE-global.md`** — If merged branches added commands
+6. **`commands/gsd-t-help.md`** — If merged branches added commands
+
+$ARGUMENTS

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

@@ -11,6 +11,10 @@ Read:
 
 Determine current status and resume from wherever the milestone left off.
 
+## Step 1.5: QA Agent Spawning
+
+Every phase that produces or validates code will automatically spawn a QA teammate. The QA agent is spawned per-phase (not once for the entire wave) because each phase has different QA responsibilities. Each phase's command file contains its own QA spawn instructions — follow them when executing that phase.
+
 ## Step 2: Execute Remaining Phases
 
 Work through each phase that hasn't been completed:

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 |
@@ -114,6 +115,7 @@ GSD-T reads all state files and tells you exactly where you left off.
 | `/user:gsd-t-log` | Sync progress Decision Log with recent git activity | Manual |
 | `/user:gsd-t-version-update` | Update GSD-T to latest version | Manual |
 | `/user:gsd-t-version-update-all` | Update GSD-T + all registered projects | Manual |
+| `/user:gsd-t-triage-and-merge` | Auto-review, merge, and publish GitHub branches | Manual |
 
 ---
 

package/docs/architecture.md

@@ -0,0 +1,82 @@
+# Architecture — GSD-T Framework (@tekyzinc/gsd-t)
+
+## Last Updated: 2026-02-18
+
+## System Overview
+
+GSD-T is an npm-distributed methodology framework for Claude Code. It provides slash commands (markdown files), a CLI installer (Node.js), and document templates that together enable contract-driven development with AI assistance.
+
+The framework has no runtime — it is consumed entirely by Claude Code's slash command system and the user's shell. The CLI handles installation, updates, and diagnostics. The command files define the workflow methodology that Claude Code follows.
+
+## Components
+
+### CLI Installer (bin/gsd-t.js)
+- **Purpose**: Install, update, diagnose, and manage GSD-T across projects
+- **Location**: `bin/gsd-t.js`
+- **Dependencies**: Node.js built-ins only (fs, path, os, child_process, https)
+- **Subcommands**: install, update, status, doctor, init, uninstall, update-all, register, changelog
+
+### Slash Commands (commands/*.md)
+- **Purpose**: Define the GSD-T methodology as executable workflows for Claude Code
+- **Location**: `commands/`
+- **Count**: 41 (37 GSD-T workflow + 4 utility)
+- **Format**: Pure markdown with step-numbered instructions, team mode blocks, and document ripple sections
+
+### Templates (templates/*.md)
+- **Purpose**: Starter files for project initialization
+- **Location**: `templates/`
+- **Count**: 9 (CLAUDE-global, CLAUDE-project, requirements, architecture, workflows, infrastructure, progress, backlog, backlog-settings)
+- **Tokens**: `{Project Name}`, `{Date}`, `{app}` replaced during init
+
+### Heartbeat System (scripts/gsd-t-heartbeat.js)
+- **Purpose**: Real-time event logging via Claude Code hooks
+- **Location**: `scripts/gsd-t-heartbeat.js`
+- **Output**: `.gsd-t/heartbeat-{session}.jsonl` files
+
+### Examples (examples/)
+- **Purpose**: Reference project structure and settings
+- **Location**: `examples/`
+- **Contents**: settings.json, .gsd-t/ with sample contracts and domain structure
+
+## Data Models
+
+### Progress State (.gsd-t/progress.md)
+| Field | Type | Notes |
+|-------|------|-------|
+| Project | string | Name from CLAUDE.md |
+| Version | semver | Major.Minor.Patch |
+| Status | enum | INITIALIZED, IN_PROGRESS, READY |
+| Current Milestone | string | Active milestone name or "None" |
+| Decision Log | entries | Timestamped log of all changes |
+
+### Backlog (.gsd-t/backlog.md)
+| Field | Type | Notes |
+|-------|------|-------|
+| ID | Bn | Sequential backlog item ID |
+| Type | enum | bug, feature, improvement, ux, architecture |
+| App | string | Target application |
+| Category | string | Domain/module category |
+| Description | string | Item summary |
+
+### Contracts (.gsd-t/contracts/)
+| Contract | Purpose |
+|----------|---------|
+| command-interface-contract.md | Slash command file format and structure |
+| file-format-contract.md | File naming and organization rules |
+| integration-points.md | How components connect |
+| backlog-file-formats.md | Backlog markdown structure |
+| domain-structure.md | Domain directory layout |
+| pre-commit-gate.md | Commit checklist contract |
+| progress-file-format.md | Progress.md structure |
+| wave-phase-sequence.md | Phase ordering rules |
+
+## Design Decisions
+
+| Date | Decision | Rationale | Alternatives Considered |
+|------|----------|-----------|------------------------|
+| 2026-02-07 | Zero external dependencies for CLI | Simplicity, no install failures, no supply chain risk | Using commander.js, yargs |
+| 2026-02-07 | Markdown-only command files | Claude Code native format, no build step, human-readable | YAML frontmatter, JSON config |
+| 2026-02-09 | Semantic versioning with git tags | Standard npm practice, enables update checks | CalVer, build numbers |
+| 2026-02-12 | Heartbeat via Claude Code hooks | Non-invasive monitoring, no command file changes needed | Polling, WebSocket |
+| 2026-02-13 | Semantic router over keyword matching | Better intent detection, fewer misroutes | Regex patterns, ML classifier |
+| 2026-02-16 | Mandatory Playwright for all projects | Consistent E2E testing, no "we'll add tests later" | Optional testing, Jest-only |

package/docs/infrastructure.md

@@ -0,0 +1,72 @@
+# Infrastructure — GSD-T Framework (@tekyzinc/gsd-t)
+
+## Last Updated: 2026-02-18
+
+## Quick Reference
+
+| Task | Command |
+|------|---------|
+| Install GSD-T | `npx @tekyzinc/gsd-t install` |
+| Check status | `npx @tekyzinc/gsd-t status` |
+| Update GSD-T | `npx @tekyzinc/gsd-t update` |
+| Update all projects | `npx @tekyzinc/gsd-t update-all` |
+| Diagnose issues | `npx @tekyzinc/gsd-t doctor` |
+| View changelog | `npx @tekyzinc/gsd-t changelog` |
+| Publish to npm | `npm publish` |
+
+## Local Development
+
+### Setup
+```bash
+# Clone and install
+git clone https://github.com/Tekyz-Inc/get-stuff-done-teams.git
+cd get-stuff-done-teams
+
+# No npm install needed — zero dependencies
+# Test the CLI directly:
+node bin/gsd-t.js status
+```
+
+### Testing
+```bash
+# Test CLI subcommands
+node bin/gsd-t.js install
+node bin/gsd-t.js status
+node bin/gsd-t.js doctor
+node bin/gsd-t.js init test-project
+
+# Validate command files exist
+ls commands/*.md | wc -l  # Should be 41
+ls templates/*.md | wc -l  # Should be 9
+```
+
+## Distribution
+
+### npm Package
+- **Registry**: https://www.npmjs.com/package/@tekyzinc/gsd-t
+- **Publish**: `npm publish` (requires npm login with Tekyz account)
+- **Version**: Managed in `package.json`, synced to `.gsd-t/progress.md`
+
+### Installed Locations
+| What | Where |
+|------|-------|
+| Slash commands | `~/.claude/commands/` |
+| Global config | `~/.claude/CLAUDE.md` |
+| Heartbeat hook | `~/.claude/settings.json` (hooks section) |
+| Version cache | `~/.claude/.gsd-t-version` |
+| Update cache | `~/.claude/.gsd-t-update-cache` |
+| Project registry | `~/.claude/.gsd-t-projects` |
+
+## Repository Structure
+
+```
+get-stuff-done-teams/
+├── bin/gsd-t.js        — CLI (zero dependencies)
+├── commands/           — 41 slash command files
+├── templates/          — 9 document templates
+├── scripts/            — Heartbeat hook script
+├── examples/           — Reference project structure
+├── docs/               — Methodology + living docs
+├── .gsd-t/             — GSD-T state (self-managed)
+└── package.json        — npm package config
+```

package/docs/requirements.md

@@ -0,0 +1,43 @@
+# Requirements — GSD-T Framework (@tekyzinc/gsd-t)
+
+## Last Updated: 2026-02-18
+
+## Functional Requirements
+
+| ID | Requirement | Priority | Status | Tests |
+|----|-------------|----------|--------|-------|
+| REQ-001 | CLI installer with install, update, status, doctor, init, uninstall, update-all, register, changelog subcommands | P1 | complete | manual CLI testing |
+| REQ-002 | 37 GSD-T workflow slash commands for Claude Code | P1 | complete | validated by use |
+| REQ-003 | 4 utility commands (branch, checkin, Claude-md, gsd smart router) | P1 | complete | validated by use |
+| REQ-004 | Backlog management system (7 commands: add, list, move, edit, remove, promote, settings) | P1 | complete | validated by use |
+| REQ-005 | Contract-driven development with domain partitioning | P1 | complete | validated by use |
+| REQ-006 | Wave orchestration (full cycle: partition → plan → execute → test-sync → integrate → verify) | P1 | complete | validated by use |
+| REQ-007 | Heartbeat system via Claude Code hooks | P2 | complete | hook scripts installed |
+| REQ-008 | Automatic update check against npm registry | P2 | complete | CLI + slash command |
+| REQ-009 | Document templates for living docs (9 templates) | P1 | complete | used by gsd-t-init |
+| REQ-010 | Smart router — natural language intent → command routing | P2 | complete | validated by use |
+
+## Technical Requirements
+
+| ID | Requirement | Priority | Status |
+|----|-------------|----------|--------|
+| TECH-001 | Zero external npm dependencies | P1 | complete |
+| TECH-002 | Node.js >= 16 compatibility | P1 | complete |
+| TECH-003 | Cross-platform support (macOS, Linux, Windows) | P1 | complete |
+| TECH-004 | Semantic versioning with git tags | P1 | complete |
+| TECH-005 | Pre-Commit Gate enforced on every commit | P1 | complete |
+
+## Non-Functional Requirements
+
+| ID | Requirement | Metric | Status |
+|----|-------------|--------|--------|
+| NFR-001 | CLI install completes in < 5 seconds | < 5s | complete |
+| NFR-002 | No runtime crashes on missing files | graceful fallback | complete |
+| NFR-003 | Command files are pure markdown (no frontmatter) | 100% compliance | complete |
+
+## Test Coverage
+
+| Requirement | Test File | Test Name | Status |
+|-------------|-----------|-----------|--------|
+| REQ-001 | manual | CLI subcommand testing | passing |
+| REQ-002–010 | manual | Workflow validation by use | passing |