opencode-swarm 2.1.2 → 2.2.1

package/README.md

@@ -2,78 +2,308 @@
 
 ![License](https://img.shields.io/badge/license-MIT-blue)
 ![OpenCode Plugin](https://img.shields.io/badge/opencode-plugin-green)
-![Agentic Architecture](https://img.shields.io/badge/architecture-architect--centric-purple)
+![Architecture](https://img.shields.io/badge/architecture-architect--centric-purple)
+![Version](https://img.shields.io/badge/version-2.2.1-orange)
 
-**Architect-driven, multi-agent development for OpenCode.**  
-Design-first orchestration with domain-aware SMEs, heterogeneous model perspectives, production-grade code generation, and layered QA.
+**Architect-driven, multi-agent development for OpenCode.**
 
-OpenCode Swarm is built for engineers who want **structured reasoning, controlled delegation, and predictable outcomes**—not parallel agent noise.
+Design-first orchestration with codebase discovery, domain-aware SMEs, heterogeneous model perspectives, and layered QA review.
 
----
+```
+┌──────────────────────────────────────────────────────────────────────────┐
+│  "Review this PowerShell application for security issues"                │
+└──────────────────────────────────────────────────────────────────────────┘
+                                    │
+                                    ▼
+┌──────────────────────────────────────────────────────────────────────────┐
+│  ARCHITECT: Delegating to @explorer for codebase analysis...             │
+└──────────────────────────────────────────────────────────────────────────┘
+                                    │
+                                    ▼
+┌──────────────────────────────────────────────────────────────────────────┐
+│  EXPLORER: PowerShell module, 12 files, domains: powershell, security    │
+│  → Flagged: auth.ps1, invoke-command.ps1 for SME review                  │
+└──────────────────────────────────────────────────────────────────────────┘
+                                    │
+                                    ▼
+┌──────────────────────────────────────────────────────────────────────────┐
+│  SME_POWERSHELL: Remoting patterns detected, needs constrained endpoints │
+│  SME_SECURITY: Credential handling issues in auth.ps1:42-58              │
+└──────────────────────────────────────────────────────────────────────────┘
+                                    │
+                                    ▼
+┌──────────────────────────────────────────────────────────────────────────┐
+│  ARCHITECT: Collated review with 3 HIGH findings, 2 recommendations      │
+└──────────────────────────────────────────────────────────────────────────┘
+```
 
-## Why OpenCode Swarm
+---
 
-Most agent frameworks parallelize everything and hope coherence emerges later.  
-OpenCode Swarm enforces discipline:
+## Why OpenCode Swarm?
 
-- A single Architect owns analysis and decisions
-- Experts are consulted only when technically relevant
-- Agents execute serially for traceability
-- Security and correctness are validated before delivery
-- Different models can be assigned per role, introducing genuinely distinct perspectives
+Most agent frameworks parallelize everything and hope coherence emerges.
+**OpenCode Swarm enforces discipline:**
 
-This design improves **accuracy, efficiency, and failure detection**, especially on complex or high-stakes tasks.
+| 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 |
 
 ---
 
-## Key Advantage: Heterogeneous Model Perspectives
-
-OpenCode Swarm allows **per-role model selection** so that each cognitive function is optimized independently:
+## Architecture
 
-- Architect → deep reasoning and synthesis
-- SMEs → domain recall and speed
-- Coder → implementation fidelity
-- QA → adversarial review and audit rigor
+```
+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
+└─────────────┘
+```
 
-Using different models per role reduces correlated failure modes, increases early error detection, and mirrors how real engineering teams benefit from diverse expertise.
+### Agent Permissions
 
-See: [docs/design-rationale.md](docs/design-rationale.md)
+| Agent | Read | Write | Role |
+|-------|:----:|:-----:|------|
+| Architect | ✅ | ✅ | Orchestrator - can fall back if delegation fails |
+| Explorer | ✅ | ❌ | Discovery - scans, summarizes, identifies domains |
+| SMEs (×11) | ✅ | ❌ | 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 |
 
 ---
 
-## Architecture Overview
+## Heterogeneous Model Perspectives
 
-OpenCode Swarm implements a hub-and-spoke pipeline with a single controlling Architect.
+OpenCode Swarm allows **different models per role**, reducing correlated failures:
 
-```
-User → Architect (analysis)
-     → Reader (optional)
-     → Relevant SMEs (serial)
-     → Architect (spec synthesis)
-     → Coder
-     → Security Review → Audit
-     → Architect (triage)
-     → Test Engineer
+```json
+{
+  "agents": {
+    "architect": { "model": "anthropic/claude-sonnet-4-5" },
+    "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" }
+  }
+}
 ```
 
-See: [docs/architecture.md](docs/architecture.md)
+**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
 
 ---
 
 ## Installation
 
+Add to your `opencode.json`:
+
 ```json
 {
   "plugin": ["opencode-swarm"]
 }
 ```
 
+Or install via CLI:
+
 ```bash
 bunx opencode-swarm install
 ```
 
 ---
 
+## Configuration
+
+Create `~/.config/opencode/opencode-swarm.json`:
+
+```json
+{
+  "agents": {
+    "architect": { "model": "anthropic/claude-sonnet-4-5" },
+    "explorer": { "model": "google/gemini-2.0-flash" },
+    "coder": { "model": "anthropic/claude-sonnet-4-5" },
+    "_sme": { "model": "google/gemini-2.0-flash" },
+    "_qa": { "model": "google/gemini-2.0-flash" },
+    "test_engineer": { "model": "google/gemini-2.0-flash" }
+  }
+}
+```
+
+### Category Defaults
+
+`_sme` and `_qa` set defaults for all agents in that category:
+
+```json
+{
+  "agents": {
+    "_sme": { "model": "google/gemini-2.0-flash" },
+    "sme_oracle": { "model": "anthropic/claude-sonnet-4-5" }
+  }
+}
+```
+
+### Disable Unused Domains
+
+```json
+{
+  "agents": {
+    "sme_vmware": { "disabled": true },
+    "sme_azure": { "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. |
+
+### 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 |
+
+### 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 |
+
+---
+
+## Tools
+
+| 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
+
+---
+
+## Documentation
+
+- [Architecture Details](docs/architecture.md)
+- [Design Rationale](docs/design-rationale.md)
+- [Installation Guide](docs/installation.md)
+
+---
+
 ## License
 
 MIT

package/dist/agents/explorer.d.ts

@@ -0,0 +1,2 @@
+import type { AgentDefinition } from './architect';
+export declare function createExplorerAgent(model: string, customPrompt?: string, customAppendPrompt?: string): AgentDefinition;

package/dist/agents/index.d.ts

@@ -13,7 +13,7 @@ export declare function createAgents(config?: PluginConfig): AgentDefinition[];
 export declare function getAgentConfigs(config?: PluginConfig): Record<string, SDKAgentConfig>;
 export { createArchitectAgent } from './architect';
 export { createCoderAgent } from './coder';
-export { createReaderAgent } from './reader';
+export { createExplorerAgent } from './explorer';
 export { createSecurityReviewerAgent } from './security-reviewer';
 export { createAuditorAgent } from './auditor';
 export { createTestEngineerAgent } from './test-engineer';

package/dist/config/constants.d.ts

@@ -1,9 +1,9 @@
 export declare const SME_AGENTS: readonly ["sme_windows", "sme_powershell", "sme_python", "sme_oracle", "sme_network", "sme_security", "sme_linux", "sme_vmware", "sme_azure", "sme_active_directory", "sme_ui_ux"];
 export declare const QA_AGENTS: readonly ["security_reviewer", "auditor"];
-export declare const PIPELINE_AGENTS: readonly ["reader", "coder", "test_engineer"];
+export declare const PIPELINE_AGENTS: readonly ["explorer", "coder", "test_engineer"];
 export declare const ORCHESTRATOR_NAME: "architect";
-export declare const ALL_SUBAGENT_NAMES: readonly ["sme_windows", "sme_powershell", "sme_python", "sme_oracle", "sme_network", "sme_security", "sme_linux", "sme_vmware", "sme_azure", "sme_active_directory", "sme_ui_ux", "security_reviewer", "auditor", "reader", "coder", "test_engineer"];
-export declare const ALL_AGENT_NAMES: readonly ["architect", "sme_windows", "sme_powershell", "sme_python", "sme_oracle", "sme_network", "sme_security", "sme_linux", "sme_vmware", "sme_azure", "sme_active_directory", "sme_ui_ux", "security_reviewer", "auditor", "reader", "coder", "test_engineer"];
+export declare const ALL_SUBAGENT_NAMES: readonly ["sme_windows", "sme_powershell", "sme_python", "sme_oracle", "sme_network", "sme_security", "sme_linux", "sme_vmware", "sme_azure", "sme_active_directory", "sme_ui_ux", "security_reviewer", "auditor", "explorer", "coder", "test_engineer"];
+export declare const ALL_AGENT_NAMES: readonly ["architect", "sme_windows", "sme_powershell", "sme_python", "sme_oracle", "sme_network", "sme_security", "sme_linux", "sme_vmware", "sme_azure", "sme_active_directory", "sme_ui_ux", "security_reviewer", "auditor", "explorer", "coder", "test_engineer"];
 export type SMEAgentName = (typeof SME_AGENTS)[number];
 export type QAAgentName = (typeof QA_AGENTS)[number];
 export type PipelineAgentName = (typeof PIPELINE_AGENTS)[number];

package/dist/index.js

@@ -25,7 +25,7 @@ var SME_AGENTS = [
   "sme_ui_ux"
 ];
 var QA_AGENTS = ["security_reviewer", "auditor"];
-var PIPELINE_AGENTS = ["reader", "coder", "test_engineer"];
+var PIPELINE_AGENTS = ["explorer", "coder", "test_engineer"];
 var ORCHESTRATOR_NAME = "architect";
 var ALL_SUBAGENT_NAMES = [
   ...SME_AGENTS,
@@ -42,7 +42,7 @@ var CATEGORY_PREFIXES = {
 };
 var DEFAULT_MODELS = {
   architect: "anthropic/claude-sonnet-4-5",
-  reader: "google/gemini-2.0-flash",
+  explorer: "google/gemini-2.0-flash",
   coder: "anthropic/claude-sonnet-4-5",
   test_engineer: "google/gemini-2.0-flash",
   _sme: "google/gemini-2.0-flash",
@@ -13844,11 +13844,11 @@ function loadAgentPrompt(agentName) {
 // src/agents/architect.ts
 var ARCHITECT_PROMPT = `You are Architect - an AI coding orchestrator that coordinates specialists to deliver quality code.
 
-**Role**: Analyze requests, consult domain SMEs, delegate implementation, and manage QA review.
+**Role**: Analyze requests, delegate discovery to Explorer, consult domain SMEs, delegate implementation, and manage QA review.
 
 **Agents**:
 
-@reader - Fast data processing agent for analyzing large files, codebases, or outputs
+@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
@@ -13866,35 +13866,38 @@ var ARCHITECT_PROMPT = `You are Architect - an AI coding orchestrator that coord
 @auditor - Code quality review, correctness verification
 @test_engineer - Test case generation and validation scripts
 
-**CRITICAL: @reader MUST be your FIRST delegation for code reviews**
-When asked to review, analyze, or examine any codebase:
-1. IMMEDIATELY delegate to @reader - do not read the code yourself
-2. Wait for @reader's summary
-3. Use that summary to decide which SMEs to consult
-4. Never skip @reader for code review tasks
+**WORKFLOW**:
 
-**Workflow**:
+## 1. Parse Request (you do this briefly)
+Understand what the user wants. Determine task type:
+- Code review/analysis \u2192 Explorer + SMEs + Collate
+- New implementation \u2192 Explorer + SMEs + Coder + QA + Test
+- Bug fix \u2192 Explorer + SMEs + Coder + QA
+- Question about codebase \u2192 Explorer + answer
 
-## 1. Analyze Request (you do this briefly)
-Parse what user wants. If it involves reviewing code \u2192 go directly to step 2.
+## 2. Explorer FIRST (delegate immediately for any code task)
+"Delegating to @explorer for codebase analysis..."
+@explorer scans the codebase and returns:
+- Project summary (languages, frameworks, structure)
+- Key files identified
+- Relevant domains for SME consultation
+- Files flagged for deeper review
 
-## 2. Reader FIRST (for any code review/analysis)
-"Delegating to @reader for codebase analysis..."
-- Send the codebase/files to @reader
-- Wait for summary response
-- Use summary to identify domains and issues
-
-## 3. SME Consultation (based on @reader's findings)
-Consult only SMEs for domains identified from @reader's summary.
-Usually 1-3 SMEs, not all 11. Wait for each response.
+## 3. SME Consultation (based on @explorer findings)
+From @explorer's "Relevant Domains" list, delegate to appropriate SMEs:
+- Usually 1-3 SMEs, not all 11
+- Serial execution (one at a time)
+- SMEs review the files flagged by @explorer
 
 ## 4. Collate (you do this)
-Combine @reader summary + SME inputs into final review or specification.
+Synthesize @explorer summary + SME inputs into:
+- For reviews: final findings report
+- For implementation: unified specification for @coder
 
-## 5. Code (delegate to @coder) - only if writing new code
-Send specification to @coder. Wait for implementation.
+## 5. Code (delegate to @coder) - if implementation needed
+Send specification to @coder with file paths from @explorer.
 
-## 6. QA Review (delegate serially) - only if code was written
+## 6. QA Review (delegate serially) - if code was written
 @security_reviewer first, then @auditor.
 
 ## 7. Triage (you do this)
@@ -13902,22 +13905,18 @@ APPROVED \u2192 @test_engineer | REVISION_NEEDED \u2192 @coder | BLOCKED \u2192
 
 ## 8. Test (delegate to @test_engineer) - if approved
 
-**Order of Operations for Code Review**:
-1. @reader (ALWAYS FIRST - analyzes codebase)
-2. @sme_* (only relevant domains based on @reader findings)
-3. Collate findings into review
-
-**Order of Operations for New Code**:
-1. @reader (if analyzing existing code first)
-2. @sme_* (relevant domains)
-3. @coder (implementation)
-4. @security_reviewer \u2192 @auditor (QA)
-5. @test_engineer (tests)
+**DELEGATION RULES**:
+- @explorer is ALWAYS your first delegation for tasks involving code
+- Wait for each agent response before calling the next
+- Only consult SMEs for domains identified by @explorer
+- Brief notices: "Delegating to @explorer..." not lengthy explanations
+- If an agent fails or gives poor output, you can handle it yourself
 
-**Communication**:
-- Be direct, no preamble
-- Don't ask for confirmation between phases
-- You analyze, collate, and triage. You never write code yourself.`;
+**COMMUNICATION**:
+- Be direct, 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.`;
 function createArchitectAgent(model, customPrompt, customAppendPrompt) {
   let prompt = ARCHITECT_PROMPT;
   if (customPrompt) {
@@ -13999,7 +13998,12 @@ ${customAppendPrompt}`;
     config: {
       model,
       temperature: 0.1,
-      prompt
+      prompt,
+      tools: {
+        write: false,
+        edit: false,
+        patch: false
+      }
     }
   };
 }
@@ -14050,63 +14054,85 @@ ${customAppendPrompt}`;
   };
 }
 
-// src/agents/reader.ts
-var READER_PROMPT = `You are Reader - a fast data processing specialist.
+// src/agents/explorer.ts
+var EXPLORER_PROMPT = `You are Explorer - a fast codebase discovery and analysis specialist.
 
-**Role**: Quickly analyze large datasets, codebases, or outputs and provide concise summaries for the Architect.
+**Role**: Quickly scan and summarize codebases so the Architect can make informed decisions. You are ALWAYS the first agent called for any task involving existing code.
 
-**Behavior**:
-- Read and process the provided content efficiently
-- Extract key information relevant to the task
-- Summarize findings in a structured, actionable format
-- Focus on what matters for implementation decisions
+**Capabilities**:
+- Scan directory structure (glob, ls, tree)
+- Read and summarize key files (README, configs, entry points)
+- Identify languages, frameworks, patterns
+- Search for specific patterns (grep)
+- Provide file paths for deeper analysis
 
-**Use cases**:
-- Analyzing gitingest output to understand a codebase
-- Reviewing large log files or data dumps
-- Summarizing documentation or specifications
-- Processing API responses or test results
+**Behavior**:
+- Be fast - scan broadly, read selectively
+- Focus on understanding structure before diving into details
+- Identify which technical domains are relevant (powershell, python, security, etc.)
+- Flag files that need deeper SME review
 
 **Output Format**:
-<summary>
-[2-3 sentence overview of what you analyzed]
-</summary>
 
-<key_findings>
-- [Finding 1: specific, actionable]
-- [Finding 2: specific, actionable]
-- [Finding 3: specific, actionable]
-</key_findings>
+<codebase_summary>
+**Project**: [name/type - e.g., "PowerShell module for AD management"]
+**Languages**: [primary languages detected]
+**Framework/Stack**: [if applicable]
+
+**Structure**:
+\`\`\`
+[brief directory tree of key folders]
+\`\`\`
+
+**Key Files**:
+- \`/path/to/entry.ps1\` - Main entry point, [brief description]
+- \`/path/to/config.json\` - Configuration, [what it configures]
+
+**Architecture**:
+[2-3 sentences on how the code is organized]
+
+**Patterns Observed**:
+- [coding patterns, conventions, potential issues]
 
-<relevant_details>
-[Specific code patterns, file paths, function names, or data points the Architect needs]
-</relevant_details>
+**Relevant Domains**: [comma-separated: powershell, security, windows, etc.]
+</codebase_summary>
 
-<recommendations>
-[Brief suggestions based on your analysis]
-</recommendations>
+<files_for_review>
+[List specific files that need deeper analysis, with brief reason]
+- \`/path/to/file1.ps1\` - Complex logic, needs @sme_powershell review
+- \`/path/to/auth.ps1\` - Security-sensitive, needs @sme_security review
+</files_for_review>
+
+<initial_observations>
+[Any immediate concerns, questions, or notable findings]
+</initial_observations>
 
 **Constraints**:
-- No code writing
-- No delegation
-- Focus on speed and accuracy
-- Keep total output under 2000 characters`;
-function createReaderAgent(model, customPrompt, customAppendPrompt) {
-  let prompt = READER_PROMPT;
+- Keep total output under 4000 characters
+- No code writing or modification
+- No delegation to other agents
+- Focus on discovery, not implementation`;
+function createExplorerAgent(model, customPrompt, customAppendPrompt) {
+  let prompt = EXPLORER_PROMPT;
   if (customPrompt) {
     prompt = customPrompt;
   } else if (customAppendPrompt) {
-    prompt = `${READER_PROMPT}
+    prompt = `${EXPLORER_PROMPT}
 
 ${customAppendPrompt}`;
   }
   return {
-    name: "reader",
-    description: "Fast data processing agent for analyzing large files, codebases, or outputs. Returns concise summaries.",
+    name: "explorer",
+    description: "Fast codebase discovery and analysis. Scans directory structure, identifies languages/frameworks, summarizes key files, and flags areas needing SME review.",
     config: {
       model,
       temperature: 0.1,
-      prompt
+      prompt,
+      tools: {
+        write: false,
+        edit: false,
+        patch: false
+      }
     }
   };
 }
@@ -14163,7 +14189,12 @@ ${customAppendPrompt}`;
     config: {
       model,
       temperature: 0.1,
-      prompt
+      prompt,
+      tools: {
+        write: false,
+        edit: false,
+        patch: false
+      }
     }
   };
 }
@@ -14288,7 +14319,12 @@ ${customAppendPrompt}`;
     config: {
       model,
       temperature: 0.2,
-      prompt
+      prompt,
+      tools: {
+        write: false,
+        edit: false,
+        patch: false
+      }
     }
   };
 }
@@ -14605,10 +14641,10 @@ function createAgents(config2) {
     const architect = createArchitectAgent(getModel("architect"), architectPrompts.prompt, architectPrompts.appendPrompt);
     agents.push(applyOverrides(architect, config2));
   }
-  if (!isAgentDisabled("reader", config2)) {
-    const readerPrompts = getPrompts("reader");
-    const reader = createReaderAgent(getModel("reader"), readerPrompts.prompt, readerPrompts.appendPrompt);
-    agents.push(applyOverrides(reader, config2));
+  if (!isAgentDisabled("explorer", config2)) {
+    const explorerPrompts = getPrompts("explorer");
+    const explorer = createExplorerAgent(getModel("explorer"), explorerPrompts.prompt, explorerPrompts.appendPrompt);
+    agents.push(applyOverrides(explorer, config2));
   }
   const smeAgents = createAllSMEAgents(getModel, getPrompts);
   for (const sme of smeAgents) {

package/package.json

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

package/dist/agents/reader.d.ts

@@ -1,2 +0,0 @@
-import type { AgentDefinition } from './architect';
-export declare function createReaderAgent(model: string, customPrompt?: string, customAppendPrompt?: string): AgentDefinition;