gsd-opencode 1.3.31

package/command/gsd/consider-issues.md

@@ -0,0 +1,201 @@
+---
+name: gsd:consider-issues
+description: Review deferred issues with codebase context, close resolved ones, identify urgent ones
+allowed-tools:
+  - Read
+  - Bash
+  - Grep
+  - Glob
+  - Edit
+  - question
+---
+
+<objective>
+Review all open issues from ISSUES.md with current codebase context. Identify which issues are resolved (can close), which are now urgent (should address), and which can continue waiting.
+
+This prevents issue pile-up by providing a triage mechanism with codebase awareness.
+</objective>
+
+<context>
+@.planning/ISSUES.md
+@.planning/STATE.md
+@.planning/ROADMAP.md
+</context>
+
+<process>
+
+<step name="verify">
+**Verify issues file exists:**
+
+If no `.planning/ISSUES.md`:
+```
+No issues file found.
+
+This means no enhancements have been deferred yet (Rule 5 hasn't triggered).
+
+Nothing to review.
+```
+Exit.
+
+If ISSUES.md exists but has no open issues (only template or empty "Open Enhancements"):
+```
+No open issues to review.
+
+All clear - continue with current work.
+```
+Exit.
+</step>
+
+<step name="parse">
+**Parse all open issues:**
+
+Extract from "## Open Enhancements" section:
+- ISS number (ISS-001, ISS-002, etc.)
+- Brief description
+- Discovered phase/date
+- Type (Performance/Refactoring/UX/Testing/Documentation/Accessibility)
+- Description details
+- Effort estimate
+
+Build list of issues to analyze.
+</step>
+
+<step name="analyze">
+**For each open issue, perform codebase analysis:**
+
+1. **Check if still relevant:**
+   - Search codebase for related code/files mentioned in issue
+   - If code no longer exists or was significantly refactored: likely resolved
+
+2. **Check if accidentally resolved:**
+   - Look for commits/changes that may have addressed this
+   - Check if the enhancement was implemented as part of other work
+
+3. **Assess current urgency:**
+   - Is this blocking upcoming phases?
+   - Has this become a pain point mentioned in recent summaries?
+   - Is this now affecting code we're actively working on?
+
+4. **Check natural fit:**
+   - Does this align with an upcoming phase in the roadmap?
+   - Would addressing it now touch the same files as current work?
+
+**Categorize each issue:**
+- **Resolved** - Can be closed (code changed, no longer applicable)
+- **Urgent** - Should address before continuing (blocking or causing problems)
+- **Natural fit** - Good candidate for upcoming phase X
+- **Can wait** - Keep deferred, no change in status
+</step>
+
+<step name="report">
+**Present categorized report:**
+
+```
+# Issue Review
+
+**Analyzed:** [N] open issues
+**Last reviewed:** [today's date]
+
+## Resolved (can close)
+
+### ISS-XXX: [description]
+**Reason:** [Why it's resolved - code changed, implemented elsewhere, no longer applicable]
+**Evidence:** [What you found - file changes, missing code, etc.]
+
+[Repeat for each resolved issue, or "None" if none resolved]
+
+---
+
+## Urgent (should address now)
+
+### ISS-XXX: [description]
+**Why urgent:** [What changed - blocking next phase, causing active problems, etc.]
+**Recommendation:** Insert plan before Phase [X] / Add to current phase
+**Effort:** [Quick/Medium/Substantial]
+
+[Repeat for each urgent issue, or "None - all issues can wait" if none urgent]
+
+---
+
+## Natural Fit for Upcoming Work
+
+### ISS-XXX: [description]
+**Fits with:** Phase [X] - [phase name]
+**Reason:** [Same files, same subsystem, natural inclusion]
+
+[Repeat for each, or "None" if no natural fits]
+
+---
+
+## Can Wait (no change)
+
+### ISS-XXX: [description]
+**Status:** Still valid, not urgent, keep deferred
+
+[Repeat for each, or list ISS numbers if many]
+```
+</step>
+
+<step name="offer_actions">
+**Offer batch actions:**
+
+Based on analysis, present options:
+
+```
+## Actions
+
+What would you like to do?
+```
+
+Use question with appropriate options based on findings:
+
+**If resolved issues exist:**
+- "Close resolved issues" - Move to Closed Enhancements section
+- "Review each first" - Show details before closing
+
+**If urgent issues exist:**
+- "Insert urgent phase" - Create phase to address urgent issues (/gsd:insert-phase)
+- "Add to current plan" - Include in next plan being created
+- "Defer anyway" - Keep as-is despite urgency
+
+**If natural fits exist:**
+- "Note for phase planning" - Will be picked up during /gsd:plan-phase
+- "Add explicit reminder" - Update issue with "Include in Phase X"
+
+**Always include:**
+- "Done for now" - Exit without changes
+</step>
+
+<step name="execute_actions">
+**Execute selected actions:**
+
+**If closing resolved issues:**
+1. Read current ISSUES.md
+2. For each resolved issue:
+   - Remove from "## Open Enhancements"
+   - Add to "## Closed Enhancements" with resolution note:
+     ```
+     ### ISS-XXX: [description]
+     **Resolved:** [date] - [reason]
+     ```
+3. Write updated ISSUES.md
+4. Update STATE.md deferred issues count
+
+**If inserting urgent phase:**
+- Display the command for user to run after clearing: `/gsd:insert-phase [after-phase] Address urgent issues ISS-XXX, ISS-YYY`
+
+**If noting for phase planning:**
+- Update issue's "Suggested phase" field with specific phase number
+- These will be picked up by /gsd:plan-phase workflow
+</step>
+
+</process>
+
+<success_criteria>
+- [ ] All open issues analyzed against current codebase
+- [ ] Each issue categorized (resolved/urgent/natural-fit/can-wait)
+- [ ] Clear reasoning provided for each categorization
+- [ ] Actions offered based on findings
+- [ ] ISSUES.md updated if user takes action
+- [ ] STATE.md updated if issue count changes
+</success_criteria>

