opencode-swarm 2.0.2 → 2.1.1

package/README.md

@@ -1,161 +1,78 @@
 # OpenCode Swarm
 
-Architect-centric agentic swarm plugin for OpenCode. Hub-and-spoke orchestration with SME consultation, code generation, and QA review.
+![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)
 
-## Overview
+**Architect-driven, multi-agent development for OpenCode.**  
+Design-first orchestration with domain-aware SMEs, heterogeneous model perspectives, production-grade code generation, and layered QA.
 
-OpenCode Swarm implements a multi-agent development pipeline where:
+OpenCode Swarm is built for engineers who want **structured reasoning, controlled delegation, and predictable outcomes**—not parallel agent noise.
 
-1. **Architect** (central orchestrator) analyzes requests and coordinates all agents
-2. **SME Agents** provide domain-specific technical expertise (serial execution)
-3. **Coder** implements unified specifications
-4. **QA Agents** (Security Reviewer + Auditor) validate code quality
-5. **Test Engineer** generates test cases for approved code
+---
 
-```
-User → Architect (analyze) → [SME Pool - serial] → Architect (collate)
-     → Coder → [QA: Security + Auditor] → Architect (triage) → Test
-```
+## Why OpenCode Swarm
 
-## Installation
+Most agent frameworks parallelize everything and hope coherence emerges later.  
+OpenCode Swarm enforces discipline:
 
-```bash
-bunx opencode-swarm install
-```
+- 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
 
-Then start OpenCode:
+This design improves **accuracy, efficiency, and failure detection**, especially on complex or high-stakes tasks.
 
-```bash
-opencode
-```
-
-## Configuration
+---
 
-Edit `~/.config/opencode/opencode-swarm.json`:
-
-```json
-{
-  "preset": "hybrid",
-  "presets": {
-    "remote": {
-      "architect": { "model": "anthropic/claude-sonnet-4.5" },
-      "coder": { "model": "openai/gpt-5.2-codex" },
-      "_sme": { "model": "google/gemini-3-flash" },
-      "_qa": { "model": "google/gemini-3-flash" },
-      "test_engineer": { "model": "google/gemini-3-flash" }
-    },
-    "hybrid": {
-      "architect": { "model": "anthropic/claude-sonnet-4.5" },
-      "coder": { "model": "ollama/qwen3:72b" },
-      "_sme": { "model": "npu/qwen3:14b" },
-      "_qa": { "model": "npu/qwen3:14b" },
-      "test_engineer": { "model": "npu/qwen3:14b" }
-    }
-  },
-  "swarm_mode": "hybrid",
-  "gpu_url": "http://192.168.1.100:1234/v1",
-  "npu_url": "http://localhost:11435/v1",
-  "max_iterations": 5
-}
-```
+## Key Advantage: Heterogeneous Model Perspectives
 
-### Category Defaults
+OpenCode Swarm allows **per-role model selection** so that each cognitive function is optimized independently:
 
-Use `_sme` and `_qa` to set models for all agents in a category:
+- Architect → deep reasoning and synthesis
+- SMEs → domain recall and speed
+- Coder → implementation fidelity
+- QA → adversarial review and audit rigor
 
-```json
-{
-  "agents": {
-    "_sme": { "model": "npu/qwen3:14b" },
-    "_qa": { "model": "npu/qwen3:14b" }
-  }
-}
-```
+Using different models per role reduces correlated failure modes, increases early error detection, and mirrors how real engineering teams benefit from diverse expertise.
 
-To override a specific agent within a category:
+See: [docs/design-rationale.md](docs/design-rationale.md)
 
-```json
-{
-  "agents": {
-    "_sme": { "model": "npu/qwen3:14b" },
-    "sme_oracle": { "model": "ollama/qwen3:72b" }
-  }
-}
-```
+---
 
-### Custom Prompts
+## Architecture Overview
 
-Place custom prompts in `~/.config/opencode/opencode-swarm/`:
+OpenCode Swarm implements a hub-and-spoke pipeline with a single controlling Architect.
 
