gsd-opencode 1.10.2 → 1.20.1

package/get-shit-done/workflows/resume-project.md

@@ -7,10 +7,7 @@ Use this workflow when:
 </trigger>
 
 <purpose>
-Instantly restore full project context and present clear status.
-Enables seamless session continuity for fully autonomous workflows.
-
-"Where were we?" should have an immediate, complete answer.
+Instantly restore full project context so "Where were we?" has an immediate, complete answer.
 </purpose>
 
 <required_reading>
@@ -19,18 +16,18 @@ Enables seamless session continuity for fully autonomous workflows.
 
 <process>
 
-<step name="detect_existing_project">
-Check if this is an existing project:
+<step name="initialize">
+Load all context in one call:
 
 ```bash
-ls .planning/STATE.md 2>/dev/null && echo "Project exists"
-ls .planning/ROADMAP.md 2>/dev/null && echo "Roadmap exists"
-ls .planning/PROJECT.md 2>/dev/null && echo "Project file exists"
+INIT=$(node ~/.config/opencode/get-shit-done/bin/gsd-tools.cjs init resume)
 ```
 
-**If STATE.md exists:** Proceed to load_state
-**If only ROADMAP.md/PROJECT.md exist:** Offer to reconstruct STATE.md
-**If .planning/ doesn't exist:** This is a new project - route to /gsd-new-project
+Parse JSON for: `state_exists`, `roadmap_exists`, `project_exists`, `planning_exists`, `has_interrupted_agent`, `interrupted_agent_id`, `commit_docs`.
+
+**If `state_exists` is true:** Proceed to load_state
+**If `state_exists` is false but `roadmap_exists` or `project_exists` is true:** Offer to reconstruct STATE.md
+**If `planning_exists` is false:** This is a new project - route to /gsd-new-project
 </step>
 
 <step name="load_state">
