gsd-opencode 1.3.31

package/command/gsd/new-milestone.md

@@ -0,0 +1,59 @@
+---
+name: gsd:new-milestone
+description: Create a new milestone with phases for an existing project
+argument-hint: "[milestone name, e.g., 'v2.0 Features']"
+---
+
+<objective>
+Create a new milestone for an existing project with defined phases.
+
+Purpose: After completing a milestone (or when ready to define next chunk of work), creates the milestone structure in ROADMAP.md with phases, updates STATE.md, and creates phase directories.
+Output: New milestone in ROADMAP.md, updated STATE.md, phase directories created
+</objective>
+
+<execution_context>
+@~/.config/opencode/get-shit-done/workflows/create-milestone.md
+@~/.config/opencode/get-shit-done/templates/roadmap.md
+</execution_context>
+
+<context>
+Milestone name: $ARGUMENTS (optional - will prompt if not provided)
+
+**Load project state first:**
+@.planning/STATE.md
+
+**Load roadmap:**
+@.planning/ROADMAP.md
+
+**Load milestones (if exists):**
+@.planning/MILESTONES.md
+</context>
+
+<process>
+1. Load project context (STATE.md, ROADMAP.md, MILESTONES.md)
+2. Calculate next milestone version and starting phase number
+3. If milestone name provided in arguments, use it; otherwise prompt
+4. Gather phases (per depth setting: quick 3-5, standard 5-8, comprehensive 8-12):
+   - If called from /gsd:discuss-milestone, use provided context
+   - Otherwise, prompt for phase breakdown
+5. Detect research needs for each phase
+6. Confirm phases (respect config.json gate settings)
+7. Follow create-milestone.md workflow:
+   - Update ROADMAP.md with new milestone section
+   - Create phase directories
+   - Update STATE.md for new milestone
+   - Git commit milestone creation
+8. Offer next steps (discuss first phase, plan first phase, review)
+</process>
+
+<success_criteria>
+
+- Next phase number calculated correctly (continues from previous milestone)
+- Phases defined per depth setting (quick: 3-5, standard: 5-8, comprehensive: 8-12)
+- Research flags assigned for each phase
+- ROADMAP.md updated with new milestone section
+- Phase directories created
+- STATE.md reset for new milestone
+- Git commit made
+- User knows next steps
+  </success_criteria>

package/command/gsd/new-project.md

