gsd-opencode 1.3.33 → 1.4.2

package/command/gsd/execute-phase.md

@@ -0,0 +1,137 @@
+---
+name: gsd:execute-phase
+description: Execute all plans in a phase with wave-based parallelization
+argument-hint: "<phase-number>"
+allowed-tools:
+  - read
+  - write
+  - edit
+  - glob
+  - grep
+  - bash
+  - task
+  - todowrite
+  - question
+---
+
+<objective>
+Execute all plans in a phase using wave-based parallel execution.
+
+Orchestrator stays lean: discover plans, analyze dependencies, group into waves, spawn subagents, collect results. Each subagent loads the full execute-plan context and handles its own plan.
+
+Context budget: ~15% orchestrator, 100% fresh per subagent.
+</objective>
+
+<execution_context>
+@~/.config/opencode/get-shit-done/workflows/execute-phase.md
+@~/.config/opencode/get-shit-done/templates/subagent-task-prompt.md
+</execution_context>
+
+<context>
+Phase: ($ARGUMENTS)
+
+@.planning/ROADMAP.md
+@.planning/STATE.md
+</context>
+
+<process>
+1. **Validate phase exists**
+   - Find phase directory matching argument
+   - Count PLAN.md files
+   - Error if no plans found
+
+2. **Discover plans**
+   - List all *-PLAN.md files in phase directory
+   - Check which have *-SUMMARY.md (already complete)
+   - Build list of incomplete plans
+
+3. **Group by wave**
+   - Read `wave` from each plan's frontmatter
+   - Group plans by wave number
+   - Report wave structure to user
+
+4. **Execute waves**
+   For each wave in order:
+   - Fill subagent-task-prompt template for each plan
+   - Spawn all agents in wave simultaneously (parallel task calls)
+   - Wait for completion (task blocks)
+   - Verify SUMMARYs created
+   - Proceed to next wave
+
+5. **Aggregate results**
+   - Collect summaries from all plans
+   - Report phase completion status
+   - Update ROADMAP.md
+
+6. **Offer next steps**
+   - More phases → `/gsd:plan-phase {next}`
+   - Milestone complete → `/gsd:complete-milestone`
+</process>
+
+<wave_execution>
+**Parallel spawning:**
+
+Spawn all plans in a wave with a single message containing multiple task calls:
+
+```
+task(prompt=filled_template_for_plan_01, subagent_type="general")
+task(prompt=filled_template_for_plan_02, subagent_type="general")
+task(prompt=filled_template_for_plan_03, subagent_type="general")
+```
+
+All three run in parallel. task tool blocks until all complete.
+
+**No polling.** No background agents.
+</wave_execution>
+
+<checkpoint_handling>
+Plans with `autonomous: false` in frontmatter have checkpoints:
+- Run in their assigned wave (can be parallel with other plans)
+- Pause at checkpoint, return to orchestrator
+- Orchestrator presents checkpoint to user
+- User responds, orchestrator resumes agent
+</checkpoint_handling>
+
+<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.**
+</commit_rules>
+
+<success_criteria>
+- [ ] All incomplete plans in phase executed
+- [ ] Each plan has SUMMARY.md
+- [ ] STATE.md reflects phase completion
+- [ ] ROADMAP.md updated
+- [ ] User informed of next steps
+</success_criteria>

package/command/gsd/execute-plan.md

@@ -3,126 +3,101 @@ 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
+  - read
+  - glob
+  - grep
+  - bash
+  - task
+  - todowrite
   - question
 ---
 
 <objective>
-Execute a PLAN.md file with per-task atomic commits, create SUMMARY.md, update project state.
+Execute a single PLAN.md file by spawning a subagent.
 
-Commit strategy:
-- Each task → 1 commit immediately after completion (feat/fix/test/refactor)
-- Plan completion → 1 metadata commit (docs: SUMMARY + STATE + ROADMAP)
+Orchestrator stays lean: validate plan, spawn subagent, handle checkpoints, report completion. Subagent loads full execute-plan workflow and handles all execution details.
 
