gsd-opencode 1.20.2 → 1.20.4

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

@@ -3,20 +3,20 @@
 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)
+- `.planning/oc_config.json` — source of truth for profile state (profile_type, stage-to-model mapping)
+- `opencode.json` — agent model assignments (derived from profile; updated automatically by CLI)
+- `opencode.json` — external_directory permissions for reading GSD config folder (added automatically)
 
-Do NOT modify agent .md files. Profile switching updates `opencode.json` in the project root.
+Do NOT modify agent .md files. Profile switching only updates these two JSON files.
 </role>
 
 <context>
-**Invocation styles:**
+## Invocation
 
-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`
+1. **Interactive wizard (no args):** `/gsd-set-profile`
+2. **Direct switch (positional arg):** `/gsd-set-profile simple|smart|genius`
 
-**Stage-to-agent mapping (11 agents):**
+## Stage-to-Agent Mapping (11 agents)
 
 | Stage        | Agents |
 |--------------|--------|
@@ -24,297 +24,161 @@ Do NOT modify agent .md files. Profile switching updates `opencode.json` in the
 | Execution    | gsd-executor, gsd-debugger |
 | Verification | gsd-verifier, gsd-integration-checker |
 
-**Profile types:**
+## 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
+| Profile  | Models | Stage assignment |
+|----------|--------|-----------------|
+| Simple   | 1      | All stages use the same model |
+| Smart    | 2      | Planning + Execution share one model; Verification uses a different model |
+| Genius   | 3      | Each stage uses a 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)
+## Output Format (reused throughout)
 
-
-## Step 3: Display current state
-
-If profile exists:
+When displaying profile state, always use this format:
 
 ```
-Active profile: {profile_type}
+Active profile: **{profile_name}**
 
-Current configuration:
 | Stage        | Model |
 |--------------|-------|
-| planning     | {models.planning} |
-| execution    | {models.execution} |
-| verification | {models.verification} |
+| Planning     | {models.planning} |
+| Execution    | {models.execution} |
+| Verification | {models.verification} |
 ```
+</context>
 
-## Step 4: Determine requested profile
-
-**A) Check for positional argument:**
-- If user typed `/gsd-set-profile simple|smart|genius`, use that as `newProfileType`
+<behavior>
 
-**B) Interactive picker (no args):**
+## Step 0: Ensure GSD config read permission
 
-Use question tool:
+Before any profile operations, ensure opencode.json has permission to read the GSD config folder:
 
+```bash
+node ~/.config/opencode/get-shit-done/bin/gsd-oc-tools.cjs allow-read-config --dry-run
 ```
-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:
+Parse the response:
+- **`success: true` with `action: "permission_exists"`** — Permission already configured. Continue to Step 1.
+- **`success: true` with `action: "add_permission"`** — Permission would be added. Execute without `--dry-run`:
 
+Attempt to switch to the saved profile:
 ```bash
-node gsd-opencode/get-shit-done/bin/gsd-tools.cjs profile-switch {newProfileType} --reuse --raw
+node ~/.config/opencode/get-shit-done/bin/gsd-oc-tools.cjs allow-read-config
 ```
 
-Parse the reuse analysis:
-- Shows which stages can reuse existing models
-- Displays suggestions for each stage
+- **`success: false`** — Handle error appropriately.
 
-Present to user:
+This ensures gsd-opencode can access workflow files, templates, and configuration from `~/.config/opencode/get-shit-done/`.
 
-```
-Model Reuse Analysis for {newProfileType} profile:
+## Step 1: Load current profile
 
-Current models:
-- Planning: {current.planning}
-- Execution: {current.execution}
-- Verification: {current.verification}
+Run `get-profile` to read the current state from `.planning/oc_config.json`:
 
-Suggested reuse:
-{reuse analysis from tool}
-
-Use these suggestions? (yes/no)
+```bash
+node ~/.config/opencode/get-shit-done/bin/gsd-oc-tools.cjs get-profile
 ```
 
-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.
+Parse the JSON response:
 
+- **`success: true`** — Extract `data` (keyed by profile name) containing `planning`, `execution`, `verification` model IDs. Display the profile using the Output Format. Continue to Step 2.
+- **`success: false` with `CONFIG_NOT_FOUND`** — No profile exists yet. Skip display, go directly to Step 2.
 
-### Genius Profile (3 models)
+## Step 2: Determine target profile
 
-Use gsd-oc-select-model skill
+### Path A — Positional argument provided
 
+If the user typed `/gsd-set-profile {type}` where `{type}` is one of `simple`, `smart`, `genius`:
 
-**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:
-
+Attempt to switch to the saved profile:
 ```bash
-opencode models | grep -q "^{model}$" && echo "valid" || echo "invalid"
+node ~/.config/opencode/get-shit-done/bin/gsd-oc-tools.cjs set-profile {type}
 ```
 
-If any model invalid:
-- Print error with list of missing models
-- Stop. Do NOT write config files.
+- **`success: true`** — The profile already has saved model assignments. Display the updated configuration using the Output Format. Print: `Use /gsd-set-profile (without parameter) to change models assigned to stages.` **Stop.**
+- **`PROFILE_NOT_FOUND` error** — No saved models for this profile type. Fall through to Path B (interactive wizard) with the profile type pre-selected (skip the profile type picker, go straight to Step 3).
 
-## Step 8: Apply changes
+### Path B — No argument (interactive wizard)
 
-### Save config.json
-
-Save config.json Or build and save manually:
+Prompt the user to choose a profile type using the question tool:
 
 ```json
 {
-  "profiles": {
-    "profile_type": "{simple|smart|genius}",
-    "models": {
-      "planning": "{model}",
-      "execution": "{model}",
-      "verification": "{model}"
-    }
-  }
+  "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" },
+    { "label": "Genius", "description": "3 models: different model for each stage" },
+    { "label": "Cancel", "description": "Exit without changes" }
+  ]
 }
 ```
 