package/command/gsd/create-roadmap.md

@@ -0,0 +1,115 @@
+---
+name: gsd:create-roadmap
+description: Create roadmap with phases for the project
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - question
+  - Glob
+---
+
+<objective>
+Create project roadmap with phase breakdown.
+
+Roadmaps define what work happens in what order. Run after /gsd:new-project.
+</objective>
+
+<execution_context>
+@~/.config/opencode/get-shit-done/workflows/create-roadmap.md
+@~/.config/opencode/get-shit-done/templates/roadmap.md
+@~/.config/opencode/get-shit-done/templates/state.md
+</execution_context>
+
+<context>
+@.planning/PROJECT.md
+@.planning/config.json
+</context>
+
+<process>
+
+<step name="validate">
+```bash
+# Verify project exists
+[ -f .planning/PROJECT.md ] || { echo "ERROR: No PROJECT.md found. Run /gsd:new-project first."; exit 1; }
+```
+</step>
+
+<step name="check_existing">
+Check if roadmap already exists:
+
+```bash
+[ -f .planning/ROADMAP.md ] && echo "ROADMAP_EXISTS" || echo "NO_ROADMAP"
+```
+
+**If ROADMAP_EXISTS:**
+Use question:
+- header: "Roadmap exists"
+- question: "A roadmap already exists. What would you like to do?"
+- options:
+  - "View existing" - Show current roadmap
+  - "Replace" - Create new roadmap (will overwrite)
+  - "Cancel" - Keep existing roadmap
+
+If "View existing": `cat .planning/ROADMAP.md` and exit
+If "Cancel": Exit
+If "Replace": Continue with workflow
+</step>
+
+<step name="create_roadmap">
+Follow the create-roadmap.md workflow starting from detect_domain step.
+
+The workflow handles:
+- Domain expertise detection
+- Phase identification
+- Research flags for each phase
+- Confirmation gates (respecting config mode)
+- ROADMAP.md creation
+- STATE.md initialization
+- Phase directory creation
+- Git commit
+</step>
+
+<step name="done">
+```
+Roadmap created:
+- Roadmap: .planning/ROADMAP.md
+- State: .planning/STATE.md
+- [N] phases defined
+
+---
+
+## ▶ Next Up
+
+**Phase 1: [Name]** — [Goal from ROADMAP.md]
+
+`/gsd:plan-phase 1`
+
+*`/clear` first → fresh context window*
+
+---
+
+**Also available:**
+- `/gsd:discuss-phase 1` — gather context first
+- `/gsd:research-phase 1` — investigate unknowns
+- Review roadmap
+
+---
+```
+</step>
+
+</process>
+
+<output>
+- `.planning/ROADMAP.md`
+- `.planning/STATE.md`
+- `.planning/phases/XX-name/` directories
+</output>
+
+<success_criteria>
+- [ ] PROJECT.md validated
+- [ ] ROADMAP.md created with phases
+- [ ] STATE.md initialized
+- [ ] Phase directories created
+- [ ] Changes committed
+</success_criteria>