-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>
+Context budget: ~15% orchestrator, 100% fresh for subagent.
+</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
+@~/.config/opencode/get-shit-done/templates/subagent-task-prompt.md
 </execution_context>
 
 <context>
-Plan path: $ARGUMENTS
+Plan path: ($ARGUMENTS)
 
-**Load project state first:**
 @.planning/STATE.md
-
-**Load workflow config:**
-@.planning/config.json
+@.planning/config.json (if exists)
 </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
+1. **Validate plan exists**
+   - Confirm file at ($ARGUMENTS) exists
+   - Error if not found: "Plan not found: {path}"
+
+2. **Check if already executed**
+   - Derive SUMMARY path from plan path (replace PLAN.md with SUMMARY.md)
+   - If SUMMARY exists: "Plan already executed. SUMMARY: {path}"
+   - Offer: re-execute or exit
+
+3. **Parse plan identifiers**
+   Extract from path like `.planning/phases/03-auth/03-02-PLAN.md`:
+   - phase_number: `03`
+   - phase_name: `auth`
+   - plan_number: `02`
+   - plan_path: full path
+
+4. **Fill and spawn subagent**
+   - Fill subagent-task-prompt template with extracted values
+   - Spawn: `task(prompt=filled_template, subagent_type="general")`
+
+5. **Handle subagent return**
+   - If contains "## CHECKPOINT REACHED": Execute checkpoint_handling
+   - If contains "## PLAN COMPLETE": Verify SUMMARY exists, report success
+
+6. **Report completion**
+   - Show SUMMARY path
+   - Show commits from subagent return
+   - Offer next steps
 </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)
+<checkpoint_handling>
+When subagent returns with checkpoint:
 
-- Execute in main context
-- Decision outcomes affect subsequent tasks
-- Quality maintained through small scope (2-3 tasks per plan)
-  </execution_strategies>
+**1. Parse return:**
+```
+## CHECKPOINT REACHED
 
-<deviation_rules>
-During execution, handle discoveries automatically:
+**Type:** [human-verify | decision | human-action]
+**Plan:** {phase}-{plan}
+**Progress:** {completed}/{total} tasks complete
 
-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
+[Checkpoint content]
 
-Only rule 4 requires user intervention.
-</deviation_rules>
+**Awaiting:** [Resume signal]
+```
 
-<commit_rules>
-**Per-Task Commits:**
+**2. Present to user:**
+Display the checkpoint content exactly as returned by subagent.
 
-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
+**3. Collect response:**
+Wait for user input:
+- human-verify: "approved" or description of issues
+- decision: option selection
+- human-action: "done" when complete
 
-**Plan Metadata Commit:**
+**4. Resume subagent:**
+```
+task(resume="{agent_id}", prompt="User response: {user_input}")
+```
 
-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>
+**5. Repeat:**
+Continue handling returns until "## PLAN COMPLETE" or user stops.
+</checkpoint_handling>
 
 <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>
+- [ ] Plan executed (SUMMARY.md created)
+- [ ] All checkpoints handled
+- [ ] User informed of completion and next steps
+</success_criteria>

package/command/gsd/help.md

@@ -56,7 +56,7 @@ Usage: `/gsd:create-roadmap`
 **`/gsd:map-codebase`**
 Map an existing codebase for brownfield projects.
 
-- Analyzes codebase with parallel Explore agents
+- Analyzes codebase with parallel explore agents
 - Creates `.planning/codebase/` with 7 focused documents
 - Covers stack, architecture, structure, conventions, testing, integrations, concerns
 - Use before `/gsd:new-project` on existing codebases
@@ -85,10 +85,10 @@ Comprehensive ecosystem research for niche/complex domains.
 Usage: `/gsd:research-phase 3`
 
 **`/gsd:list-phase-assumptions <number>`**
-See what Claude is planning to do before it starts.
+See what OpenCode is planning to do before it starts.
 
