gsd-vscode-copilot 1.0.0

package/templates/prompts/gsd-execute-plan.prompt.md

@@ -0,0 +1,96 @@
+---
+description: "GSD: Execute a plan file (run verify, stop on checkpoints)"
+argument-hint: "Provide the plan path (e.g., .planning/phases/03-auth/03-01-PLAN.md)"
+agent: agent
+---
+
+Execute a GSD-style plan file.
+
+## Instructions
+
+1. If no plan path provided, ask which PLAN file to execute.
+2. Read the PLAN file — it IS the executable prompt.
+3. Execute tasks sequentially.
+
+## For each task
+
+### `type="auto"` tasks
+
+1. Implement the changes described in `<action>`
+2. Run the `<verify>` command(s)
+3. If verification fails: stop and report the failure with proposed fixes
+4. If verification passes: confirm `<done>` criteria met and continue
+
+### `type="checkpoint:*"` tasks
+
+1. **STOP immediately** (do not continue to next task)
+2. Display a clear checkpoint message:
+
+```
+════════════════════════════════════════
+CHECKPOINT: [Type]
+════════════════════════════════════════
+
+Task [X] of [Y]: [Task name]
+
+[For human-verify]: What was built, how to verify
+[For decision]: Options with pros/cons
+
+Resume signal: [How to continue]
+════════════════════════════════════════
+```
+
+3. Wait for my response before continuing
+
+## After all tasks complete
+
+1. Run the overall `<verification>` checks from the plan
+2. Confirm all `<success_criteria>` are met
+3. Create the SUMMARY file as specified in `<output>`
+
+### SUMMARY format
+
+Create `.planning/phases/NN-name/NN-PP-SUMMARY.md`:
+
+```markdown
+# Phase [X] Plan [Y]: [Name] Summary
+
+**[One-liner describing what was accomplished]**
+
+## Accomplishments
+- [What was built]
+
+## Files Created/Modified
+- `path/to/file` - What it does
+
+## Decisions Made
+[Key decisions, or "None - followed plan as specified"]
+
+## Issues Encountered
+[Problems and resolutions, or "None"]
+
+## Next Phase Readiness
+[What's ready for next phase]
+```
+
+4. Update `.planning/STATE.md` with:
+   - Current position
+   - Any decisions made
+   - Next action
+
+## Git commits
+
+After verification passes, offer to create a commit:
+- Show `git status` summary
+- Propose a commit message following: `feat(NN-PP): [description]`
+- Ask for explicit confirmation before committing
+
+**Never commit without explicit "yes" from the user.**
+
+## Output
+
+Report:
+- Tasks completed
+- Verification results
+- Summary path
+- Any follow-ups or risks discovered

package/templates/prompts/gsd-plan-slice.prompt.md

