gsd-opencode 1.9.1 → 1.9.2

package/command/gsd/settings.md

@@ -1,136 +1,33 @@
 ---
 name: gsd-settings
-description: Configure GSD workflow toggles and model profile
+description: Configure GSD model profiles and workflow settings
+agent: gsd-settings
 tools:
   - read
   - write
+  - bash
   - question
 ---
 
 <objective>
-Allow users to toggle workflow agents on/off and select model profile via interactive settings.
+Open an interactive settings menu.
 
-Updates `.planning/config.json` with workflow preferences and model profile selection.
+This delegates the implementation to the `gsd-settings` agent, which manages `.planning/config.json` and regenerates `opencode.json` when needed.
 </objective>
 
 <process>
 
-## 1. Validate Environment
-
-```bash
-ls .planning/config.json 2>/dev/null
-```
-
-**If not found:** Error - run `/gsd-new-project` first.
-
-## 2. read Current Config
-
-```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
-- `model_profile` — which model each agent uses (default: `balanced`)
-
-## 3. Present Settings
-
-Use question with current values shown:
-
-```
-question([
-  {
-    question: "Which model profile for agents?",
-    header: "Model",
-    multiSelect: false,
-    options: [
-      { label: "Quality", description: "Opus everywhere except verification (highest cost)" },
-      { label: "Balanced (Recommended)", description: "Opus for planning, Sonnet for execution/verification" },
-      { label: "Budget", description: "Sonnet for writing, Haiku for research/verification (lowest cost)" }
-    ]
-  },
-  {
-    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" }
-    ]
-  }
-])
-```
-
-**Pre-select based on current config values.**
-
-## 4. Update Config
-
-Merge new settings into existing config.json:
-
-```json
-{
-  ...existing_config,
-  "model_profile": "quality" | "balanced" | "budget",
-  "workflow": {
-    "research": true/false,
-    "plan_check": true/false,
-    "verifier": true/false
-  }
-}
-```
-
-write updated config to `.planning/config.json`.
-
-## 5. Confirm Changes
-
-Display:
-
-```
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
- GSD ► SETTINGS UPDATED
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-| Setting              | Value |
-|----------------------|-------|
-| Model Profile        | {quality/balanced/budget} |
-| Plan Researcher      | {On/Off} |
-| Plan Checker         | {On/Off} |
-| Execution Verifier   | {On/Off} |
-
-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
-```
+Run the interactive settings flow using the `gsd-settings` agent.
 
 </process>
 
 <success_criteria>
-- [ ] Current config read
-- [ ] User presented with 4 settings (profile + 3 toggles)
-- [ ] Config updated with model_profile and workflow section
-- [ ] Changes confirmed to user
+
+- [ ] `.planning/` is validated as an existing GSD project (or a clear error is shown)
+- [ ] Current settings are displayed (active profile, effective models, workflow toggles)
+- [ ] User can update profile and workflow toggles via interactive UI
+- [ ] Updates are persisted to `.planning/config.json`
+- [ ] `opencode.json` is regenerated/updated to reflect effective models
+- [ ] A clear confirmation is shown ("GSD ► SETTINGS UPDATED")
+
 </success_criteria>

package/get-shit-done/references/model-profiles.md

@@ -2,72 +2,103 @@
 
 Model profiles control which OpenCode model each GSD agent uses. This allows balancing quality vs token spend.
 
-## Profile Definitions
-
-| Agent | `quality` | `balanced` | `budget` |
-|-------|-----------|------------|----------|
-| gsd-planner | opus | opus | sonnet |
-| gsd-roadmapper | opus | sonnet | sonnet |
-| gsd-executor | opus | sonnet | sonnet |
-| gsd-phase-researcher | opus | sonnet | haiku |
-| gsd-project-researcher | opus | sonnet | haiku |
-| gsd-research-synthesizer | sonnet | sonnet | haiku |
-| gsd-debugger | opus | sonnet | sonnet |
-| gsd-codebase-mapper | sonnet | haiku | haiku |
-| gsd-verifier | sonnet | sonnet | haiku |
-| gsd-plan-checker | sonnet | sonnet | haiku |
-| gsd-integration-checker | sonnet | sonnet | haiku |
+## Stage-to-Agent Mapping
+
+Agents are grouped by stage. Each profile assigns a model to each stage:
+
+| 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, gsd-set-profile, gsd-settings |
+
+## Profile Configuration
+
+Models are **user-configured**, not hardcoded. OpenCode supports multiple providers (Anthropic, OpenAI, local models, etc.), so available models vary per installation.
+
+On first run, `/gsd-settings` runs the **Preset Setup Wizard**:
+
+1. Queries `opencode models` to discover available models
+2. Prompts user to select models for each profile/stage combination
+3. Saves to `.planning/config.json`
+
+Configuration structure:
+
+```json
+{
+  "profiles": {
+    "active_profile": "balanced",
+    "presets": {
+      "quality": { "planning": "...", "execution": "...", "verification": "..." },
+      "balanced": { "planning": "...", "execution": "...", "verification": "..." },
+      "budget": { "planning": "...", "execution": "...", "verification": "..." }
+    }
+  }
+}
+```
 
 ## Profile Philosophy
 
+When configuring presets, consider these guidelines:
+
 **quality** - Maximum reasoning power
-- Opus for all decision-making agents
-- Sonnet for read-only verification
+
+- Use your most capable model for all stages
 - Use when: quota available, critical architecture work
 
 **balanced** (default) - Smart allocation
-- Opus only for planning (where architecture decisions happen)
-- Sonnet for execution and research (follows explicit instructions)
-- Sonnet for verification (needs reasoning, not just pattern matching)
+
+- Strong model for planning (where architecture decisions happen)
+- Mid-tier model for execution (follows explicit instructions)
+- Mid-tier model for verification (needs reasoning, not just pattern matching)
 - Use when: normal development, good balance of quality and cost
 
-**budget** - Minimal Opus usage
-- Sonnet for anything that writes code
-- Haiku for research and verification
+**budget** - Minimal token spend
+
+- Mid-tier model for anything that writes code
+- Lightweight model for research and verification
 - Use when: conserving quota, high-volume work, less critical phases
 
 ## Resolution Logic
 
 Orchestrators resolve model before spawning:
 
+```text
+1. Read .planning/config.json
+2. Get active_profile (default: "balanced")
+3. Look up preset[profile][stage] for the agent's stage
+4. Apply any custom_overrides[profile][stage] if set
+5. Pass model parameter to Task call
 ```
-1. read .planning/config.json
-2. Get model_profile (default: "balanced")
-3. Look up agent in table above
-4. Pass model parameter to Task call
-```
+
+Agent-to-model mappings are written to `opencode.json` by `/gsd-set-profile` and `/gsd-settings`.
 
 ## Switching Profiles
 
 Runtime: `/gsd-set-profile <profile>`
 
