@tekyzinc/gsd-t 2.18.2 → 2.19.1

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 All notable changes to GSD-T are documented here. Updated with each release.
 
+## [2.19.1] - 2026-02-16
+
+### Changed
+- **Quick**: Now runs the FULL test suite (not just affected tests), requires comprehensive test creation for new/changed code paths including Playwright E2E, and verifies against requirements and contracts. "Quick doesn't mean skip testing."
+
+## [2.19.0] - 2026-02-16
+
+### Changed
+- **Execute**: "No feature code without test code" — every task must include comprehensive unit tests AND Playwright E2E specs for all new code paths, modes, and flows. Tests are part of the deliverable, not a follow-up
+- **Test-Sync**: Creates tests immediately during execute phase instead of deferring gaps to verify. Missing Playwright specs for new features/modes are created on the spot
+- **Verify**: Zero test coverage on new functionality is now a FAIL (not WARN). Coverage audit checks that every new feature, mode, page, and flow has comprehensive Playwright specs covering happy path, error states, edge cases, and all modes/flags
+
 ## [2.18.2] - 2026-02-16
 
 ### Added

package/commands/gsd-t-execute.md

@@ -30,11 +30,20 @@ For each task:
 3. Read the domain's constraints.md — follow all patterns
 4. **Destructive Action Guard**: Before implementing, check if the task involves any 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 with what exists, what will change, what will break, and a safe migration path. Wait for explicit approval before proceeding.
 5. Implement the task
-5. Verify acceptance criteria are met
-6. Run affected unit tests — fix any failures before proceeding
-7. If E2E framework exists and task changed UI/routes/flows: run affected E2E specs, update specs if needed
-8. Run the Pre-Commit Gate checklist from CLAUDE.md — update ALL affected docs BEFORE committing
-9. Commit with a descriptive message: `[{domain}] Task {N}: {description}`
+6. Verify acceptance criteria are met
+7. **Write comprehensive tests for every new or changed code path** (MANDATORY — no exceptions):
+   a. **Unit/integration tests**: Cover the happy path, common edge cases, error cases, and boundary conditions for every new or modified function
+   b. **Playwright E2E tests** (if UI/routes/flows/modes changed): Detect `playwright.config.*` or Playwright in dependencies. If present:
+      - Create NEW specs for new features, pages, modes, or flows — not just update existing ones
+      - Cover: happy path, form validation errors, empty states, loading states, error states, responsive breakpoints
+      - Cover: all feature modes/flags (e.g., if `--component` mode was added, test `--component` mode specifically)
+      - Cover: common edge cases (network errors, invalid input, rapid clicking, back/forward navigation)
+      - Use descriptive test names that explain the scenario being tested
+   c. If no test framework exists: set one up as part of the task (at minimum, Playwright for E2E)
+   d. **"No feature code without test code"** — implementation and tests are ONE deliverable, not two separate steps
+8. **Run ALL tests** — unit, integration, and full Playwright suite. Fix any failures before proceeding (up to 2 attempts)
+9. Run the Pre-Commit Gate checklist from CLAUDE.md — update ALL affected docs BEFORE committing
+10. Commit with a descriptive message: `[{domain}] Task {N}: {description}`
 10. Update `.gsd-t/progress.md` — mark task complete
 11. If you've reached a CHECKPOINT in integration-points.md, pause and verify the contract before continuing
 
@@ -55,6 +64,10 @@ RULES FOR ALL TEAMMATES:
 - **Destructive Action Guard**: NEVER drop tables, remove columns, delete data, replace architecture patterns, or remove working modules without messaging the lead first. The lead must get user approval before any destructive action proceeds.
 - Only modify files listed in your domain's scope.md
 - Implement interfaces EXACTLY as specified in contracts
+- **Write comprehensive tests with every task** — no feature code without test code:
+  - Unit/integration tests: happy path + edge cases + error cases for every new/changed function
+  - Playwright E2E specs (if UI/routes/flows/modes changed): new specs for new features, cover all modes/flags, form validation, empty/loading/error states, common edge cases
+  - Tests are part of the deliverable, not a follow-up
 - If a task is marked BLOCKED, message the lead and wait
 - Run the Pre-Commit Gate checklist from CLAUDE.md BEFORE every commit — update all affected docs
 - After completing each task, message the lead with:

package/commands/gsd-t-quick.md

@@ -52,14 +52,23 @@ If `.gsd-t/progress.md` exists, assess what documentation was affected and updat
 
 ### Skip what's not affected — most quick tasks will only touch 1-2 of these.
 
-## Step 5: Test Verification
-
-Before committing, verify the change works:
-
-1. **Update tests**: If the change adds or modifies behavior, update or add tests to cover it
-2. **Run affected tests**: Execute all tests related to the changed files and domain
-3. **Verify passing**: All tests must pass. If any fail, fix before proceeding (up to 2 attempts)
-4. **Run E2E tests**: If the change touched UI, routes, or user flows and an E2E framework exists, run affected specs
-5. **No test framework?**: At minimum, manually verify the change works as expected and document how you verified it in the commit message
+## Step 5: Test & Verify (MANDATORY)
+
+Quick does not mean skip testing. Before committing:
+
+1. **Write/update tests for every new or changed code path**:
+   - Unit tests: happy path + common edge cases + error cases
+   - Playwright E2E specs (if UI/routes/flows/modes changed): create new specs for new functionality, update existing specs for changed behavior
+   - Cover all modes/flags affected by this change
+   - "No feature code without test code" applies to quick tasks too
+2. **Run the FULL test suite** — not just affected tests:
+   - All unit/integration tests
+   - Full Playwright E2E suite (if configured)
+   - Fix any failures before proceeding (up to 2 attempts)
+3. **Verify against requirements**:
+   - Does the change satisfy its intended requirement?
+   - Did the change break any existing functionality? (the full test run catches this)
+   - If a contract exists for the interface touched, does the code still match?
+4. **No test framework?**: Set one up, or at minimum manually verify and document how in the commit message
 
 $ARGUMENTS

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