-- `{agent}.md` - Replace the default prompt entirely
-- `{agent}_append.md` - Append to the default prompt
-
-Example: `architect_append.md` to add custom instructions to the Architect.
-
-## Agents
-
-### Orchestrator
-
-| Agent | Role |
-|-------|------|
-| `architect` | Central orchestrator, coordinates all phases |
-
-### SME Specialists (Domain Experts)
-
-| Agent | Domain |
-|-------|--------|
-| `sme_windows` | Windows OS internals, registry, services |
-| `sme_powershell` | PowerShell scripting, cmdlets, modules |
-| `sme_python` | Python ecosystem, libraries, best practices |
-| `sme_oracle` | Oracle Database, SQL/PLSQL, administration |
-| `sme_network` | Networking, firewalls, DNS, TLS/SSL |
-| `sme_security` | STIG compliance, hardening, encryption |
-| `sme_linux` | Linux administration, systemd, packages |
-| `sme_vmware` | VMware vSphere, ESXi, PowerCLI |
-| `sme_azure` | Azure cloud services, Entra ID, ARM/Bicep |
-| `sme_active_directory` | Active Directory, LDAP, Group Policy |
-| `sme_ui_ux` | UI/UX design, interaction patterns |
-
-### Pipeline Agents
-
-| Agent | Role |
-|-------|------|
-| `coder` | Implements specifications, writes production code |
-| `security_reviewer` | Security vulnerability assessment |
-| `auditor` | Code correctness and quality review |
-| `test_engineer` | Test case and validation script generation |
-
-## Workflow Phases
-
-1. **ANALYZE** - Parse request, identify domains, create initial spec
-2. **SME_CONSULTATION** - Consult domain experts serially
-3. **COLLATE** - Synthesize SME outputs into unified spec
-4. **CODE** - Generate implementation
-5. **QA_REVIEW** - Security and quality review (parallel)
-6. **TRIAGE** - Approve, request revision, or block
-7. **TEST** - Generate tests for approved code
-
-## Delegation Rules
+```
+User → Architect (analysis)
+     → Reader (optional)
+     → Relevant SMEs (serial)
+     → Architect (spec synthesis)
+     → Coder
+     → Security Review → Audit
+     → Architect (triage)
+     → Test Engineer
+```
 
-The Architect enforces resource-aware delegation:
+See: [docs/architecture.md](docs/architecture.md)
 
-- **SME agents**: Execute serially (one at a time) to avoid overwhelming local inference
-- **QA agents**: May execute in parallel (independent analysis)
-- **Cross-category**: One agent per category may run simultaneously
+---
 
-## Tools
+## Installation
 
-| Tool | Description |
-|------|-------------|
-| `detect_domains` | Auto-detect SME domains from text |
-| `extract_code_blocks` | Extract and save code blocks to files |
+```json
+{
+  "plugin": ["opencode-swarm"]
+}
+```
 
-## Environment Variables
+```bash
+bunx opencode-swarm install
+```
 
-| Variable | Description |
-|----------|-------------|
-| `OPENCODE_SWARM_PRESET` | Override preset selection |
-| `OPENCODE_SWARM_DEBUG` | Enable debug logging (`1` to enable) |
+---
 
 ## License
 

package/dist/agents/index.d.ts

@@ -13,7 +13,8 @@ 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 { createSecurityReviewerAgent } from './security-reviewer';
 export { createAuditorAgent } from './auditor';
 export { createTestEngineerAgent } from './test-engineer';
-export { createUnifiedSMEAgent, AVAILABLE_DOMAINS } from './sme-unified';
+export { createAllSMEAgents, createSMEAgent, listDomains } from './sme';

package/dist/agents/reader.d.ts

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

package/dist/config/constants.d.ts

@@ -1,19 +1,20 @@
-export declare const SME_AGENT: "sme";
+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 ["coder", "test_engineer"];
+export declare const PIPELINE_AGENTS: readonly ["reader", "coder", "test_engineer"];
 export declare const ORCHESTRATOR_NAME: "architect";
