opencode-swarm 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,162 @@
+# OpenCode Swarm
+
+Architect-centric agentic swarm plugin for OpenCode. Hub-and-spoke orchestration with SME consultation, code generation, and QA review.
+
+## Overview
+
+OpenCode Swarm implements a multi-agent development pipeline where:
+
+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
+```
+
+## Installation
+
+```bash
+bunx opencode-swarm install
+```
+
+Then start OpenCode:
+
+```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
+}
+```
+
+### Category Defaults
+
+Use `_sme` and `_qa` to set models for all agents in a category:
+
+```json
+{
+  "agents": {
+    "_sme": { "model": "npu/qwen3:14b" },
+    "_qa": { "model": "npu/qwen3:14b" }
+  }
+}
+```
+
+To override a specific agent within a category:
+
+```json
+{
+  "agents": {
+    "_sme": { "model": "npu/qwen3:14b" },
+    "sme_oracle": { "model": "ollama/qwen3:72b" }
+  }
+}
+```
+
+### Custom Prompts
+
+Place custom prompts in `~/.config/opencode/opencode-swarm/`:
+
+- `{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
+
+The Architect enforces resource-aware delegation:
+
+- **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
+
+| Tool | Description |
+|------|-------------|
+| `detect_domains` | Auto-detect SME domains from text |
+| `extract_code_blocks` | Extract and save code blocks to files |
+
+## Environment Variables
+
+| Variable | Description |
+|----------|-------------|
+| `OPENCODE_SWARM_PRESET` | Override preset selection |
+| `OPENCODE_SWARM_DEBUG` | Enable debug logging (`1` to enable) |
+
+## License
+
+MIT

package/dist/agents/architect.d.ts

@@ -0,0 +1,7 @@
+import type { AgentConfig } from '@opencode-ai/sdk';
+export interface AgentDefinition {
+    name: string;
+    description?: string;
+    config: AgentConfig;
+}
+export declare function createArchitectAgent(model: string, customPrompt?: string, customAppendPrompt?: string): AgentDefinition;

package/dist/agents/auditor.d.ts

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

package/dist/agents/coder.d.ts

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

package/dist/agents/index.d.ts

@@ -0,0 +1,19 @@
+import type { AgentConfig as SDKAgentConfig } from '@opencode-ai/sdk';
+import { type PluginConfig } from '../config';
+import { type AgentDefinition } from './architect';
+export type { AgentDefinition } from './architect';
+/**
+ * Create all agent definitions with configuration applied
+ */
+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';
+export { createCoderAgent } from './coder';
+export { createSecurityReviewerAgent } from './security-reviewer';
+export { createAuditorAgent } from './auditor';
+export { createTestEngineerAgent } from './test-engineer';
+export { createAllSMEAgents, createSMEAgent, listDomains } from './sme';

package/dist/agents/security-reviewer.d.ts

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

package/dist/agents/sme/active-directory.d.ts

@@ -0,0 +1,2 @@
+import type { SMEDomainConfig } from './base';
+export declare const activeDirectorySMEConfig: SMEDomainConfig;

package/dist/agents/sme/azure.d.ts

@@ -0,0 +1,2 @@
+import type { SMEDomainConfig } from './base';
+export declare const azureSMEConfig: SMEDomainConfig;

package/dist/agents/sme/base.d.ts

@@ -0,0 +1,13 @@
+import type { AgentDefinition } from '../architect';
+/**
+ * SME domain configuration
+ */
+export interface SMEDomainConfig {
+    domain: string;
+    description: string;
+    guidance: string;
+}
+/**
+ * Create an SME agent definition
+ */
+export declare function createSMEAgent(agentName: string, domainConfig: SMEDomainConfig, model: string, customPrompt?: string, customAppendPrompt?: string): AgentDefinition;

package/dist/agents/sme/index.d.ts

@@ -0,0 +1,20 @@
+import type { AgentDefinition } from '../architect';
+import { type SMEDomainConfig } from './base';
+export declare const SME_CONFIGS: Record<string, SMEDomainConfig>;
+export declare const AGENT_TO_DOMAIN: Record<string, string>;
+/**
+ * Create all SME agent definitions
+ */
+export declare function createAllSMEAgents(getModel: (agentName: string) => string, loadPrompt: (agentName: string) => {
+    prompt?: string;
+    appendPrompt?: string;
+}): AgentDefinition[];
+/**
+ * Get list of available SME domains
+ */
+export declare function listDomains(): string[];
+/**
+ * Get SME agent name for a domain
+ */
+export declare function domainToAgent(domain: string): string | undefined;
+export { createSMEAgent, type SMEDomainConfig } from './base';

package/dist/agents/sme/linux.d.ts

@@ -0,0 +1,2 @@
+import type { SMEDomainConfig } from './base';
+export declare const linuxSMEConfig: SMEDomainConfig;

package/dist/agents/sme/network.d.ts

@@ -0,0 +1,2 @@
+import type { SMEDomainConfig } from './base';
+export declare const networkSMEConfig: SMEDomainConfig;

package/dist/agents/sme/oracle.d.ts

@@ -0,0 +1,2 @@
+import type { SMEDomainConfig } from './base';
+export declare const oracleSMEConfig: SMEDomainConfig;

package/dist/agents/sme/powershell.d.ts

@@ -0,0 +1,2 @@
+import type { SMEDomainConfig } from './base';
+export declare const powershellSMEConfig: SMEDomainConfig;

package/dist/agents/sme/python.d.ts

@@ -0,0 +1,2 @@
+import type { SMEDomainConfig } from './base';
+export declare const pythonSMEConfig: SMEDomainConfig;

package/dist/agents/sme/security.d.ts

@@ -0,0 +1,2 @@
+import type { SMEDomainConfig } from './base';
+export declare const securitySMEConfig: SMEDomainConfig;

package/dist/agents/sme/ui-ux.d.ts

@@ -0,0 +1,2 @@
+import type { SMEDomainConfig } from './base';
+export declare const uiUxSMEConfig: SMEDomainConfig;

package/dist/agents/sme/vmware.d.ts

@@ -0,0 +1,2 @@
+import type { SMEDomainConfig } from './base';
+export declare const vmwareSMEConfig: SMEDomainConfig;

package/dist/agents/sme/windows.d.ts

@@ -0,0 +1,2 @@
+import type { SMEDomainConfig } from './base';
+export declare const windowsSMEConfig: SMEDomainConfig;

package/dist/agents/test-engineer.d.ts

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

package/dist/cli/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+export {};

package/dist/cli/index.js

@@ -0,0 +1,148 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/cli/index.ts
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+var CONFIG_DIR = path.join(process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config"), "opencode");
+var OPENCODE_CONFIG_PATH = path.join(CONFIG_DIR, "config.json");
+var PLUGIN_CONFIG_PATH = path.join(CONFIG_DIR, "opencode-swarm.json");
+var PROMPTS_DIR = path.join(CONFIG_DIR, "opencode-swarm");
+function ensureDir(dir) {
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+}
+function loadJson(filepath) {
+  try {
+    const content = fs.readFileSync(filepath, "utf-8");
+    const stripped = content.replace(/\\"|"(?:\\"|[^"])*"|(\/\/.*|\/\*[\s\S]*?\*\/)/g, (match, comment) => comment ? "" : match).replace(/,(\s*[}\]])/g, "$1");
+    return JSON.parse(stripped);
+  } catch {
+    return null;
+  }
+}
+function saveJson(filepath, data) {
+  fs.writeFileSync(filepath, JSON.stringify(data, null, 2) + `
+`, "utf-8");
+}
+async function install() {
+  console.log(`\uD83D\uDC1D Installing OpenCode Swarm...
+`);
+  ensureDir(CONFIG_DIR);
+  ensureDir(PROMPTS_DIR);
+  let opencodeConfig = loadJson(OPENCODE_CONFIG_PATH);
+  if (!opencodeConfig) {
+    opencodeConfig = {};
+  }
+  if (!opencodeConfig.plugin) {
+    opencodeConfig.plugin = [];
+  }
+  const pluginName = "opencode-swarm";
+  opencodeConfig.plugin = opencodeConfig.plugin.filter((p) => p !== pluginName && !p.startsWith(`${pluginName}@`));
+  opencodeConfig.plugin.push(pluginName);
+  if (!opencodeConfig.agent) {
+    opencodeConfig.agent = {};
+  }
+  opencodeConfig.agent.explore = { disable: true };
+  opencodeConfig.agent.general = { disable: true };
+  saveJson(OPENCODE_CONFIG_PATH, opencodeConfig);
+  console.log("\u2713 Added opencode-swarm to OpenCode plugins");
+  console.log("\u2713 Disabled default OpenCode agents (explore, general)");
+  if (!fs.existsSync(PLUGIN_CONFIG_PATH)) {
+    const defaultConfig = {
+      preset: "remote",
+      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: "remote",
+      max_iterations: 5,
+      auto_detect_domains: true,
+      inject_phase_reminders: true
+    };
+    saveJson(PLUGIN_CONFIG_PATH, defaultConfig);
+    console.log("\u2713 Created default plugin config at:", PLUGIN_CONFIG_PATH);
+  } else {
+    console.log("\u2713 Plugin config already exists at:", PLUGIN_CONFIG_PATH);
+  }
+  console.log(`
+\uD83D\uDCC1 Configuration files:`);
+  console.log(`   OpenCode config: ${OPENCODE_CONFIG_PATH}`);
+  console.log(`   Plugin config:   ${PLUGIN_CONFIG_PATH}`);
+  console.log(`   Custom prompts:  ${PROMPTS_DIR}/`);
+  console.log(`
+\uD83D\uDE80 Installation complete!`);
+  console.log(`
+Next steps:`);
+  console.log("1. Edit the plugin config to customize models and settings");
+  console.log('2. Run "opencode" to start using the swarm');
+  console.log("3. The Architect agent will orchestrate your requests");
+  console.log(`
+\uD83D\uDCD6 Available SME domains:`);
+  console.log(`   windows, powershell, python, oracle, network, security,
+` + "   linux, vmware, azure, active_directory, ui_ux");
+  return 0;
+}
+function printHelp() {
+  console.log(`
+opencode-swarm - Architect-centric agentic swarm plugin for OpenCode
+
+Usage: bunx opencode-swarm [command] [OPTIONS]
+
+Commands:
+  install     Install and configure the plugin (default)
+
+Options:
+  -h, --help  Show this help message
+
+Configuration:
+  Edit ~/.config/opencode/opencode-swarm.json to customize:
+  - Model assignments per agent or category
+  - Preset configurations (remote, hybrid)
+  - Local inference endpoints (GPU/NPU URLs)
+  - Max iterations and other settings
+
+Custom Prompts:
+  Place custom prompts in ~/.config/opencode/opencode-swarm/
+  - {agent}.md       - Replace default prompt
+  - {agent}_append.md - Append to default prompt
+
+Examples:
+  bunx opencode-swarm install
+  bunx opencode-swarm --help
+`);
+}
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.includes("-h") || args.includes("--help")) {
+    printHelp();
+    process.exit(0);
+  }
+  const command = args[0] || "install";
+  if (command === "install") {
+    const exitCode = await install();
+    process.exit(exitCode);
+  } else {
+    console.error(`Unknown command: ${command}`);
+    console.error("Run with --help for usage information");
+    process.exit(1);
+  }
+}
+main().catch((err) => {
+  console.error("Fatal error:", err);
+  process.exit(1);
+});

