gsd-opencode 1.10.2 → 1.20.1

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

@@ -0,0 +1,320 @@
+
+<role>
+You are executing the `/gsd-set-profile` command. Switch the project's active model profile (simple/smart/genius) with optional model reuse.
+
+This command reads/writes:
+- `.planning/config.json` — profile state (profile_type, models)
+- `opencode.json` — agent model assignments (derived from profile)
+
+Do NOT modify agent .md files. Profile switching updates `opencode.json` in the project root.
+</role>
+
+<context>
+**Invocation styles:**
+
+1. No args (interactive wizard): `/gsd-set-profile`
+2. Positional with type: `/gsd-set-profile simple|smart|genius`
+3. With reuse flag: `/gsd-set-profile smart --reuse`
+
+**Stage-to-agent mapping (11 agents):**
+
+| Stage        | Agents |
+|--------------|--------|
+| Planning     | gsd-planner, gsd-plan-checker, gsd-phase-researcher, gsd-roadmapper, gsd-project-researcher, gsd-research-synthesizer, gsd-codebase-mapper |
+| Execution    | gsd-executor, gsd-debugger |
+| Verification | gsd-verifier, gsd-integration-checker |
+
+**Profile types:**
+
+- **Simple**: 1 model total — all stages use same model
+- **Smart**: 2 models — planning+execution share model, verification uses different
+- **Genius**: 3 models — each stage can have different model
+
+**Migration:** Old configs with `model_profile: quality / balanced / budget` are auto-migrated to genius profile.
+</context>
+
+<behavior>
+
+## Step 1: Load and validate config
+
+read `.planning/config.json`. Handle these cases:
+
+**Case A: File missing or invalid**
+- Print: `Error: No GSD project found. Run /gsd-new-project first.`
+- Stop.
+
+**Case B: Legacy config (has model_profile but no profiles.profile_type)**
+- Auto-migrate to genius profile
+- Use OLD_PROFILE_MODEL_MAP to convert quality / balanced / budget → genius
+
+**Case C: Current config**
+- Use `profiles.profile_type` and `profiles.models`
+
+**Also check `opencode.json`:**
+- If missing, it will be created
+- If exists, merge agent assignments (preserve other keys)
+
+
+## Step 3: Display current state
+
+If profile exists:
+
+```
+Active profile: {profile_type}
+
+Current configuration:
+| Stage        | Model |
+|--------------|-------|
+| planning     | {models.planning} |
+| execution    | {models.execution} |
+| verification | {models.verification} |
+```
+
+## Step 4: Determine requested profile
+
+**A) Check for positional argument:**
+- If user typed `/gsd-set-profile simple|smart|genius`, use that as `newProfileType`
+
+**B) Interactive picker (no args):**
+
+Use question tool:
+
+```
+header: "Profile Type"
+question: "Select a profile type for model configuration"
+options:
+  - label: "Simple"
+    description: "1 model for all gsd stages (easiest setup)"
+  - label: "Smart"
+    description: "2 models: advanced for planning & execution, cheaper for verification stages"
+  - label: "Genius"
+    description: "3 models: different model for planning, execution, or verification stages"
+  - label: "Cancel"
+    description: "Exit without changes"
+```
+
+If Cancel selected, print cancellation message and stop.
+
+**C) Invalid profile handling:**
+
+If invalid profile name:
+- Print: `Unknown profile type '{name}'. Valid options: simple, smart, genius`
+- Fall back to interactive picker
+
+## Step 5: Handle --reuse flag
+
+If `--reuse` flag present and current profile exists:
+
+```bash
+node gsd-opencode/get-shit-done/bin/gsd-tools.cjs profile-switch {newProfileType} --reuse --raw
+```
+
+Parse the reuse analysis:
+- Shows which stages can reuse existing models
+- Displays suggestions for each stage
+
+Present to user:
+
+```
+Model Reuse Analysis for {newProfileType} profile:
+
+Current models:
+- Planning: {current.planning}
+- Execution: {current.execution}
+- Verification: {current.verification}
+
+Suggested reuse:
+{reuse analysis from tool}
+
+Use these suggestions? (yes/no)
+```
+
+If yes, proceed with suggested models.
+If no, run full model selection wizard.
+
+## Step 6: Model selection wizard
+
+Based on profile type, prompt for models:
+
+### Simple Profile (1 model)
+
+Use gsd-oc-select-model skill to select model for "Simple Profile - One model to rule them all".
+
+Store selected model. All stages will use this model.
+
+### Smart Profile (2 models)
+
+Use gsd-oc-select-model skill twice.
+
+**First model** (planning + execution):
+
+Use gsd-oc-select-model skill to select model for "Smart Profile - Planning & Execution"
+
+**Second model** (verification):
+
+Use gsd-oc-select-model skill to select model for "Smart Profile - Verification"
+
+Store selected models. 
+
+Planning + Execution will use First model selected.
+Verification will use Second model selected.
+
+
+### Genius Profile (3 models)
+
+Use gsd-oc-select-model skill
+
+
+**First model** (planning):
+
+Use gsd-oc-select-model skill to select model for "Genius Profile - Planning"
+
+**Second model** (execution)
+
+Use gsd-oc-select-model skill to select model for "Genius Profile - Execution"
+
+**Thrid model** (verification):
+
+Use gsd-oc-select-model skill to select model for "Genius Profile - Verification"
+
+Store selected models. 
+
+Planning will use First model selected.
+Execution will use Second model selected.
+Verification will use Third model selected.
+
+
+
+## Step 7: Validate selected models
+
+Before writing files, validate models exist:
+
+```bash
+opencode models | grep -q "^{model}$" && echo "valid" || echo "invalid"
+```
+
+If any model invalid:
+- Print error with list of missing models
+- Stop. Do NOT write config files.
+
+## Step 8: Apply changes
+
+### Save config.json
+
+Save config.json Or build and save manually:
+
+```json
+{
+  "profiles": {
+    "profile_type": "{simple|smart|genius}",
+    "models": {
+      "planning": "{model}",
+      "execution": "{model}",
+      "verification": "{model}"
+    }
+  }
+}
+```
+
+
+## Step 8: Check for changes
+
+If no changes were made (all stages selected "Keep current"):
+```
+No changes made to {targetProfile} profile.
+```
+Stop.
+
+## Step 9: Save changes
+
+Use the **write tool directly** to update files. Do NOT use bash, python, or other scripts—use native file writing.
+
+1. **Update .planning/config.json:**
+
+    - Set `config.profiles.presets[targetProfile].planning` to selected value
+    - Set `config.profiles.presets[targetProfile].execution` to selected value
+    - Set `config.profiles.presets[targetProfile].verification` to selected value
+    - write the config file (preserve all other keys)
+
+2. **Update opencode.json (only if targetProfile is active):**
+
+Check if `config.profiles.active_profile === targetProfile`. If so, regenerate `opencode.json` with the new effective models.
+
+Compute effective models (preset + overrides):
+```
+overrides = config.profiles.genius_overrides[targetProfile] || {}
+effective.planning = overrides.planning || newPreset.planning
+effective.execution = overrides.execution || newPreset.execution
+effective.verification = overrides.verification || newPreset.verification
+```
+
+Build agent config:
+
+```json
+{
+  "$schema": "https://opencode.ai/config.json",
+  "agent": {
+    "gsd-planner": { "model": "{effective.planning}" },
+    "gsd-plan-checker": { "model": "{effective.planning}" },
+    "gsd-phase-researcher": { "model": "{effective.planning}" },
+    "gsd-roadmapper": { "model": "{effective.planning}" },
+    "gsd-project-researcher": { "model": "{effective.planning}" },
+    "gsd-research-synthesizer": { "model": "{effective.planning}" },
+    "gsd-codebase-mapper": { "model": "{effective.planning}" },
+    "gsd-executor": { "model": "{effective.execution}" },
+    "gsd-debugger": { "model": "{effective.execution}" },
+    "gsd-verifier": { "model": "{effective.verification}" },
+    "gsd-integration-checker": { "model": "{effective.verification}" },
+  }
+}
+```
+
+If `opencode.json` already exists, merge the `agent` key (preserve other top-level keys).
+
+## Step 10: Report success
+
+```text
+✓ Updated {targetProfile} profile:
+
+| Stage        | Model |
+|--------------|-------|
+| planning     | {newPreset.planning} |
+| execution    | {newPreset.execution} |
+| verification | {newPreset.verification} |
+```
+
+If `targetProfile` is the active profile:
+```text
+Note: This is your active profile. Quit and relaunch OpenCode to apply model changes.
+```
+
+If `targetProfile` is NOT the active profile:
+```text
+To use this profile, run: /gsd-set-profile {targetProfile}
+```
+
+</behavior>
+
+
+Parse output and write to `opencode.json`, merging with existing content.
+
+Note: Quit and relaunch OpenCode to apply model changes.
+```
+
+If migration occurred:
+```
+⚡ Auto-migrated from {old_profile} to genius profile
+```
+
+</behavior>
+
+<notes>
+- Use question tool for ALL user input
+- Always show full model IDs (e.g., `opencode/glm-4.7-free`)
+- Preserve all other config.json keys when writing
+- Do NOT rewrite agent .md files — only update opencode.json
+- If opencode.json doesn't exist, create it
+- **Source of truth:** `config.json` stores profile_type and models; `opencode.json` is derived
+- When migrating, preserve old model_profile field for backward compat during transition
+- Model selection uses gsd-oc-select-model skill 
+</notes>

package/{commands/gsd → get-shit-done/workflows}/pause-work.md

@@ -1,26 +1,22 @@
----
-name: gsd-pause-work
-description: Create context handoff when pausing work mid-phase
-tools:
-  - read
-  - write
-  - bash
----
-
-<objective>
-Create `.continue-here.md` handoff file to preserve complete work state across sessions.
+<purpose>
+Create `.continue-here.md` handoff file to preserve complete work state across sessions. Enables seamless resumption with full context restoration.
+</purpose>
 
-Enables seamless resumption in fresh session with full context restoration.
-</objective>
-
-<context>
-@.planning/STATE.md
-</context>
+<required_reading>
+read all files referenced by the invoking prompt's execution_context before starting.
+</required_reading>
 
 <process>
 
 <step name="detect">
-Find current phase directory from most recently modified files.
+Find current phase directory from most recently modified files:
+
+```bash
+# Find most recent phase directory with work
+ls -lt .planning/phases/*/PLAN.md 2>/dev/null | head -1 | grep -oP 'phases/\K[^/]+'
+```
+
+If no active phase detected, ask user which phase they're pausing work on.
 </step>
 
 <step name="gather">
@@ -34,7 +30,7 @@ Find current phase directory from most recently modified files.
 6. **Mental context**: The approach, next steps, "vibe"
 7. **Files modified**: What's changed but not committed
 
-Ask user for clarifications if needed.
+Ask user for clarifications if needed via conversational questions.
 </step>
 
 <step name="write">
@@ -46,7 +42,7 @@ phase: XX-name
 task: 3
 total_tasks: 7
 status: in_progress
-last_updated: [timestamp]
+last_updated: [timestamp from current-timestamp]
 ---
 
 <current_state>
@@ -55,23 +51,23 @@ last_updated: [timestamp]
 
 <completed_work>
 
-- Task 1: [name] - Done
-- Task 2: [name] - Done
-- Task 3: [name] - In progress, [what's done]
-  </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>
+- 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>
+</decisions_made>
 
 <blockers>
 - [Blocker 1]: [status/workaround]
@@ -87,23 +83,16 @@ Start with: [specific first action when resuming]
 ```
 
 Be specific enough for a fresh OpenCode to understand immediately.
-</step>
-
-<step name="commit">
-**Check planning config:**
 
+Use `current-timestamp` for last_updated field. You can use init todos (which provides timestamps) or call directly:
 ```bash
-COMMIT_PLANNING_DOCS=$(cat .planning/config.json 2>/dev/null | grep -o '"commit_docs"[[:space:]]*:[[:space:]]*[^,}]*' | grep -o 'true\|false' || echo "true")
-git check-ignore -q .planning 2>/dev/null && COMMIT_PLANNING_DOCS=false
+timestamp=$(node ~/.config/opencode/get-shit-done/bin/gsd-tools.cjs current-timestamp full --raw)
 ```
+</step>
 
-**If `COMMIT_PLANNING_DOCS=false`:** Skip git operations
-
-**If `COMMIT_PLANNING_DOCS=true` (default):**
-
+<step name="commit">
 ```bash
-git add .planning/phases/*/.continue-here.md
-git commit -m "wip: [phase-name] paused at task [X]/[Y]"
+node ~/.config/opencode/get-shit-done/bin/gsd-tools.cjs commit "wip: [phase-name] paused at task [X]/[Y]" --files .planning/phases/*/.continue-here.md
 ```
 </step>
 
@@ -114,7 +103,7 @@ git commit -m "wip: [phase-name] paused at task [X]/[Y]"
 Current state:
 
 - Phase: [XX-name]
-- Task: [X] of [Y]
+- task: [X] of [Y]
 - Status: [in_progress/blocked]
 - Committed as WIP
 
@@ -131,4 +120,3 @@ To resume: /gsd-resume-work
 - [ ] Committed as WIP
 - [ ] User knows location and how to resume
 </success_criteria>
-```

package/{commands/gsd → get-shit-done/workflows}/plan-milestone-gaps.md

@@ -1,39 +1,10 @@
----
-name: gsd-plan-milestone-gaps
-description: Create phases to close all gaps identified by milestone audit
-tools:
-  - read
-  - write
-  - bash
-  - glob
-  - grep
-  - question
----
-
-<objective>
-Create all phases necessary to close gaps identified by `/gsd-audit-milestone`.
-
-Reads MILESTONE-AUDIT.md, groups gaps into logical phases, creates phase entries in ROADMAP.md, and offers to plan each phase.
-
-One command creates all fix phases — no manual `/gsd-add-phase` per gap.
-</objective>
-
-<execution_context>
-<!-- Spawns gsd-planner agent which has all planning expertise baked in -->
-</execution_context>
-
-<context>
-**Audit results:**
-glob: .planning/v*-MILESTONE-AUDIT.md (use most recent)
+<purpose>
+Create all phases necessary to close gaps identified by `/gsd-audit-milestone`. Reads MILESTONE-AUDIT.md, groups gaps into logical phases, creates phase entries in ROADMAP.md, and offers to plan each phase. One command creates all fix phases — no manual `/gsd-add-phase` per gap.
+</purpose>
 
-**Original intent (for prioritization):**
-@.planning/PROJECT.md
-@.planning/REQUIREMENTS.md
-
-**Current state:**
-@.planning/ROADMAP.md
-@.planning/STATE.md
-</context>
+<required_reading>
+read all files referenced by the invoking prompt's execution_context before starting.
+</required_reading>
 
 <process>
 
@@ -93,7 +64,9 @@ Gap: Flow "View dashboard" broken at data fetch
 
 Find highest existing phase:
 ```bash
-ls -d .planning/phases/*/ | sort -V | tail -1
+# Get sorted phase list, extract last one
+PHASES=$(node ~/.config/opencode/get-shit-done/bin/gsd-tools.cjs phases list)
+HIGHEST=$(echo "$PHASES" | jq -r '.directories[-1]')
 ```
 
 New phases continue from there:
@@ -150,31 +123,34 @@ Add new phases to current milestone:
 ...
 ```
 