-export declare const ALL_SUBAGENT_NAMES: readonly ["sme", "security_reviewer", "auditor", "coder", "test_engineer"];
-export declare const ALL_AGENT_NAMES: readonly ["architect", "sme", "security_reviewer", "auditor", "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", "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 type SMEAgentName = (typeof SME_AGENTS)[number];
 export type QAAgentName = (typeof QA_AGENTS)[number];
 export type PipelineAgentName = (typeof PIPELINE_AGENTS)[number];
 export type AgentName = (typeof ALL_AGENT_NAMES)[number];
-export type SMEAgentName = 'sme';
 export declare const CATEGORY_PREFIXES: {
     readonly sme: "_sme";
     readonly qa: "_qa";
 };
 export declare const DEFAULT_MODELS: Record<string, string>;
 export declare const DOMAIN_PATTERNS: Record<string, RegExp[]>;
-export declare function domainToAgentName(_domain: string): 'sme';
+export declare function domainToAgentName(domain: string): SMEAgentName;
+export declare function isSMEAgent(name: string): name is SMEAgentName;
 export declare function isQAAgent(name: string): name is QAAgentName;
 export declare function isSubagent(name: string): boolean;

package/dist/config/index.d.ts

@@ -1,4 +1,4 @@
-export { ALL_AGENT_NAMES, ALL_SUBAGENT_NAMES, CATEGORY_PREFIXES, DEFAULT_MODELS, DOMAIN_PATTERNS, ORCHESTRATOR_NAME, PIPELINE_AGENTS, QA_AGENTS, SME_AGENT, domainToAgentName, isQAAgent, isSubagent, } from './constants';
+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';

package/dist/index.js

@@ -11,12 +11,24 @@ var __export = (target, all) => {
 };
 
 // src/config/constants.ts
-var SME_AGENT = "sme";
+var SME_AGENTS = [
+  "sme_windows",
+  "sme_powershell",
+  "sme_python",
+  "sme_oracle",
+  "sme_network",
+  "sme_security",
+  "sme_linux",
+  "sme_vmware",
+  "sme_azure",
+  "sme_active_directory",
+  "sme_ui_ux"
+];
 var QA_AGENTS = ["security_reviewer", "auditor"];
-var PIPELINE_AGENTS = ["coder", "test_engineer"];
+var PIPELINE_AGENTS = ["reader", "coder", "test_engineer"];
 var ORCHESTRATOR_NAME = "architect";
 var ALL_SUBAGENT_NAMES = [
-  SME_AGENT,
+  ...SME_AGENTS,
   ...QA_AGENTS,
   ...PIPELINE_AGENTS
 ];
@@ -29,13 +41,13 @@ var CATEGORY_PREFIXES = {
   qa: "_qa"
 };
 var DEFAULT_MODELS = {
-  architect: "anthropic/claude-sonnet-4.5",
-  sme: "google/gemini-3-flash",
-  coder: "anthropic/claude-sonnet-4.5",
-  test_engineer: "google/gemini-3-flash",
-  _sme: "google/gemini-3-flash",
-  _qa: "google/gemini-3-flash",
-  default: "google/gemini-3-flash"
+  architect: "anthropic/claude-sonnet-4-5",
+  reader: "google/gemini-2.0-flash",
+  coder: "anthropic/claude-sonnet-4-5",
+  test_engineer: "google/gemini-2.0-flash",
+  _sme: "google/gemini-2.0-flash",
+  _qa: "google/gemini-2.0-flash",
+  default: "google/gemini-2.0-flash"
 };
 var DOMAIN_PATTERNS = {
   windows: [
@@ -191,6 +203,9 @@ var DOMAIN_PATTERNS = {
     /\bresponsive\b/i
   ]
 };
+function isSMEAgent(name) {
+  return SME_AGENTS.includes(name);
+}
 function isQAAgent(name) {
   return QA_AGENTS.includes(name);
 }
@@ -13829,32 +13844,42 @@ 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 SME for domain expertise, delegate implementation, and manage QA review.
+**Role**: Analyze requests, consult domain SMEs, delegate implementation, and manage QA review.
 
 **Agents**:
 
-@sme - Multi-domain subject matter expert (handles all technical domains in one call)
+@reader - Fast data processing agent for analyzing large files, codebases, or outputs
+@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
+
 @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
 
-**Available SME Domains**: windows, powershell, python, oracle, network, security, linux, vmware, azure, active_directory, ui_ux
-
 **Workflow**:
 
 ## 1. Analyze (you do this)
 Parse request: explicit requirements + implicit needs.
-Identify which domains are relevant.
+Identify which domains are relevant (usually 1-3, not all).
 Create initial specification.
 
-## 2. SME Consultation (single call to @sme)
-Delegate to @sme with ALL relevant domains in one request.
-Example: "I need expertise for: windows, powershell, security"
-Wait for response.
+## 2. SME Consultation (delegate only relevant SMEs, serially)
+For each relevant domain, delegate to @sme_* agent one at a time.
+Only consult SMEs for domains that actually apply to the task.
+Wait for each response before calling the next.
 
 ## 3. Collate (you do this)
-Synthesize SME input into unified specification.
+Synthesize SME inputs into unified specification.
 Ensure clarity and completeness.
 
 ## 4. Code (delegate to @coder)
@@ -13874,11 +13899,17 @@ Review QA feedback and decide:
 ## 7. Test (delegate to @test_engineer)
 Send approved code to @test_engineer for test generation.
 
+**Using @reader**:
+- Delegate to @reader when you need to process large amounts of data
+- Use for: analyzing gitingest output, reviewing large files, summarizing codebases
+- @reader returns condensed summaries you can use for decision-making
+
 **Delegation Rules**:
 - All agents run serially (one at a time)
 - Wait for each agent response before calling the next
+- Only consult SMEs for domains relevant to the task (1-3 typically)
 - Reference paths/lines, don't paste entire files
-- Brief delegation notices: "Consulting @sme for windows, powershell..."
+- Brief delegation notices: "Consulting @sme_powershell..."
 
 **Communication**:
 - Be direct, no preamble or flattery
@@ -14017,6 +14048,67 @@ ${customAppendPrompt}`;
   };
 }
 
+// src/agents/reader.ts
+var READER_PROMPT = `You are Reader - a fast data processing specialist.
+
+**Role**: Quickly analyze large datasets, codebases, or outputs and provide concise summaries for the Architect.
+
+**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
+
+**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
+
+**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>
+
+<relevant_details>
+[Specific code patterns, file paths, function names, or data points the Architect needs]
+</relevant_details>
+
+<recommendations>
+[Brief suggestions based on your analysis]
+</recommendations>
+
+**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;
+  if (customPrompt) {
+    prompt = customPrompt;
+  } else if (customAppendPrompt) {
+    prompt = `${READER_PROMPT}
+
+${customAppendPrompt}`;
+  }
+  return {
+    name: "reader",
+    description: "Fast data processing agent for analyzing large files, codebases, or outputs. Returns concise summaries.",
+    config: {
+      model,
+      temperature: 0.1,
+      prompt
+    }
+  };
+}
+
 // src/agents/security-reviewer.ts
 var SECURITY_REVIEWER_PROMPT = `You are Security Reviewer - a security audit specialist.
 
@@ -14141,60 +14233,56 @@ ${customAppendPrompt}`;
   };
 }
 
