gsd-opencode 1.9.0 → 1.9.2

package/agents/gsd-settings.md

@@ -0,0 +1,303 @@
+---
+name: gsd-settings
+description: Interactive settings for model profiles, per-stage overrides, and workflow settings
+tools:
+  read: true
+  write: true
+  bash: true
+  question: true
+---
+
+<role>
+You are executing the `/gsd-settings` command. Display current model profile settings and provide an interactive menu to manage them.
+
+Files managed:
+
+- `.planning/config.json` — profile state and workflow toggles (source of truth)
+- `opencode.json` — agent model assignments (derived from config.json)
+
+Do NOT modify agent .md files.
+</role>
+
+<context>
+**Stage-to-agent mapping:**
+
+- **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, gsd-set-model
+
+**Model discovery:** Presets are user-defined, not hardcoded. On first run (or reset), query `opencode models` to discover available models and prompt user to configure presets.
+</context>
+
+<rules>
+**UI Rules (apply throughout):**
+
+- Always use the Question tool for user input — never print menus as text
+- Custom/freeform answers are not allowed; re-prompt on invalid selection
+- Apply changes immediately without extra confirmation prompts
+- After any action except Exit, return to the main menu (Step 3 → Step 4)
+
+**Config Rules:**
+
+- Never overwrite existing presets — only create defaults for new/migrated projects
+- Keep `model_profile` in sync with `profiles.active_profile`
+- Merge into existing `opencode.json` (preserve non-agent keys)
+</rules>
+
+<behavior>
+
+## Step 1: Load Config
+
+```bash
+ls .planning/ 2>/dev/null
+```
+
+If `.planning/` not found: print `Error: No GSD project found. Run /gsd-new-project first.` and stop.
+
+```bash
+cat .planning/config.json 2>/dev/null
+```
+
+Handle config state:
+
+- **Missing/invalid:** Run **Preset Setup Wizard** (see below), then continue
+- **Legacy (no `profiles` key):** Run **Preset Setup Wizard**, preserve other existing keys
+- **Current:** Use as-is
+
+Ensure `workflow` section exists (defaults: `research: true`, `plan_check: true`, `verifier: true`).
+
+### Preset Setup Wizard
+
+This wizard runs on first use or when "Reset presets" is selected. It queries available models and lets the user configure all three profiles.
+
+**Step W1: Discover models**
+
+```bash
+opencode models 2>/dev/null
+```
+
+Parse the output to extract model IDs. If command fails or returns no models, print `Error: Could not fetch available models. Check your OpenCode installation.` and stop.
+
+**Step W2: Configure each profile**
+
+For each profile (quality, balanced, budget), use a multi-question call:
+
+```json
+[
+  { "header": "{Profile} Profile - Planning", "question": "Which model for planning agents?", "options": ["{model1}", "{model2}", ...] },
+  { "header": "{Profile} Profile - Execution", "question": "Which model for execution agents?", "options": ["{model1}", "{model2}", ...] },
+  { "header": "{Profile} Profile - Verification", "question": "Which model for verification agents?", "options": ["{model1}", "{model2}", ...] }
+]
+```
+
+**Step W3: Save config**
+
+Create config with user selections:
+
+```json
+{
+  "profiles": {
+    "active_profile": "balanced",
+    "presets": {
+      "quality": { "planning": "{user_selection}", "execution": "{user_selection}", "verification": "{user_selection}" },
+      "balanced": { "planning": "{user_selection}", "execution": "{user_selection}", "verification": "{user_selection}" },
+      "budget": { "planning": "{user_selection}", "execution": "{user_selection}", "verification": "{user_selection}" }
+    },
+    "custom_overrides": { "quality": {}, "balanced": {}, "budget": {} }
+  },
+  "workflow": { "research": true, "plan_check": true, "verifier": true }
+}
+```
+
+Print:
+
+```text
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ GSD ► PRESETS CONFIGURED
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Your model presets have been saved. Use "Reset presets" 
+from the settings menu if available models change.
+
+Note: Quit and relaunch OpenCode to apply model changes.
+```
+
+## Step 2: Compute Effective Models
+
+```text
+activeProfile = config.profiles.active_profile
+preset = config.profiles.presets[activeProfile]
+overrides = config.profiles.custom_overrides[activeProfile] || {}
+
+effective.planning = overrides.planning || preset.planning
+effective.execution = overrides.execution || preset.execution
+effective.verification = overrides.verification || preset.verification
+```
+
+A stage is "overridden" if `overrides[stage]` exists and differs from `preset[stage]`.
+
+## Step 3: Display State
+
+**Print this as text output (do NOT use Question tool here):**
+
+```text
+Active profile: {activeProfile}
+
+| Stage        | Model                                    |
+|--------------|------------------------------------------|
+| planning     | {effective.planning}{* if overridden}   |
+| execution    | {effective.execution}{* if overridden}  |
+| verification | {effective.verification}{* if overridden}|
+
+{if any overridden: "* = overridden" else: "No overrides"}
+
+Workflow:
+| Toggle     | Value                  |
+|------------|------------------------|
+| research   | {workflow.research}    |
+| plan_check | {workflow.plan_check}  |
+| verifier   | {workflow.verifier}    |
+```
+
+## Step 4: Show Menu
+
+Use Question tool (single prompt, not multi-question):
+
+```
+header: "GSD Settings"
+question: "Choose an action"
+options:
+  - label: "Quick settings"
+    description: "Update profile and workflow toggles"
+  - label: "Set stage override"
+    description: "Set a per-stage model override for the active profile"
+  - label: "Clear stage override"
+    description: "Remove a per-stage override for the active profile"
+  - label: "Reset presets"
+    description: "Re-run model discovery and reconfigure all presets (clears overrides)"
+  - label: "Exit"
+    description: "Save and quit"
+```
+
+## Step 5: Handle Actions
+
+### Quick settings
+
+Use multi-question call with pre-selected current values:
+
+```json
+[
+  { "header": "Model", "question": "Which model profile?", "options": ["Quality", "Balanced", "Budget"] },
+  { "header": "Research", "question": "Spawn Plan Researcher?", "options": ["Yes", "No"] },
+  { "header": "Plan Check", "question": "Spawn Plan Checker?", "options": ["Yes", "No"] },
+  { "header": "Verifier", "question": "Spawn Execution Verifier?", "options": ["Yes", "No"] }
+]
+```
+
+On selection:
+
+- Map: Quality→`quality`, Balanced→`balanced`, Budget→`budget`
+- Set `profiles.active_profile`, `model_profile`, and `workflow.*` accordingly
+- Quick settings does NOT modify `presets` or `custom_overrides`
+- If nothing changed, print `No changes.` and return to menu
+- Otherwise save and print confirmation banner:
+
+```text
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ GSD ► SETTINGS UPDATED
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+| Setting            | Value                     |
+|--------------------|---------------------------|
+| Model Profile      | {quality|balanced|budget} |
+| Plan Researcher    | {On/Off}                  |
+| Plan Checker       | {On/Off}                  |
+| Execution Verifier | {On/Off}                  |
+
+Note: Quit and relaunch OpenCode to apply model changes.
+
+Quick commands:
+- /gsd-set-profile <profile>
+- /gsd-plan-phase --research | --skip-research | --skip-verify
+```
+
+### Set stage override
+
+1. Pick stage: Planning / Execution / Verification / Cancel
+2. If Cancel, return to menu
+3. Fetch models via `opencode models` command
+4. If command fails: print error and stop
+5. Pick model from list (include Cancel option)
+6. Set `custom_overrides[activeProfile][stage]` = model
+7. Save, print "Saved", return to menu
+
+### Clear stage override
+
+If no overrides exist for current profile, print `No overrides set for {activeProfile} profile.` and return to menu immediately.
+
+Otherwise:
+
+1. Print current overrides:
+
+```text
+Current overrides for {activeProfile} profile:
+- planning: {model} (or omit if not overridden)
+- execution: {model} (or omit if not overridden)
+- verification: {model} (or omit if not overridden)
+```
+
+2. Pick stage: Planning / Execution / Verification / Cancel (only show stages that have overrides)
+3. If Cancel, return to menu
+4. Delete `custom_overrides[activeProfile][stage]`
+5. Save, print "Cleared {stage} override.", return to menu
+
+### Reset presets
+
+Run the **Preset Setup Wizard** (see Step 1). This re-queries available models and lets the user reconfigure all three profiles from scratch. Existing `custom_overrides` are cleared. After completion, return to menu.
+
+### Exit
+
+Print "Settings saved." and stop.
+
+## Save Changes
+
+After any change, use the **write tool directly** to update both files. Do NOT use bash, python, or other scripts—use native file writing.
+
+1. Read existing `opencode.json` (if it exists) to preserve non-agent keys
+2. Write `.planning/config.json` with updated config
+3. Write `opencode.json` with merged agent mappings:
+
+```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}" },
+    "gsd-set-profile": { "model": "{effective.verification}" },
+    "gsd-settings": { "model": "{effective.verification}" },
+    "gsd-set-model": { "model": "{effective.verification}" }
+  }
+}
+```
+
+Preserve existing non-agent keys in `opencode.json`.
+
+</behavior>
+
+<notes>
+
+- Menu loop until Exit — always return to Step 3 after actions
+- Overrides are profile-scoped: `custom_overrides.{profile}.{stage}`
+- Source of truth: `config.json`; `opencode.json` is derived
+- OpenCode does not hot-reload model assignments; user must quit and relaunch to apply changes
+
+</notes>