package/dist/config/constants.d.ts

@@ -0,0 +1,20 @@
+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 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", "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", "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 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): 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

@@ -0,0 +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, PresetSchema, SwarmModeSchema, } from './schema';
+export type { AgentOverrideConfig, PluginConfig, Preset, SwarmMode, } from './schema';
+export { getOutputDir, loadAgentPrompt, loadPluginConfig, } from './loader';

package/dist/config/loader.d.ts

@@ -0,0 +1,23 @@
+import { type PluginConfig } from './schema';
+/**
+ * Load plugin configuration from user and project config files.
+ *
+ * Config locations:
+ * 1. User config: ~/.config/opencode/opencode-swarm.json
+ * 2. Project config: <directory>/.opencode/opencode-swarm.json
+ *
+ * Project config takes precedence. Nested objects are deep-merged.
+ */
+export declare function loadPluginConfig(directory: string): PluginConfig;
+/**
+ * Load custom prompt for an agent from the prompts directory.
+ * Checks for {agent}.md (replaces default) and {agent}_append.md (appends).
+ */
+export declare function loadAgentPrompt(agentName: string): {
+    prompt?: string;
+    appendPrompt?: string;
+};
+/**
+ * Get the output directory for generated files.
+ */
+export declare function getOutputDir(config: PluginConfig, projectDir: string): string;