@@ -108,13 +108,27 @@ Determine which E2E specs are affected:
 - Changed database schema? → Run specs that depend on that data
 - Not sure what's affected? → Run the full E2E suite
 
-### C) Update E2E Tests
-If code changes affect user flows, update E2E test specs:
-- New pages/routes → create new E2E specs
+### C) Create and Update Playwright E2E Tests (MANDATORY when UI/routes/flows/modes changed)
+
+If Playwright is configured (`playwright.config.*` or Playwright in dependencies):
+
+**For new features, pages, modes, or flows — CREATE comprehensive specs:**
+- Happy path for every new user flow
+- All feature modes/flags (e.g., `--component` mode gets its own test suite, not just default mode)
+- Form validation: valid input, invalid input, empty fields, boundary values
+- Error states: network failures, API errors, permission denied, timeout
+- Empty states: no data, first-time user, cleared data
+- Loading states: skeleton screens, spinners, progressive loading
+- Edge cases: rapid clicking, double submission, back/forward navigation, browser refresh mid-flow
+- Responsive: test at mobile and desktop breakpoints if layout changes
+
+**For changed features — UPDATE existing specs AND add missing coverage:**
 - Changed UI elements (selectors, text, layout) → update locators and assertions
 - Changed form fields or validation → update form fill steps and error assertions
-- New features → add E2E specs covering the happy path + key error cases
 - Removed features → remove or update affected E2E specs
+- Review existing specs for missing edge cases and add them
+
+**This is NOT optional.** Every new code path that a user can reach must have a Playwright spec. "We'll add tests later" is never acceptable.
 
 ### D) Capture Results
 For all test types:
@@ -236,13 +250,14 @@ If issues found, add to current domain's tasks:
 
 ### During Execute Phase (auto-invoked):
 After each task completes:
-1. Quick scan of changed files
-2. Run affected unit/integration tests
-3. Run affected E2E tests (if E2E framework detected)
-4. If failures: pause and report
-5. If E2E specs need updating: update them before continuing
-6. If gaps: note for end-of-phase sync
-7. Continue execution
+1. Scan changed files and map to existing tests
+2. **If new code paths have zero test coverage: write tests NOW** — do not defer
+3. Run ALL affected unit/integration tests
+4. Run ALL affected Playwright E2E tests
+5. If failures: fix immediately (up to 2 attempts) before continuing
+6. If E2E specs are missing for new features/modes/flows: **create them NOW**, not later
+7. If E2E specs need updating for changed behavior: update them before continuing
+8. **No task is complete until its tests exist and pass** — do not move to the next task with test gaps
 
 ### During Verify Phase (auto-invoked):
 Full sync:

package/commands/gsd-t-verify.md

@@ -19,8 +19,12 @@ Standard dimensions (adjust based on project):
 1. **Functional Correctness**: Does it work per requirements?
 2. **Contract Compliance**: Does every domain honor its contracts?
 3. **Code Quality**: Conventions, patterns, error handling, readability
-4. **Test Coverage**: Are critical paths tested? Are edge cases covered?
-5. **E2E Tests**: Run the full E2E suite (Playwright, Cypress, etc.) — all specs must pass
+4. **Test Coverage Completeness**: Every new or changed code path MUST have tests. Check:
+   - Do all new functions have unit tests (happy path + edge cases + error cases)?
+   - Do all new features/modes/flows have Playwright E2E specs?
+   - Do all new UI components have interaction tests?
+   - **Zero test coverage on new functionality = FAIL** (not WARN, not "nice to have" — FAIL)
+5. **E2E Tests**: Run the FULL Playwright suite — all specs must pass. If new features lack specs, create them before proceeding.
 6. **Security**: Auth flows, input validation, data exposure, dependencies
 7. **Integration Integrity**: Do the seams between domains hold under stress?
 
@@ -35,10 +39,14 @@ Work through each dimension sequentially. For each:
 
 **Mandatory test execution:**
 1. Run ALL unit/integration tests — every test must pass
-2. Detect E2E framework (check for `playwright.config.*`, `cypress.config.*`, E2E deps in package.json)
-3. If E2E framework exists, run the FULL E2E suite — every spec must pass
-4. If E2E specs are missing or stale, invoke `gsd-t-test-sync` to update them first, then re-run
-5. Tests are NOT optional — verification cannot pass without running them
+2. Detect Playwright (check for `playwright.config.*`, Playwright deps in package.json)
+3. Run the FULL Playwright E2E suite — every spec must pass
+4. **Coverage audit**: For every new feature, mode, page, or flow added in this milestone:
+   - Confirm Playwright specs exist that specifically test it
+   - Confirm specs cover: happy path, error states, edge cases, all modes/flags
+   - If specs are missing or incomplete → invoke `gsd-t-test-sync` to create them, then re-run
+   - **Missing E2E coverage on new functionality = verification FAIL**
+5. Tests are NOT optional — verification cannot pass without running them and confirming comprehensive coverage
 
 ### Team Mode (when agent teams are enabled)
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tekyzinc/gsd-t",
-  "version": "2.18.2",
+  "version": "2.19.1",
   "description": "GSD-T: Contract-Driven Development for Claude Code — 41 slash commands with backlog management, impact analysis, test sync, and milestone archival",
   "author": "Tekyz, Inc.",
   "license": "MIT",