-## 7. Create Phase Directories
+## 7. Update REQUIREMENTS.md Traceability Table (REQUIRED)
+
+For each REQ-ID assigned to a gap closure phase:
+- Update the Phase column to reflect the new gap closure phase
+- Reset Status to `Pending`
+
+Reset checked-off requirements the audit found unsatisfied:
+- Change `[x]` → `[ ]` for any requirement marked unsatisfied in the audit
+- Update coverage count at top of REQUIREMENTS.md
 
 ```bash
-mkdir -p ".planning/phases/{NN}-{name}"
+# Verify traceability table reflects gap closure assignments
+grep -c "Pending" .planning/REQUIREMENTS.md
 ```
 
-## 8. Commit Roadmap Update
-
-**Check planning config:**
+## 8. Create Phase Directories
 
 ```bash
-COMMIT_PLANNING_DOCS=$(cat .planning/config.json 2>/dev/null | grep -o '"commit_docs"[[:space:]]*:[[:space:]]*[^,}]*' | grep -o 'true\|false' || echo "true")
-git check-ignore -q .planning 2>/dev/null && COMMIT_PLANNING_DOCS=false
+mkdir -p ".planning/phases/{NN}-{name}"
 ```
 
-**If `COMMIT_PLANNING_DOCS=false`:** Skip git operations
-
-**If `COMMIT_PLANNING_DOCS=true` (default):**
+## 9. Commit Roadmap and Requirements Update
 
 ```bash
-git add .planning/ROADMAP.md
-git commit -m "docs(roadmap): add gap closure phases {N}-{M}"
+node ~/.config/opencode/get-shit-done/bin/gsd-tools.cjs commit "docs(roadmap): add gap closure phases {N}-{M}" --files .planning/ROADMAP.md .planning/REQUIREMENTS.md
 ```
 
-## 9. Offer Next Steps
+## 10. Offer Next Steps
 
 ```markdown
 ## ✓ Gap Closure Phases Created
@@ -289,7 +265,10 @@ becomes:
 - [ ] Gaps grouped into logical phases
 - [ ] User confirmed phase plan
 - [ ] ROADMAP.md updated with new phases
+- [ ] REQUIREMENTS.md traceability table updated with gap closure phase assignments
+- [ ] Unsatisfied requirement checkboxes reset (`[x]` → `[ ]`)
+- [ ] Coverage count updated in REQUIREMENTS.md
 - [ ] Phase directories created
-- [ ] Changes committed
+- [ ] Changes committed (includes REQUIREMENTS.md)
 - [ ] User knows to run `/gsd-plan-phase` next
 </success_criteria>