package/dist/config/schema.d.ts

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+export declare const AgentOverrideConfigSchema: z.ZodObject<{
+    model: z.ZodOptional<z.ZodString>;
+    temperature: z.ZodOptional<z.ZodNumber>;
+    disabled: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type AgentOverrideConfig = z.infer<typeof AgentOverrideConfigSchema>;
+export declare const PresetSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
+    model: z.ZodOptional<z.ZodString>;
+    temperature: z.ZodOptional<z.ZodNumber>;
+    disabled: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>>;
+export type Preset = z.infer<typeof PresetSchema>;
+export declare const SwarmModeSchema: z.ZodEnum<{
+    remote: "remote";
+    hybrid: "hybrid";
+}>;
+export type SwarmMode = z.infer<typeof SwarmModeSchema>;
+export declare const PluginConfigSchema: z.ZodObject<{
+    preset: z.ZodOptional<z.ZodString>;
+    presets: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodObject<{
+        model: z.ZodOptional<z.ZodString>;
+        temperature: z.ZodOptional<z.ZodNumber>;
+        disabled: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>>;
+    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>>>;
+    max_iterations: z.ZodDefault<z.ZodNumber>;
+    output_dir: z.ZodOptional<z.ZodString>;
+    swarm_mode: z.ZodDefault<z.ZodEnum<{
+        remote: "remote";
+        hybrid: "hybrid";
+    }>>;
+    gpu_url: z.ZodOptional<z.ZodString>;
+    gpu_model: z.ZodOptional<z.ZodString>;
+    npu_url: z.ZodOptional<z.ZodString>;
+    npu_model: z.ZodOptional<z.ZodString>;
+    global_fallback_models: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    auto_detect_domains: z.ZodDefault<z.ZodBoolean>;
+    inject_phase_reminders: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export type PluginConfig = z.infer<typeof PluginConfigSchema>;
+export type { AgentName, SMEAgentName, QAAgentName, PipelineAgentName, } from './constants';

package/dist/hooks/index.d.ts

@@ -0,0 +1 @@
+export { createPipelineTrackerHook } from './pipeline-tracker';

package/dist/hooks/pipeline-tracker.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Pipeline Tracker Hook
+ *
+ * Injects phase reminders into messages to keep the Architect on track.
+ * Uses experimental.chat.messages.transform so it doesn't show in UI.
+ *
+ * Research: "LLMs Get Lost In Multi-Turn Conversation" shows ~40% compliance
+ * drop after 2-3 turns without reminders.
+ */
+import type { PluginConfig } from '../config';
+interface MessageInfo {
+    role: string;
+    agent?: string;
+    sessionID?: string;
+}
+interface MessagePart {
+    type: string;
+    text?: string;
+    [key: string]: unknown;
+}
+interface MessageWithParts {
+    info: MessageInfo;
+    parts: MessagePart[];
+}
+/**
+ * Creates the experimental.chat.messages.transform hook for pipeline tracking.
+ * Only injects for the architect agent.
+ */
+export declare function createPipelineTrackerHook(config: PluginConfig): {
+    'experimental.chat.messages.transform': (_input: Record<string, never>, output: {
+        messages: MessageWithParts[];
+    }) => Promise<void>;
+};
+export {};

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+import type { Plugin } from '@opencode-ai/plugin';
+/**
+ * OpenCode Swarm Plugin
+ *
+ * Architect-centric agentic swarm for code generation.
+ * Hub-and-spoke architecture with:
+ * - Architect as central orchestrator
+ * - Dynamic SME consultation (serial)
+ * - Code generation with QA review
+ * - Iterative refinement with triage
+ */
+declare const OpenCodeSwarm: Plugin;
+export default OpenCodeSwarm;
+export type { AgentName, PluginConfig, SMEAgentName, QAAgentName, PipelineAgentName, SwarmMode, } from './config';
+export type { AgentDefinition } from './agents';