@tudeorangbiasa/sdd-multiagent-opencode 0.3.1 → 0.4.1

package/.opencode/commands/sdd-construct.md

@@ -177,10 +177,10 @@ Ask:
 
 > Explainer: SDD routes different agents to different models. Paid models get planning and orchestration roles. Free models get implementation and exploration roles. This section configures that routing.
 
-Present the default model profile (from `.sdd/templates/model-profile-template.json`) and ask:
+Read `~/.config/opencode/sdd-multiagent-opencode.json` and summarize the current global routing. If the file is missing or still uses defaults, ask:
 1. **Do you have a paid model subscription?** (OpenAI Plus, OpenCode Go, OpenCode Zen, or direct API keys)
 2. **If yes, which provider?** This determines which agents get routed to paid models.
-3. **If no, accept the free-model defaults.** Implementation will still work but planning may be slower.
+3. **If no, keep the free-model defaults.** Implementation will still work but planning may be slower.
 
 ### Section D — Issue Tracker (ALL types)
 
@@ -293,18 +293,13 @@ If Phase 1 used the sniff test (no subagent spawned), write the stack profile no
 
 This ensures `.sdd/stack-profile.json` always exists after `/sdd-construct`, regardless of whether a subagent was used.
 
-### 3.2 `.sdd/model-profile.json`
+### 3.2 Global SDD config
 
-Populate the template with model routing based on Phase 2 Section C:
-- If user has paid subscription → route orchestrator and planner to paid model
-- If user has no paid subscription → use free model defaults
-- Keep explorer, implementer, verifier, reviewer on free models
+Do not create per-project model or reasoning profiles. SDD runtime configuration lives in `~/.config/opencode/sdd-multiagent-opencode.json`.
 
-### 3.3 `.sdd/reasoning-profile.json`
+If the global config is missing, report it and suggest creating it. Do not write outside the project unless the user explicitly asks.
 
-Copy the template. No changes needed — defaults are appropriate for all project sizes.
-
-### 3.4 `CONTEXT.md` (at repo root)
+### 3.3 `CONTEXT.md` (at repo root)
 
 Create the domain glossary. Format:
 
@@ -627,8 +622,7 @@ Before reporting completion, verify:
 ### Universal checks (ALL project types):
 - [ ] `.sdd/stack-profile.json` exists (written by explorer or by planner after sniff test)
 - [ ] `.sdd/project-profile.json` exists and has non-null values for detected stack
-- [ ] `.sdd/model-profile.json` exists and has agent routing configured
-- [ ] `.sdd/reasoning-profile.json` exists
+- [ ] `~/.config/opencode/sdd-multiagent-opencode.json` exists or missing global config was reported
 - [ ] `CONTEXT.md` exists at repo root (even if empty tables)
 - [ ] `docs/adr/0001-project-initialization.md` exists
 - [ ] `AGENTS.md` or `CLAUDE.md` has `## Agent skills` block
@@ -657,7 +651,7 @@ Before final output, verify:
 - [ ] Grilling questions were asked one at a time (not dumped all at once)
 - [ ] CONTEXT.md contains domain terms from the grilling session, not generic placeholders
 - [ ] ADR documents actual decisions made during the session
-- [ ] Model routing reflects user's subscription status, not defaults
+- [ ] Global model routing reflects user's subscription status, or missing global config was reported
 - [ ] No file paths or code snippets in CONTEXT.md
 - [ ] Type-specific guardrails match classified project type
 - [ ] No DESIGN.md generated for non-UI projects (backend, library, cli)
@@ -675,8 +669,6 @@ changed: SDD project initialized
 Artifacts created:
 - `.sdd/stack-profile.json` — raw stack detection results (from explorer or sniff test)
 - `.sdd/project-profile.json` — stack detection results
-- `.sdd/model-profile.json` — model routing configuration
-- `.sdd/reasoning-profile.json` — reasoning effort per agent
 - `CONTEXT.md` — domain glossary
 - `docs/adr/0001-project-initialization.md` — initialization decisions
 - `docs/agents/issue-tracker.md` — issue tracker configuration

package/.opencode/plugins/sdd-auto-reasoning.js

@@ -1,11 +1,23 @@
 import fs from "node:fs";
 import path from "node:path";
-import { fileURLToPath } from "node:url";
 
-const pluginDir = path.dirname(fileURLToPath(import.meta.url));
 const LEVELS = new Set(["low", "medium", "high"]);
 const pendingOverrides = new Map();
 const recentCommands = new Map();
