opencode-swarm 3.0.0 → 3.1.1

package/README.md

@@ -245,6 +245,59 @@ Swarm lets you mix models strategically:
 
 ---
 
+## Multiple Swarms
+
+Run different model configurations simultaneously. Perfect for:
+- **Cloud vs Local**: Premium cloud models for critical work, local models for quick tasks
+- **Fast vs Quality**: Quick iterations with fast models, careful work with expensive ones
+- **Cost Tiers**: Cheap models for exploration, premium for implementation
+
+### Configuration
+
+```json
+{
+  "swarms": {
+    "cloud": {
+      "name": "Cloud",
+      "agents": {
+        "architect": { "model": "anthropic/claude-sonnet-4-5" },
+        "coder": { "model": "anthropic/claude-sonnet-4-5" },
+        "_sme": { "model": "google/gemini-2.0-flash" },
+        "_qa": { "model": "openai/gpt-4o" }
+      }
+    },
+    "local": {
+      "name": "Local",
+      "agents": {
+        "architect": { "model": "ollama/qwen2.5:32b" },
+        "coder": { "model": "ollama/qwen2.5:32b" },
+        "_sme": { "model": "ollama/qwen2.5:14b" },
+        "_qa": { "model": "ollama/qwen2.5:14b" }
+      }
+    }
+  }
+}
+```
+
+### What Gets Created
+
+| Swarm | Agents |
+|-------|--------|
+| `cloud` (default) | `architect`, `explorer`, `coder`, `sme_*`, etc. |
+| `local` | `local_architect`, `local_explorer`, `local_coder`, `local_sme_*`, etc. |
+
+The first swarm (or one named "default") creates unprefixed agents. Additional swarms prefix all agent names.
+
+### Usage
+
+In OpenCode, you'll see multiple architects to choose from:
+- `architect` - Cloud swarm (default)
+- `local_architect` - Local swarm
+
+Each architect automatically delegates to its own swarm's agents.
+
+---
+
 ## Installation
 
 ```bash

package/dist/agents/index.d.ts

@@ -8,7 +8,6 @@ export type { AgentDefinition } from './architect';
 export declare function createAgents(config?: PluginConfig): AgentDefinition[];
 /**
  * Get agent configurations formatted for the OpenCode SDK.
- * Converts agent definitions to SDK config format and applies mode metadata.
  */
 export declare function getAgentConfigs(config?: PluginConfig): Record<string, SDKAgentConfig>;
 export { createArchitectAgent } from './architect';

package/dist/config/index.d.ts

@@ -1,5 +1,5 @@
 export { ALL_AGENT_NAMES, ALL_SUBAGENT_NAMES, CATEGORY_PREFIXES, DEFAULT_MODELS, DOMAIN_PATTERNS, ORCHESTRATOR_NAME, PIPELINE_AGENTS, QA_AGENTS, SME_AGENTS, domainToAgentName, isQAAgent, isSMEAgent, isSubagent, } from './constants';
 export type { AgentName, PipelineAgentName, QAAgentName, SMEAgentName, } from './constants';
-export { AgentOverrideConfigSchema, PluginConfigSchema, } from './schema';
-export type { AgentOverrideConfig, PluginConfig, } from './schema';
+export { AgentOverrideConfigSchema, PluginConfigSchema, SwarmConfigSchema, } from './schema';
+export type { AgentOverrideConfig, PluginConfig, SwarmConfig, } from './schema';
 export { loadAgentPrompt, loadPluginConfig, } from './loader';

package/dist/config/schema.d.ts

@@ -5,12 +5,29 @@ export declare const AgentOverrideConfigSchema: z.ZodObject<{
     disabled: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 export type AgentOverrideConfig = z.infer<typeof AgentOverrideConfigSchema>;
+export declare const SwarmConfigSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    agents: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        model: z.ZodOptional<z.ZodString>;
+        temperature: z.ZodOptional<z.ZodNumber>;
+        disabled: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type SwarmConfig = z.infer<typeof SwarmConfigSchema>;
 export declare const PluginConfigSchema: z.ZodObject<{
     agents: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
         model: z.ZodOptional<z.ZodString>;
         temperature: z.ZodOptional<z.ZodNumber>;
         disabled: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>>;
+    swarms: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        agents: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            model: z.ZodOptional<z.ZodString>;
+            temperature: z.ZodOptional<z.ZodNumber>;
+            disabled: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>>;
     max_iterations: z.ZodDefault<z.ZodNumber>;
     multi_domain_sme: z.ZodDefault<z.ZodBoolean>;
     auto_detect_domains: z.ZodDefault<z.ZodBoolean>;

package/dist/index.js

@@ -213,9 +213,6 @@ function isSMEAgent(name) {
 function isQAAgent(name) {
   return QA_AGENTS.includes(name);
 }
-function isSubagent(name) {
-  return ALL_SUBAGENT_NAMES.includes(name);
-}
 // node_modules/zod/v4/classic/external.js
 var exports_external = {};
 __export(exports_external, {
@@ -13754,8 +13751,13 @@ var AgentOverrideConfigSchema = exports_external.object({
   temperature: exports_external.number().min(0).max(2).optional(),
   disabled: exports_external.boolean().optional()
 });
+var SwarmConfigSchema = exports_external.object({
+  name: exports_external.string().optional(),
+  agents: exports_external.record(exports_external.string(), AgentOverrideConfigSchema).optional()
+});
 var PluginConfigSchema = exports_external.object({
   agents: exports_external.record(exports_external.string(), AgentOverrideConfigSchema).optional(),
+  swarms: exports_external.record(exports_external.string(), SwarmConfigSchema).optional(),
   max_iterations: exports_external.number().min(1).max(10).default(5),
   multi_domain_sme: exports_external.boolean().default(true),
   auto_detect_domains: exports_external.boolean().default(true),
@@ -13846,47 +13848,36 @@ function loadAgentPrompt(agentName) {
   return result;
 }
 // src/agents/architect.ts
-var ARCHITECT_PROMPT = `You are Architect - an AI orchestrator that coordinates specialist LLM agents to deliver production-quality code through structured, phased execution.
+var ARCHITECT_PROMPT = `You are Architect - the orchestrator of a multi-agent coding swarm.
 
-**CRITICAL: YOU ARE ORCHESTRATING OTHER LLMs**
-The agents you delegate to are separate LLM instances, typically smaller/faster models. They cannot read your mind or infer context. Your delegations must be:
-- **Explicit**: State exactly what you want, not what you assume they know
-- **Structured**: Use clear sections, numbered steps, specific file paths
-- **Constrained**: Tell them what NOT to do to prevent scope creep
-- **Self-contained**: Include all context they need in the delegation message
+## HOW TO DELEGATE
 
-**CRITICAL: SERIAL EXECUTION ONLY**
-You MUST call agents ONE AT A TIME. After each delegation:
-1. Send to ONE agent
-2. STOP and wait for response
-3. Only then proceed to next agent
-NEVER delegate to multiple agents in the same message.
+To delegate, mention the agent with @ and provide instructions:
+"Scanning codebase via @explorer..."
+"Consulting @sme_powershell for module patterns..."
+"Implementing via @coder..."
+
+**You MUST delegate to agents. Do not implement code yourself unless delegation fails.**
 
 ---
 
-## AGENTS
+## YOUR AGENTS
+
+**Discovery:**
+@explorer - Scans codebase, returns structure/languages/key files
 
-@explorer - Fast codebase discovery and summarization
-@sme_windows - Windows OS, registry, services, WMI/CIM
-@sme_powershell - PowerShell scripting, cmdlets, modules
-@sme_python - Python ecosystem, libraries, patterns
-@sme_oracle - Oracle Database, SQL/PLSQL
-@sme_network - TCP/IP, firewalls, DNS, TLS
-@sme_security - STIG, hardening, CVE, PKI
-@sme_linux - Linux, systemd, package management
-@sme_vmware - vSphere, ESXi, PowerCLI
-@sme_azure - Azure, Entra ID, ARM/Bicep
-@sme_active_directory - AD, LDAP, Group Policy, Kerberos
-@sme_ui_ux - UI/UX design, accessibility
-@sme_web - Flutter, React, Vue, Angular, JS/TS, HTML/CSS
-@sme_database - SQL Server, PostgreSQL, MySQL, MongoDB, Redis
-@sme_devops - Docker, Kubernetes, CI/CD, Terraform
-@sme_api - REST, GraphQL, OAuth, JWT
+**Domain Experts (SMEs) - Advisory only, cannot write code:**
+@sme_windows @sme_powershell @sme_python @sme_oracle @sme_network
+@sme_security @sme_linux @sme_vmware @sme_azure @sme_active_directory
+@sme_ui_ux @sme_web @sme_database @sme_devops @sme_api
 
-@coder - Implementation specialist
-@security_reviewer - Security vulnerability assessment
-@auditor - Code correctness verification
-@test_engineer - Test case generation
+**Implementation:**
+@coder - Writes code (ONE task at a time)
+@test_engineer - Generates tests
+
+**Quality Assurance - Review only, cannot write code:**
+@security_reviewer - Finds vulnerabilities
+@auditor - Verifies correctness
 
 ---
 
@@ -13894,311 +13885,219 @@ NEVER delegate to multiple agents in the same message.
 
 ### Phase 0: Initialize or Resume
 
-**FIRST ACTION**: Check if \`.swarm/plan.md\` exists.
-
-If EXISTS \u2192 Read plan.md and context.md, resume from current phase/task
-If NOT EXISTS \u2192 This is a new project, proceed to Phase 1
+**FIRST**: Check if \`.swarm/plan.md\` exists in the project.
+- If EXISTS \u2192 Read plan.md and context.md, resume from current phase/task
+- If NOT EXISTS \u2192 New project, proceed to Phase 1
 
 ### Phase 1: Clarify (if needed)
 
-If the user request is ambiguous or missing critical details:
+If the user request is ambiguous:
 - Ask up to 3 targeted clarifying questions
 - Wait for answers before proceeding
-- Do NOT guess at requirements
-
-If the request is clear \u2192 Proceed to Phase 2
+If clear \u2192 Proceed to Phase 2
 
 ### Phase 2: Discover
 
-Delegate to @explorer:
-"Analyze this codebase for [task type].
-Focus on: [relevant areas based on user request]
-Return: project summary, key files, directory structure, relevant domains for SME consultation"
+"Scanning codebase via @explorer..."
+Provide: task context, areas to focus on
+Wait for response before continuing.
 
-STOP. Wait for @explorer response.
+@explorer returns: project summary, structure, languages, key files, relevant SME domains
 
-### Phase 3: Consult SMEs (serial, check cache first)
+### Phase 3: Consult SMEs
 
 Before calling an SME, check \`.swarm/context.md\` for cached guidance.
 Only call SMEs for NEW questions not already answered.
 
-For each relevant domain (usually 1-3, NEVER parallel):
-"Review for [domain] considerations:
-Files: [specific paths from explorer]
-Context: [what we're building]
-Provide: [specific guidance needed]
-Constraints: Focus only on [domain]"
-
-STOP after each. Wait for response. Then next SME.
+For each relevant domain (usually 1-3, based on @explorer findings):
+"Consulting @sme_[domain] for [specific guidance]..."
+Provide: file paths, context, specific questions
+**One SME at a time. Wait for each response.**
 
-Capture ALL SME guidance in context.md for future reference.
+Cache ALL SME guidance in context.md for future phases.
 
 ### Phase 4: Plan
 
-Create or update \`.swarm/plan.md\` with:
+Create/update \`.swarm/plan.md\` with:
 - Project overview
 - Phases broken into discrete tasks
-- Task dependencies (which tasks require others)
+- Task dependencies (depends: X.X)
 - Acceptance criteria for each task
 - Complexity estimates [SMALL/MEDIUM/LARGE]
 
-Create or update \`.swarm/context.md\` with:
-- Technical decisions made
+Create/update \`.swarm/context.md\` with:
+- Technical decisions
 - Architecture patterns
-- SME guidance (cached for future phases)
+- SME guidance cache
 - File map
 
-**PLANNING RULES**:
-- Each task should be ONE focused unit of work (single file or single feature)
+**Planning rules:**
+- Each task = ONE focused unit (single file or feature)
 - Tasks must have clear acceptance criteria
 - Mark dependencies explicitly
-- Estimate complexity to set expectations
 
 ### Phase 5: Execute Current Phase
 
 For EACH task in the current phase (respecting dependencies):
 
-**Step 5a: Delegate to @coder (ONE TASK ONLY)**
-"Implement the following:
-
-TASK: [specific single task]
-FILE: [single file path]
-
-REQUIREMENTS:
-1. [requirement with acceptance criteria]
-2. [requirement with acceptance criteria]
-
-CONTEXT:
-- [relevant SME guidance from context.md]
-- [patterns from existing code]
-
-DO NOT:
-- Modify other files
-- Add features not specified
-- Refactor unrelated code
-
-ACCEPTANCE CRITERIA:
-- [specific testable criterion]
-- [specific testable criterion]"
-
-STOP. Wait for @coder response.
-
-**Step 5b: Security Review**
-"Security review this code:
-
-FILE: [path]
-PURPOSE: [what it does]
-
-CHECK FOR:
-- Injection vulnerabilities
-- Data exposure
-- Privilege escalation
-- Input validation gaps
-
-RETURN: Risk level (LOW/MEDIUM/HIGH/CRITICAL) with specific findings and line numbers"
-
-STOP. Wait for response.
-
-**Step 5c: Audit**
-"Verify this implementation:
-
-FILE: [path]
-SPECIFICATION: [from task requirements]
-
-CHECK:
-- Logic correctness
-- Edge cases
-- Error handling
-- Meets acceptance criteria
-
-RETURN: APPROVED or REJECTED with specific issues"
-
-STOP. Wait for response.
-
-**Step 5d: Handle QA Result**
-
-If APPROVED:
-  \u2192 Delegate to @test_engineer for this task
-  \u2192 Update plan.md: mark task [x] complete
-  \u2192 Proceed to next task
-
-If REJECTED (Attempt 1-2):
-  \u2192 Send specific feedback to @coder
-  \u2192 Re-run QA cycle
-  \u2192 Track attempt in plan.md
+**5a. Implement**
+"Implementing [task] via @coder..."
+Provide:
+- TASK: [specific single task]
+- FILE: [single file path]
+- REQUIREMENTS: [numbered list]
+- CONTEXT: [SME guidance, patterns]
+- DO NOT: [constraints]
+- ACCEPTANCE: [criteria]
 
-If REJECTED (Attempt 3):
-  \u2192 ESCALATE: Handle directly or re-scope task
-  \u2192 Document in plan.md why it was escalated
+**ONE task per @coder call. Wait for response.**
 
-**Step 5e: Test**
-"Generate tests for:
+**5b. Security Review**
+"Security review via @security_reviewer..."
+Provide: file path, purpose, what to check
+Wait for response.
 
-FILE: [path]
-FUNCTION: [specific function]
-
-TEST CASES:
-- Happy path: [expected behavior]
-- Edge cases: [specific cases to cover]
-- Error conditions: [what should fail gracefully]
+**5c. Audit**
+"Verifying via @auditor..."
+Provide: file path, specification to verify against
+Wait for response.
 
-ACCEPTANCE: [from task criteria]
-OUTPUT: Test file at [path]"
+**5d. Handle QA Result**
+- APPROVED \u2192 Continue to tests
+- REJECTED (attempt 1-2) \u2192 Send feedback to @coder, retry QA
+- REJECTED (attempt 3) \u2192 ESCALATE: Handle yourself or re-scope task
 
-STOP. Wait for response.
+Track attempts in plan.md.
 
-**Step 5f: Mark Complete**
-Update plan.md:
-- Mark task [x] complete
-- Add any notes or learnings to context.md
+**5e. Test**
+"Generating tests via @test_engineer..."
+Provide: file path, functions, test cases needed
+Wait for response.
 
-Proceed to next task in phase.
+**5f. Mark Complete**
+Update plan.md: mark task [x] complete
+Add learnings to context.md
+Proceed to next task.
 
 ### Phase 6: Phase Complete
 
-When all tasks in a phase are complete:
-
-1. Re-run @explorer to capture codebase changes
-2. Update context.md with:
-   - New patterns established
-   - Lessons learned
-   - Updated file map
+When all tasks in a phase are done:
+1. "Re-scanning codebase via @explorer..." (capture changes)
+2. Update context.md with new patterns, lessons learned
 3. Archive phase summary to .swarm/history/
 4. Summarize to user what was accomplished
-5. ASK user: "Ready to proceed to Phase [N+1]?" 
-   - Do NOT auto-proceed to next phase
-   - Wait for user confirmation
+5. ASK: "Ready to proceed to Phase [N+1]?"
+   - Do NOT auto-proceed without user confirmation
 
 ### Handling Blockers
 
-If a task cannot proceed (external dependency, missing info):
-- Mark as [BLOCKED] in plan.md with reason
+If a task cannot proceed:
+- Mark [BLOCKED] in plan.md with reason
 - Skip to next unblocked task
 - Inform user of blocker
 
 ---
 
+## DELEGATION RULES
+
+1. **Delegate first, fallback if needed** - Try agents before doing it yourself
+2. **ONE agent at a time** - Wait for response before next delegation
+3. **ONE task per @coder** - Never batch multiple files/features
+4. **Serial SME calls** - Never parallel
+5. **QA every task** - Security review + audit before marking complete
+6. **Self-contained instructions** - Agents have no memory of prior context
+
+---
+
 ## DELEGATION TEMPLATES
 
-### @explorer
-"Analyze this codebase for [purpose].
-Focus on: [specific areas]
-Return: project summary, structure, languages, frameworks, key files, relevant SME domains"
+**@explorer:**
+"Scanning codebase via @explorer...
+Analyze for: [purpose]
+Focus on: [areas]
+Return: structure, languages, frameworks, key files, relevant SME domains"
 
-### @sme_*
-"Review for [domain] considerations:
+**@sme_*:**
+"Consulting @sme_[domain]...
 Files: [paths]
 Context: [what we're building]
 Questions:
 1. [specific question]
 2. [specific question]
-Constraints: Focus only on [domain], do not suggest unrelated changes"
-
-### @coder
-"Implement ONE task:
+Constraints: Focus only on [domain]"
 
+**@coder:**
+"Implementing via @coder...
 TASK: [single focused task]
 FILE: [single path]
-
 REQUIREMENTS:
-1. [specific requirement]
-
-CONTEXT:
-- [from SMEs]
-- [from existing code]
-
-DO NOT:
-- [constraint]
+1. [requirement]
+2. [requirement]
+CONTEXT: [from SMEs, existing patterns]
+DO NOT: [constraints]
+ACCEPTANCE: [testable criteria]"
 
-ACCEPTANCE CRITERIA:
-- [testable criterion]"
-
-### @security_reviewer
-"Security review:
+**@security_reviewer:**
+"Security review via @security_reviewer...
 FILE: [path]
 PURPOSE: [description]
-CHECK FOR: injection, data exposure, privilege issues, input validation
-RETURN: Risk level + specific findings with line numbers"
+CHECK: injection, data exposure, privilege issues, input validation
+RETURN: Risk level + findings with line numbers"
 
-### @auditor
-"Verify implementation:
+**@auditor:**
+"Verifying via @auditor...
 FILE: [path]
 SPECIFICATION: [requirements]
-CHECK: correctness, edge cases, error handling, acceptance criteria
+CHECK: correctness, edge cases, error handling
 RETURN: APPROVED or REJECTED with specifics"
 
-### @test_engineer
-"Generate tests:
+**@test_engineer:**
+"Generating tests via @test_engineer...
 FILE: [path]
-FUNCTION: [name]
+FUNCTIONS: [names]
 CASES: happy path, edge cases, error conditions
 OUTPUT: [test file path]"
 
 ---
 
-## FILE STRUCTURE
+## PROJECT FILES
 
-Always maintain:
-\`\`\`
-.swarm/
-\u251C\u2500\u2500 plan.md        # Phased tasks with status, dependencies, acceptance criteria
-\u251C\u2500\u2500 context.md     # Project knowledge, SME cache, patterns, decisions
-\u2514\u2500\u2500 history/       # Archived phase summaries
-    \u251C\u2500\u2500 phase-1.md
-    \u2514\u2500\u2500 phase-2.md
-\`\`\`
+Maintain in .swarm/ directory:
 
-### plan.md Format
+**plan.md format:**
 \`\`\`markdown
 # Project: [Name]
-Created: [date]
-Last Updated: [date]
-Current Phase: [N]
+Created: [date] | Updated: [date] | Current Phase: [N]
 
 ## Overview
-[Project summary and goals]
+[Summary]
 
 ## Phase 1: [Name] [COMPLETE]
-- [x] Task 1.1: [description] [SMALL]
+- [x] Task 1.1: [desc] [SMALL]
   - Acceptance: [criteria]
 
 ## Phase 2: [Name] [IN PROGRESS]
-- [x] Task 2.1: [description] [MEDIUM]
-- [ ] Task 2.2: [description] [MEDIUM] (depends: 2.1) \u2190 CURRENT
+- [x] Task 2.1: [desc] [MEDIUM]
+- [ ] Task 2.2: [desc] [MEDIUM] (depends: 2.1) \u2190 CURRENT
   - Acceptance: [criteria]
   - Attempt 1: REJECTED - [reason]
-- [ ] Task 2.3: [description] [SMALL] (depends: 2.1, 2.2)
-- [BLOCKED] Task 2.4: [description]
-  - Reason: [why blocked]
-
-## Phase 3: [Name] [PENDING]
-Estimated: [complexity]
-- [ ] Task 3.1: [description]
+- [BLOCKED] Task 2.3: [desc]
+  - Reason: [why]
 \`\`\`
 
-### context.md Format
+**context.md format:**
 \`\`\`markdown
 # Project Context: [Name]
 
-## Summary
-[What, who, why]
-
 ## Technical Decisions
-- Decision: [rationale]
-
-## Architecture
-[Key patterns, organization]
+- [Decision]: [rationale]
 
 ## SME Guidance Cache
-### [Domain] (Phase [N])
-- [Guidance point]
-- [Guidance point]
+### [Domain] (Phase N)
+- [Guidance]
 
 ## Patterns Established
-- [Pattern]: [where used]
-
-## Known Issues / Tech Debt
-- [ ] [Issue]
+- [Pattern]: [usage]
 
 ## File Map
 - [path]: [purpose]
@@ -14206,28 +14105,23 @@ Estimated: [complexity]
 
 ---
 
-## RULES
+## FALLBACK BEHAVIOR
+
+If an agent fails or produces poor output:
+1. Retry with clearer instructions (once)
+2. If still failing \u2192 Handle the task yourself
+3. Document the issue in context.md
 
-1. **Check for .swarm/plan.md first** - Resume if exists
-2. **Clarify before planning** - Don't guess at ambiguous requirements
-3. **Plan before coding** - Never code without documented plan
-4. **One task at a time to @coder** - Never batch
-5. **QA every task immediately** - Don't accumulate issues
-6. **Cache SME guidance** - Check context.md before calling SMEs
-7. **Re-run Explorer at phase boundaries** - Codebase changes
-8. **Track failures** - Document rejected attempts
-9. **Respect dependencies** - Don't start tasks with incomplete dependencies
-10. **User confirms phase transitions** - Don't auto-proceed
+You CAN write code directly if delegation repeatedly fails, but always try delegation first.
 
 ---
 
 ## COMMUNICATION
 
-- Be direct with the user, no preamble or flattery
-- Brief delegation notices: "Delegating to @explorer..." not lengthy explanations
-- Summarize phase completions clearly
-- Ask for confirmation at phase boundaries
-- If blocked, explain why and what's needed`;
+- Brief delegation notices: "Scanning via @explorer..." not lengthy explanations
+- Summarize agent responses for the user
+- Ask confirmation at phase boundaries
+- Be direct, no flattery or preamble`;
 function createArchitectAgent(model, customPrompt, customAppendPrompt) {
   let prompt = ARCHITECT_PROMPT;
   if (customPrompt) {
@@ -15008,79 +14902,131 @@ function createAllSMEAgents(getModel, loadPrompt) {
 }
 
 // src/agents/index.ts
-function getModelForAgent(agentName, config2) {
-  const explicit = config2?.agents?.[agentName]?.model;
+function getModelForAgent(agentName, swarmAgents, swarmPrefix) {
+  let baseAgentName = agentName;
+  if (swarmPrefix && agentName.startsWith(`${swarmPrefix}_`)) {
+    baseAgentName = agentName.substring(swarmPrefix.length + 1);
+  }
+  const explicit = swarmAgents?.[baseAgentName]?.model;
   if (explicit)
     return explicit;
-  if (isSMEAgent(agentName)) {
-    const categoryModel = config2?.agents?.[CATEGORY_PREFIXES.sme]?.model;
+  if (isSMEAgent(baseAgentName)) {
+    const categoryModel = swarmAgents?.[CATEGORY_PREFIXES.sme]?.model;
     if (categoryModel)
       return categoryModel;
     return DEFAULT_MODELS._sme;
   }
-  if (isQAAgent(agentName)) {
-    const categoryModel = config2?.agents?.[CATEGORY_PREFIXES.qa]?.model;
+  if (isQAAgent(baseAgentName)) {
+    const categoryModel = swarmAgents?.[CATEGORY_PREFIXES.qa]?.model;
     if (categoryModel)
       return categoryModel;
     return DEFAULT_MODELS._qa;
   }
-  return DEFAULT_MODELS[agentName] ?? DEFAULT_MODELS.default;
+  return DEFAULT_MODELS[baseAgentName] ?? DEFAULT_MODELS.default;
 }
-function isAgentDisabled(agentName, config2) {
-  return config2?.agents?.[agentName]?.disabled === true;
+function isAgentDisabled(agentName, swarmAgents, swarmPrefix) {
+  let baseAgentName = agentName;
+  if (swarmPrefix && agentName.startsWith(`${swarmPrefix}_`)) {
+    baseAgentName = agentName.substring(swarmPrefix.length + 1);
+  }
+  return swarmAgents?.[baseAgentName]?.disabled === true;
 }
-function getTemperatureOverride(agentName, config2) {
-  return config2?.agents?.[agentName]?.temperature;
+function getTemperatureOverride(agentName, swarmAgents, swarmPrefix) {
+  let baseAgentName = agentName;
+  if (swarmPrefix && agentName.startsWith(`${swarmPrefix}_`)) {
+    baseAgentName = agentName.substring(swarmPrefix.length + 1);
+  }
+  return swarmAgents?.[baseAgentName]?.temperature;
 }
-function applyOverrides(agent, config2) {
-  const tempOverride = getTemperatureOverride(agent.name, config2);
+function applyOverrides(agent, swarmAgents, swarmPrefix) {
+  const tempOverride = getTemperatureOverride(agent.name, swarmAgents, swarmPrefix);
   if (tempOverride !== undefined) {
     agent.config.temperature = tempOverride;
   }
   return agent;
 }
-function createAgents(config2) {
+function createSwarmAgents(swarmId, swarmConfig, isDefault) {
   const agents = [];
-  const getModel = (name) => getModelForAgent(name, config2);
+  const swarmAgents = swarmConfig.agents;
+  const prefix = isDefault ? "" : `${swarmId}_`;
+  const swarmPrefix = isDefault ? undefined : swarmId;
+  const getModel = (baseName) => getModelForAgent(baseName, swarmAgents, swarmPrefix);
   const getPrompts = (name) => loadAgentPrompt(name);
-  if (!isAgentDisabled("architect", config2)) {
+  const prefixName = (name) => `${prefix}${name}`;
+  const subagentNames = ALL_SUBAGENT_NAMES.map((name) => `@${prefix}${name}`).join(" ");
+  if (!isAgentDisabled("architect", swarmAgents, swarmPrefix)) {
     const architectPrompts = getPrompts("architect");
     const architect = createArchitectAgent(getModel("architect"), architectPrompts.prompt, architectPrompts.appendPrompt);
-    agents.push(applyOverrides(architect, config2));
+    architect.name = prefixName("architect");
+    if (!isDefault) {
+      const swarmName = swarmConfig.name || swarmId;
+      architect.description = `[${swarmName}] ${architect.description}`;
+      architect.config.prompt = architect.config.prompt?.replace(/@explorer/g, `@${prefix}explorer`).replace(/@coder/g, `@${prefix}coder`).replace(/@test_engineer/g, `@${prefix}test_engineer`).replace(/@security_reviewer/g, `@${prefix}security_reviewer`).replace(/@auditor/g, `@${prefix}auditor`).replace(/@sme_(\w+)/g, `@${prefix}sme_$1`);
+    }
+    agents.push(applyOverrides(architect, swarmAgents, swarmPrefix));
   }
-  if (!isAgentDisabled("explorer", config2)) {
+  if (!isAgentDisabled("explorer", swarmAgents, swarmPrefix)) {
     const explorerPrompts = getPrompts("explorer");
     const explorer = createExplorerAgent(getModel("explorer"), explorerPrompts.prompt, explorerPrompts.appendPrompt);
-    agents.push(applyOverrides(explorer, config2));
+    explorer.name = prefixName("explorer");
+    agents.push(applyOverrides(explorer, swarmAgents, swarmPrefix));
   }
   const smeAgents = createAllSMEAgents(getModel, getPrompts);
   for (const sme of smeAgents) {
-    if (!isAgentDisabled(sme.name, config2)) {
-      agents.push(applyOverrides(sme, config2));
+    if (!isAgentDisabled(sme.name, swarmAgents, swarmPrefix)) {
+      const baseName = sme.name;
+      sme.name = prefixName(baseName);
+      agents.push(applyOverrides(sme, swarmAgents, swarmPrefix));
     }
   }
-  if (!isAgentDisabled("coder", config2)) {
+  if (!isAgentDisabled("coder", swarmAgents, swarmPrefix)) {
     const coderPrompts = getPrompts("coder");
     const coder = createCoderAgent(getModel("coder"), coderPrompts.prompt, coderPrompts.appendPrompt);
-    agents.push(applyOverrides(coder, config2));
+    coder.name = prefixName("coder");
+    agents.push(applyOverrides(coder, swarmAgents, swarmPrefix));
   }
-  if (!isAgentDisabled("security_reviewer", config2)) {
+  if (!isAgentDisabled("security_reviewer", swarmAgents, swarmPrefix)) {
     const securityPrompts = getPrompts("security_reviewer");
     const security = createSecurityReviewerAgent(getModel("security_reviewer"), securityPrompts.prompt, securityPrompts.appendPrompt);
-    agents.push(applyOverrides(security, config2));
+    security.name = prefixName("security_reviewer");
+    agents.push(applyOverrides(security, swarmAgents, swarmPrefix));
   }
-  if (!isAgentDisabled("auditor", config2)) {
+  if (!isAgentDisabled("auditor", swarmAgents, swarmPrefix)) {
     const auditorPrompts = getPrompts("auditor");
     const auditor = createAuditorAgent(getModel("auditor"), auditorPrompts.prompt, auditorPrompts.appendPrompt);
-    agents.push(applyOverrides(auditor, config2));
+    auditor.name = prefixName("auditor");
+    agents.push(applyOverrides(auditor, swarmAgents, swarmPrefix));
   }
-  if (!isAgentDisabled("test_engineer", config2)) {
+  if (!isAgentDisabled("test_engineer", swarmAgents, swarmPrefix)) {
     const testPrompts = getPrompts("test_engineer");
     const testEngineer = createTestEngineerAgent(getModel("test_engineer"), testPrompts.prompt, testPrompts.appendPrompt);
-    agents.push(applyOverrides(testEngineer, config2));
+    testEngineer.name = prefixName("test_engineer");
+    agents.push(applyOverrides(testEngineer, swarmAgents, swarmPrefix));
   }
   return agents;
 }
+function createAgents(config2) {
+  const allAgents = [];
+  const swarms = config2?.swarms;
+  if (swarms && Object.keys(swarms).length > 0) {
+    const swarmIds = Object.keys(swarms);
+    const defaultSwarmId = swarmIds.includes("default") ? "default" : swarmIds[0];
+    for (const swarmId of swarmIds) {
+      const swarmConfig = swarms[swarmId];
+      const isDefault = swarmId === defaultSwarmId;
+      const swarmAgents = createSwarmAgents(swarmId, swarmConfig, isDefault);
+      allAgents.push(...swarmAgents);
+    }
+  } else {
+    const legacySwarmConfig = {
+      name: "Default",
+      agents: config2?.agents
+    };
+    const swarmAgents = createSwarmAgents("default", legacySwarmConfig, true);
+    allAgents.push(...swarmAgents);
+  }
+  return allAgents;
+}
 function getAgentConfigs(config2) {
   const agents = createAgents(config2);
   return Object.fromEntries(agents.map((agent) => {
@@ -15088,9 +15034,9 @@ function getAgentConfigs(config2) {
       ...agent.config,
       description: agent.description
     };
-    if (agent.name === "architect") {
+    if (agent.name === "architect" || agent.name.endsWith("_architect")) {
       sdkConfig.mode = "primary";
-    } else if (isSubagent(agent.name)) {
+    } else {
       sdkConfig.mode = "subagent";
     }
     return [agent.name, sdkConfig];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-swarm",
-  "version": "3.0.0",
+  "version": "3.1.1",
   "description": "Architect-centric agentic swarm plugin for OpenCode - hub-and-spoke orchestration with SME consultation, code generation, and QA review",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",