@@ -0,0 +1,105 @@
+---
+description: "GSD: Plan a small executable slice (2–3 tasks)"
+argument-hint: "What slice are we planning? (e.g., 'Phase 03: User authentication')"
+agent: agent
+---
+
+Plan the next small slice of work as a **GSD-style phase plan** (2–3 tasks max).
+
+## Context to load
+
+- Read `.planning/STATE.md` and `.planning/ROADMAP.md`.
+- Identify the current phase directory under `.planning/phases/` (or ask me which phase).
+- If a feature is mentioned, locate the relevant code and reference the specific files to be changed.
+
+## Plan file location
+
+Create a new plan file under:
+- `.planning/phases/<NN-name>/` (create the directory if missing)
+
+Name the file:
+- `<NN>-<PP>-PLAN.md` (example: `03-01-PLAN.md` for Phase 3, Plan 1)
+
+## Plan format
+
+Follow the template in `.github/vendor/get-shit-done/templates/phase-prompt.md`.
+
+### Required structure
+
+```markdown
+---
+phase: NN-name
+plan: PP
+type: execute
+wave: 1
+depends_on: []
+files_modified: []
+autonomous: true
+---
+
+<objective>
+[What this plan accomplishes]
+
+Purpose: [Why this matters]
+Output: [What artifacts will be created]
+</objective>
+
+<context>
+@.planning/PROJECT.md
+@.planning/ROADMAP.md
+@.planning/STATE.md
+[Relevant source files]
+</context>
+
+<tasks>
+
+<task type="auto">
+  <name>Task 1: [Action-oriented name]</name>
+  <files>path/to/file.ext</files>
+  <action>[Specific implementation - what to do, how to do it, what to avoid and WHY]</action>
+  <verify>[Command or check to prove it worked]</verify>
+  <done>[Measurable acceptance criteria]</done>
+</task>
+
+<!-- Repeat for 2-3 tasks total -->
+
+</tasks>
+
+<verification>
+Before declaring plan complete:
+- [ ] [Specific test/build command]
+- [ ] [Behavior verification]
+</verification>
+
+<success_criteria>
+- All tasks completed
+- All verification checks pass
+- [Plan-specific criteria]
+</success_criteria>
+
+<output>
+After completion, create `.planning/phases/NN-name/NN-PP-SUMMARY.md`
+</output>
+```
+
+## Task types
+
+| Type | Use for |
+|------|---------|
+| `auto` | Everything that can be done autonomously |
+| `checkpoint:human-verify` | Visual/functional verification needed |
+| `checkpoint:decision` | Implementation choice needed |
+
+## Guidelines
+
+- **2–3 tasks max** per plan
+- Each task must have: `<files>`, `<action>`, `<verify>`, `<done>`
+- `<verify>` should use actual commands for your stack (e.g., `npm test`, `dotnet build`)
+- Prefer vertical slices (model + API + UI) over horizontal layers
+
+## Output
+
+Write the plan file, then reply with:
+- Plan path
+- Summary of what will be built
+- Any open questions that block execution

package/templates/prompts/gsd-progress.prompt.md

@@ -0,0 +1,50 @@
+---
+description: "GSD: Progress + next action (reads .planning/STATE.md)"
+argument-hint: "What changed since last update? Any blockers?"
+agent: ask
+---
+
+Read `.planning/STATE.md` and `.planning/ROADMAP.md` and give me a quick status update.
+
+## Report
+
+Tell me (concisely):
+
+1. **Where we are now** (1–2 sentences)
+   - Current phase and plan
+   - What was last completed
+
+2. **What's blocked** (if anything)
+   - Pending decisions
+   - External dependencies
+   - Technical blockers
+
+3. **The next best action**
+   - Which prompt to run next
+   - What specific slice to work on
+
+## If `.planning/` files are missing
+
+Propose the minimal bootstrap steps:
+
+```
+.planning/ not initialized.
+
+Run: gsd-bootstrap-planning.prompt.md
+
+This will create:
+  - PROJECT.md
+  - REQUIREMENTS.md  
+  - ROADMAP.md
+  - STATE.md
+```
+
+## Format
+
+Keep it short — this is a quick status check, not a full report.
+
+```
+📍 Status: Phase 2 / Plan 1 complete
+📋 Last: User auth endpoints implemented
+⏭️ Next: Run gsd-plan-slice for "Phase 2 Plan 2: Protected routes"
+```

package/templates/prompts/gsd-verify-work.prompt.md