package/bin/install.js

@@ -126,10 +126,25 @@ function copyWithPathReplacement(srcDir, destDir, pathPrefix) {
     if (entry.isDirectory()) {
       copyWithPathReplacement(srcPath, destPath, pathPrefix);
     } else if (entry.name.endsWith(".md")) {
-      // Replace ~/.claude/ and ./.claude/ with OpenCode paths
+      // Replace repo-local prompt references so installed prompts work outside this repo.
+      // IMPORTANT: order matters to avoid double-rewrites.
       let content = fs.readFileSync(srcPath, "utf8");
+
+      // 1) @-references to this repo → install-relative @-references
+      //    @gsd-opencode/... → @~/.config/opencode/... (global)
+      //    @gsd-opencode/... → @./.opencode/... (local)
+      content = content.replace(/@gsd-opencode\//g, `@${pathPrefix}`);
+
+      // 2) Plain (non-@) repo-local paths → install-relative paths
+      //    gsd-opencode/... → ~/.config/opencode/... (global)
+      //    gsd-opencode/... → ./.opencode/... (local)
+      content = content.replace(/\bgsd-opencode\//g, pathPrefix);
+
+      // 3) Back-compat: rewrite legacy Claude paths → OpenCode paths
+      // NOTE: keep these rewrites verbatim for backward compatibility.
       content = content.replace(/~\/\.claude\//g, pathPrefix);
       content = content.replace(/\.\/\.claude\//g, "./.opencode/");
+
       fs.writeFileSync(destPath, content);
     } else {
       fs.copyFileSync(srcPath, destPath);
@@ -164,6 +179,68 @@ function install(isGlobal) {
       : "~/.config/opencode/"
     : "./.opencode/";
 
+  function scanForUnresolvedRepoLocalTokens(destRoot) {
+    const tokenRegex = /@gsd-opencode\/|\bgsd-opencode\//g;
+    const maxHits = 10;
+    const hits = [];
+
+    function walk(dir) {
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (hits.length >= maxHits) return;
+
+        const filePath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+          walk(filePath);
+          continue;
+        }
+
+        if (!entry.name.endsWith(".md")) continue;
+
+        const content = fs.readFileSync(filePath, "utf8");
+        tokenRegex.lastIndex = 0;
+        if (!tokenRegex.test(content)) continue;
+
+        // Capture a readable snippet (first matching line)
+        const lines = content.split(/\r?\n/);
+        for (let i = 0; i < lines.length; i++) {
+          tokenRegex.lastIndex = 0;
+          if (tokenRegex.test(lines[i])) {
+            hits.push({
+              file: filePath,
+              line: i + 1,
+              snippet: lines[i].trim().slice(0, 200),
+            });
+            break;
+          }
+        }
+      }
+    }
+
+    walk(destRoot);
+
+    if (hits.length > 0) {
+      console.log(
+        `\n  ${yellow}⚠️  Install sanity check: unresolved repo-local tokens found${reset}`,
+      );
+      console.log(
+        `  ${yellow}This may cause commands like /gsd-settings to fail in other repos (ENOENT).${reset}`,
+      );
+      console.log(`  ${dim}Showing up to ${maxHits} matches:${reset}`);
+
+      for (const hit of hits) {
+        const displayPath = isGlobal
+          ? hit.file.replace(os.homedir(), "~")
+          : hit.file.replace(process.cwd(), ".");
+        console.log(
+          `  - ${displayPath}:${hit.line}\n    ${dim}${hit.snippet}${reset}`,
+        );
+      }
+
+      console.log("");
+    }
+  }
+
   console.log(`  Installing to ${cyan}${locationLabel}${reset}\n`);
 
   // Create commands directory (singular "command" not "commands")
@@ -188,6 +265,9 @@ function install(isGlobal) {
   copyWithPathReplacement(skillSrc, skillDest, pathPrefix);
   console.log(`  ${green}✓${reset} Installed get-shit-done`);
 
+  // Post-install diagnostic (do not fail install).
+  scanForUnresolvedRepoLocalTokens(opencodeDir);
+
   // Create VERSION file
   fs.writeFileSync(path.join(skillDest, "VERSION"), `v${pkg.version}`);
   console.log(`  ${green}✓${reset} Created VERSION file`);

package/command/gsd/insert-phase.md

@@ -1,6 +1,6 @@
 ---
 name: gsd-insert-phase
-description: Insert urgent work as decimal phase (e.g., 72.1) between existing phases
+description: Insert urgent work (e.g., "72.1 quick fix" - immediately after 72.1 phase)
 argument-hint: <after> <description>
 tools:
   - read

package/command/gsd/new-project.md

@@ -327,9 +327,9 @@ questions: [
     question: "Which AI models for planning agents?",
     multiSelect: false,
     options: [
-      { label: "Balanced (Recommended)", description: "Sonnet for most agents — good quality/cost ratio" },
-      { label: "Quality", description: "Opus for research/roadmap — higher cost, deeper analysis" },
-      { label: "Budget", description: "Haiku where possible — fastest, lowest cost" }
+      { label: "Balanced", description: "planning/verifier: opencode/glm-4.7-free, execution: opencode/minimax-m2.1-free" },
+      { label: "Quality", description: "All stages: opencode/glm-4.7-free" },
+      { label: "Budget", description: "planning/verifier: opencode/minimax-m2.1-free, execution: opencode/grok-code" }
     ]
   }
 ]
@@ -344,6 +344,31 @@ Create `.planning/config.json` with all settings:
   "parallelization": true|false,
   "commit_docs": true|false,
   "model_profile": "quality|balanced|budget",
+  "profiles": {
+    "active_profile": "balanced",
+    "presets": {
+      "quality": {
+        "planning": "opencode/glm-4.7-free",
+        "execution": "opencode/glm-4.7-free",
+        "verification": "opencode/glm-4.7-free"
+      },
+      "balanced": {
+        "planning": "opencode/glm-4.7-free",
+        "execution": "opencode/minimax-m2.1-free",
+        "verification": "opencode/glm-4.7-free"
+      },
+      "budget": {
+        "planning": "opencode/minimax-m2.1-free",
+        "execution": "opencode/grok-code",
+        "verification": "opencode/minimax-m2.1-free"
+      }
+    },
+    "custom_overrides": {
+      "quality": {},
+      "balanced": {},
+      "budget": {}
+    }
+  },
   "workflow": {
     "research": true|false,
     "plan_check": true|false,
@@ -374,6 +399,46 @@ EOF
 )"
 ```
 
+**Generate opencode.json from active profile:**
+
+Create `opencode.json` in the project root. This is a derived config that assigns a model to each GSD agent.
+
+Use the effective stage models from `.planning/config.json`:
+
+- planning model = `profiles.presets.{active_profile}.planning` (unless overridden)
+- execution model = `profiles.presets.{active_profile}.execution` (unless overridden)
+- verification model = `profiles.presets.{active_profile}.verification` (unless overridden)
+
+Write `opencode.json`:
+
+```json
+{
+  "$schema": "https://opencode.ai/config.json",
+  "agent": {
+    "gsd-planner": { "model": "{planning model}" },
+    "gsd-plan-checker": { "model": "{planning model}" },
+    "gsd-phase-researcher": { "model": "{planning model}" },
+    "gsd-roadmapper": { "model": "{planning model}" },
+    "gsd-project-researcher": { "model": "{planning model}" },
+    "gsd-research-synthesizer": { "model": "{planning model}" },
+    "gsd-codebase-mapper": { "model": "{planning model}" },
+    "gsd-executor": { "model": "{execution model}" },
+    "gsd-debugger": { "model": "{execution model}" },
+    "gsd-verifier": { "model": "{verification model}" },
+    "gsd-integration-checker": { "model": "{verification model}" }
+  }
+}
+```
+
+**Commit opencode.json:**
+
+```bash
+git add opencode.json
+git commit -m "chore: configure opencode agent models"
+```
+
+**Important:** OpenCode loads `opencode.json` at session start and does not hot-reload. If you change profiles later via `/gsd-set-profile` or `/gsd-settings`, run `/new` (or restart OpenCode) for it to take effect.
+
 **Note:** Run `/gsd-settings` anytime to update these preferences.
 
 ## Phase 5.5: Resolve Model Profile

package/command/gsd/set-model.md

@@ -0,0 +1,77 @@
+---
+name: gsd-set-model
+description: Configure models for a specific profile's stages (planning/execution/verification)
+arguments:
+  - name: profile
+    description: "Profile name: quality, balanced, or budget (optional - will prompt if not provided)"
+    required: false
+agent: gsd-set-model
+tools:
+  - read
+  - write
+  - bash
+  - question
+---
+
+<objective>
+Configure the models assigned to each stage (planning, execution, verification) for a specific profile.
+
+Unlike `/gsd-set-profile` which switches between profiles, this command lets you define *what models* a profile uses. Implementation lives in the `gsd-set-model` agent.
+</objective>
+
+<process>
+
+Run the model configuration flow using the `gsd-set-model` agent.
+
+</process>
+
+<examples>
+
+**Configure the balanced profile:**
+
+```text
+/gsd-set-model balanced
+
+Configuring models for: balanced
+
+Select model for Planning stage:
+> anthropic/claude-sonnet-4-20250514
+
+Select model for Execution stage:
+> anthropic/claude-sonnet-4-20250514
+
+Select model for Verification stage:
+> openai/gpt-4o-mini
+
+✓ Updated balanced profile:
+| Stage | Model |
+|-------|-------|
+| planning | anthropic/claude-sonnet-4-20250514 |
+| execution | anthropic/claude-sonnet-4-20250514 |
+| verification | openai/gpt-4o-mini |
+```
+
+**Interactive mode (no argument):**
+
+```text
+/gsd-set-model
+
+Which profile do you want to configure?
+> Balanced
+
+Configuring models for: balanced
+...
+```
+
+</examples>
+
+<success_criteria>
+
+- [ ] `.planning/config.json` exists (or clear error shown)
+- [ ] User selects a profile (or provides via argument)
+- [ ] User selects models for all three stages from available models
+- [ ] Profile preset is updated in `.planning/config.json`
+- [ ] `opencode.json` is regenerated if the modified profile is active
+- [ ] Clear confirmation shown with updated model assignments
+
+</success_criteria>