-Per-project default: Set in `.planning/config.json`:
+Interactive settings: `/gsd-settings`
+
+Per-project default stored in `.planning/config.json`:
+
 ```json
 {
-  "model_profile": "balanced"
+  "profiles": {
+    "active_profile": "balanced"
+  }
 }
 ```
 
 ## Design Rationale
 
-**Why Opus for gsd-planner?**
+**Why use your strongest model for planning?**
 Planning involves architecture decisions, goal decomposition, and task design. This is where model quality has the highest impact.
 
-**Why Sonnet for gsd-executor?**
+**Why mid-tier for execution?**
 Executors follow explicit PLAN.md instructions. The plan already contains the reasoning; execution is implementation.
 
-**Why Sonnet (not Haiku) for verifiers in balanced?**
-Verification requires goal-backward reasoning - checking if code *delivers* what the phase promised, not just pattern matching. Sonnet handles this well; Haiku may miss subtle gaps.
+**Why mid-tier (not lightweight) for verification?**
+Verification requires goal-backward reasoning - checking if code *delivers* what the phase promised, not just pattern matching. Mid-tier models handle this well; lightweight models may miss subtle gaps.
 
-**Why Haiku for gsd-codebase-mapper?**
-read-only exploration and pattern extraction. No reasoning required, just structured output from file contents.
+**Why lightweight for codebase mapping?**
+Read-only exploration and pattern extraction. No complex reasoning required, just structured output from file contents.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gsd-opencode",
-  "version": "1.9.1",
+  "version": "1.9.2",
   "description": "A meta-prompting, context engineering and spec-driven development system for OpenCode by TÂCHES.",
   "keywords": [
     "opencode",