-// src/agents/sme-unified.ts
-var DOMAIN_EXPERTISE = {
-  windows: `Windows OS: Registry, services, WMI/CIM, event logs, scheduled tasks, Group Policy, installers, WinRM`,
-  powershell: `PowerShell: Cmdlets, modules, remoting, Pester testing, pipeline, error handling, PSCustomObject`,
-  python: `Python: pip, venv, Django, Flask, pandas, numpy, pytest, async/await, type hints`,
-  oracle: `Oracle DB: SQL/PLSQL, tablespaces, RMAN, DataGuard, ASM, RAC, TNS, ORA errors`,
-  network: `Networking: TCP/UDP, DNS, DHCP, firewalls, VLANs, routing, load balancing, TLS/SSL, certificates`,
-  security: `Security: STIG compliance, hardening, CVE remediation, SCAP, FIPS, PKI, encryption, CAC`,
-  linux: `Linux: systemd, bash, yum/apt, cron, permissions, SELinux, journalctl`,
-  vmware: `VMware: vSphere, ESXi, vCenter, VSAN, NSX, PowerCLI, datastores, vMotion`,
-  azure: `Azure: Entra ID, ARM/Bicep, KeyVault, Blob storage, Azure DevOps, managed identities`,
-  active_directory: `Active Directory: LDAP, Group Policy, Kerberos, SPNs, domain trusts, ADUC, replication`,
-  ui_ux: `UI/UX: Interaction patterns, accessibility (WCAG), responsive design, typography, color theory, layout`
-};
-var UNIFIED_SME_PROMPT = `You are SME (Subject Matter Expert) - a multi-domain technical specialist.
+// src/agents/sme/base.ts
+function createSMEPrompt(config2) {
+  const { domain: domain2, description, guidance } = config2;
+  return `You are ${domain2}_SME - a subject matter expert in ${description}.
+
+**Role**: Provide domain-specific technical context to enhance the Architect's specification. Your output will be read by the Architect for collation, not directly by a human or coder.
 
-**Role**: Provide domain-specific technical context for all requested domains in a single response. Your output will be read by the Architect for collation.
+**Domain Expertise**:
+${guidance}
 
 **Behavior**:
-- Address ALL domains listed in the request
-- Be specific: exact names, paths, parameters, API signatures
-- Be concise: focus only on implementation-relevant details
+- Be specific: exact names, paths, parameters, not general advice
+- Be concise: under 4000 characters
 - Be actionable: information the Coder can directly use