@@ -0,0 +1,60 @@
+---
+description: "GSD: Conversational UAT for a plan or slice"
+argument-hint: "Which plan/slice should we verify? (optional plan path)"
+agent: ask
+---
+
+Run a conversational verification session for the most recently executed plan (or a plan I specify).
+
+## Instructions
+
+1. If no plan specified, find the most recent `*-SUMMARY.md` in `.planning/phases/`
+2. Read the SUMMARY and corresponding PLAN to understand what was built
+3. Determine what "should happen" based on the plan + the changed files
+
+## Verification flow
+
+Test one thing at a time. For each test:
+
+1. Tell me what to test and how
+2. Ask: "Does it behave like this?"
+3. Wait for my response:
+   - **yes/ok/pass** → record as PASS, continue to next test
+   - **describe an issue** → record as FAIL with details
+
+## Record results
+
+Create or update a UAT file: `.planning/uat/UAT-YYYYMMDD.md`
+
+```markdown
+# UAT Session - [Date]
+
+**Plan(s) tested:** [plan IDs]
+
+## Test Results
+
+| # | Test | Result | Notes |
+|---|------|--------|-------|
+| 1 | [description] | PASS/FAIL | [details] |
+| 2 | [description] | PASS/FAIL | [details] |
+
+## Issues Found
+
+### Issue 1: [Title]
+- **Severity:** low/medium/high
+- **Description:** [what's wrong]
+- **Repro steps:** [how to reproduce]
+
+## Summary
+
+- **Passed:** X
+- **Failed:** Y
+- **Skipped:** Z
+```
+
+## Output
+
+At the end, summarize:
+- What passed
+- What failed
+- Suggested fixes (or propose a new plan to address issues)

package/templates/vendor/references/checkpoints.md

@@ -0,0 +1,123 @@
+# Checkpoints Reference
+
+Checkpoints are pause points where AI stops and asks for human input.
+
+## Checkpoint Types
+
+### checkpoint:human-verify
+
+**Use for:** Visual/functional verification that requires human eyes.
+
+```xml
+<task type="checkpoint:human-verify" gate="blocking">
+  <what-built>[What was built]</what-built>
+  <how-to-verify>
+    1. Run: npm run dev
+    2. Visit: http://localhost:3000/login
+    3. Test: Enter credentials and submit
+    4. Confirm: Redirects to dashboard on success
+  </how-to-verify>
+  <resume-signal>Type "approved" or describe issues</resume-signal>
+</task>
+```
+
+**AI behavior:**
+1. Stop immediately when reaching this task
+2. Display what was built and verification steps
+3. Wait for user response
+4. Continue if "approved", or address issues
+
+### checkpoint:decision
+
+**Use for:** Implementation choices that need human input.
+
+```xml
+<task type="checkpoint:decision" gate="blocking">
+  <decision>Choose authentication strategy</decision>
+  <context>Need to decide how to handle user sessions</context>
+  <options>
+    <option id="jwt">
+      <name>JWT Tokens</name>
+      <pros>Stateless, scalable, good for APIs</pros>
+      <cons>Can't revoke easily, larger payload</cons>
+    </option>
+    <option id="sessions">
+      <name>Server Sessions</name>
+      <pros>Easy revocation, smaller cookies</pros>
+      <cons>Requires session store, harder to scale</cons>
+    </option>
+  </options>
+  <resume-signal>Select: jwt or sessions</resume-signal>
+</task>
+```
+
+**AI behavior:**
+1. Stop and present options clearly
+2. Wait for user to select
+3. Record decision in STATE.md
+4. Continue with chosen approach
+
+### checkpoint:human-action
+
+**Use for:** Truly unavoidable manual steps (rare).
+
+```xml
+<task type="checkpoint:human-action" gate="blocking">
+  <action>Complete OAuth app registration</action>
+  <context>Need client ID and secret from GitHub</context>
+  <instructions>
+    1. Go to GitHub > Settings > Developer settings > OAuth Apps
+    2. Click "New OAuth App"
+    3. Set callback URL to http://localhost:3000/auth/callback
+    4. Copy Client ID and Client Secret
+    5. Add to .env.local:
+       GITHUB_CLIENT_ID=xxx
+       GITHUB_CLIENT_SECRET=xxx
+  </instructions>
+  <verify>cat .env.local | grep GITHUB_CLIENT</verify>
+  <resume-signal>Type "done" when complete</resume-signal>
+</task>
+```
+
+**AI behavior:**
+1. Stop and show clear instructions
+2. Wait for user to complete
+3. Run verification if specified
+4. Continue once confirmed
+
+---
+
+## When to Use Checkpoints
+
+**DO use checkpoints for:**
+- UI/UX verification (visual appearance)
+- Deployment verification (site is live)
+- Architecture decisions with trade-offs
+- External service setup (OAuth, API keys)
+
+**DON'T use checkpoints for:**
+- Things that can be automated (tests, linting)
+- Decisions that have obvious answers
+- Steps AI can verify programmatically
+
+---
+
+## Display Format
+
+When hitting a checkpoint, display clearly:
+
+```
+════════════════════════════════════════
+CHECKPOINT: [Type]
+════════════════════════════════════════
+
+Task [X] of [Y]: [Task name]
+
+[Checkpoint-specific content]
+
+────────────────────────────────────────
+→ YOUR ACTION: [Resume signal]
+────────────────────────────────────────
+```
+
+Then **STOP** and wait for response.