@@ -74,10 +71,9 @@ for plan in .planning/phases/*/*-PLAN.md; do
   [ ! -f "$summary" ] && echo "Incomplete: $plan"
 done 2>/dev/null
 
-# Check for interrupted agents
-if [ -f .planning/current-agent-id.txt ] && [ -s .planning/current-agent-id.txt ]; then
-  AGENT_ID=$(cat .planning/current-agent-id.txt | tr -d '\n')
-  echo "Interrupted agent: $AGENT_ID"
+# Check for interrupted agents (use has_interrupted_agent and interrupted_agent_id from init)
+if [ "$has_interrupted_agent" = "true" ]; then
+  echo "Interrupted agent: $interrupted_agent_id"
 fi
 ```
 
@@ -122,10 +118,10 @@ Present complete project status to user:
 [If interrupted agent found:]
 ⚠️  Interrupted agent detected:
     Agent ID: [id]
-    Task: [task description from agent-history.json]
+    task: [task description from agent-history.json]
     Interrupted: [timestamp]
 
-    Resume with: Task tool (resume parameter with agent ID)
+    Resume with: task tool (resume parameter with agent ID)
 
 [If pending todos exist:]
 📋 [N] pending todos — /gsd-check-todos to review
@@ -145,7 +141,7 @@ Present complete project status to user:
 Based on project state, determine the most logical next action:
 
 **If interrupted agent exists:**
-→ Primary: Resume interrupted agent (Task tool with resume parameter)
+→ Primary: Resume interrupted agent (task tool with resume parameter)
 → Option: Start fresh (abandon agent work)
 
 **If .continue-here file exists:**
@@ -200,7 +196,7 @@ What would you like to do?
 **Note:** When offering phase planning, check for CONTEXT.md existence first:
 
 ```bash
-ls .planning/phases/XX-name/CONTEXT.md 2>/dev/null
+ls .planning/phases/XX-name/*-CONTEXT.md 2>/dev/null
 ```
 
 If missing, suggest discuss-phase before plan. If exists, offer plan directly.
@@ -290,17 +286,12 @@ This handles cases where:
   </reconstruction>
 
 <quick_resume>
-For users who want minimal friction:
-
-If user says just "continue" or "go":
-
+If user says "continue" or "go":
 - Load state silently
 - Determine primary action
 - Execute immediately without presenting options
 
 "Continuing from [state]... [action]"
-
-This enables fully autonomous "just keep going" workflow.
 </quick_resume>
 
 <success_criteria>

package/get-shit-done/workflows/set-profile.md

@@ -0,0 +1,80 @@
+<purpose>
+Switch the model profile used by GSD agents. Controls which OpenCode model each agent uses, balancing quality vs token spend.
+</purpose>
+
+<required_reading>
+read all files referenced by the invoking prompt's execution_context before starting.
+</required_reading>
+
+<process>
+
+<step name="validate">
+Validate argument:
+
+```
+if $ARGUMENTS.profile not in ["quality", "balanced", "budget"]:
+  Error: Invalid profile "$ARGUMENTS.profile"
+  Valid profiles: quality, balanced, budget
+  EXIT
+```
+</step>
+
+<step name="ensure_and_load_config">
+Ensure config exists and load current state:
+
+```bash
+node ~/.config/opencode/get-shit-done/bin/gsd-tools.cjs config-ensure-section
+INIT=$(node ~/.config/opencode/get-shit-done/bin/gsd-tools.cjs state load)
+```
+
+This creates `.planning/config.json` with defaults if missing and loads current config.
+</step>
+
+<step name="update_config">
+read current config from state load or directly:
+
+Update `model_profile` field:
+```json
+{
+  "model_profile": "$ARGUMENTS.profile"
+}
+```
+
+write updated config back to `.planning/config.json`.
+</step>
+
+<step name="confirm">
+Display confirmation with model table for selected profile:
+
+```
+✓ Model profile set to: $ARGUMENTS.profile
+
+Agents will now use:
+
+[Show table from MODEL_PROFILES in gsd-tools.cjs for selected profile]
+
+Example:
+| Agent | Model |
+|-------|-------|
+| gsd-planner | opus |
+| gsd-executor | sonnet |
+| gsd-verifier | haiku |
+| ... | ... |
+
+Next spawned agents will use the new profile.
+```
+
+Map profile names:
+- quality: use "quality" column from MODEL_PROFILES
+- balanced: use "balanced" column from MODEL_PROFILES
+- budget: use "budget" column from MODEL_PROFILES
+</step>
+
+</process>
+
+<success_criteria>
+- [ ] Argument validated
+- [ ] Config file ensured
+- [ ] Config updated with new model_profile
+- [ ] Confirmation displayed with model table
+</success_criteria>

package/get-shit-done/workflows/settings.md

@@ -0,0 +1,213 @@
+<purpose>
+Interactive configuration of GSD workflow agents (research, plan_check, verifier) and model profile selection via multi-question prompt. Updates .planning/config.json with user preferences. Optionally saves settings as global defaults (~/.gsd/defaults.json) for future projects.
+</purpose>
+
+<required_reading>
+read all files referenced by the invoking prompt's execution_context before starting.
+</required_reading>
+
+<process>
+
+<step name="ensure_and_load_config">
+Ensure config exists and load current state:
+
+```bash
+node ~/.config/opencode/get-shit-done/bin/gsd-tools.cjs config-ensure-section
+INIT=$(node ~/.config/opencode/get-shit-done/bin/gsd-tools.cjs state load)
+```
+
+Creates `.planning/config.json` with defaults if missing and loads current config values.
+</step>
+
+<step name="read_current">
+```bash
+cat .planning/config.json
+```
+
+Parse current values (default to `true` if not present):
+- `workflow.research` — spawn researcher during plan-phase
+- `workflow.plan_check` — spawn plan checker during plan-phase
+- `workflow.verifier` — spawn verifier during execute-phase
+- `workflow.nyquist_validation` — validation architecture research during plan-phase
+- `model_profile` — which model each agent uses (default: `simple`)
+- `git.branching_strategy` — branching approach (default: `"none"`)
+</step>
+
+<step name="present_settings">
+Use question with current values pre-selected:
+
+```
+question([
+  {
+    question: "Which model profile for agents?",
+    header: "Model",
+    multiSelect: false,
+    options: [
+      { label: "Simple", description: "One model for all agents (not flexible)" },
+      { label: "Smart (Recommended)", description: "Two models: one for reseach and planing, other for execution and verification" },
+      { label: "Custom (most flexible)", description: "Three models: different for every stage" }
+    ]
+  },
+  {
+    question: "Spawn Plan Researcher? (researches domain before planning)",
+    header: "Research",
+    multiSelect: false,
+    options: [
+      { label: "Yes", description: "Research phase goals before planning" },
+      { label: "No", description: "Skip research, plan directly" }
+    ]
+  },
+  {
+    question: "Spawn Plan Checker? (verifies plans before execution)",
+    header: "Plan Check",
+    multiSelect: false,
+    options: [
+      { label: "Yes", description: "Verify plans meet phase goals" },
+      { label: "No", description: "Skip plan verification" }
+    ]
+  },
+  {
+    question: "Spawn Execution Verifier? (verifies phase completion)",
+    header: "Verifier",
+    multiSelect: false,
+    options: [
+      { label: "Yes", description: "Verify must-haves after execution" },
+      { label: "No", description: "Skip post-execution verification" }
+    ]
+  },
+  {
+    question: "Auto-advance pipeline? (discuss → plan → execute automatically)",
+    header: "Auto",
+    multiSelect: false,
+    options: [
+      { label: "No (Recommended)", description: "Manual /new + paste between stages" },
+      { label: "Yes", description: "Chain stages via task() subagents (same isolation)" }
+    ]
+  },
+  {
+    question: "Enable Nyquist Validation? (researches test coverage during planning)",
+    header: "Nyquist",
+    multiSelect: false,
+    options: [
+      { label: "Yes (Recommended)", description: "Research automated test coverage during plan-phase. Adds validation requirements to plans. Blocks approval if tasks lack automated verify." },
+      { label: "No", description: "Skip validation research. Good for rapid prototyping or no-test phases." }
+    ]
+  },
+  {
+    question: "Git branching strategy?",
+    header: "Branching",
+    multiSelect: false,
+    options: [
+      { label: "None (Recommended)", description: "Commit directly to current branch" },
+      { label: "Per Phase", description: "Create branch for each phase (gsd/phase-{N}-{name})" },
+      { label: "Per Milestone", description: "Create branch for entire milestone (gsd/{version}-{name})" }
+    ]
+  }
+])
+```
+</step>
+
+<step name="update_config">
+Merge new settings into existing config.json:
+
+```json
+{
+  ...existing_config,
+  "model_profile": "simple" | "smart" | "custom",
+  "workflow": {
+    "research": true/false,
+    "plan_check": true/false,
+    "verifier": true/false,
+    "auto_advance": true/false,
+    "nyquist_validation": true/false
+  },
+  "git": {
+    "branching_strategy": "none" | "phase" | "milestone"
+  }
+}
+```
+
+write updated config to `.planning/config.json`.
+</step>
+
+<step name="save_as_defaults">
+Ask whether to save these settings as global defaults for future projects:
+
+```
+question([
+  {
+    question: "Save these as default settings for all new projects?",
+    header: "Defaults",
+    multiSelect: false,
+    options: [
+      { label: "Yes", description: "New projects start with these settings (saved to ~/.gsd/defaults.json)" },
+      { label: "No", description: "Only apply to this project" }
+    ]
+  }
+])
+```
+
+If "Yes": write the same config object (minus project-specific fields like `brave_search`) to `~/.gsd/defaults.json`:
+
+```bash
+mkdir -p ~/.gsd
+```
+
+write `~/.gsd/defaults.json` with:
+```json
+{
+  "mode": <current>,
+  "depth": <current>,
+  "model_profile": <current>,
+  "commit_docs": <current>,
+  "parallelization": <current>,
+  "branching_strategy": <current>,
+  "workflow": {
+    "research": <current>,
+    "plan_check": <current>,
+    "verifier": <current>,
+    "auto_advance": <current>,
+    "nyquist_validation": <current>
+  }
+}
+```
+</step>
+
+<step name="confirm">
+Display:
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ GSD ► SETTINGS UPDATED
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+| Setting              | Value |
+|----------------------|-------|
+| Model Profile        | {simple/smart/custom} |
+| Plan Researcher      | {On/Off} |
+| Plan Checker         | {On/Off} |
+| Execution Verifier   | {On/Off} |
+| Auto-Advance         | {On/Off} |
+| Nyquist Validation   | {On/Off} |
+| Git Branching        | {None/Per Phase/Per Milestone} |
+| Saved as Defaults    | {Yes/No} |
+
+These settings apply to future /gsd-plan-phase and /gsd-execute-phase runs.
+
+Quick commands:
+- /gsd-set-profile <profile> — switch model profile
+- /gsd-plan-phase --research — force research
+- /gsd-plan-phase --skip-research — skip research
+- /gsd-plan-phase --skip-verify — skip plan check
+```
+</step>
+
+</process>
+
+<success_criteria>
+- [ ] Current config read
+- [ ] User presented with 7 settings (profile + 5 workflow toggles + git branching)
+- [ ] Config updated with model_profile, workflow, and git sections
+- [ ] User offered to save as global defaults (~/.gsd/defaults.json)
+- [ ] Changes confirmed to user
+</success_criteria>

package/get-shit-done/workflows/transition.md

@@ -118,39 +118,22 @@ If found, delete them — phase is complete, handoffs are stale.
 
 </step>
 
-<step name="update_roadmap">
+<step name="update_roadmap_and_state">
 
-Update the roadmap file:
+**Delegate ROADMAP.md and STATE.md updates to gsd-tools:**
 
 ```bash
-ROADMAP_FILE=".planning/ROADMAP.md"
+TRANSITION=$(node ~/.config/opencode/get-shit-done/bin/gsd-tools.cjs phase complete "${current_phase}")
 ```
 
-Update the file:
+The CLI handles:
+- Marking the phase checkbox as `[x]` complete with today's date
+- Updating plan count to final (e.g., "3/3 plans complete")
+- Updating the Progress table (Status → Complete, adding date)
+- Advancing STATE.md to next phase (Current Phase, Status → Ready to plan, Current Plan → Not started)
+- Detecting if this is the last phase in the milestone
 
-- Mark current phase: `[x] Complete`
-- Add completion date
-- Update plan count to final (e.g., "3/3 plans complete")
-- Update Progress table
-- Keep next phase as `[ ] Not started`
-
-**Example:**
-
-```markdown
-## Phases
-
-- [x] Phase 1: Foundation (completed 2025-01-15)
-- [ ] Phase 2: Authentication ← Next
-- [ ] Phase 3: Core Features
-
-## Progress
-
-| Phase             | Plans Complete | Status      | Completed  |
-| ----------------- | -------------- | ----------- | ---------- |
-| 1. Foundation     | 3/3            | Complete    | 2025-01-15 |
-| 2. Authentication | 0/2            | Not started | -          |
-| 3. Core Features  | 0/1            | Not started | -          |
-```
+Extract from result: `completed_phase`, `plans_executed`, `next_phase`, `next_phase_name`, `is_last_phase`.
 
 </step>
 
@@ -250,61 +233,21 @@ After (Phase 2 shipped JWT auth, discovered rate limiting needed):
 
 <step name="update_current_position_after_transition">
 
-Update Current Position section in STATE.md to reflect phase completion and transition.
+**Note:** Basic position updates (Current Phase, Status, Current Plan, Last Activity) were already handled by `gsd-tools phase complete` in the update_roadmap_and_state step.
 
-**Format:**
+Verify the updates are correct by reading STATE.md. If the progress bar needs updating, use:
 
-```markdown
-Phase: [next] of [total] ([Next phase name])
-Plan: Not started
-Status: Ready to plan
-Last activity: [today] — Phase [X] complete, transitioned to Phase [X+1]
-
-Progress: [updated progress bar]
-```
-
-**Instructions:**
-
-- Increment phase number to next phase
-- Reset plan to "Not started"
-- Set status to "Ready to plan"
-- Update last activity to describe transition
-- Recalculate progress bar based on completed plans
-
-**Example — transitioning from Phase 2 to Phase 3:**
-
-Before:
-
-```markdown
-## Current Position
-
-Phase: 2 of 4 (Authentication)
-Plan: 2 of 2 in current phase
-Status: Phase complete
-Last activity: 2025-01-20 — Completed 02-02-PLAN.md
-
-Progress: ███████░░░ 60%
+```bash
+PROGRESS=$(node ~/.config/opencode/get-shit-done/bin/gsd-tools.cjs progress bar --raw)
 ```
 
-After:
-
-```markdown
-## Current Position
-
-Phase: 3 of 4 (Core Features)
-Plan: Not started
-Status: Ready to plan
-Last activity: 2025-01-20 — Phase 2 complete, transitioned to Phase 3
-
-Progress: ███████░░░ 60%
-```
+Update the progress bar line in STATE.md with the result.
 
 **Step complete when:**
 
-- [ ] Phase number incremented to next phase
-- [ ] Plan status reset to "Not started"
-- [ ] Status shows "Ready to plan"
-- [ ] Last activity describes the transition
+- [ ] Phase number incremented to next phase (done by phase complete)
+- [ ] Plan status reset to "Not started" (done by phase complete)
+- [ ] Status shows "Ready to plan" (done by phase complete)
 - [ ] Progress bar reflects total completed plans
 
 </step>
@@ -394,26 +337,20 @@ Resume file: None
 
 **MANDATORY: Verify milestone status before presenting next steps.**
 
-**Step 1: read ROADMAP.md and identify phases in current milestone**
-
-read the ROADMAP.md file and extract:
-1. Current phase number (the phase just transitioned from)
-2. All phase numbers in the current milestone section
+**Use the transition result from `gsd-tools phase complete`:**
 
-To find phases, look for:
-- Phase headers: lines starting with `### Phase` or `#### Phase`
-- Phase list items: lines like `- [ ] **Phase X:` or `- [x] **Phase X:`
+The `is_last_phase` field from the phase complete result tells you directly:
+- `is_last_phase: false` → More phases remain → Go to **Route A**
+- `is_last_phase: true` → Milestone complete → Go to **Route B**
 
-Count total phases and identify the highest phase number in the milestone.
+The `next_phase` and `next_phase_name` fields give you the next phase details.
 
-State: "Current phase is {X}. Milestone has {N} phases (highest: {Y})."
-
-**Step 2: Route based on milestone status**
+If you need additional context, use:
+```bash
+ROADMAP=$(node ~/.config/opencode/get-shit-done/bin/gsd-tools.cjs roadmap analyze)
+```
 
-| Condition | Meaning | Action |
-|-----------|---------|--------|
-| current phase < highest phase | More phases remain | Go to **Route A** |
-| current phase = highest phase | Milestone complete | Go to **Route B** |
+This returns all phases with goals, disk status, and completion info.
 
 ---
 
@@ -421,10 +358,18 @@ State: "Current phase is {X}. Milestone has {N} phases (highest: {Y})."
 
 read ROADMAP.md to get the next phase's name and goal.
 
+**Check if next phase has CONTEXT.md:**
+
+```bash
+ls .planning/phases/*[X+1]*/*-CONTEXT.md 2>/dev/null
+```
+
 **If next phase exists:**
 
 <if mode="yolo">
 
+**If CONTEXT.md exists:**
+
 ```
 Phase [X] marked complete.
 