-- Shows Claude's intended approach for a phase
-- Lets you course-correct if Claude misunderstood your vision
+- Shows OpenCode's intended approach for a phase
+- Lets you course-correct if OpenCode misunderstood your vision
 - No files created - conversational output only
 
 Usage: `/gsd:list-phase-assumptions 3`
@@ -107,15 +107,29 @@ Result: Creates `.planning/phases/01-foundation/01-01-PLAN.md`
 ### Execution
 
 **`/gsd:execute-plan <path>`**
-Execute a PLAN.md file directly.
+Execute a single PLAN.md file.
 
 - Runs plan tasks sequentially
 - Creates SUMMARY.md after completion
 - Updates STATE.md with accumulated context
-- Fast execution without loading full skill context
+- Use for interactive execution with checkpoints
 
 Usage: `/gsd:execute-plan .planning/phases/01-foundation/01-01-PLAN.md`
 
+**`/gsd:execute-phase <phase-number>`**
+Execute all unexecuted plans in a phase with parallel agents.
+
+- Analyzes plan dependencies and spawns independent plans concurrently
+- Use when phase has 2+ plans and you want "walk away" execution
+- Respects max_concurrent_agents from config.json
+
+Usage: `/gsd:execute-phase 5`
+
+Options (via `.planning/config.json` parallelization section):
+- `max_concurrent_agents`: Limit parallel agents (default: 3)
+- `skip_checkpoints`: Skip human checkpoints in background (default: true)
+- `min_plans_for_parallel`: Minimum plans to trigger parallelization (default: 2)
+
 ### Roadmap Management
 
 **`/gsd:add-phase <description>`**
@@ -225,6 +239,46 @@ Review deferred issues with codebase context.
 
 Usage: `/gsd:consider-issues`
 
+### Debugging
+
+**`/gsd:debug [issue description]`**
+Systematic debugging with persistent state across context resets.
+
+- Gathers symptoms through adaptive questioning
+- Creates `.planning/debug/[slug].md` to track investigation
+- Investigates using scientific method (evidence → hypothesis → test)
+- Survives `/clear` — run `/gsd:debug` with no args to resume
+- Archives resolved issues to `.planning/debug/resolved/`
+
+Usage: `/gsd:debug "login button doesn't work"`
+Usage: `/gsd:debug` (resume active session)
+
+### Todo Management
+
+**`/gsd:add-todo [description]`**
+Capture idea or task as todo from current conversation.
+
+- Extracts context from conversation (or uses provided description)
+- Creates structured todo file in `.planning/todos/pending/`
+- Infers area from file paths for grouping
+- Checks for duplicates before creating
+- Updates STATE.md todo count
+
+Usage: `/gsd:add-todo` (infers from conversation)
+Usage: `/gsd:add-todo Add auth token refresh`
+
+**`/gsd:check-todos [area]`**
+List pending todos and select one to work on.
+
+- Lists all pending todos with title, area, age
+- Optional area filter (e.g., `/gsd:check-todos api`)
+- Loads full context for selected todo
+- Routes to appropriate action (work now, add to phase, brainstorm)
+- Moves todo to done/ when work begins
+
+Usage: `/gsd:check-todos`
+Usage: `/gsd:check-todos api`
+
 ### Utility Commands
 
 **`/gsd:help`**
@@ -239,6 +293,11 @@ Show this command reference.
 ├── STATE.md              # Project memory & context
 ├── ISSUES.md             # Deferred enhancements (created when needed)
 ├── config.json           # Workflow mode & gates
+├── todos/                # Captured ideas and tasks
+│   ├── pending/          # Todos waiting to be worked on
+│   └── done/             # Completed todos
+├── debug/                # Active debug sessions
+│   └── resolved/         # Archived resolved issues
 ├── codebase/             # Codebase map (brownfield projects)
 │   ├── STACK.md          # Languages, frameworks, dependencies
 │   ├── ARCHITECTURE.md   # Patterns, layers, data flow