-
-**Domain Expertise Available**:
-${Object.entries(DOMAIN_EXPERTISE).map(([domain2, desc]) => `- ${domain2}: ${desc}`).join(`
-`)}
+- Focus on implementation-relevant details only
+- Include version-specific notes if applicable
 
 **Output Format**:
-<sme_context>
-For each relevant domain, provide:
+<${domain2}_context>
+**Critical Considerations**:
+[Must-know information that affects implementation]
+
+**Recommended Approach**:
+[Best practices and patterns for this domain]
 
-**[Domain Name]**:
-- Critical considerations for implementation
-- Recommended approach and patterns
-- Specific APIs, cmdlets, or functions to use
-- Common gotchas to avoid
-- Dependencies required
+**API/Syntax Details**:
+[Exact cmdlet names, function signatures, class names]
 
-</sme_context>
+**Gotchas**:
+[Common mistakes to avoid]
 
-Keep total response under 4000 characters for efficient processing.`;
-function createUnifiedSMEAgent(model, customPrompt, customAppendPrompt) {
-  let prompt = UNIFIED_SME_PROMPT;
+**Dependencies**:
+[Required modules, services, permissions]
+
+**Code Patterns**:
+[Short snippets showing correct usage if helpful]
+</${domain2}_context>`;
+}
+function createSMEAgent(agentName, domainConfig, model, customPrompt, customAppendPrompt) {
+  let prompt = createSMEPrompt(domainConfig);
   if (customPrompt) {
     prompt = customPrompt;
   } else if (customAppendPrompt) {
-    prompt = `${UNIFIED_SME_PROMPT}
+    prompt = `${prompt}
 
 ${customAppendPrompt}`;
   }
   return {
-    name: "sme",
-    description: "Multi-domain subject matter expert. Provides technical context for multiple domains in a single call.",
+    name: agentName,
+    description: `Subject matter expert for ${domainConfig.description}. Provides domain-specific technical context for the Architect.`,
     config: {
       model,
       temperature: 0.2,
@@ -14202,14 +14290,284 @@ ${customAppendPrompt}`;
     }
   };
 }