+const globalConfigPath = path.join(
+  process.env.HOME || process.env.USERPROFILE || "",
+  ".config",
+  "opencode",
+  "sdd-multiagent-opencode.json"
+);
+
+const DEFAULT_REASONING = {
+  default: "low",
+  applyProviderOptions: true,
+  resetToolOverrideAfterNextRequest: true,
+  agents: {},
+  commands: {},
+};
 
 function readJson(filePath) {
   if (!fs.existsSync(filePath)) return null;
@@ -18,24 +30,8 @@ function readJson(filePath) {
 }
 
 function readProfile() {
-  const candidates = [
-    path.join(process.cwd(), ".sdd", "reasoning-profile.json"),
-    path.join(pluginDir, "..", "..", ".sdd", "reasoning-profile.json"),
-    path.join(pluginDir, "..", ".sdd", "reasoning-profile.json"),
-  ];
-
-  for (const candidate of candidates) {
-    const profile = readJson(candidate);
-    if (profile) return profile;
-  }
-
-  return {
-    default: "low",
-    applyProviderOptions: true,
-    resetToolOverrideAfterNextRequest: true,
-    agents: {},
-    commands: {},
-  };
+  const pluginConfig = readJson(globalConfigPath);
+  return pluginConfig?.reasoning ?? DEFAULT_REASONING;
 }
 
 function normalizeLevel(level, fallback = "low") {

package/.opencode/plugins/sdd-model-router.js

@@ -1,57 +1,96 @@
 import fs from "node:fs";
 import path from "node:path";
-import { fileURLToPath } from "node:url";
-
-const pluginDir = path.dirname(fileURLToPath(import.meta.url));
-
-function readProfile() {
-  const candidates = [
-    path.join(process.cwd(), ".sdd", "model-profile.json"),
-    path.join(pluginDir, "..", "..", ".sdd", "model-profile.json"),
-    path.join(pluginDir, "..", ".sdd", "model-profile.json"),
-  ];
-
-  for (const profilePath of candidates) {
-    if (!fs.existsSync(profilePath)) {
-      continue;
-    }
-
-    try {
-      return JSON.parse(fs.readFileSync(profilePath, "utf-8"));
-    } catch {
-      return null;
-    }
+
+const globalConfigPath = path.join(
+  process.env.HOME || process.env.USERPROFILE || "",
+  ".config",
+  "opencode",
+  "sdd-multiagent-opencode.json"
+);
+const DEFAULT_PLUGIN_CONFIG = {
+  model: "openai/gpt-5.5",
+  small_model: "opencode/deepseek-v4-flash-free",
+  agent: {
+    "sdd-orchestrator": { model: "openai/gpt-5.5" },
+    "sdd-planner": { model: "openai/gpt-5.5" },
+    "sdd-explorer": { model: "opencode/deepseek-v4-flash-free" },
+    "sdd-implementer": { model: "opencode/deepseek-v4-flash-free" },
+    "sdd-verifier": { model: "opencode/qwen3.6-plus-free" },
+    "sdd-reviewer": { model: "opencode/minimax-m2.5-free" },
+    "sdd-quick": { model: "opencode/qwen3.6-plus-free" },
+  },
+  reasoning: {
+    default: "low",
+    applyProviderOptions: true,
+    resetToolOverrideAfterNextRequest: true,
+    agents: {
+      general: "medium",
+      plan: "high",
+      "sdd-orchestrator": "high",
+      "sdd-planner": "high",
+      "sdd-explorer": "low",
+      "sdd-implementer": "medium",
+      "sdd-verifier": "medium",
+      "sdd-reviewer": "medium",
+      "sdd-quick": "low",
+    },
+    commands: {
+      "sdd-explore": "medium",
+      "sdd-propose": "high",
+      "sdd-apply": "medium",
+      "sdd-ship": "medium",
+      "sdd-quick": "low",
+    },
+  },
+};
+
+function ensureConfigFile() {
+  if (fs.existsSync(globalConfigPath)) return;
+
+  try {
+    fs.mkdirSync(path.dirname(globalConfigPath), { recursive: true });
+    fs.writeFileSync(globalConfigPath, `${JSON.stringify(DEFAULT_PLUGIN_CONFIG, null, 2)}\n`);
+  } catch {
+    // If the global config cannot be seeded, continue with OpenCode's existing config.
   }
+}
 
-  return null;
+function readConfig() {
+  ensureConfigFile();
+  if (!fs.existsSync(globalConfigPath)) return null;
+
+  try {
+    return JSON.parse(fs.readFileSync(globalConfigPath, "utf-8"));
+  } catch {
+    return null;
+  }
 }
 
 export default async () => {
   return {
     config: (cfg) => {
-      const profile = readProfile();
-      if (!profile) {
+      const pluginConfig = readConfig();
+      if (!pluginConfig) {
         return;
       }
 
-      if (profile.defaultPrimary) {
-        cfg.model = profile.defaultPrimary;
+      if (pluginConfig.model) {
+        cfg.model = pluginConfig.model;
       }
 
-      if (profile.small) {
-        cfg.small_model = profile.small;
+      if (pluginConfig.small_model) {
+        cfg.small_model = pluginConfig.small_model;
       }
 
       if (!cfg.agent) {
         cfg.agent = {};
       }
 
-      for (const [agentName, model] of Object.entries(profile.agents ?? {})) {
-        if (!cfg.agent[agentName]) {
-          cfg.agent[agentName] = {};
-        }
+      for (const [agentName, agentConfig] of Object.entries(pluginConfig.agent ?? {})) {
+        if (!agentConfig?.model) continue;
+        if (!cfg.agent[agentName]) continue;
 
-        cfg.agent[agentName].model = model;
+        cfg.agent[agentName].model = agentConfig.model;
       }
     },
   };

package/.opencode/plugins/sdd-register.js

@@ -1,6 +1,8 @@
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+import sddAutoReasoning from "./sdd-auto-reasoning.js";
+import sddModelRouter from "./sdd-model-router.js";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -71,7 +73,9 @@ removeOldSymlinks();
 
 const AGENTS = {
   "sdd-orchestrator": {
+    description: "Internal coordination agent for complex SDD changes. Used by SDD commands when work needs multi-agent scheduling.",
     mode: "subagent",
+    hidden: true,
     temperature: 0.3,
     permission: {
       edit: "allow",
@@ -113,7 +117,9 @@ Return a concise coordination summary with completed work, blocked work, file co
   },
 
   "sdd-planner": {
+    description: "Creates compact SDD proposal, spec, design, and task artifacts for /sdd-propose and /sdd-construct.",
     mode: "subagent",
+    hidden: true,
     temperature: 0.3,
     permission: {
       edit: "allow",
@@ -171,7 +177,9 @@ For heavy apps (monorepo, microservices, multi-team): Include optional sections:
   },
 
   "sdd-explorer": {
+    description: "Readonly codebase exploration for /sdd-explore and uncertain SDD planning requests.",
     mode: "subagent",
+    hidden: true,
     temperature: 0.1,
     permission: {
       edit: "deny",
@@ -232,7 +240,9 @@ Return findings as:
   },
 
   "sdd-implementer": {
+    description: "Systematic implementation agent for approved /sdd-apply changes and /sdd-quick edits.",
     mode: "subagent",
+    hidden: true,
     temperature: 0.3,
     permission: {
       edit: "allow",
@@ -281,7 +291,9 @@ Use the question tool for ambiguous requirements or missing information.
   },
 
   "sdd-verifier": {
+    description: "Independent SDD validation agent for implementation completeness, tests, and UI/browser checks.",
     mode: "subagent",
+    hidden: true,
     temperature: 0.1,
     permission: {
       edit: "deny",
@@ -339,7 +351,9 @@ For each acceptance criterion, find implementing code and verify it meets the cr
   },
 
   "sdd-reviewer": {
+    description: "Final SDD review agent for /sdd-ship readiness, security, performance, and spec compliance.",
     mode: "subagent",
+    hidden: true,
     temperature: 0.2,
     permission: {
       edit: "deny",
@@ -478,7 +492,7 @@ After presenting findings, walk the user through decisions one at a time. Do not
 3. Team size: solo, small team (2-5), or large team (5+)?
 
 ### Section C — Model Budget (ALL types)
-Present the default model profile and ask about paid model subscriptions.
+Explain that SDD model and reasoning routing are configured globally in ~/.config/opencode/sdd-multiagent-opencode.json. Ask about paid model subscriptions only if the global config is missing or obviously still using defaults.
 
 ### Section D — Issue Tracker (ALL types)
 Options: GitHub, GitLab, Local markdown, Other.
@@ -495,7 +509,7 @@ Options: GitHub, GitLab, Local markdown, Other.
 
 ## Phase 3: Scaffold Artifacts
 
-Generate: .sdd/project-profile.json, .sdd/stack-profile.json, .sdd/model-profile.json, .sdd/reasoning-profile.json, CONTEXT.md, docs/adr/0001-project-initialization.md, type-specific artifacts, docs/agents/issue-tracker.md, and update AGENTS.md with agent skills block.
+Generate: .sdd/project-profile.json, .sdd/stack-profile.json, CONTEXT.md, docs/adr/0001-project-initialization.md, type-specific artifacts, docs/agents/issue-tracker.md, and update AGENTS.md with agent skills block. Do not create per-project model or reasoning profiles.
 
 ## Phase 4: Verification
 
@@ -511,7 +525,7 @@ End with:
 changed: SDD project initialized
 
 Artifacts created:
-- .sdd/stack-profile.json, .sdd/project-profile.json, .sdd/model-profile.json, .sdd/reasoning-profile.json
+- .sdd/stack-profile.json, .sdd/project-profile.json
 - CONTEXT.md, docs/adr/0001-project-initialization.md, docs/agents/issue-tracker.md
 - AGENTS.md (agent skills block)
 - <type-specific artifacts>
@@ -802,10 +816,22 @@ suggestion: Run /sdd-propose "<request>" for full workflow.`,
 // ─── Plugin Export ───────────────────────────────────────────────────────────
 
 export default async ({ client, project, directory, $ }) => {
+  const modelRouterHooks = await sddModelRouter({ client, project, directory, $ });
+  const autoReasoningHooks = await sddAutoReasoning({ client, project, directory, $ });
+
   return {
-    agent: AGENTS,
+    ...autoReasoningHooks,
 
     config(cfg) {
+      // Register SDD agents through config; OpenCode 1.15 ignores top-level plugin `agent` hooks.
+      cfg.agent = cfg.agent || {};
+      for (const [name, agent] of Object.entries(AGENTS)) {
+        cfg.agent[name] = {
+          ...(cfg.agent[name] ?? {}),
+          ...agent,
+        };
+      }
+
       // Register SDD skills path
       const skillsDir = path.join(packageRoot, ".opencode", "skills");
       if (fs.existsSync(skillsDir)) {
@@ -835,54 +861,7 @@ export default async ({ client, project, directory, $ }) => {
         cfg.permission.skill["sdd-*"] = "allow";
       }
 
-      // Chain other SDD plugins via config hook
-      // Load sdd-model-router
-      try {
-        const modelRouterPath = path.join(__dirname, "sdd-model-router.js");
-        if (fs.existsSync(modelRouterPath)) {
-          import(modelRouterPath).then(async (mod) => {
-            const pluginFn = mod.default;
-            if (pluginFn) {
-              const result = await pluginFn({ client, project, directory, $ });
-              if (result.config) {
-                result.config(cfg);
-              }
-            }
-          });
-        }
-      } catch {
-        // sdd-model-router not available, skip
-      }
-
-      // Load sdd-auto-reasoning
-      try {
-        const reasoningPath = path.join(__dirname, "sdd-auto-reasoning.js");
-        if (fs.existsSync(reasoningPath)) {
-          import(reasoningPath).then(async (mod) => {
-            const pluginFn = mod.default;
-            if (pluginFn) {
-              const result = await pluginFn({ client, project, directory, $ });
-              // Merge all hooks from auto-reasoning
-              for (const [hookName, hookFn] of Object.entries(result)) {
-                if (hookName !== "config" && typeof hookFn === "function") {
-                  // Chain hook — call existing then new
-                  const existing = cfg[hookName];
-                  if (typeof existing === "function") {
-                    cfg[hookName] = async (...args) => {
-                      await existing(...args);
-                      await hookFn(...args);
-                    };
-                  } else {
-                    cfg[hookName] = hookFn;
-                  }
-                }
-              }
-            }
-          });
-        }
-      } catch {
-        // sdd-auto-reasoning not available, skip
-      }
+      modelRouterHooks.config?.(cfg);
     },
   };
 };

package/GUIDE.md

@@ -48,7 +48,7 @@ Run this once at the start of a project to set up the "spine" — stack detectio
    - Section F: Type-specific guardrails (conditional)
 
 3. **Phase 3: Scaffold Artifacts**
-   - `.sdd/project-profile.json`, `.sdd/model-profile.json`, `.sdd/reasoning-profile.json`
+   - `.sdd/project-profile.json`, plus global runtime config in `~/.config/opencode/sdd-multiagent-opencode.json`
    - `CONTEXT.md` (domain glossary)
    - `docs/adr/0001-project-initialization.md`
    - Type-specific artifacts (conditional):

package/README.md

@@ -41,7 +41,7 @@ external UI skills          # impeccable, taste, nothing-design, etc.
 | **sdd-reviewer** | configurable | Code review (security, performance, spec compliance) |
 | **sdd-quick** | configurable | Small cosmetic/config edits (~200 tokens via CLI wrapper) |
 
-**All models are configurable** via `.sdd/model-profile.json`. Edit this file to change which model each agent uses. See [Model Settings](#model-settings) below.
+**All models are configurable** via `~/.config/opencode/sdd-multiagent-opencode.json`. Edit this file to change which model each agent uses. See [Model Settings](#model-settings) below.
 
 ## Quick Start
 
@@ -64,7 +64,7 @@ To pin a specific version:
 ```json
 {
   "plugin": [
-    "@tudeorangbiasa/sdd-multiagent-opencode@0.2.2"
+    "@tudeorangbiasa/sdd-multiagent-opencode@0.4.1"
   ]
 }
 ```
@@ -116,7 +116,11 @@ Most work starts with `/sdd-propose`, then `/sdd-apply`, then `/sdd-ship`. Use `
 
 ## Model Settings
 
-The installer creates `.sdd/model-profile.json`. Edit this file to change which model each OpenCode agent uses.
+SDD model and reasoning routing are configured in one global plugin config:
+
+`~/.config/opencode/sdd-multiagent-opencode.json`
+
+Edit this file to change which model each SDD agent uses. This package does not read per-project model or reasoning profile files at runtime.
 
 **⚠️ Requirement:** SDD works best with at least **ONE paid/subscription model** for orchestrator and planner. These roles need strong reasoning + multimodal capabilities that free models lack.
 
@@ -223,22 +227,43 @@ Models available at no cost via OpenCode Zen. Run `opencode models opencode | gr
 - `groq/llama-3.3-70b-versatile` — Llama 3.3 70B via Groq
 - `openrouter/deepseek-r1-free` — DeepSeek R1 via OpenRouter (free)
 
-### Default Profile
+### Default Config
 
 Recommended starting configuration (orchestrator/planner use OpenAI GPT 5.5, others use free):
 
 ```json
 {
-  "defaultPrimary": "openai/gpt-5.5",
-  "small": "opencode/deepseek-v4-flash-free",
-  "agents": {
-    "sdd-orchestrator": "openai/gpt-5.5",
-    "sdd-planner": "openai/gpt-5.5",
-    "sdd-explorer": "opencode/deepseek-v4-flash-free",
-    "sdd-implementer": "opencode/deepseek-v4-flash-free",
-    "sdd-verifier": "opencode/qwen3.6-plus-free",
-    "sdd-reviewer": "opencode/minimax-m2.5-free",
-    "sdd-quick": "opencode/qwen3.6-plus-free"
+  "model": "openai/gpt-5.5",
+  "small_model": "opencode/deepseek-v4-flash-free",
+  "agent": {
+    "sdd-orchestrator": { "model": "openai/gpt-5.5" },
+    "sdd-planner": { "model": "openai/gpt-5.5" },
+    "sdd-explorer": { "model": "opencode/deepseek-v4-flash-free" },
+    "sdd-implementer": { "model": "opencode/deepseek-v4-flash-free" },
+    "sdd-verifier": { "model": "opencode/qwen3.6-plus-free" },
+    "sdd-reviewer": { "model": "opencode/minimax-m2.5-free" },
+    "sdd-quick": { "model": "opencode/qwen3.6-plus-free" }
+  },
+  "reasoning": {
+    "default": "low",
+    "applyProviderOptions": true,
+    "resetToolOverrideAfterNextRequest": true,
+    "agents": {
+      "sdd-orchestrator": "high",
+      "sdd-planner": "high",
+      "sdd-explorer": "low",
+      "sdd-implementer": "medium",
+      "sdd-verifier": "medium",
+      "sdd-reviewer": "medium",
+      "sdd-quick": "low"
+    },
+    "commands": {
+      "sdd-explore": "medium",
+      "sdd-propose": "high",
+      "sdd-apply": "medium",
+      "sdd-ship": "medium",
+      "sdd-quick": "low"
+    }
   }
 }
 ```
@@ -247,16 +272,16 @@ Recommended starting configuration (orchestrator/planner use OpenAI GPT 5.5, oth
 
 ```json
 {
-  "defaultPrimary": "opencode-go/deepseek-v4-pro",
-  "small": "opencode/deepseek-v4-flash-free",
-  "agents": {
-    "sdd-orchestrator": "opencode-go/deepseek-v4-pro",
-    "sdd-planner": "opencode-go/deepseek-v4-pro",
-    "sdd-explorer": "opencode/deepseek-v4-flash-free",
-    "sdd-implementer": "opencode/deepseek-v4-flash-free",
-    "sdd-verifier": "opencode-go/kimi-k2.6",
-    "sdd-reviewer": "opencode/minimax-m2.5-free",
-    "sdd-quick": "opencode-go/qwen3.6-plus"
+  "model": "opencode-go/deepseek-v4-pro",
+  "small_model": "opencode/deepseek-v4-flash-free",
+  "agent": {
+    "sdd-orchestrator": { "model": "opencode-go/deepseek-v4-pro" },
+    "sdd-planner": { "model": "opencode-go/deepseek-v4-pro" },
+    "sdd-explorer": { "model": "opencode/deepseek-v4-flash-free" },
+    "sdd-implementer": { "model": "opencode/deepseek-v4-flash-free" },
+    "sdd-verifier": { "model": "opencode-go/kimi-k2.6" },
+    "sdd-reviewer": { "model": "opencode/minimax-m2.5-free" },
+    "sdd-quick": { "model": "opencode-go/qwen3.6-plus" }
   }
 }
 ```
@@ -270,13 +295,13 @@ Recommended starting configuration (orchestrator/planner use OpenAI GPT 5.5, oth
 - **Reviewer** → MiniMax M2.5 free: structured code review output
 - **Quick** → Qwen3.6 Plus free: minimal prompt for small cosmetic/config edits (~200 tokens)
 
-`.opencode/plugins/sdd-model-router.js` reads this file at OpenCode startup and applies the model settings. **Restart OpenCode after editing it.**
+`.opencode/plugins/sdd-model-router.js` reads `~/.config/opencode/sdd-multiagent-opencode.json` at OpenCode startup and applies the model settings. **Restart OpenCode after editing it.**
 
-**Important:** Do NOT set models in `opencode.json` — they will be ignored. All model routing goes through `model-profile.json`.
+**Important:** Do NOT set SDD agent models in `opencode.json`. All SDD model routing goes through `~/.config/opencode/sdd-multiagent-opencode.json`.
 
 ### Auto Reasoning
 
-The installer also creates `.sdd/reasoning-profile.json` and installs `.opencode/plugins/sdd-auto-reasoning.js`.
+The plugin installs `.opencode/plugins/sdd-auto-reasoning.js` and reads the `reasoning` section from `~/.config/opencode/sdd-multiagent-opencode.json`.
 
 The plugin reverse-engineers the behavior of `@howaboua/pi-auto-reasoning-tool` for OpenCode:
 - sets reasoning effort automatically per agent and command
@@ -298,7 +323,7 @@ Default routing:
 }
 ```
 
-Restart OpenCode after editing `.sdd/reasoning-profile.json`.
+Restart OpenCode after editing `~/.config/opencode/sdd-multiagent-opencode.json`.
 
 ### Manual Install
 
@@ -380,8 +405,6 @@ For small cosmetic fixes:
 .sdd/
 ├── config.json               # Project configuration
 ├── project-profile.json      # Stack and skill routing config
-├── model-profile.json        # Model routing per agent
-├── reasoning-profile.json    # Reasoning effort per agent/command
 └── templates/                # Document templates
     ├── proposal-template.md
     ├── spec-template.md
@@ -407,6 +430,8 @@ specs/
 └── QUICKFIX_LOG_ARCHIVE.md   # Archived ledger entries
 ```
 
+Global runtime config lives at `~/.config/opencode/sdd-multiagent-opencode.json`.
+
 ## Workflows
 
 ### New Project Setup

package/bin/sdd-opencode.js

@@ -122,6 +122,64 @@ function parseJsonc(filePath) {
   return JSON.parse(stripped);
 }
 
+function readJsonSafe(filePath) {
+  if (!fs.existsSync(filePath)) return null;
+
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+function getNativeAuthPath() {
+  const home = process.env.HOME || process.env.USERPROFILE || "";
+  const xdgDataHome = process.env.XDG_DATA_HOME || path.join(home, ".local", "share");
+  return path.join(xdgDataHome, "opencode", "auth.json");
+}
+
+function getProviderId(model) {
+  if (typeof model !== "string") return null;
+  const separator = model.indexOf("/");
+  if (separator <= 0) return null;
+  return model.slice(0, separator);
+}
+
+function getProviderEnvNames(providerId) {
+  const explicit = {
+    openai: ["OPENAI_API_KEY"],
+    anthropic: ["ANTHROPIC_API_KEY"],
+    google: ["GOOGLE_API_KEY", "GEMINI_API_KEY"],
+    opencode: ["OPENCODE_API_KEY", "OPENCODE_ZEN_API_KEY"],
+    openrouter: ["OPENROUTER_API_KEY"],
+    groq: ["GROQ_API_KEY"],
+    deepseek: ["DEEPSEEK_API_KEY"],
+    minimax: ["MINIMAX_API_KEY"],
+    moonshot: ["MOONSHOT_API_KEY"],
+    zai: ["ZAI_API_KEY"],
+  };
+
+  if (explicit[providerId]) return explicit[providerId];
+
+  return [`${providerId.toUpperCase().replace(/[^A-Z0-9]/g, "_")}_API_KEY`];
+}
+
+function describeProviderConfig(providerId, opencodeConfig, nativeAuth) {
+  const auth = nativeAuth?.[providerId];
+  if (auth?.type === "oauth") return "configured via OpenCode native oauth";
+  if (auth?.type === "api") return "configured via OpenCode native api auth";
+  if (auth) return "configured via OpenCode native auth";
+
+  const providerConfig = opencodeConfig?.provider?.[providerId];
+  if (providerConfig?.options?.apiKey) return "configured via opencode.json provider apiKey";
+  if (providerConfig) return "configured via opencode.json provider";
+
+  const envName = getProviderEnvNames(providerId).find((name) => !!process.env[name]);
+  if (envName) return `configured via ${envName}`;
+
+  return null;
+}
+
 // ─── Backup ──────────────────────────────────────────────────────────────────
 
 function createBackup(filePath) {
@@ -177,7 +235,7 @@ function parseArgs(argv) {
 // ─── Usage ───────────────────────────────────────────────────────────────────
 
 function usage() {
-  console.log(`SDD Multi-Agent OpenCode Installer v0.3.0
+  console.log(`SDD Multi-Agent OpenCode Installer v0.4.1
 
 Usage:
   sdd-opencode init [flags]     Install SDD workflow into current project
@@ -331,8 +389,6 @@ function installSdd(ctx) {
 
   const profileTemplates = [
     { dest: "project-profile.json", template: "project-profile-template.json", populate: true },
-    { dest: "model-profile.json", template: "model-profile-template.json", populate: false },
-    { dest: "reasoning-profile.json", template: "reasoning-profile-template.json", populate: false },
   ];
 
   for (const { dest, template, populate } of profileTemplates) {
@@ -392,16 +448,6 @@ function patchOpencodeJson(ctx) {
 
   if (!targetConfig.agent) targetConfig.agent = {};
 
-  // Patch compaction from vendor rules
-  const vendorRulesJson = path.join(packageRoot, "vendor/opencode-agent-rules/opencode.json");
-  if (fs.existsSync(vendorRulesJson)) {
-    const rulesConfig = JSON.parse(fs.readFileSync(vendorRulesJson, "utf-8"));
-    if (rulesConfig.agent?.compaction && !targetConfig.agent.compaction) {
-      targetConfig.agent.compaction = rulesConfig.agent.compaction;
-      ctx.installed.push("opencode.json (compaction patch)");
-    }
-  }
-
   // Patch plugins
   const pkgJsonPath = path.join(packageRoot, "opencode.json");
   if (fs.existsSync(pkgJsonPath)) {
@@ -467,7 +513,7 @@ async function runInit(args) {
     dryRunFiles: [],
   };
 
-  console.log("\nSDD Multi-Agent OpenCode Installer v0.3.0\n");
+  console.log("\nSDD Multi-Agent OpenCode Installer v0.4.1\n");
   console.log(`Target: ${targetRoot}`);
   if (ctx.dryRun) console.log("Mode: DRY RUN (no files will be written)\n");
 
@@ -503,8 +549,8 @@ async function runInit(args) {
 
     console.log("\nNext steps:");
     console.log("  1. Edit .sdd/project-profile.json with your stack");
-    console.log("  2. Run: /sdd-propose \"your first feature\"");
-    console.log("  3. Optional TDD: /sdd-propose my-feature --tdd");
+    console.log("  2. Configure models in ~/.config/opencode/sdd-multiagent-opencode.json");
+    console.log("  3. Run: /sdd-propose \"your first feature\"");
   }
 }
 
@@ -605,42 +651,44 @@ async function runDoctor(args) {
   const cmdCount = fs.existsSync(commandsDir) ? fs.readdirSync(commandsDir).filter((f) => f.endsWith(".md")).length : 0;
   report("L1", "commands available", cmdCount >= expectedCommands ? "pass" : "warn", `${cmdCount}/${expectedCommands} command files`);
 
-  // L2: Environment variables
-  console.log("\nL2: Environment");
+  // L2: OpenCode provider configuration
+  console.log("\nL2: OpenCode Providers");
 
-  const modelProfilePath = path.join(targetRoot, ".sdd", "model-profile.json");
-  const modelProfile = fs.existsSync(modelProfilePath) ? JSON.parse(fs.readFileSync(modelProfilePath, "utf-8")) : null;
+  const sddConfigPath = path.join(globalConfigDir, "sdd-multiagent-opencode.json");
+  const sddConfig = readJsonSafe(sddConfigPath);
+  const globalOpencodeConfig = parseJsonc(path.join(globalConfigDir, "opencode.json"));
+  const nativeAuth = readJsonSafe(getNativeAuthPath());
 
-  if (modelProfile) {
+  if (sddConfig) {
     const models = new Set();
-    if (modelProfile.defaultPrimary) models.add(modelProfile.defaultPrimary);
-    if (modelProfile.agents) {
-      for (const m of Object.values(modelProfile.agents)) models.add(m);
+    if (sddConfig.model) models.add(sddConfig.model);
+    if (sddConfig.small_model) models.add(sddConfig.small_model);
+    if (sddConfig.agent) {
+      for (const agentConfig of Object.values(sddConfig.agent)) {
+        if (agentConfig?.model) models.add(agentConfig.model);
+      }
     }
 
-    const providerChecks = [
-      { name: "OPENAI_API_KEY", pattern: /openai|gpt|o1|o3/i },
-      { name: "ANTHROPIC_API_KEY", pattern: /anthropic|claude/i },
-      { name: "GOOGLE_API_KEY", pattern: /google|gemini/i },
-      { name: "OPENCODE_ZEN_API_KEY", pattern: /zen/i },
-    ];
-
-    for (const { name, pattern } of providerChecks) {
-      const modelMatch = [...models].some((m) => pattern.test(m));
-      if (modelMatch) {
-        const hasKey = !!process.env[name];
-        report("L2", `${name}`, hasKey ? "pass" : "warn", hasKey ? "set" : "not set — models requiring this provider were detected");
-      }
+    const providerIds = new Set([...models].map(getProviderId).filter(Boolean));
+
+    for (const providerId of providerIds) {
+      const configuredBy = describeProviderConfig(providerId, globalOpencodeConfig, nativeAuth);
+      report(
+        "L2",
+        `provider ${providerId}`,
+        configuredBy ? "pass" : "warn",
+        configuredBy ?? "model uses this provider but no native auth, opencode.json provider, or env key was found"
+      );
     }
   } else {
-    report("L2", "model-profile.json", "warn", "not found — using default model routing");
+    report("L2", "sdd-multiagent-opencode.json", "warn", "not found in ~/.config/opencode — using built-in defaults");
   }
 
   // L3: Liveness probe (--deep only)
   if (args.flags.deep) {
     console.log("\nL3: Liveness Probe");
 
-    const primaryModel = modelProfile?.defaultPrimary || process.env.DEFAULT_MODEL || "unknown";
+    const primaryModel = sddConfig?.model || process.env.DEFAULT_MODEL || "unknown";
     report("L3", "model endpoint", "warn", `would probe ${primaryModel} — liveness requires valid API credentials and network access`);
     report("L3", "note", "warn", "full liveness probe requires HTTP client — run manually with curl or your provider's dashboard");
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tudeorangbiasa/sdd-multiagent-opencode",
-  "version": "0.3.1",
+  "version": "0.4.1",
   "description": "Spec-Driven Development workflow kit for OpenCode with 5 core commands, multi-agent support, CLI wrappers, and configurable model routing",
   "type": "module",
   "main": ".opencode/plugins/sdd-register.js",
@@ -15,6 +15,7 @@
     "vendor",
     "README.md",
     "GUIDE.md",
+    "sdd-multiagent-opencode.json",
     "opencode.json"
   ],
   "scripts": {

package/sdd-multiagent-opencode.json

@@ -0,0 +1,50 @@
+{
+  "model": "openai/gpt-5.5",
+  "small_model": "opencode/deepseek-v4-flash-free",
+  "agent": {
+    "sdd-orchestrator": {
+      "model": "openai/gpt-5.5"
+    },
+    "sdd-planner": {
+      "model": "openai/gpt-5.5"
+    },
+    "sdd-explorer": {
+      "model": "opencode/deepseek-v4-flash-free"
+    },
+    "sdd-implementer": {
+      "model": "opencode/deepseek-v4-flash-free"
+    },
+    "sdd-verifier": {
+      "model": "opencode/qwen3.6-plus-free"
+    },
+    "sdd-reviewer": {
+      "model": "opencode/minimax-m2.5-free"
+    },
+    "sdd-quick": {
+      "model": "opencode/qwen3.6-plus-free"
+    }
+  },
+  "reasoning": {
+    "default": "low",
+    "applyProviderOptions": true,
+    "resetToolOverrideAfterNextRequest": true,
+    "agents": {
+      "general": "medium",
+      "plan": "high",
+      "sdd-orchestrator": "high",
+      "sdd-planner": "high",
+      "sdd-explorer": "low",
+      "sdd-implementer": "medium",
+      "sdd-verifier": "medium",
+      "sdd-reviewer": "medium",
+      "sdd-quick": "low"
+    },
+    "commands": {
+      "sdd-explore": "medium",
+      "sdd-propose": "high",
+      "sdd-apply": "medium",
+      "sdd-ship": "medium",
+      "sdd-quick": "low"
+    }
+  }
+}

package/vendor/opencode-agent-rules/opencode-agent-rules.json

@@ -0,0 +1,8 @@
+{
+  "agent": {
+    "compaction": {
+      "model": "opencode/minimax-m2.5-free",
+      "temperature": 0.1
+    }
+  }
+}

package/vendor/opencode-agent-rules/opencode.json

@@ -1,9 +1,3 @@
 {
-  "$schema": "https://opencode.ai/config.json",
-  "agent": {
-    "compaction": {
-      "model": "opencode/minimax-m2.5-free",
-      "temperature": 0.1
-    }
-  }
+  "$schema": "https://opencode.ai/config.json"
 }

package/.sdd/templates/model-profile-template.json

@@ -1,31 +0,0 @@
-{
-  "_info": {
-    "description": "Model routing configuration. Edit this file to change which model each agent uses. Restart OpenCode after editing.",
-    "requirement": "SDD requires at least ONE paid/subscription model for orchestrator and planner. These roles need strong reasoning that free models cannot provide.",
-    "subscription_options": {
-      "openai_plus": "GPT 5.5 with reasoning and multimodal",
-      "opencode_go": "$10/month — includes DeepSeek V4 Pro, GLM 5.1, Kimi K2.6, MiniMax M2.7",
-      "opencode_zen": "Pay-per-token, zero markup — access to Claude Opus 4.7, GPT 5.5, Gemini 3.1 Pro"
-    },
-    "recommendations": {
-      "orchestrator": "PAID: GPT 5.5 (OpenAI) or DeepSeek V4 Pro (Go) — needs strong reasoning for DAG coordination",
-      "planner": "PAID: GPT 5.5 (OpenAI), Claude Opus 4.7, or DeepSeek V4 Pro (Go) — needs maximum reasoning for architecture",
-      "explorer": "FREE: DeepSeek v4 Flash — fast readonly exploration, token-efficient",
-      "implementer": "FREE: DeepSeek v4 Flash — code generation, high token usage",
-      "verifier": "FREE: Qwen3.6 Plus — multimodal for Chrome DevTools screenshots",
-      "reviewer": "FREE: MiniMax M2.5 — structured code review output",
-      "quick": "FREE: Qwen3.6 Plus or DeepSeek v4 Flash — minimal prompt for small edits"
-    }
-  },
-  "defaultPrimary": "openai/gpt-5.5",
-  "small": "opencode/deepseek-v4-flash-free",
-  "agents": {
-    "sdd-orchestrator": "openai/gpt-5.5",
-    "sdd-planner": "openai/gpt-5.5",
-    "sdd-explorer": "opencode/deepseek-v4-flash-free",
-    "sdd-implementer": "opencode/deepseek-v4-flash-free",
-    "sdd-verifier": "opencode/qwen3.6-plus-free",
-    "sdd-reviewer": "opencode/minimax-m2.5-free",
-    "sdd-quick": "opencode/qwen3.6-plus-free"
-  }
-}

package/.sdd/templates/reasoning-profile-template.json

@@ -1,23 +0,0 @@
-{
-  "default": "low",
-  "applyProviderOptions": true,
-  "resetToolOverrideAfterNextRequest": true,
-  "agents": {
-    "general": "medium",
-    "plan": "high",
-    "sdd-orchestrator": "high",
-    "sdd-planner": "high",
-    "sdd-explorer": "low",
-    "sdd-implementer": "medium",
-    "sdd-verifier": "medium",
-    "sdd-reviewer": "medium",
-    "sdd-quick": "low"
-  },
-  "commands": {
-    "sdd-explore": "medium",
-    "sdd-propose": "high",
-    "sdd-apply": "medium",
-    "sdd-ship": "medium",
-    "sdd-quick": "low"
-  }
-}