npm - opencode-swarm - Versions diffs - 2.3.3 → 3.1.0 - Mend

opencode-swarm 2.3.3 → 3.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (6) hide show

package/README.md CHANGED Viewed

@@ -1,112 +1,223 @@
-# OpenCode Swarm
+<p align="center">
+  <img src="https://img.shields.io/badge/version-3.0.0-blue" alt="Version">
+  <img src="https://img.shields.io/badge/license-MIT-green" alt="License">
+  <img src="https://img.shields.io/badge/opencode-plugin-purple" alt="OpenCode Plugin">
+  <img src="https://img.shields.io/badge/agents-20+-orange" alt="Agents">
+</p>
+<h1 align="center">🐝 OpenCode Swarm</h1>
+<p align="center">
+  <strong>The only multi-agent framework that actually works.</strong><br>
+  Structured phases. Persistent memory. One task at a time. QA on everything.
+</p>
+<p align="center">
+  <a href="#why-swarm">Why Swarm?</a> •
+  <a href="#how-it-works">How It Works</a> •
+  <a href="#installation">Installation</a> •
+  <a href="#agents">Agents</a> •
+  <a href="#configuration">Configuration</a>
+</p>
-![License](https://img.shields.io/badge/license-MIT-blue)
-![OpenCode Plugin](https://img.shields.io/badge/opencode-plugin-green)
-![Architecture](https://img.shields.io/badge/architecture-architect--centric-purple)
-![Version](https://img.shields.io/badge/version-2.2.1-orange)
+---
+## The Problem with Every Other Multi-Agent System
+```
+You: "Build me an authentication system"
+Other Frameworks:
+├── Agent 1 starts auth module...
+├── Agent 2 starts user model... (conflicts with Agent 1)
+├── Agent 3 starts database... (wrong schema)
+├── Agent 4 starts tests... (for code that doesn't exist yet)
+└── Result: Chaos. Conflicts. Context lost. Start over.
+OpenCode Swarm:
+├── Architect analyzes request
+├── Explorer scans codebase
+├── Security SME provides auth guidance
+├── Architect creates phased plan with acceptance criteria
+├── Phase 1: User model → QA → Tests → ✓
+├── Phase 2: Auth logic → QA → Tests → ✓
+├── Phase 3: Session management → QA → Tests → ✓
+└── Result: Working code. Documented decisions. Resumable progress.
+```
+---
+## Why Swarm?
+<table>
+<tr>
+<td width="50%">
+### ❌ Other Frameworks
+- Parallel chaos, hope it converges
+- Single model = correlated failures
+- No planning, just vibes
+- Context lost between sessions
+- QA as afterthought (if at all)
+- Entire codebase in one prompt
+- No way to resume projects
+</td>
+<td width="50%">
+### ✅ OpenCode Swarm
+- **Serial execution** - predictable, traceable
+- **Heterogeneous models** - different perspectives catch errors
+- **Phased planning** - documented tasks with acceptance criteria
+- **Persistent memory** - `.swarm/` files survive sessions
+- **QA per task** - security + audit before anything ships
+- **One task at a time** - focused, quality code
+- **Resumable projects** - pick up exactly where you left off
-**Architect-driven, multi-agent development for OpenCode.**
+</td>
+</tr>
+</table>
-Design-first orchestration with codebase discovery, domain-aware SMEs, heterogeneous model perspectives, and layered QA review.
+---
+## How It Works
 ```
-┌──────────────────────────────────────────────────────────────────────────┐
-│  "Review this PowerShell application for security issues"                │
-└──────────────────────────────────────────────────────────────────────────┘
+┌─────────────────────────────────────────────────────────────────────────┐
+│  USER: "Add user authentication with JWT"                               │
+└─────────────────────────────────────────────────────────────────────────┘
+                                    │
+                                    ▼
+┌─────────────────────────────────────────────────────────────────────────┐
+│  PHASE 0: Check for .swarm/plan.md                                      │
+│           Exists? Resume. New? Continue.                                │
+└─────────────────────────────────────────────────────────────────────────┘
+                                    │
+                                    ▼
+┌─────────────────────────────────────────────────────────────────────────┐
+│  PHASE 1: Clarify (if needed)                                           │
+│           "Do you need refresh tokens? What's the session duration?"    │
+└─────────────────────────────────────────────────────────────────────────┘
+                                    │
+                                    ▼
+┌─────────────────────────────────────────────────────────────────────────┐
+│  PHASE 2: Discover                                                      │
+│           @explorer scans codebase → structure, languages, patterns     │
+└─────────────────────────────────────────────────────────────────────────┘
                                     │
                                     ▼
-┌──────────────────────────────────────────────────────────────────────────┐
-│  ARCHITECT: Delegating to @explorer for codebase analysis...             │
-└──────────────────────────────────────────────────────────────────────────┘
+┌─────────────────────────────────────────────────────────────────────────┐
+│  PHASE 3: Consult SMEs (serial, cached)                                 │
+│           @sme_security → auth best practices                           │
+│           @sme_api → JWT patterns, refresh flow                         │
+│           Guidance saved to .swarm/context.md                           │
+└─────────────────────────────────────────────────────────────────────────┘
                                     │
                                     ▼
-┌──────────────────────────────────────────────────────────────────────────┐
-│  EXPLORER: PowerShell module, 12 files, domains: powershell, security    │
-│  → Flagged: auth.ps1, invoke-command.ps1 for SME review                  │
-└──────────────────────────────────────────────────────────────────────────┘
+┌─────────────────────────────────────────────────────────────────────────┐
+│  PHASE 4: Plan                                                          │
+│           Creates .swarm/plan.md with phases, tasks, acceptance criteria│
+│                                                                         │
+│           Phase 1: Foundation [3 tasks]                                 │
+│           Phase 2: Core Auth [4 tasks]                                  │
+│           Phase 3: Session Management [3 tasks]                         │
+└─────────────────────────────────────────────────────────────────────────┘
                                     │
                                     ▼
-┌──────────────────────────────────────────────────────────────────────────┐
-│  SME_POWERSHELL: Remoting patterns detected, needs constrained endpoints │
-│  SME_SECURITY: Credential handling issues in auth.ps1:42-58              │
-└──────────────────────────────────────────────────────────────────────────┘
+┌─────────────────────────────────────────────────────────────────────────┐
+│  PHASE 5: Execute (per task)                                            │
+│                                                                         │
+│   ┌─────────┐    ┌──────────┐    ┌─────────┐    ┌──────────┐           │
+│   │ @coder  │ →  │@security │ →  │@auditor │ →  │  @test   │           │
+│   │ 1 task  │    │ review   │    │ verify  │    │ generate │           │
+│   └─────────┘    └──────────┘    └─────────┘    └──────────┘           │
+│        │                                              │                 │
+│        └──── If rejected: retry with feedback ────────┘                 │
+│                                                                         │
+│   Update plan.md: [x] Task complete                                     │
+│   Next task...                                                          │
+└─────────────────────────────────────────────────────────────────────────┘
                                     │
                                     ▼
-┌──────────────────────────────────────────────────────────────────────────┐
-│  ARCHITECT: Collated review with 3 HIGH findings, 2 recommendations      │
-└──────────────────────────────────────────────────────────────────────────┘
+┌─────────────────────────────────────────────────────────────────────────┐
+│  PHASE 6: Phase Complete                                                │
+│           Re-scan with @explorer                                        │
+│           Update context.md with learnings                              │
+│           Archive to .swarm/history/                                    │
+│           "Phase 1 complete. Ready for Phase 2?"                        │
+└─────────────────────────────────────────────────────────────────────────┘
 ```
 ---
-## Why OpenCode Swarm?
+## Persistent Project Memory
-Most agent frameworks parallelize everything and hope coherence emerges.
-**OpenCode Swarm enforces discipline:**
+Other frameworks lose everything when the session ends. Swarm doesn't.
-| Problem | Our Solution |
-|---------|--------------|
-| Agents read the same files repeatedly | Explorer scans once, shares context |
-| All 11 SMEs consulted for every task | Only relevant domains (1-3) based on Explorer findings |
-| Single model = correlated failures | Different models per role = diverse perspectives |
-| No visibility into agent decisions | Serial execution with clear delegation traces |
-| Code ships without review | Mandatory Security → Audit → Test pipeline |
+```
+.swarm/
+├── plan.md          # Your project roadmap
+├── context.md       # Everything a new Architect needs
+└── history/
+    ├── phase-1.md   # What was done, what was learned
+    └── phase-2.md
+```
----
+### plan.md - Living Roadmap
+```markdown
+# Project: Auth System
+Current Phase: 2
+## Phase 1: Foundation [COMPLETE]
+- [x] Task 1.1: Create user model [SMALL]
+- [x] Task 1.2: Add password hashing [SMALL]
+- [x] Task 1.3: Database migrations [MEDIUM]
+## Phase 2: Core Auth [IN PROGRESS]
+- [x] Task 2.1: Login endpoint [MEDIUM]
+- [ ] Task 2.2: JWT generation [MEDIUM] (depends: 2.1) ← CURRENT
+  - Acceptance: Returns valid JWT with user claims
+  - Attempt 1: REJECTED - Missing expiration
+- [ ] Task 2.3: Token validation middleware [MEDIUM]
+- [BLOCKED] Task 2.4: Refresh tokens
+  - Reason: Waiting for decision on rotation strategy
+```
-## Architecture
+### context.md - Institutional Knowledge
+```markdown
+# Project Context: Auth System
-```
-User Request
-     │
-     ▼
-┌─────────────┐
-│  ARCHITECT  │ ◄── Orchestrates everything, owns all decisions
-└─────────────┘
-     │
-     ▼
-┌─────────────┐
-│  EXPLORER   │ ◄── Fast codebase discovery (read-only)
-└─────────────┘     Returns: structure, languages, domains, flagged files
-     │
-     ▼
-┌─────────────┐
-│    SMEs     │ ◄── Domain experts consulted serially (read-only)
-└─────────────┘     Only domains identified by Explorer
-     │
-     ▼
-┌─────────────┐
-│   CODER     │ ◄── Implements unified specification
-└─────────────┘
-     │
-     ▼
-┌─────────────┐     ┌─────────────┐
-│  SECURITY   │ ──► │   AUDITOR   │ ◄── QA review (read-only)
-└─────────────┘     └─────────────┘
-     │
-     ▼
-┌─────────────┐
-│    TEST     │ ◄── Generates tests for approved code
-└─────────────┘
-```
+## Technical Decisions
+- Using bcrypt (cost 12) for password hashing
+- JWT expires in 15 minutes, refresh in 7 days
+- Storing refresh tokens in Redis
-### Agent Permissions
+## SME Guidance Cache
+### Security (Phase 1)
+- Never log tokens or passwords
+- Use constant-time comparison for tokens
+- Implement rate limiting on login
-| Agent | Read | Write | Role |
-|-------|:----:|:-----:|------|
-| Architect | ✅ | ✅ | Orchestrator - can fall back if delegation fails |
-| Explorer | ✅ | ❌ | Discovery - scans, summarizes, identifies domains |
-| SMEs (×15) | ✅ | ❌ | Advisory - domain expertise, never implements |
-| Coder | ✅ | ✅ | Implementation - writes production code |
-| Security Reviewer | ✅ | ❌ | Audit - vulnerability assessment |
-| Auditor | ✅ | ❌ | Audit - correctness verification |
-| Test Engineer | ✅ | ✅ | Testing - generates test cases |
+### API (Phase 1)
+- Return 401 for invalid credentials (not 404)
+- Include token expiry in response body
+## Patterns Established
+- Error handling: Custom ApiError class with status codes
+- Validation: Zod schemas in /validators/
+```
+**Start a new session tomorrow?** The Architect reads these files and picks up exactly where you left off.
 ---
-## Heterogeneous Model Perspectives
+## Heterogeneous Models = Better Code
+Most frameworks use one model for everything. Same blindspots everywhere.
-OpenCode Swarm allows **different models per role**, reducing correlated failures:
+Swarm lets you mix models strategically:
 ```json
 {
@@ -115,38 +226,137 @@ OpenCode Swarm allows **different models per role**, reducing correlated failure
     "explorer": { "model": "google/gemini-2.0-flash" },
     "coder": { "model": "anthropic/claude-sonnet-4-5" },
     "_sme": { "model": "google/gemini-2.0-flash" },
-    "_qa": { "model": "openai/gpt-4o" },
-    "test_engineer": { "model": "google/gemini-2.0-flash" }
+    "security_reviewer": { "model": "openai/gpt-4o" },
+    "auditor": { "model": "google/gemini-2.0-flash" }
   }
 }
 ```
-**Why this matters:**
-- Reasoning-heavy model for Architect decisions
-- Fast/cheap model for Explorer and SME consultation
-- Different model family for QA catches errors the others miss
-- Mix local (Ollama) and cloud models based on cost/capability
+| Role | Optimized For | Why Different Models? |
+|------|---------------|----------------------|
+| Architect | Deep reasoning | Needs to plan complex work |
+| Explorer | Fast scanning | Speed over depth |
+| Coder | Implementation | Best coding model you have |
+| SMEs | Domain knowledge | Fast recall, not deep reasoning |
+| Security Reviewer | Finding flaws | **Different vendor catches different bugs** |
+| Auditor | Verification | Independent perspective |
+**If Claude writes code and GPT reviews it, GPT catches Claude's blindspots.** This is why real teams have code review.
 ---
-## Installation
+## Multiple Swarms
-Add to your `opencode.json`:
+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
 {
-  "plugin": ["opencode-swarm"]
+  "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" }
+      }
+    }
+  }
 }
 ```
-Or install via CLI:
+### 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
+# Add to opencode.json
+{
+  "plugin": ["opencode-swarm"]
+}
+# Or install via CLI
 bunx opencode-swarm install
 ```
 ---