package/templates/vendor/templates/phase-prompt.md

@@ -0,0 +1,242 @@
+# Phase Prompt Template
+
+Template for `.planning/phases/XX-name/{phase}-{plan}-PLAN.md` — executable phase plans.
+
+## File Template
+
+```markdown
+---
+phase: XX-name
+plan: NN
+type: execute
+wave: N                     # Execution wave (1, 2, 3...). Plans in same wave can run in parallel.
+depends_on: []              # Plan IDs this plan requires (e.g., ["01-01"]).
+files_modified: []          # Files this plan modifies.
+autonomous: true            # false if plan has checkpoints requiring user interaction
+---
+
+<objective>
+[What this plan accomplishes]
+
+Purpose: [Why this matters for the project]
+Output: [What artifacts will be created]
+</objective>
+
+<context>
+@.planning/PROJECT.md
+@.planning/ROADMAP.md
+@.planning/STATE.md
+
+[Relevant source files:]
+@src/path/to/relevant.ts
+</context>
+
+<tasks>
+
+<task type="auto">
+  <name>Task 1: [Action-oriented name]</name>
+  <files>path/to/file.ext, another/file.ext</files>
+  <action>[Specific implementation - what to do, how to do it, what to avoid and WHY]</action>
+  <verify>[Command or check to prove it worked]</verify>
+  <done>[Measurable acceptance criteria]</done>
+</task>
+
+<task type="auto">
+  <name>Task 2: [Action-oriented name]</name>
+  <files>path/to/file.ext</files>
+  <action>[Specific implementation]</action>
+  <verify>[Command or check]</verify>
+  <done>[Acceptance criteria]</done>
+</task>
+
+<!-- Checkpoint example (use sparingly) -->
+<task type="checkpoint:human-verify" gate="blocking">
+  <what-built>[What was built that needs verification]</what-built>
+  <how-to-verify>
+    1. Run: [command to start dev server/app]
+    2. Visit: [URL to check]
+    3. Test: [Specific interactions]
+    4. Confirm: [Expected behaviors]
+  </how-to-verify>
+  <resume-signal>Type "approved" to continue, or describe issues to fix</resume-signal>
+</task>
+
+</tasks>
+
+<verification>
+Before declaring plan complete:
+- [ ] [Specific test command]
+- [ ] [Build/type check passes]
+- [ ] [Behavior verification]
+</verification>
+
+<success_criteria>
+- All tasks completed
+- All verification checks pass
+- No errors or warnings introduced
+- [Plan-specific criteria]
+</success_criteria>
+
+<output>
+After completion, create `.planning/phases/XX-name/{phase}-{plan}-SUMMARY.md`
+</output>
+```
+
+---
+
+## Frontmatter Fields
+
+| Field | Required | Purpose |
+|-------|----------|---------|
+| `phase` | Yes | Phase identifier (e.g., `01-foundation`) |
+| `plan` | Yes | Plan number within phase (e.g., `01`, `02`) |
+| `type` | Yes | Always `execute` for standard plans |
+| `wave` | Yes | Execution wave number (1, 2, 3...) |
+| `depends_on` | Yes | Array of plan IDs this plan requires |
+| `files_modified` | Yes | Files this plan touches |
+| `autonomous` | Yes | `true` if no checkpoints, `false` if has checkpoints |
+
+---
+
+## Task Types
+
+| Type | Use For | Behavior |
+|------|---------|----------|
+| `auto` | Everything that can be done independently | Execute, verify, continue |
+| `checkpoint:human-verify` | Visual/functional verification | Stop, ask user, wait for approval |
+| `checkpoint:decision` | Implementation choices | Stop, present options, wait for choice |
+| `checkpoint:human-action` | Truly unavoidable manual steps (rare) | Stop, instruct user, wait for completion |
+
+---
+
+## Scope Guidelines
+
+**Plan sizing:**
+- 2–3 tasks per plan
+- ~50% context usage maximum
+- Complex phases: Multiple focused plans, not one large plan
+
+**When to split:**
+- Different subsystems (auth vs API vs UI)
+- More than 3 tasks
+- Risk of context overflow
+
+**Prefer vertical slices:**
+```
+PREFER: Plan 01 = User (model + API + UI)
+        Plan 02 = Product (model + API + UI)
+
+AVOID:  Plan 01 = All models
+        Plan 02 = All APIs
+        Plan 03 = All UIs
+```
+
+---
+
+## Verification Examples by Stack
+
+**Node.js / TypeScript:**
+```xml
+<verify>npm run build && npm test</verify>
+```
+
+**Python:**
+```xml
+<verify>pytest tests/ && mypy src/</verify>
+```
+
+**.NET:**
+```xml
+<verify>dotnet build && dotnet test</verify>
+```
+
+**Go:**
+```xml
+<verify>go build ./... && go test ./...</verify>
+```
+
+**Rust:**
+```xml
+<verify>cargo build && cargo test</verify>
+```
+
+---
+
+## Example Plan
+
+```markdown
+---
+phase: 02-auth
+plan: 01
+type: execute
+wave: 1
+depends_on: []
+files_modified: [src/auth/login.ts, src/auth/login.test.ts]
+autonomous: true
+---
+
+<objective>
+Implement user login endpoint with JWT tokens.
+
+Purpose: Enable authenticated access to protected routes.
+Output: POST /auth/login endpoint returning JWT on success.
+</objective>
+
+<context>
+@.planning/PROJECT.md
+@.planning/ROADMAP.md
+@.planning/STATE.md
+@src/db/schema.ts
+</context>
+
+<tasks>
+
+<task type="auto">
+  <name>Task 1: Create login endpoint</name>
+  <files>src/auth/login.ts</files>
+  <action>
+    Create POST /auth/login that:
+    - Accepts { email, password } in body
+    - Validates against users table
+    - Returns JWT token on success
+    - Returns 401 on invalid credentials
+    
+    Use jose library for JWT (not jsonwebtoken - ESM issues).
+    Token should expire in 1 hour.
+  </action>
+  <verify>curl -X POST localhost:3000/auth/login -d '{"email":"test@example.com","password":"test"}' returns 200 or 401</verify>
+  <done>Login endpoint validates credentials and returns JWT</done>
+</task>
+
+<task type="auto">
+  <name>Task 2: Add login tests</name>
+  <files>src/auth/login.test.ts</files>
+  <action>
+    Write tests for:
+    - Valid credentials return 200 + token
+    - Invalid password returns 401
+    - Unknown email returns 401
+    - Missing fields return 400
+  </action>
+  <verify>npm test -- --grep "login"</verify>
+  <done>All login tests pass</done>
+</task>
+
+</tasks>
+
+<verification>
+- [ ] npm run build succeeds
+- [ ] npm test passes
+- [ ] Manual curl test works
+</verification>
+
+<success_criteria>
+- Login endpoint works with valid credentials
+- Invalid credentials properly rejected
+- Tests cover main scenarios
+</success_criteria>
+
+<output>
+After completion, create `.planning/phases/02-auth/02-01-SUMMARY.md`
+</output>
+```