@@ -433,12 +378,26 @@ Next: Phase [X+1] — [Name]
 ⚡ Auto-continuing: Plan Phase [X+1] in detail
 ```
 
-Exit skill and invoke Command("/gsd-plan-phase [X+1]")
+Exit skill and invoke command("/gsd-plan-phase [X+1] --auto")
+
+**If CONTEXT.md does NOT exist:**
+
+```
+Phase [X] marked complete.
+
+Next: Phase [X+1] — [Name]
+
+⚡ Auto-continuing: Discuss Phase [X+1] first
+```
+
+Exit skill and invoke command("/gsd-discuss-phase [X+1] --auto")
 
 </if>
 
 <if mode="interactive" OR="custom with gates.confirm_transition true">
 
+**If CONTEXT.md does NOT exist:**
+
 ```
 ## ✓ Phase [X] Complete
 
@@ -448,6 +407,31 @@ Exit skill and invoke Command("/gsd-plan-phase [X+1]")
 
 **Phase [X+1]: [Name]** — [Goal from ROADMAP.md]
 
+`/gsd-discuss-phase [X+1]` — gather context and clarify approach
+
+*`/new` first → fresh context window*
+
+---
+
+**Also available:**
+- `/gsd-plan-phase [X+1]` — skip discussion, plan directly
+- `/gsd-research-phase [X+1]` — investigate unknowns
+
+---
+```
+
+**If CONTEXT.md exists:**
+
+```
+## ✓ Phase [X] Complete
+
+---
+
+## ▶ Next Up
+
+**Phase [X+1]: [Name]** — [Goal from ROADMAP.md]
+*✓ Context gathered, ready to plan*
+
 `/gsd-plan-phase [X+1]`
 
 *`/new` first → fresh context window*