@@ -0,0 +1,316 @@
+---
+name: gsd:new-project
+description: Initialize a new project with deep context gathering and PROJECT.md
+allowed-tools:
+  - Read
+  - Bash
+  - Write
+  - question
+---
+
+<objective>
+
+Initialize a new project through comprehensive context gathering.
+
+This is the most leveraged moment in any project. Deep questioning here means better plans, better execution, better outcomes.
+
+Creates `.planning/` with PROJECT.md and config.json.
+
+</objective>
+
+<execution_context>
+
+@~/.config/opencode/get-shit-done/references/principles.md
+@~/.config/opencode/get-shit-done/references/questioning.md
+@~/.config/opencode/get-shit-done/templates/project.md
+@~/.config/opencode/get-shit-done/templates/config.json
+
+</execution_context>
+
+<process>
+
+<step name="setup">
+
+**MANDATORY FIRST STEP — Execute these checks before ANY user interaction:**
+
+1. **Abort if project exists:**
+   ```bash
+   [ -f .planning/PROJECT.md ] && echo "ERROR: Project already initialized. Use /gsd:progress" && exit 1
+   ```
+
+2. **Initialize git repo in THIS directory** (required even if inside a parent repo):
+   ```bash
+   # Check if THIS directory is already a git repo root (handles .git file for worktrees too)
+   if [ -d .git ] || [ -f .git ]; then
+       echo "Git repo exists in current directory"
+   else
+       git init
+       echo "Initialized new git repo"
+   fi
+   ```
+
+3. **Detect existing code (brownfield detection):**
+   ```bash
+   # Check for existing code files
+   CODE_FILES=$(find . -name "*.ts" -o -name "*.js" -o -name "*.py" -o -name "*.go" -o -name "*.rs" -o -name "*.swift" -o -name "*.java" 2>/dev/null | grep -v node_modules | grep -v .git | head -20)
+   HAS_PACKAGE=$([ -f package.json ] || [ -f requirements.txt ] || [ -f Cargo.toml ] || [ -f go.mod ] || [ -f Package.swift ] && echo "yes")
+   HAS_CODEBASE_MAP=$([ -d .planning/codebase ] && echo "yes")
+   ```
+
+   **You MUST run all bash commands above using the Bash tool before proceeding.**
+
+</step>
+
+<step name="brownfield_offer">
+
+**If existing code detected and .planning/codebase/ doesn't exist:**
+
+Check the results from setup step:
+- If `CODE_FILES` is non-empty OR `HAS_PACKAGE` is "yes"
+- AND `HAS_CODEBASE_MAP` is NOT "yes"
+
+Use question:
+- header: "Existing Code"
+- question: "I detected existing code in this directory. Would you like to map the codebase first?"
+- options:
+  - "Map codebase first" — Run /gsd:map-codebase to understand existing architecture (Recommended)
+  - "Skip mapping" — Proceed with project initialization
+
+**If "Map codebase first":**
+```
+Run `/gsd:map-codebase` first, then return to `/gsd:new-project`
+```
+Exit command.
+
+**If "Skip mapping":** Continue to question step.
+
+**If no existing code detected OR codebase already mapped:** Continue to question step.
+
+</step>
+
+<step name="question">
+
+**1. Open (FREEFORM — do NOT use question):**
+
+Ask inline: "What do you want to build?"
+
+Wait for their freeform response. This gives you the context needed to ask intelligent follow-up questions.
+
+**2. Follow the thread (NOW use question):**
+
+Based on their response, use question with options that probe what they mentioned:
+- header: "[Topic they mentioned]"
+- question: "You mentioned [X] — what would that look like?"
+- options: 2-3 interpretations + "Something else"
+
+**3. Sharpen the core:**
+
+Use question:
+- header: "Core"
+- question: "If you could only nail one thing, what would it be?"
+- options: Key aspects they've mentioned + "All equally important" + "Something else"
+
+**4. Find boundaries:**
+
+Use question:
+- header: "Scope"
+- question: "What's explicitly NOT in v1?"
+- options: Things that might be tempting + "Nothing specific" + "Let me list them"
+
+**5. Ground in reality:**
+
+Use question:
+- header: "Constraints"
+- question: "Any hard constraints?"
+- options: Relevant constraint types + "None" + "Yes, let me explain"
+
+**6. Decision gate:**
+
+Use question:
+- header: "Ready?"
+- question: "Ready to create PROJECT.md, or explore more?"
+- options (ALL THREE REQUIRED):
+  - "Create PROJECT.md" — Finalize and continue
+  - "Ask more questions" — I'll dig deeper
+  - "Let me add context" — You have more to share
+
+If "Ask more questions" → check coverage gaps from `questioning.md` → return to step 2.
+If "Let me add context" → receive input via their response → return to step 2.
+Loop until "Create PROJECT.md" selected.
+
+</step>
+
+<step name="project">
+
+Synthesize all context into `.planning/PROJECT.md` using the template from `templates/project.md`.
+
+**For greenfield projects:**
+
+Initialize requirements as hypotheses:
+
+```markdown
+## Requirements
+
+### Validated
+
+(None yet — ship to validate)
+
+### Active
+
+- [ ] [Requirement 1]
+- [ ] [Requirement 2]
+- [ ] [Requirement 3]
+
+### Out of Scope
+
+- [Exclusion 1] — [why]
+- [Exclusion 2] — [why]
+```
+
+All Active requirements are hypotheses until shipped and validated.
+
+**For brownfield projects (codebase map exists):**
+
+Infer Validated requirements from existing code:
+
+1. Read `.planning/codebase/ARCHITECTURE.md` and `STACK.md`
+2. Identify what the codebase already does
+3. These become the initial Validated set
+
+```markdown
+## Requirements
+
+### Validated
+
+- ✓ [Existing capability 1] — existing
+- ✓ [Existing capability 2] — existing
+- ✓ [Existing capability 3] — existing
+
+### Active
+
+- [ ] [New requirement 1]
+- [ ] [New requirement 2]
+
+### Out of Scope
+
+- [Exclusion 1] — [why]
+```
+
+**Key Decisions:**
+
+Initialize with any decisions made during questioning:
+
+```markdown
+## Key Decisions
+
+| Decision | Rationale | Outcome |
+|----------|-----------|---------|
+| [Choice from questioning] | [Why] | — Pending |
+```
+
+**Last updated footer:**
+
+```markdown
+---
+*Last updated: [date] after initialization*
+```
+
+Do not compress. Capture everything gathered.
+
+</step>
+
+<step name="mode">
+
+Ask workflow mode preference:
+
+Use question:
+
+- header: "Mode"
+- question: "How do you want to work?"
+- options:
+  - "Interactive" — Confirm at each step
+  - "YOLO" — Auto-approve, just execute
+
+</step>
+
+<step name="depth">
+
+Ask planning depth preference:
+
+Use question:
+
+- header: "Depth"
+- question: "How thorough should planning be?"
+- options:
+  - "Quick" — Ship fast, minimal phases/plans (3-5 phases, 1-3 plans each)
+  - "Standard" — Balanced scope and speed (5-8 phases, 3-5 plans each)
+  - "Comprehensive" — Thorough coverage, more phases/plans (8-12 phases, 5-10 plans each)
+
+**Depth controls compression tolerance, not artificial inflation.** All depths use 2-3 tasks per plan. Comprehensive means "don't compress complex work"—it doesn't mean "pad simple work to hit a number."
+
+Create `.planning/config.json` with chosen mode and depth using `templates/config.json` structure.
+
+</step>
+
+<step name="commit">
+
+```bash
+git add .planning/PROJECT.md .planning/config.json
+git commit -m "$(cat <<'EOF'
+docs: initialize [project-name]
+
+[One-liner from PROJECT.md]
+
+Creates PROJECT.md with requirements and constraints.
+EOF
+)"
+```
+
+</step>
+
+<step name="done">
+
+Present completion with next steps (see ~/.config/opencode/get-shit-done/references/continuation-format.md):
+
+```
+Project initialized:
+
+- Project: .planning/PROJECT.md
+- Config: .planning/config.json (mode: [chosen mode])
+[If .planning/codebase/ exists:] - Codebase: .planning/codebase/ (7 documents)
+
+---
+
+## ▶ Next Up
+
+**[Project Name]** — create roadmap
+
+`/gsd:create-roadmap`
+
+*`/clear` first → fresh context window*
+
+---
+
+```
+
+</step>
+
+</process>
+
+<output>
+
+- `.planning/PROJECT.md`
+- `.planning/config.json`
+
+</output>
+
+<success_criteria>
+
+- [ ] Deep questioning completed (not rushed)
+- [ ] PROJECT.md captures full context with evolutionary structure
+- [ ] Requirements initialized as hypotheses (greenfield) or with inferred Validated (brownfield)
+- [ ] Key Decisions table initialized
+- [ ] config.json has workflow mode
+- [ ] All committed to git
+
+</success_criteria>