-var AVAILABLE_DOMAINS = Object.keys(DOMAIN_EXPERTISE);
+
+// src/agents/sme/active-directory.ts
+var activeDirectorySMEConfig = {
+  domain: "active_directory",
+  description: "Active Directory and identity management",
+  guidance: `For Active Directory tasks, provide:
+- AD PowerShell module cmdlets (Get-ADUser, Set-ADUser, etc.)
+- LDAP filter syntax and examples
+- Distinguished name (DN) formats
+- Group Policy structure and processing order
+- Kerberos authentication flow considerations
+- SPN (Service Principal Name) configuration
+- AD schema and common attributes
+- Replication and site topology concepts
+- Organizational Unit (OU) design patterns
+- Security group types (Domain Local, Global, Universal)
+- Delegation of control patterns
+- Fine-grained password policies
+- AD object GUIDs and SIDs
+- Trust relationships
+- ADSI/DirectoryServices .NET classes
+- Common AD error codes and resolutions
+- Group Policy preferences vs policies`
+};
+
+// src/agents/sme/azure.ts
+var azureSMEConfig = {
+  domain: "azure",
+  description: "Microsoft Azure cloud services",
+  guidance: `For Azure tasks, provide:
+- Az PowerShell module cmdlets (Az.Accounts, Az.Compute, etc.)
+- Azure CLI (az) command syntax
+- ARM template structure and syntax
+- Bicep syntax and patterns
+- Entra ID (formerly Azure AD) configuration
+- RBAC role assignments and custom roles
+- Resource naming conventions and constraints
+- Service principal and managed identity configuration
+- Azure resource provider namespaces
+- Common Azure resource types and properties
+- Subscription and resource group scoping
+- Azure networking (VNet, NSG, Load Balancer)
+- Storage account types and access tiers
+- Azure Key Vault integration patterns
+- Cost management considerations
+- Azure Government differences if applicable`
+};
+
+// src/agents/sme/linux.ts
+var linuxSMEConfig = {
+  domain: "linux",
+  description: "Linux system administration",
+  guidance: `For Linux tasks, provide:
+- Distribution-specific commands (RHEL/CentOS vs Ubuntu/Debian)
+- Systemd unit file structure (service, timer, socket units)
+- File permissions and ownership (chmod, chown, ACLs)
+- SELinux/AppArmor considerations (contexts, policies, booleans)
+- Package management commands (yum/dnf vs apt)
+- Cron syntax and systemd timer alternatives
+- Log file locations (/var/log, journalctl)
+- Service management patterns (systemctl, enable, start)
+- User and group management
+- Filesystem hierarchy standard (FHS) paths
+- Shell scripting best practices (bash, POSIX compliance)
+- Process management (ps, top, kill signals)
+- Network configuration (nmcli, ip, netplan)
+- Environment variables and profile scripts`
+};
+
+// src/agents/sme/network.ts
+var networkSMEConfig = {
+  domain: "network",
+  description: "network architecture, protocols, and security",
+  guidance: `For network tasks, provide:
+- Protocol specifications and standard port numbers
+- Firewall rule syntax (Windows Firewall, iptables, firewalld)
+- DNS record types and configuration (A, AAAA, CNAME, MX, TXT, SRV)
+- Certificate requirements and chain validation
+- TLS/SSL configuration best practices (cipher suites, protocols)
+- Load balancer and proxy considerations
+- Network troubleshooting commands (ping, tracert, nslookup, netstat)
+- Security group and ACL patterns
+- IP addressing and subnetting
+- VLAN configuration concepts
+- NAT and port forwarding
+- HTTP/HTTPS specifics (headers, status codes, methods)
+- Socket programming considerations
+- Common network errors and their causes`
+};
+
+// src/agents/sme/oracle.ts
+var oracleSMEConfig = {
+  domain: "oracle",
+  description: "Oracle Database administration and SQL/PLSQL",
+  guidance: `For Oracle tasks, provide:
+- Correct SQL syntax for Oracle (not MySQL/SQL Server)
+- PL/SQL block structure and exception handling
+- CDB/PDB architecture considerations
+- Parameter names and valid values (init.ora, spfile)
+- Required privileges and roles (DBA, SYSDBA, specific grants)
+- Data dictionary views (DBA_*, ALL_*, USER_*, V$*, GV$*)
+- RMAN commands and syntax
+- TNS configuration and connectivity (tnsnames.ora, listener.ora)
+- Oracle-specific functions (NVL, DECODE, LISTAGG, etc.)
+- Bind variable usage for performance
+- Transaction handling (COMMIT, ROLLBACK, savepoints)
+- LOB handling (CLOB, BLOB operations)
+- Date/timestamp handling (TO_DATE, TO_TIMESTAMP, NLS settings)
+- Execution plan analysis (EXPLAIN PLAN, hints)`
+};
+
+// src/agents/sme/powershell.ts
+var powershellSMEConfig = {
+  domain: "powershell",
+  description: "PowerShell scripting and automation",
+  guidance: `For PowerShell tasks, provide:
+- Correct cmdlet names, parameters, and syntax
+- Required modules and how to import them (Import-Module, #Requires)
+- Pipeline patterns and object handling
+- Error handling with try/catch and $ErrorActionPreference
+- Output formatting and object types ([PSCustomObject], etc.)
+- Remote execution (PSSession, Invoke-Command, -ComputerName)
+- Module compatibility (Windows PowerShell 5.1 vs PowerShell 7+)
+- Common parameter patterns (-Verbose, -WhatIf, -Confirm, -ErrorAction)
+- Splatting for complex parameter sets
+- Advanced function patterns ([CmdletBinding()], param blocks)
+- Pester testing patterns for the code
+- Credential handling (Get-Credential, [PSCredential])
+- Output streams (Write-Output, Write-Verbose, Write-Error)`
+};
+
+// src/agents/sme/python.ts
+var pythonSMEConfig = {
+  domain: "python",
+  description: "Python development and ecosystem",
+  guidance: `For Python tasks, provide:
+- Recommended libraries for the task (stdlib vs third-party)
+- Windows-specific modules (pywin32, wmi, winreg, ctypes)
+- Correct API usage patterns and idioms
+- Virtual environment considerations (venv, pip install)
+- Type hints and dataclass usage
+- Exception handling patterns (specific exceptions, context managers)
+- File handling (pathlib vs os.path, encoding considerations)
+- Cross-platform compatibility notes
+- Async patterns if applicable (asyncio, aiohttp)
+- Logging configuration (logging module setup)
+- Package structure for larger scripts
+- Python version compatibility (3.8+ features)
+- Common gotchas (mutable default arguments, import cycles)`
+};
+
+// src/agents/sme/security.ts
+var securitySMEConfig = {
+  domain: "security",
+  description: "cybersecurity, compliance, and hardening",
+  guidance: `For security tasks, provide:
+- STIG requirements and check IDs (V-#####, SV-#####)
+- DISA compliance requirements
+- FIPS 140-2/3 considerations (approved algorithms, modes)
+- CAC/PIV/PKI implementation details
+- Encryption standards and key management
+- Audit logging requirements (what to log, retention)
+- Least privilege patterns
+- Secure configuration baselines
+- CIS Benchmark references if applicable
+- Common vulnerability patterns to avoid
+- Authentication and authorization best practices
+- Secrets management (no hardcoding, secure storage)
+- Input validation and sanitization
+- Secure communication requirements (TLS versions, cipher suites)
+- DoD/Federal specific requirements if applicable`
+};
+
+// src/agents/sme/ui-ux.ts
+var uiUxSMEConfig = {
+  domain: "ui_ux",
+  description: "UI/UX design, interaction patterns, and visual systems",
+  guidance: `For UI/UX tasks, provide:
+- Information architecture and navigation flow
+- Interaction patterns and states (loading, empty, error, success)
+- Responsive layout guidance and breakpoints
+- Typography scale and hierarchy recommendations
+- Spacing system (8px grid, consistent margins/padding)
+- Color usage (primary, secondary, semantic colors)
+- Contrast and accessibility requirements (WCAG 2.1 AA)
+- Component structure and reusability patterns
+- Form design best practices (labels, validation, feedback)
+- Motion/animation guidance (purposeful, not excessive)
+- Touch target sizes for mobile (44px minimum)
+- Focus management for keyboard navigation
+- Icon usage and consistency
+- Empty states and error message design
+- Progressive disclosure patterns
+- Loading and skeleton states`
+};
+
+// src/agents/sme/vmware.ts
+var vmwareSMEConfig = {
+  domain: "vmware",
+  description: "VMware vSphere and virtualization",
+  guidance: `For VMware tasks, provide:
+- PowerCLI cmdlet names and syntax (Get-VM, Set-VM, etc.)
+- vSphere API objects and methods
+- ESXi shell commands (esxcli, vim-cmd)
+- Datastore path formats ([datastore1] path/to/file.vmdk)
+- VM hardware version compatibility
+- vMotion and DRS requirements and constraints
+- Storage policy configuration (SPBM)
+- Network adapter types and configurations (vmxnet3, e1000e)
+- Snapshot management considerations
+- Template and clone operations
+- Resource pool and cluster concepts
+- vCenter Server connection handling
+- Certificate and authentication requirements
+- Common vSphere error codes and solutions
+- Performance metrics and monitoring (Get-Stat)`
+};
+
+// src/agents/sme/windows.ts
+var windowsSMEConfig = {
+  domain: "windows",
+  description: "Windows operating system internals and administration",
+  guidance: `For Windows tasks, provide:
+- Registry paths and correct hive locations (HKLM, HKCU, HKU)
+- WMI/CIM class names and properties (Win32_*, CIM_*)
+- Service names (exact), dependencies, and startup types
+- File system locations (System32, SysWOW64, ProgramData, AppData)
+- Permission requirements (admin, SYSTEM, TrustedInstaller)
+- COM objects and interfaces when relevant
+- Event log sources, channels, and event IDs
+- Scheduled task configuration (triggers, actions, principals)
+- Windows API calls if needed (P/Invoke signatures)
+- UAC considerations and elevation requirements
+- 32-bit vs 64-bit considerations (WoW64 redirection)`
+};
+
+// src/agents/sme/index.ts
+var SME_CONFIGS = {
+  windows: windowsSMEConfig,
+  powershell: powershellSMEConfig,
+  python: pythonSMEConfig,
+  oracle: oracleSMEConfig,
+  network: networkSMEConfig,
+  security: securitySMEConfig,
+  linux: linuxSMEConfig,
+  vmware: vmwareSMEConfig,
+  azure: azureSMEConfig,
+  active_directory: activeDirectorySMEConfig,
+  ui_ux: uiUxSMEConfig
+};
+var AGENT_TO_DOMAIN = {
+  sme_windows: "windows",
+  sme_powershell: "powershell",
+  sme_python: "python",
+  sme_oracle: "oracle",
+  sme_network: "network",
+  sme_security: "security",
+  sme_linux: "linux",
+  sme_vmware: "vmware",
+  sme_azure: "azure",
+  sme_active_directory: "active_directory",
+  sme_ui_ux: "ui_ux"
+};
+function createAllSMEAgents(getModel, loadPrompt) {
+  return Object.entries(AGENT_TO_DOMAIN).map(([agentName, domain2]) => {
+    const config2 = SME_CONFIGS[domain2];
+    const model = getModel(agentName);
+    const prompts = loadPrompt(agentName);
+    return createSMEAgent(agentName, config2, model, prompts.prompt, prompts.appendPrompt);
+  });
+}
 
 // src/agents/index.ts
 function getModelForAgent(agentName, config2) {
   const explicit = config2?.agents?.[agentName]?.model;
   if (explicit)
     return explicit;
-  if (agentName === "sme") {
+  if (isSMEAgent(agentName)) {
     const categoryModel = config2?.agents?.[CATEGORY_PREFIXES.sme]?.model;
     if (categoryModel)
       return categoryModel;
@@ -14245,10 +14603,16 @@ function createAgents(config2) {
     const architect = createArchitectAgent(getModel("architect"), architectPrompts.prompt, architectPrompts.appendPrompt);
     agents.push(applyOverrides(architect, config2));
   }
-  if (!isAgentDisabled("sme", config2)) {
-    const smePrompts = getPrompts("sme");
-    const sme = createUnifiedSMEAgent(getModel("sme"), smePrompts.prompt, smePrompts.appendPrompt);
-    agents.push(applyOverrides(sme, config2));
+  if (!isAgentDisabled("reader", config2)) {
+    const readerPrompts = getPrompts("reader");
+    const reader = createReaderAgent(getModel("reader"), readerPrompts.prompt, readerPrompts.appendPrompt);
+    agents.push(applyOverrides(reader, config2));
+  }
+  const smeAgents = createAllSMEAgents(getModel, getPrompts);
+  for (const sme of smeAgents) {
+    if (!isAgentDisabled(sme.name, config2)) {
+      agents.push(applyOverrides(sme, config2));
+    }
   }
   if (!isAgentDisabled("coder", config2)) {
     const coderPrompts = getPrompts("coder");
@@ -26802,6 +27166,40 @@ Errors:
     return result;
   }
 });
+// src/tools/gitingest.ts
+async function fetchGitingest(args) {
+  const response = await fetch("https://gitingest.com/api/ingest", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      input_text: args.url,
+      max_file_size: args.maxFileSize ?? 50000,
+      pattern: args.pattern ?? "",
+      pattern_type: args.patternType ?? "exclude"
+    })
+  });
+  if (!response.ok) {
+    throw new Error(`gitingest API error: ${response.status} ${response.statusText}`);
+  }
+  const data = await response.json();
+  return `${data.summary}
+
+${data.tree}
+
+${data.content}`;
+}
+var gitingest = tool({
+  description: "Fetch a GitHub repository's full content via gitingest.com. Returns summary, directory tree, and file contents optimized for LLM analysis. Use when you need to understand an external repository's structure or code.",
+  args: {
+    url: tool.schema.string().describe("GitHub repository URL (e.g., https://github.com/owner/repo)"),
+    maxFileSize: tool.schema.number().optional().describe("Maximum file size in bytes to include (default: 50000)"),
+    pattern: tool.schema.string().optional().describe("Glob pattern to filter files (e.g., '*.ts' or 'src/**/*.py')"),
+    patternType: tool.schema.enum(["include", "exclude"]).optional().describe("Whether pattern includes or excludes matching files (default: exclude)")
+  },
+  async execute(args, _context) {
+    return fetchGitingest(args);
+  }
+});
 // src/utils/logger.ts
 var DEBUG = process.env.OPENCODE_SWARM_DEBUG === "1";
 function log(message, data) {
@@ -26830,7 +27228,8 @@ var OpenCodeSwarm = async (ctx) => {
     agent: agents,
     tool: {
       detect_domains,
-      extract_code_blocks
+      extract_code_blocks,
+      gitingest
     },
     config: async (opencodeConfig) => {
       if (!opencodeConfig.agent) {

package/dist/tools/gitingest.d.ts

@@ -0,0 +1,15 @@
+import { tool } from '@opencode-ai/plugin';
+export interface GitingestArgs {
+    url: string;
+    maxFileSize?: number;
+    pattern?: string;
+    patternType?: 'include' | 'exclude';
+}
+/**
+ * Fetch repository content via gitingest.com API
+ */
+export declare function fetchGitingest(args: GitingestArgs): Promise<string>;
+/**
+ * Gitingest tool for fetching GitHub repository contents
+ */
+export declare const gitingest: ReturnType<typeof tool>;

package/dist/tools/index.d.ts

@@ -1,2 +1,3 @@
 export { detect_domains } from './domain-detector';
 export { extract_code_blocks } from './file-extractor';
+export { gitingest, fetchGitingest, type GitingestArgs } from './gitingest';

package/package.json

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