@@ -455,9 +439,8 @@ Exit skill and invoke Command("/gsd-plan-phase [X+1]")
 ---
 
 **Also available:**
-- `/gsd-discuss-phase [X+1]` — gather context first
+- `/gsd-discuss-phase [X+1]` — revisit context
 - `/gsd-research-phase [X+1]` — investigate unknowns
-- Review roadmap
 
 ---
 ```
@@ -468,6 +451,11 @@ Exit skill and invoke Command("/gsd-plan-phase [X+1]")
 
 **Route B: Milestone complete (all phases done)**
 
+**Clear auto-advance** — milestone boundary is the natural stopping point:
+```bash
+node ~/.config/opencode/get-shit-done/bin/gsd-tools.cjs config-set workflow.auto_advance false
+```
+
 <if mode="yolo">
 
 ```
@@ -478,7 +466,7 @@ Phase {X} marked complete.
 ⚡ Auto-continuing: Complete milestone and archive
 ```
 
-Exit skill and invoke Command("/gsd-complete-milestone {version}")
+Exit skill and invoke command("/gsd-complete-milestone {version}")
 
 </if>
 
@@ -514,15 +502,7 @@ Exit skill and invoke Command("/gsd-complete-milestone {version}")
 </process>
 
 <implicit_tracking>
-
-Progress tracking is IMPLICIT:
-
-- "Plan phase 2" → Phase 1 must be done (or ask)
-- "Plan phase 3" → Phases 1-2 must be done (or ask)
-- Transition workflow makes it explicit in ROADMAP.md
-
-No separate "update progress" step. Forward motion IS progress.
-
+Progress tracking is IMPLICIT: planning phase N implies phases 1-(N-1) complete. No separate progress step—forward motion IS progress.
 </implicit_tracking>
 
 <partial_completion>