+- If **Cancel** selected: print cancellation message and **stop**.
+- If invalid profile name was provided as positional arg: print `Unknown profile type '{name}'. Valid options: simple, smart, genius` and show this picker.
 
-## Step 8: Check for changes
+## Step 3: Model selection
 
-If no changes were made (all stages selected "Keep current"):
-```
-No changes made to {targetProfile} profile.
-```
-Stop.
+Based on the selected profile type, collect model choices. If a current profile exists from Step 1, offer to reuse its models where applicable.
 
-## Step 9: Save changes
+### Simple (1 model)
 
-Use the **write tool directly** to update files. Do NOT use bash, python, or other scripts—use native file writing.
+Ask the user (via question tool) if they want to keep the current model (only if one exists from Step 1).
+- **Yes:** Use existing model for all three stages. Go to Step 4.
+- **No** (or no current model exists): Load the `gsd-oc-select-model` skill. Select one model for "Simple Profile - All stages".
 
-1. **Update .planning/config.json:**
+Assign the selected model to `planning`, `execution`, and `verification`.
 
-    - 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)
+### Smart (2 models)
 
-2. **Update opencode.json (only if targetProfile is active):**
+Load the `gsd-oc-select-model` skill, then:
 
-Check if `config.profiles.active_profile === targetProfile`. If so, regenerate `opencode.json` with the new effective models.
+1. Select model for **"Smart Profile - Planning & Execution"** — assign to `planning` and `execution`.
+2. Select model for **"Smart Profile - Verification"** — assign to `verification`.
 
-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
-```
+### Genius (3 models)
 
-Build agent config:
+Load the `gsd-oc-select-model` skill, then:
 
-```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}" },
-  }
-}
-```
+1. Select model for **"Genius Profile - Planning"** — assign to `planning`.
+2. Select model for **"Genius Profile - Execution"** — assign to `execution`.
+3. Select model for **"Genius Profile - Verification"** — assign to `verification`.
 
-If `opencode.json` already exists, merge the `agent` key (preserve other top-level keys).
+## Step 4: Apply changes
 
-## Step 10: Report success
+Using the collected values (`profile_name`, `model_for_planning_stage`, `model_for_execution_stage`, `model_for_verification_stage`), execute:
 
-```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}
+```bash
+node ~/.config/opencode/get-shit-done/bin/gsd-oc-tools.cjs set-profile '{profile_name}:{"planning": "{model_for_planning_stage}", "execution": "{model_for_execution_stage}", "verification": "{model_for_verification_stage}"}'
 ```
 
-</behavior>
+Parse the response. On success, the CLI updates both `.planning/oc_config.json` and `opencode.json` (with automatic backup).
 
+## Step 5: Confirm result
 
-Parse output and write to `opencode.json`, merging with existing content.
+Display the updated profile using the Output Format, prefixed with a checkmark:
 
-Note: Quit and relaunch OpenCode to apply model changes.
 ```
+Done! Updated {profile_name} profile:
 
-If migration occurred:
-```
-⚡ Auto-migrated from {old_profile} to genius profile
+| Stage        | Model |
+|--------------|-------|
+| Planning     | {models.planning} |
+| Execution    | {models.execution} |
+| Verification | {models.verification} |
 ```
 
+We just updated the `./opencode.json` file. Apply the agent settings you need to **restart your opencode**.
+
+Note: GSD config read permission has been configured to allow access to `~/.config/opencode/get-shit-done/`.
+
 </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 
+- Use the question tool for ALL user input — never prompt via text.
+- Always display full model IDs (e.g., `bailian-coding-plan/qwen3-coder-plus`), never abbreviate.
+- All file reads/writes go through `gsd-oc-tools.cjs` — do not manually edit JSON files.
+- Backups are created automatically by the CLI when writing changes.
+- `.planning/oc_config.json` is the source of truth; `opencode.json` is always derived from it.
+- The `gsd-oc-select-model` skill handles paginated provider/model browsing — load it via the skill tool when model selection is needed.
 </notes>

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

@@ -45,7 +45,7 @@ question([
     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" }
+      { label: "Genius (most flexible)", description: "Three models: different for every stage" }
     ]
   },
   {
@@ -113,7 +113,7 @@ Merge new settings into existing config.json:
 ```json
 {
   ...existing_config,
-  "model_profile": "simple" | "smart" | "custom",
+  "model_profile": "simple" | "smart" | "genius",
   "workflow": {
     "research": true/false,
     "plan_check": true/false,
@@ -128,6 +128,7 @@ Merge new settings into existing config.json:
 ```
 
 write updated config to `.planning/config.json`.
+
 </step>
 
 <step name="save_as_defaults">
@@ -183,7 +184,7 @@ Display:
 
 | Setting              | Value |
 |----------------------|-------|
-| Model Profile        | {simple/smart/custom} |
+| Model Profile        | {simple/smart/genius} |
 | Plan Researcher      | {On/Off} |
 | Plan Checker         | {On/Off} |
 | Execution Verifier   | {On/Off} |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gsd-opencode",
-  "version": "1.20.2",
+  "version": "1.20.4",
   "description": "GSD-OpenCode distribution manager - install, verify, and maintain your GSD-OpenCode installation",
   "type": "module",
   "main": "bin/gsd.js",
@@ -51,6 +51,6 @@
     "ora": "^9.3.0"
   },
   "devDependencies": {
-    "vitest": "^3.0.0"
+    "vitest": "^3.2.4"
   }
 }