package/command/gsd/discuss-milestone.md

@@ -0,0 +1,47 @@
+---
+name: gsd:discuss-milestone
+description: Gather context for next milestone through adaptive questioning
+---
+
+<objective>
+Help you figure out what to build in the next milestone through collaborative thinking.
+
+Purpose: After completing a milestone, explore what features you want to add, improve, or fix. Features first — scope and phases derive from what you want to build.
+Output: Context gathered, then routes to /gsd:new-milestone
+</objective>
+
+<execution_context>
+@~/.config/opencode/get-shit-done/workflows/discuss-milestone.md
+</execution_context>
+
+<context>
+**Load project state first:**
+@.planning/STATE.md
+
+**Load roadmap:**
+@.planning/ROADMAP.md
+
+**Load milestones (if exists):**
+@.planning/MILESTONES.md
+</context>
+
+<process>
+1. Verify previous milestone complete (or acknowledge active milestone)
+2. Present context from previous milestone (accomplishments, phase count)
+3. Follow discuss-milestone.md workflow with **ALL questions using question**:
+   - Use question: "What do you want to add, improve, or fix?" with feature categories
+   - Use question to dig into features they mention
+   - Use question to help them articulate what matters most
+   - Use question for decision gate (ready / ask more / let me add context)
+4. Hand off to /gsd:new-milestone with gathered context
+
+**CRITICAL: ALL questions use question. Never ask inline text questions.**
+</process>
+
+<success_criteria>
+
+- Project state loaded and presented
+- Previous milestone context summarized
+- Milestone scope gathered through adaptive questioning
+- Context handed off to /gsd:new-milestone
+  </success_criteria>

package/command/gsd/discuss-phase.md

@@ -0,0 +1,60 @@
+---
+name: gsd:discuss-phase
+description: Gather phase context through adaptive questioning before planning
+argument-hint: "[phase]"
+---
+
+<objective>
+Help the user articulate their vision for a phase through collaborative thinking.
+
+Purpose: Understand HOW the user imagines this phase working — what it looks like, what's essential, what's out of scope. You're a thinking partner helping them crystallize their vision, not an interviewer gathering technical requirements.
+
+Output: {phase}-CONTEXT.md capturing the user's vision for the phase
+</objective>
+
+<execution_context>
+@~/.config/opencode/get-shit-done/workflows/discuss-phase.md
+@~/.config/opencode/get-shit-done/templates/context.md
+</execution_context>
+
+<context>
+Phase number: $ARGUMENTS (required)
+
+**Load project state first:**
+@.planning/STATE.md
+
+**Load roadmap:**
+@.planning/ROADMAP.md
+</context>
+
+<process>
+1. Validate phase number argument (error if missing or invalid)
+2. Check if phase exists in roadmap
+3. Check if CONTEXT.md already exists (offer to update if yes)
+4. Follow discuss-phase.md workflow with **ALL questions using question**:
+   - Present phase from roadmap
+   - Use question: "How do you imagine this working?" with interpretation options
+   - Use question to follow their thread — probe what excites them
+   - Use question to sharpen the core — what's essential for THIS phase
+   - Use question to find boundaries — what's explicitly out of scope
+   - Use question for decision gate (ready / ask more / let me add context)
+   - Create CONTEXT.md capturing their vision
+5. Offer next steps (research or plan the phase)
+
+**CRITICAL: ALL questions use question. Never ask inline text questions.**
+
+User is the visionary, you are the builder:
+- Ask about vision, feel, essential outcomes
+- DON'T ask about technical risks (you figure those out)
+- DON'T ask about codebase patterns (you read the code)
+- DON'T ask about success metrics (too corporate)
+- DON'T interrogate about constraints they didn't mention
+</process>
+
+<success_criteria>
+
+- Phase validated against roadmap
+- Vision gathered through collaborative thinking (not interrogation)
+- CONTEXT.md captures: how it works, what's essential, what's out of scope
+- User knows next steps (research or plan the phase)
+</success_criteria>

package/command/gsd/execute-plan.md