package/command/gsd/pause-work.md

@@ -0,0 +1,122 @@
+---
+name: gsd:pause-work
+description: Create context handoff when pausing work mid-phase
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+---
+
+<objective>
+Create `.continue-here.md` handoff file to preserve complete work state across sessions.
+
+Enables seamless resumption in fresh session with full context restoration.
+</objective>
+
+<context>
+@.planning/STATE.md
+</context>
+
+<process>
+
+<step name="detect">
+Find current phase directory from most recently modified files.
+</step>
+
+<step name="gather">
+**Collect complete state for handoff:**
+
+1. **Current position**: Which phase, which plan, which task
+2. **Work completed**: What got done this session
+3. **Work remaining**: What's left in current plan/phase
+4. **Decisions made**: Key decisions and rationale
+5. **Blockers/issues**: Anything stuck
+6. **Mental context**: The approach, next steps, "vibe"
+7. **Files modified**: What's changed but not committed
+
+Ask user for clarifications if needed.
+</step>
+
+<step name="write">
+**Write handoff to `.planning/phases/XX-name/.continue-here.md`:**
+
+```markdown
+---
+phase: XX-name
+task: 3
+total_tasks: 7
+status: in_progress
+last_updated: [timestamp]
+---
+
+<current_state>
+[Where exactly are we? Immediate context]
+</current_state>
+
+<completed_work>
+
+- Task 1: [name] - Done
+- Task 2: [name] - Done
+- Task 3: [name] - In progress, [what's done]
+  </completed_work>
+
+<remaining_work>
+
+- Task 3: [what's left]
+- Task 4: Not started
+- Task 5: Not started
+  </remaining_work>
+
+<decisions_made>
+
+- Decided to use [X] because [reason]
+- Chose [approach] over [alternative] because [reason]
+  </decisions_made>
+
+<blockers>
+- [Blocker 1]: [status/workaround]
+</blockers>
+
+<context>
+[Mental state, what were you thinking, the plan]
+</context>
+
+<next_action>
+Start with: [specific first action when resuming]
+</next_action>
+```
+
+Be specific enough for a fresh Claude to understand immediately.
+</step>
+
+<step name="commit">
+```bash
+git add .planning/phases/*/.continue-here.md
+git commit -m "wip: [phase-name] paused at task [X]/[Y]"
+```
+</step>
+
+<step name="confirm">
+```
+✓ Handoff created: .planning/phases/[XX-name]/.continue-here.md
+
+Current state:
+
+- Phase: [XX-name]
+- Task: [X] of [Y]
+- Status: [in_progress/blocked]
+- Committed as WIP
+
+To resume: /gsd:resume-work
+
+```
+</step>
+
+</process>
+
+<success_criteria>
+- [ ] .continue-here.md created in correct phase directory
+- [ ] All sections filled with specific content
+- [ ] Committed as WIP
+- [ ] User knows location and how to resume
+</success_criteria>