@@ -306,6 +365,24 @@ Change anytime by editing `.planning/config.json`
 /gsd:new-project  # Start next milestone
 ```
 
+**Capturing ideas during work:**
+
+```
+/gsd:add-todo                    # Capture from conversation context
+/gsd:add-todo Fix modal z-index  # Capture with explicit description
+/gsd:check-todos                 # Review and work on todos
+/gsd:check-todos api             # Filter by area
+```
+
+**Debugging an issue:**
+
+```
+/gsd:debug "form submission fails silently"  # Start debug session
+# ... investigation happens, context fills up ...
+/clear
+/gsd:debug                                    # Resume from where you left off
+```
+
 ## Getting Help
 
 - Read `.planning/PROJECT.md` for project vision

package/command/gsd/insert-phase.md

@@ -1,17 +1,17 @@
 ---
 name: gsd:insert-phase
-description: Insert urgent work as decimal phase (e.g., 7.1) between existing phases
+description: Insert urgent work as decimal phase (e.g., 72.1) between existing phases
 argument-hint: <after> <description>
 allowed-tools:
-  - Read
-  - Write
-  - Bash
+  - read
+  - write
+  - bash
 ---
 
 <objective>
 Insert a decimal phase for urgent work discovered mid-milestone that must be completed between existing integer phases.
 
-Uses decimal numbering (7.1, 7.2, etc.) to preserve the logical sequence of planned phases while accommodating urgent insertions.
+Uses decimal numbering (72.1, 72.2, etc.) to preserve the logical sequence of planned phases while accommodating urgent insertions.
 
 Purpose: Handle urgent work discovered during execution without renumbering entire roadmap.
 </objective>
@@ -25,11 +25,11 @@ Purpose: Handle urgent work discovered during execution without renumbering enti
 
 <step name="parse_arguments">
 Parse the command arguments:
-- First argument ($1) : integer phase number to insert after
-- Remaining arguments ($2 $3 $4 $5 $6 $7 $8 $9 $10 $11): phase description
+- First argument ($1): integer phase number to insert after 
+- Remaining arguments ($2 $3 $4 $5 $6 $7 $8 $9 $10 $11 #12 ...): phase description
 
-Example: `/gsd:insert-phase 7 Fix critical auth bug`
-→ after = 7
+Example: `/gsd:insert-phase 72 Fix critical auth bug`
+→ after = 72
 → description = "Fix critical auth bug"
 
 Validation:
@@ -38,7 +38,7 @@ Validation:
 if [ $# -lt 2 ]; then
   echo "ERROR: Both phase number and description required"
   echo "Usage: /gsd:insert-phase <after> <description>"
-  echo "Example: /gsd:insert-phase 7 Fix critical auth bug"
+  echo "Example: /gsd:insert-phase 72 Fix critical auth bug"
   exit 1
 fi
 ```
@@ -94,17 +94,17 @@ Verify that the target phase exists in the roadmap:
 Find existing decimal phases after the target phase:
 
 1. Search for all "### Phase {after_phase}.N:" headings
-2. Extract decimal suffixes (e.g., for Phase 7: find 7.1, 7.2, 7.3)
+2. Extract decimal suffixes (e.g., for Phase 72: find 72.1, 72.2, 72.3)
 3. Find the highest decimal suffix
 4. Calculate next decimal: max + 1
 
 Examples:
 
-- Phase 7 with no decimals → next is 7.1
-- Phase 7 with 7.1 → next is 7.2
-- Phase 7 with 7.1, 7.2 → next is 7.3
+- Phase 72 with no decimals → next is 72.1
+- Phase 72 with 72.1 → next is 72.2
+- Phase 72 with 72.1, 72.2 → next is 72.3
 
-Store as: `decimal_phase="${after_phase}.${next_decimal}"`
+Store as: `decimal_phase="$(printf "%02d" $after_phase).${next_decimal}"`
 </step>
 
 <step name="generate_slug">