@@ -0,0 +1,128 @@
+---
+name: gsd:execute-plan
+description: Execute a PLAN.md file
+argument-hint: "[path-to-PLAN.md]"
+allowed-tools:
+  - Read
+  - Write
+  - Edit
+  - Bash
+  - Glob
+  - Grep
+  - Task
+  - question
+---
+
+<objective>
+Execute a PLAN.md file with per-task atomic commits, create SUMMARY.md, update project state.
+
+Commit strategy:
+- Each task → 1 commit immediately after completion (feat/fix/test/refactor)
+- Plan completion → 1 metadata commit (docs: SUMMARY + STATE + ROADMAP)
+
+Uses intelligent segmentation:
+- Plans without checkpoints → spawn subagent for full autonomous execution
+- Plans with verify checkpoints → segment execution, pause at checkpoints
+- Plans with decision checkpoints → execute in main context
+  </objective>
+
+<execution_context>
+@~/.config/opencode/get-shit-done/workflows/execute-phase.md
+@~/.config/opencode/get-shit-done/templates/summary.md
+@~/.config/opencode/get-shit-done/references/checkpoints.md
+@~/.config/opencode/get-shit-done/references/tdd.md
+</execution_context>
+
+<context>
+Plan path: $ARGUMENTS
+
+**Load project state first:**
+@.planning/STATE.md
+
+**Load workflow config:**
+@.planning/config.json
+</context>
+
+<process>
+1. Check .planning/ directory exists (error if not - user should run /gsd:new-project)
+2. Verify plan at $ARGUMENTS exists
+3. Check if SUMMARY.md already exists (plan already executed?)
+4. Load workflow config for mode (interactive/yolo)
+5. Follow execute-phase.md workflow:
+   - Parse plan and determine execution strategy (A/B/C)
+   - Execute tasks (via subagent or main context as appropriate)
+   - Handle checkpoints and deviations
+   - Create SUMMARY.md
+   - Update STATE.md
+   - Commit changes
+</process>
+
+<execution_strategies>
+**Strategy A: Fully Autonomous** (no checkpoints)
+
+- Spawn subagent to execute entire plan
+- Subagent creates SUMMARY.md and commits
+- Main context: orchestration only (~5% usage)
+
+**Strategy B: Segmented** (has verify-only checkpoints)
+
+- Execute in segments between checkpoints
+- Subagent for autonomous segments
+- Main context for checkpoints
+- Aggregate results → SUMMARY → commit
+
+**Strategy C: Decision-Dependent** (has decision checkpoints)
+
+- Execute in main context
+- Decision outcomes affect subsequent tasks
+- Quality maintained through small scope (2-3 tasks per plan)
+  </execution_strategies>
+
+<deviation_rules>
+During execution, handle discoveries automatically:
+
+1. **Auto-fix bugs** - Fix immediately, document in Summary
+2. **Auto-add critical** - Security/correctness gaps, add and document
+3. **Auto-fix blockers** - Can't proceed without fix, do it and document
+4. **Ask about architectural** - Major structural changes, stop and ask user
+5. **Log enhancements** - Nice-to-haves, log to ISSUES.md, continue
+
+Only rule 4 requires user intervention.
+</deviation_rules>
+
+<commit_rules>
+**Per-Task Commits:**
+
+After each task completes:
+1. Stage only files modified by that task
+2. Commit with format: `{type}({phase}-{plan}): {task-name}`
+3. Types: feat, fix, test, refactor, perf, chore
+4. Record commit hash for SUMMARY.md
+
+**Plan Metadata Commit:**
+
+After all tasks complete:
+1. Stage planning artifacts only: PLAN.md, SUMMARY.md, STATE.md, ROADMAP.md
+2. Commit with format: `docs({phase}-{plan}): complete [plan-name] plan`
+3. NO code files (already committed per-task)
+
+**NEVER use:**
+- `git add .`
+- `git add -A`
+- `git add src/` or any broad directory
+
+**Always stage files individually.**
+
+See ~/.config/opencode/get-shit-done/references/git-integration.md for full commit strategy.
+</commit_rules>
+
+<success_criteria>
+
+- [ ] All tasks executed
+- [ ] Each task committed individually (feat/fix/test/refactor)
+- [ ] SUMMARY.md created with substantive content and commit hashes
+- [ ] STATE.md updated (position, decisions, issues, session)
+- [ ] ROADMAP updated (plan count, phase status)
+- [ ] Metadata committed with docs({phase}-{plan}): complete [plan-name] plan
+- [ ] User informed of next steps
+      </success_criteria>