+## Agents
+### 🎯 Orchestrator
+| Agent | Role |
+|-------|------|
+| `architect` | Central coordinator. Plans phases, delegates tasks, manages QA, maintains project memory. |
+### 🔍 Discovery
+| Agent | Role |
+|-------|------|
+| `explorer` | Fast codebase scanner. Identifies structure, languages, frameworks, key files. |
+### 🧠 Domain Experts (15 SMEs)
+| Agent | Domain |
+|-------|--------|
+| `sme_web` | Flutter, React, Vue, Angular, JS/TS, HTML/CSS |
+| `sme_api` | REST, GraphQL, OAuth, JWT, webhooks |
+| `sme_database` | SQL Server, PostgreSQL, MySQL, MongoDB, Redis |
+| `sme_devops` | Docker, Kubernetes, CI/CD, Terraform |
+| `sme_security` | STIG, hardening, CVE, encryption, PKI |
+| `sme_python` | Python ecosystem, libraries, patterns |
+| `sme_powershell` | PowerShell scripting, modules, remoting |
+| `sme_windows` | Windows internals, registry, services, WMI |
+| `sme_linux` | Linux, systemd, package management |
+| `sme_network` | TCP/IP, firewalls, DNS, TLS |
+| `sme_azure` | Azure services, Entra ID, ARM/Bicep |
+| `sme_vmware` | vSphere, ESXi, PowerCLI |
+| `sme_oracle` | Oracle Database, SQL/PLSQL |
+| `sme_active_directory` | AD, LDAP, Group Policy, Kerberos |
+| `sme_ui_ux` | UI/UX design, accessibility |
+### 💻 Implementation
+| Agent | Role |
+|-------|------|
+| `coder` | Implements ONE task at a time with full context |
+| `test_engineer` | Generates tests for each completed task |
+### ✅ Quality Assurance
+| Agent | Role |
+|-------|------|
+| `security_reviewer` | Vulnerability assessment per task |
+| `auditor` | Correctness verification per task |
+---
 ## Configuration
 Create `~/.config/opencode/opencode-swarm.json`:
@@ -166,143 +376,60 @@ Create `~/.config/opencode/opencode-swarm.json`:
 ### Category Defaults
-`_sme` and `_qa` set defaults for all agents in that category:
+- `_sme` → All 15 SME agents
+- `_qa` → security_reviewer + auditor
+Override specific agents:
 ```json
 {
-  "agents": {
-    "_sme": { "model": "google/gemini-2.0-flash" },
-    "sme_oracle": { "model": "anthropic/claude-sonnet-4-5" }
-  }
+  "_sme": { "model": "google/gemini-2.0-flash" },
+  "sme_security": { "model": "anthropic/claude-sonnet-4-5" }
 }
 ```
 ### Disable Unused Domains
 ```json
 {
-  "agents": {
-    "sme_vmware": { "disabled": true },
-    "sme_azure": { "disabled": true }
-  }
+  "sme_vmware": { "disabled": true },
+  "sme_oracle": { "disabled": true }
 }
 ```
-### Custom Prompts
-Place in `~/.config/opencode/opencode-swarm/`:
-- `{agent}.md` - Replace default prompt
-- `{agent}_append.md` - Append to default prompt
 ---
-## Agents
-### Orchestrator
-| Agent | Description |
-|-------|-------------|
-| `architect` | Central orchestrator. Analyzes requests, delegates to specialists, synthesizes outputs, triages QA feedback. |
+## Comparison
-### Discovery
-| Agent | Description |
-|-------|-------------|
-| `explorer` | Fast codebase scanner. Identifies structure, languages, frameworks, and flags files for SME review. |
-### Domain Experts (SMEs)
-| Agent | Domain |
-|-------|--------|
-| `sme_windows` | Windows internals, registry, services, WMI/CIM |
-| `sme_powershell` | PowerShell scripting, cmdlets, modules, remoting |
-| `sme_python` | Python ecosystem, libraries, packaging |
-| `sme_oracle` | Oracle Database, SQL/PLSQL, administration |
-| `sme_network` | TCP/IP, firewalls, DNS, TLS, load balancing |
-| `sme_security` | STIG compliance, hardening, CVEs, PKI |
-| `sme_linux` | Linux administration, systemd, package management |
-| `sme_vmware` | vSphere, ESXi, PowerCLI, virtualization |
-| `sme_azure` | Azure services, Entra ID, ARM/Bicep |
-| `sme_active_directory` | AD, LDAP, Group Policy, Kerberos |
-| `sme_ui_ux` | UI/UX design, accessibility, interaction patterns |
-| `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, GitHub Actions |
-| `sme_api` | REST, GraphQL, OAuth, JWT, webhooks |
-### Implementation
-| Agent | Description |
-|-------|-------------|
-| `coder` | Writes production code from unified specifications |
-| `test_engineer` | Generates test cases and validation scripts |
-### Quality Assurance
-| Agent | Description |
-|-------|-------------|
-| `security_reviewer` | Vulnerability assessment, injection risks, data exposure |
-| `auditor` | Correctness verification, logic errors, edge cases |
+| Feature | OpenCode Swarm | AutoGen | CrewAI | LangGraph |
+|---------|---------------|---------|--------|-----------|
+| Execution | Serial (predictable) | Parallel (chaotic) | Parallel | Configurable |
+| Planning | Phased with acceptance criteria | Ad-hoc | Role-based | Graph-based |
+| Memory | Persistent `.swarm/` files | Session only | Session only | Checkpoints |
+| QA | Per-task (security + audit) | Optional | Optional | Manual |
+| Model mixing | Per-agent configuration | Limited | Limited | Manual |
+| Resume projects | ✅ Native | ❌ | ❌ | Partial |
+| SME domains | 15 specialized | Generic | Generic | Generic |
+| Task granularity | One at a time | Batched | Batched | Varies |
 ---
-## Tools
+## Design Principles
-| Tool | Description |
-|------|-------------|
-| `gitingest` | Fetch GitHub repository contents for analysis |
-| `detect_domains` | Auto-detect relevant SME domains from text |
-| `extract_code_blocks` | Extract code blocks to files |
-### gitingest Example
-```
-"Analyze the architecture of https://github.com/user/repo"
-"Use gitingest to fetch https://github.com/user/repo with pattern *.py include"
-```
----
-## Workflow Examples
-### Code Review
-```
-User: "Review this codebase for issues"
-  → Explorer scans, identifies: TypeScript, React, needs sme_security
-  → SME_Security reviews flagged files
-  → Architect collates findings into review report
-```
-### Implementation
-```
-User: "Add authentication to this API"
-  → Explorer scans existing code
-  → SME_Security + SME_Network consulted
-  → Coder implements spec
-  → Security_Reviewer → Auditor validates
-  → Test_Engineer generates tests
-```
-### Bug Fix
-```
-User: "Fix the null reference in user.ts:42"
-  → Explorer locates context
-  → Relevant SME consulted
-  → Coder implements fix
-  → QA validates
-```
----
-## Design Philosophy
-1. **Single point of control** - Architect owns all decisions
-2. **Discovery before action** - Explorer maps the terrain first
-3. **Selective expertise** - Only relevant SMEs consulted
-4. **Serial execution** - Traceable, debuggable, predictable
-5. **Mandatory QA** - No code ships without security + audit review
-6. **Fail-safe orchestration** - Architect can handle tasks itself if agents fail
+1. **Plan before code** - Documented phases with acceptance criteria
+2. **One task at a time** - Focused work, quality output
+3. **QA everything immediately** - Security + audit per task, not per project
+4. **Cache SME knowledge** - Don't re-ask answered questions
+5. **Persistent memory** - `.swarm/` files survive sessions
+6. **Serial execution** - Predictable, debuggable, no race conditions
+7. **Heterogeneous models** - Different perspectives catch different bugs
+8. **User checkpoints** - Confirm before proceeding to next phase
+9. **Failure tracking** - Document rejections, escalate after 3 attempts
+10. **Resumable by design** - Any Architect can pick up any project
 ---
 ## Documentation
-- [Architecture Details](docs/architecture.md)
+- [Architecture Deep Dive](docs/architecture.md)
 - [Design Rationale](docs/design-rationale.md)
 - [Installation Guide](docs/installation.md)
@@ -311,3 +438,9 @@ User: "Fix the null reference in user.ts:42"
 ## License
 MIT
+---
+<p align="center">
+  <strong>Stop hoping your agents figure it out. Start shipping code that works.</strong>
+</p>

package/dist/agents/index.d.ts CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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,197 +13848,280 @@ function loadAgentPrompt(agentName) {
   return result;
 }
 // src/agents/architect.ts
-var ARCHITECT_PROMPT = `You are Architect - an AI coding orchestrator that coordinates specialist LLM agents to deliver quality code.
+var ARCHITECT_PROMPT = `You are Architect - the orchestrator of a multi-agent coding swarm.
+## HOW TO DELEGATE
+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.**
+---
+## YOUR AGENTS
+**Discovery:**
+@explorer - Scans codebase, returns structure/languages/key files
+**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
+**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
+---
+## WORKFLOW
+### Phase 0: Initialize or Resume
-**Role**: Analyze requests, delegate to specialist agents with clear instructions, synthesize their outputs, and manage the pipeline.
+**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
-**CRITICAL: YOU ARE ORCHESTRATING OTHER LLMs**
-The agents you delegate to are separate LLM instances, typically smaller/faster models optimized for specific tasks. 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, limit scope to prevent drift
-- **Self-contained**: Include all context they need in the delegation message
+### Phase 1: Clarify (if needed)
-**CRITICAL RULE: 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. This is mandatory.
+If the user request is ambiguous:
+- Ask up to 3 targeted clarifying questions
+- Wait for answers before proceeding
+If clear \u2192 Proceed to Phase 2
-**Agents**:
+### Phase 2: Discover
-@explorer - Fast codebase discovery and summarization (ALWAYS FIRST for code tasks)
-@sme_windows - Windows OS internals, registry, services, WMI/CIM
-@sme_powershell - PowerShell scripting, cmdlets, modules, remoting
-@sme_python - Python ecosystem, libraries, best practices
-@sme_oracle - Oracle Database, SQL/PLSQL, administration
-@sme_network - Networking, firewalls, DNS, TLS/SSL, load balancing
-@sme_security - STIG compliance, hardening, CVE, encryption, PKI
-@sme_linux - Linux administration, systemd, package management
-@sme_vmware - VMware vSphere, ESXi, PowerCLI, virtualization
-@sme_azure - Azure cloud services, Entra ID, ARM/Bicep
-@sme_active_directory - Active Directory, LDAP, Group Policy, Kerberos
-@sme_ui_ux - UI/UX design, interaction patterns, accessibility
-@sme_web - Web/frontend (Flutter, React, Vue, Angular, JS/TS, HTML/CSS)
-@sme_database - Databases (SQL Server, PostgreSQL, MySQL, MongoDB, Redis)
-@sme_devops - DevOps, CI/CD, Docker, Kubernetes, Terraform, GitHub Actions
-@sme_api - API design, REST, GraphQL, OAuth, JWT, webhooks
+"Scanning codebase via @explorer..."
+Provide: task context, areas to focus on
+Wait for response before continuing.
-@coder - Implementation specialist, writes production code
-@security_reviewer - Security audit, vulnerability assessment
-@auditor - Code quality review, correctness verification
-@test_engineer - Test case generation and validation scripts
+@explorer returns: project summary, structure, languages, key files, relevant SME domains
-**HOW TO DELEGATE TO EACH AGENT**:
+### Phase 3: Consult SMEs
-## @explorer
-Provide: The task context and what you need to understand
-Format:
-  "Analyze this codebase for [task type].
-   Focus on: [specific areas]
-   Return: project summary, key files, relevant domains for SME consultation"
+Before calling an SME, check \`.swarm/context.md\` for cached guidance.
+Only call SMEs for NEW questions not already answered.
-## @sme_* (domain experts)
-Provide: Specific files/code to review, what expertise you need
-Format:
-  "Review the following for [domain] considerations:
-   Files: [list specific paths]
-   Context: [what the code does]
-   Provide: [specific guidance needed]
-   Constraints: Focus only on [domain], do not suggest unrelated changes"
+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.**
-## @coder
-**IMPORTANT: ONE TASK AT A TIME**
-If you have multiple coding tasks, send them to @coder ONE AT A TIME.
-Do NOT batch multiple files or features into a single delegation.
-Wait for @coder to complete each task before sending the next.
+Cache ALL SME guidance in context.md for future phases.
-Provide: Complete specification for ONE focused task
-Format:
-  "Implement the following:
-   TASK: [one specific task - single file or single feature]
-   FILE: [single path to create/modify]
-   REQUIREMENTS:
-   1. [specific requirement]
-   2. [specific requirement]
-   CONTEXT:
-   - [relevant info from explorer/SMEs]
-   - [patterns from existing code]
-   DO NOT:
-   - Modify other files
-   - Add features not specified
-   - Refactor unrelated code
-   OUTPUT: [single deliverable]"
+### Phase 4: Plan
-Example of CORRECT coding delegation:
-  Turn 1: "Implement the logging module" \u2192 @coder \u2192 wait for completion
-  Turn 2: "Implement the config parser" \u2192 @coder \u2192 wait for completion
-  Turn 3: "Implement the main entry point" \u2192 @coder \u2192 wait for completion
+Create/update \`.swarm/plan.md\` with:
+- Project overview
+- Phases broken into discrete tasks
+- Task dependencies (depends: X.X)
+- Acceptance criteria for each task
+- Complexity estimates [SMALL/MEDIUM/LARGE]
-Example of WRONG batched delegation (NEVER DO THIS):
-  "Implement the logging module, config parser, and main entry point" \u2190 WRONG
+Create/update \`.swarm/context.md\` with:
+- Technical decisions
+- Architecture patterns
+- SME guidance cache
+- File map
-## @security_reviewer
-Provide: Code to review with context
-Format:
-  "Security review the following code:
-   FILES: [paths]
-   PURPOSE: [what the code does]
-   CHECK FOR:
-   - Injection vulnerabilities
-   - Data exposure
-   - Privilege issues
-   - Input validation
-   RETURN: Risk level (LOW/MEDIUM/HIGH/CRITICAL) and specific findings with line numbers"
+**Planning rules:**
+- Each task = ONE focused unit (single file or feature)
+- Tasks must have clear acceptance criteria
+- Mark dependencies explicitly
-## @auditor
-Provide: Code and specification to verify against
-Format:
-  "Verify this implementation:
-   FILES: [paths]
-   SPECIFICATION: [what it should do]
-   CHECK:
-   - Logic correctness
-   - Edge cases handled
-   - Error handling
-   - Specification compliance
-   RETURN: APPROVED or REJECTED with specific issues"
+### Phase 5: Execute Current Phase
-## @test_engineer
-Provide: Code and what to test
-Format:
-  "Generate tests for:
-   FILES: [paths]
-   FUNCTIONS TO TEST: [list]
-   COVERAGE:
-   - Happy path
-   - Edge cases: [specific cases]
-   - Error conditions
-   FRAMEWORK: [test framework to use]
-   OUTPUT: Test file(s) at [paths]"
+For EACH task in the current phase (respecting dependencies):
-**WORKFLOW**:
+**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]
-## 1. Parse Request (you do this briefly)
-Understand what the user wants. Determine task type.
+**ONE task per @coder call. Wait for response.**
-## 2. Explorer FIRST (one delegation, wait for response)
-Delegate to @explorer with clear instructions. STOP and wait.
+**5b. Security Review**
+"Security review via @security_reviewer..."
+Provide: file path, purpose, what to check
+Wait for response.
-## 3. SME Consultation (ONE AT A TIME, wait between each)
-Based on @explorer's domains, delegate to each SME serially.
-Each SME delegation must be self-contained with file paths and context.
+**5c. Audit**
+"Verifying via @auditor..."
+Provide: file path, specification to verify against
+Wait for response.
-## 4. Collate (you do this)
-Synthesize all inputs into a clear specification or report.
+**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
-## 5. Code (ONE TASK AT A TIME to @coder)
-If you have multiple coding tasks:
-- Break them into individual, focused tasks
-- Send first task to @coder, WAIT for completion
-- Review output, then send next task
-- Repeat until all tasks complete
-NEVER send multiple tasks/files to @coder in one delegation.
+Track attempts in plan.md.
-## 6. QA Review (serial: @security_reviewer first, wait, then @auditor)
-Send completed code with context. Tell them exactly what to check.
+**5e. Test**
+"Generating tests via @test_engineer..."
+Provide: file path, functions, test cases needed
+Wait for response.
-## 7. Triage (you do this)
-APPROVED \u2192 @test_engineer | REVISION_NEEDED \u2192 back to @coder with specific fixes | BLOCKED \u2192 explain
+**5f. Mark Complete**
+Update plan.md: mark task [x] complete
+Add learnings to context.md
+Proceed to next task.
-## 8. Test (one delegation to @test_engineer)
-Send code with specific test requirements.
+### Phase 6: Phase Complete
-**DELEGATION RULES**:
-- ONE agent per turn. Wait for response. Then next agent.
-- ONE coding task per @coder delegation. Break multi-file work into separate calls.
-- Every delegation must be self-contained (agent has no memory of prior context)
-- Include file paths, not just descriptions
-- Tell agents what NOT to do to prevent scope creep
-- Use structured formats (numbered lists, sections) not prose
-- If an agent's output is poor, provide clearer instructions or handle yourself
+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: "Ready to proceed to Phase [N+1]?"
+   - Do NOT auto-proceed without user confirmation
-**COMMUNICATION**:
-- Be direct with the user, no preamble or flattery
-- Don't ask for confirmation between phases - proceed automatically
-- If request is vague, ask ONE targeted question before starting
-- You orchestrate and synthesize. Prefer delegation over doing it yourself.`;
+### Handling Blockers
+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:**
+"Scanning codebase via @explorer...
+Analyze for: [purpose]
+Focus on: [areas]
+Return: structure, languages, frameworks, key files, relevant SME domains"
+**@sme_*:**
+"Consulting @sme_[domain]...
+Files: [paths]
+Context: [what we're building]
+Questions:
+1. [specific question]
+2. [specific question]
+Constraints: Focus only on [domain]"
+**@coder:**
+"Implementing via @coder...
+TASK: [single focused task]
+FILE: [single path]
+REQUIREMENTS:
+1. [requirement]
+2. [requirement]
+CONTEXT: [from SMEs, existing patterns]
+DO NOT: [constraints]
+ACCEPTANCE: [testable criteria]"
+**@security_reviewer:**
+"Security review via @security_reviewer...
+FILE: [path]
+PURPOSE: [description]
+CHECK: injection, data exposure, privilege issues, input validation
+RETURN: Risk level + findings with line numbers"
+**@auditor:**
+"Verifying via @auditor...
+FILE: [path]
+SPECIFICATION: [requirements]
+CHECK: correctness, edge cases, error handling
+RETURN: APPROVED or REJECTED with specifics"
+**@test_engineer:**
+"Generating tests via @test_engineer...
+FILE: [path]
+FUNCTIONS: [names]
+CASES: happy path, edge cases, error conditions
+OUTPUT: [test file path]"
+---
+## PROJECT FILES
+Maintain in .swarm/ directory:
+**plan.md format:**
+\`\`\`markdown
+# Project: [Name]
+Created: [date] | Updated: [date] | Current Phase: [N]
+## Overview
+[Summary]
+## Phase 1: [Name] [COMPLETE]
+- [x] Task 1.1: [desc] [SMALL]
+  - Acceptance: [criteria]
+## Phase 2: [Name] [IN PROGRESS]
+- [x] Task 2.1: [desc] [MEDIUM]
+- [ ] Task 2.2: [desc] [MEDIUM] (depends: 2.1) \u2190 CURRENT
+  - Acceptance: [criteria]
+  - Attempt 1: REJECTED - [reason]
+- [BLOCKED] Task 2.3: [desc]
+  - Reason: [why]
+\`\`\`
+**context.md format:**
+\`\`\`markdown
+# Project Context: [Name]
+## Technical Decisions
+- [Decision]: [rationale]
+## SME Guidance Cache
+### [Domain] (Phase N)
+- [Guidance]
+## Patterns Established
+- [Pattern]: [usage]
+## File Map
+- [path]: [purpose]
+\`\`\`
+---
+## 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
+You CAN write code directly if delegation repeatedly fails, but always try delegation first.
+---
+## COMMUNICATION
+- 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) {
@@ -14817,79 +14902,120 @@ function createAllSMEAgents(getModel, loadPrompt) {
 }
 // src/agents/index.ts
-function getModelForAgent(agentName, config2) {
-  const explicit = config2?.agents?.[agentName]?.model;
+function getModelForAgent(agentName, swarmAgents) {
+  const baseAgentName = agentName.includes("_") ? agentName.substring(agentName.indexOf("_") + 1) : agentName;
+  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) {
+  const baseAgentName = agentName.includes("_") ? agentName.substring(agentName.indexOf("_") + 1) : agentName;
+  return swarmAgents?.[baseAgentName]?.disabled === true;
 }
-function getTemperatureOverride(agentName, config2) {
-  return config2?.agents?.[agentName]?.temperature;
+function getTemperatureOverride(agentName, swarmAgents) {
+  const baseAgentName = agentName.includes("_") ? agentName.substring(agentName.indexOf("_") + 1) : agentName;
+  return swarmAgents?.[baseAgentName]?.temperature;
 }
-function applyOverrides(agent, config2) {
-  const tempOverride = getTemperatureOverride(agent.name, config2);
+function applyOverrides(agent, swarmAgents) {
+  const tempOverride = getTemperatureOverride(agent.name, swarmAgents);
   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 getModel = (name) => getModelForAgent(name, swarmAgents);
   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)) {
     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));
   }
-  if (!isAgentDisabled("explorer", config2)) {
+  if (!isAgentDisabled("explorer", swarmAgents)) {
     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));
   }
   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)) {
+      sme.name = prefixName(sme.name);
+      agents.push(applyOverrides(sme, swarmAgents));
     }
   }
-  if (!isAgentDisabled("coder", config2)) {
+  if (!isAgentDisabled("coder", swarmAgents)) {
     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));
   }
-  if (!isAgentDisabled("security_reviewer", config2)) {
+  if (!isAgentDisabled("security_reviewer", swarmAgents)) {
     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));
   }
-  if (!isAgentDisabled("auditor", config2)) {
+  if (!isAgentDisabled("auditor", swarmAgents)) {
     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));
   }
-  if (!isAgentDisabled("test_engineer", config2)) {
+  if (!isAgentDisabled("test_engineer", swarmAgents)) {
     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));
   }
   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) => {
@@ -14897,9 +15023,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 CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "opencode-swarm",
-  "version": "2.3.3",
+  "version": "3.1.0",
   "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",