@@ -115,7 +115,7 @@ slug=$(echo "$description" | tr '[:upper:]' '[:lower:]' | sed 's/[^a-z0-9]/-/g'
 ```
 
 Phase directory name: `{decimal-phase}-{slug}`
-Example: `7.1-fix-critical-auth-bug`
+Example: `06.1-fix-critical-auth-bug` (phase 6 insertion)
 </step>
 
 <step name="create_phase_directory">

package/command/gsd/list-phase-assumptions.md

@@ -1,18 +1,18 @@
 ---
 name: gsd:list-phase-assumptions
-description: Surface Claude's assumptions about a phase approach before planning
+description: Surface OpenCode's assumptions about a phase approach before planning
 argument-hint: "[phase]"
 allowed-tools:
-  - Read
-  - Bash
-  - Grep
-  - Glob
+  - read
+  - bash
+  - grep
+  - glob
 ---
 
 <objective>
-Analyze a phase and present Claude's assumptions about technical approach, implementation order, scope boundaries, risk areas, and dependencies.
+Analyze a phase and present OpenCode's assumptions about technical approach, implementation order, scope boundaries, risk areas, and dependencies.
 
-Purpose: Help users see what Claude thinks BEFORE planning begins - enabling course correction early when assumptions are wrong.
+Purpose: Help users see what OpenCode thinks BEFORE planning begins - enabling course correction early when assumptions are wrong.
 Output: Conversational output only (no file creation) - ends with "What do you think?" prompt
 </objective>
 
@@ -21,7 +21,7 @@ Output: Conversational output only (no file creation) - ends with "What do you t
 </execution_context>
 
 <context>
-Phase number: $ARGUMENTS (required)
+Phase number: ($ARGUMENTS) (required)
 
 **Load project state first:**
 @.planning/STATE.md

package/command/gsd/map-codebase.md

@@ -1,20 +1,20 @@
 ---
 name: gsd:map-codebase
-description: Analyze codebase with parallel Explore agents to produce .planning/codebase/ documents
+description: Analyze codebase with parallel explore agents to produce .planning/codebase/ documents
 argument-hint: "[optional: specific area to map, e.g., 'api' or 'auth']"
 allowed-tools:
-  - Read
-  - Bash
-  - Glob
-  - Grep
-  - Write
-  - Task
+  - read
+  - bash
+  - glob
+  - grep
+  - write
+  - task
 ---
 
 <objective>
-Analyze existing codebase using parallel Explore agents to produce structured codebase documents.
+Analyze existing codebase using parallel explore agents to produce structured codebase documents.
 
-This command spawns multiple Explore agents to analyze different aspects of the codebase in parallel, each with fresh context.
+This command spawns multiple explore agents to analyze different aspects of the codebase in parallel, each with fresh context.
 
 Output: .planning/codebase/ folder with 7 structured documents about the codebase state.
 </objective>
@@ -31,7 +31,7 @@ Output: .planning/codebase/ folder with 7 structured documents about the codebas
 </execution_context>
 
 <context>
-Focus area: $ARGUMENTS (optional - if provided, tells agents to focus on specific subsystem)
+Focus area: ($ARGUMENTS) (optional - if provided, tells agents to focus on specific subsystem)
 
 **Load project state if exists:**
 Check for .planning/STATE.md - loads context if project already initialized
@@ -58,7 +58,7 @@ Check for .planning/STATE.md - loads context if project already initialized
 <process>
 1. Check if .planning/codebase/ already exists (offer to refresh or skip)
 2. Create .planning/codebase/ directory structure
-3. Spawn 4 parallel Explore agents to analyze codebase:
+3. Spawn 4 parallel explore agents to analyze codebase:
    - Agent 1: Stack + Integrations (technology focus)
    - Agent 2: Architecture + Structure (organization focus)
    - Agent 3: Conventions + Testing (quality focus)

package/command/gsd/new-milestone.md

@@ -17,7 +17,7 @@ Output: New milestone in ROADMAP.md, updated STATE.md, phase directories created
 </execution_context>
 
 <context>
-Milestone name: $ARGUMENTS (optional - will prompt if not provided)
+Milestone name: ($ARGUMENTS) (optional - will prompt if not provided)
 
 **Load project state first:**
 @.planning/STATE.md