package/command/gsd/plan-fix.md

@@ -0,0 +1,205 @@
+---
+name: gsd:plan-fix
+description: Plan fixes for UAT issues from verify-work
+argument-hint: "[plan, e.g., '04-02']"
+allowed-tools:
+  - Read
+  - Bash
+  - Write
+  - Glob
+  - Grep
+  - question
+---
+
+<objective>
+Create FIX.md plan from UAT issues found during verify-work.
+
+Purpose: Plan fixes for issues logged in phase-scoped ISSUES.md files.
+Output: {plan}-FIX.md in the phase directory, ready for execution.
+</objective>
+
+<execution_context>
+@~/.config/opencode/get-shit-done/references/plan-format.md
+@~/.config/opencode/get-shit-done/references/checkpoints.md
+</execution_context>
+
+<context>
+Plan number: $ARGUMENTS (required - e.g., "04-02" or "09-01")
+
+**Load project state:**
+@.planning/STATE.md
+@.planning/ROADMAP.md
+</context>
+
+<process>
+
+<step name="parse">
+**Parse plan argument:**
+
+$ARGUMENTS should be a plan number like "04-02" or "09-01".
+Extract phase number (XX) and plan number (NN).
+
+If no argument provided:
+```
+Error: Plan number required.
+
+Usage: /gsd:plan-fix 04-02
+
+This creates a fix plan from .planning/phases/XX-name/04-02-ISSUES.md
+```
+Exit.
+</step>
+
+<step name="find">
+**Find ISSUES.md file:**
+
+Search for matching ISSUES.md:
+```bash
+ls .planning/phases/*/{plan}-ISSUES.md 2>/dev/null
+```
+
+If not found:
+```
+No ISSUES.md found for plan {plan}.
+
+ISSUES.md files are created by /gsd:verify-work when UAT finds issues.
+If no issues were found during testing, no fix plan is needed.
+```
+Exit.
+</step>
+
+<step name="read">
+**Read issues:**
+
+Read the ISSUES.md file.
+Parse each issue:
+- ID (UAT-XXX)
+- Title
+- Severity (critical/major/minor)
+- Description/steps to reproduce
+- Acceptance criteria
+
+Count total issues by severity.
+</step>
+
+<step name="plan">
+**Create fix tasks:**
+
+For each issue (or logical group):
+- Create one task per issue OR
+- Group related minor issues into single task
+
+Task structure:
+```xml
+<task type="auto">
+  <name>Fix UAT-001: [issue title]</name>
+  <files>[affected files from issue]</files>
+  <action>
+[What to fix based on issue description]
+[Reference original acceptance criteria]
+  </action>
+  <verify>[Test that issue is resolved]</verify>
+  <done>[Issue acceptance criteria met]</done>
+</task>
+```
+
+Prioritize: critical → major → minor
+</step>
+
+<step name="write">
+**Write FIX.md:**
+
+Create `.planning/phases/XX-name/{plan}-FIX.md`:
+
+```markdown
+---
+phase: XX-name
+plan: {plan}-FIX
+type: fix
+---
+
+<objective>
+Fix {N} UAT issues from plan {plan}.
+
+Source: {plan}-ISSUES.md
+Priority: {critical count} critical, {major count} major, {minor count} minor
+</objective>
+
+<execution_context>
+@~/.config/opencode/get-shit-done/workflows/execute-phase.md
+@~/.config/opencode/get-shit-done/templates/summary.md
+</execution_context>
+
+<context>
+@.planning/STATE.md
+@.planning/ROADMAP.md
+
+**Issues being fixed:**
+@.planning/phases/XX-name/{plan}-ISSUES.md
+
+**Original plan for reference:**
+@.planning/phases/XX-name/{plan}-PLAN.md
+</context>
+
+<tasks>
+[Generated fix tasks]
+</tasks>
+
+<verification>
+Before declaring plan complete:
+- [ ] All critical issues fixed
+- [ ] All major issues fixed
+- [ ] Minor issues fixed or documented as deferred
+- [ ] Original acceptance criteria from issues met
+</verification>
+
+<success_criteria>
+- All UAT issues from {plan}-ISSUES.md addressed
+- Tests pass
+- Ready for re-verification
+</success_criteria>
+
+<output>
+After completion, create `.planning/phases/XX-name/{plan}-FIX-SUMMARY.md`
+</output>
+```
+</step>
+
+<step name="offer">
+**Offer execution:**
+
+```
+---
+
+## ✓ Fix Plan Created
+
+**{plan}-FIX.md** — {N} issues to fix
+
+| Severity | Count |
+|----------|-------|
+| Critical | {n}   |
+| Major    | {n}   |
+| Minor    | {n}   |
+
+---
+
+Would you like to:
+1. Execute the fix plan now
+2. Review the plan first
+3. Modify the plan before executing
+
+---
+```
+
+Use question to get response.
+If execute: `/gsd:execute-plan .planning/phases/XX-name/{plan}-FIX.md`
+</step>
+
+</process>
+
+<success_criteria>
+- [ ] ISSUES.md found and parsed
+- [ ] Fix tasks created for each issue
+- [ ] FIX.md written with proper structure
+- [ ] User offered to execute or review
+</success_criteria>