opencode-orchestrator 0.1.8 → 0.1.9

package/README.md

@@ -1,156 +1,141 @@
 # OpenCode Orchestrator
 
-> **Multi-Agent Plugin for [OpenCode](https://opencode.ai)** — Make cheap models outperform expensive ones
+> **Multi-Agent Plugin for [OpenCode](https://opencode.ai)**
 
 <div align="center">
 
 [![MIT License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+[![npm](https://img.shields.io/npm/v/opencode-orchestrator.svg)](https://www.npmjs.com/package/opencode-orchestrator)
 [![OpenCode Plugin](https://img.shields.io/badge/OpenCode-Plugin-purple.svg)](https://opencode.ai)
 
 </div>
 
 ---
 
-## 💡 Philosophy
+## What is this?
 
-**The model doesn't matter. The workflow does.**
+A 6-agent collaborative system that turns any LLM into a reliable coding team.
 
-Any model — even lightweight ones — can produce reliable, production-quality code when:
+**Core idea**: Break complex tasks into atomic units, verify each step, fix errors automatically.
 
-1. **Tasks are atomic** — one function, one fix, one file at a time
-2. **Every change is verified** — quality gate catches errors immediately
-3. **Errors trigger fixes** — self-correcting loop until it works
+---
+
+## Why Orchestrator?
 
-This plugin implements a **6-agent team** that turns any model into a disciplined development process.
+| Traditional | With Orchestrator |
+|-------------|-------------------|
+| One big prompt → Hope it works | Atomic tasks → Verified every step |
+| Expensive model required | Any model works |
+| Errors compound silently | Self-correcting loop |
+| Unpredictable results | Consistent quality |
 
 ---
 
-## 🚀 Quick Start
+## Features
 
-### Install
+- **🦀 Rust Core** — Fast, memory-safe search and analysis tools
+- **🧠 Micro-Task Architecture** — Atomic task decomposition for reliability
+- **🔄 Self-Correcting Loop** — Every change reviewed, errors auto-fixed
+- **👥 6-Agent Team** — Specialized roles working together
+- **🛡️ Circuit Breaker** — Stops after 3 same errors, prevents infinite loops
+- **⚡ Full Autonomy** — `/auto` command handles everything
+
+---
+
+## How It Works
 
-```bash
-npm install opencode-orchestrator
-# or
-bun add opencode-orchestrator
+```
+User Request
+     │
+     ▼
+┌─────────┐
+│ PLANNER │ → Break into atomic tasks
+└────┬────┘
+     │
+     ▼
+┌──────────────────────────────────────────┐
+│  For each task:                          │
+│                                          │
+│   Search → Code → Review → Fix           │
+│       ↑                      │           │
+│       └──────────────────────┘           │
+│           (until PASS)                   │
+└──────────────────────────────────────────┘
+     │
+     ▼
+✅ Done
 ```
 
-Plugin auto-registers. Just restart OpenCode.
+---
 
-### Use
+## Install
 
-```
-/auto implement user authentication with JWT
+```bash
+npm install opencode-orchestrator
 ```
 
-That's it. The agents handle the rest.
+Auto-registers with OpenCode. Just restart.
 
 ---
 
-## 🤖 How It Works
+## Usage
 
 ```
-┌─────────────────────────────────────────────────────────────┐
-│                    SELF-CORRECTING LOOP                     │
-├─────────────────────────────────────────────────────────────┤
-│                                                             │
-│   User Request                                              │
-│        │                                                    │
-│        ▼                                                    │
-│   ┌─────────┐     ┌─────────────────────────────────────┐   │
-│   │ PLANNER │────▶│ Atomic Tasks: [T1] [T2] [T3] ...   │   │
-│   └─────────┘     └─────────────────────────────────────┘   │
-│                              │                              │
-│                              ▼                              │
-│   ┌──────────────────────────────────────────────────────┐  │
-│   │  FOR EACH TASK:                                      │  │
-│   │                                                      │  │
-│   │    SEARCHER ─▶ CODER ─▶ REVIEWER ─┬─▶ ✅ NEXT       │  │
-│   │                            │      │                  │  │
-│   │                         ❌ FAIL   │                  │  │
-│   │                            │      │                  │  │
-│   │                            ▼      │                  │  │
-│   │                         FIXER ────┘                  │  │
-│   │                        (retry ≤3)                    │  │
-│   │                                                      │  │
-│   └──────────────────────────────────────────────────────┘  │
-│                              │                              │
-│                              ▼                              │
-│                        ✅ COMPLETE                          │
-│                                                             │
-└─────────────────────────────────────────────────────────────┘
+/auto implement user authentication with JWT
 ```
 
-### Agents
-
-| Agent | Job |
-|-------|-----|
-| **Planner** | Decomposes complex tasks into atomic units |
-| **Searcher** | Finds patterns and context in codebase |
-| **Coder** | Implements one atomic task at a time |
-| **Reviewer** | Quality gate — catches all errors |
-| **Fixer** | Applies targeted fixes from reviewer feedback |
-
 ---
 
-## 📋 Commands
+## Commands
 
 | Command | Description |
 |---------|-------------|
-| `/auto "task"` | Autonomous execution until complete |
-| `/plan "task"` | Decompose into atomic tasks |
-| `/review "code"` | Quality check |
-| `/fix "errors"` | Apply fixes |
-| `/search "pattern"` | Find context |
+| `/auto` | Autonomous execution until complete |
+| `/plan` | Decompose into atomic tasks |
+| `/review` | Quality check |
+| `/fix` | Fix specific error |
+| `/search` | Find patterns in codebase |
 
 ---
 
-## 🛡️ Error Prevention
+## Agents
 
-| Feature | What It Does |
-|---------|--------------|
-| **Self-Correcting Loop** | Errors trigger fix → verify cycle |
-| **Retry Limit** | Same error 3x = stop and ask user |
-| **Iteration Cap** | Max 100 iterations prevents runaway |
-| **Atomic Tasks** | Small scope = fewer errors |
+| Agent | Role |
+|-------|------|
+| **Orchestrator** | Team leader — coordinates, decides, adapts |
+| **Planner** | Breaks work into atomic tasks |
+| **Coder** | Implements one task at a time |
+| **Reviewer** | Quality gate — catches all errors |
+| **Fixer** | Targeted error resolution |
+| **Searcher** | Finds context before coding |
 
 ---
 
-## ⚡ Why This Works
-
-### Traditional Approach
-```
-[Big Model] ──────────────────────────▶ [Hope it works?]
-```
-
-### Orchestrator Approach
-```
-[Any Model] ──▶ [Small Task] ──▶ [Verify] ──▶ [Fix if needed] ──▶ ✅
-```
+## Documentation
 
-**Results:**
-- 🔧 **Fewer errors**: Each change is verified
-- 💰 **Lower cost**: Cheap models work fine
-- 🔄 **Self-healing**: Errors get fixed automatically
-- 📊 **Predictable**: Clear progress tracking
+- [Architecture](docs/ARCHITECTURE.md) — Detailed workflow
+- [Configuration](examples/orchestrator.jsonc) — Customize settings
 
 ---
 
-## 📚 Documentation
+## Open Source
+
+MIT License. No telemetry. No backdoors.
 
-- **[Architecture Guide](docs/ARCHITECTURE.md)** — Detailed workflow documentation
-- **[Configuration](examples/orchestrator.jsonc)** — Customize agent settings
+[github.com/agnusdei1207/opencode-orchestrator](https://github.com/agnusdei1207/opencode-orchestrator)
 
 ---
 
-## 📄 License
+## Author's Note
 
-[MIT](LICENSE) — Use freely, modify freely, no strings attached.
+> My goal is to prove that **affordable models like GLM-4.7** can produce results as good as expensive APIs — when you structure the work right.
+>
+> Break tasks down, verify every step, fix errors automatically. The model doesn't need to be smart. The process needs to be disciplined.
+>
+> — [@agnusdei1207](https://github.com/agnusdei1207)
 
 ---
 
-<div align="center">
-
-**Built for [OpenCode](https://opencode.ai)** • Make cheap models work like expensive ones
+## License
 
-</div>
+[MIT](LICENSE)

package/package.json

@@ -1,12 +1,12 @@
 {
     "name": "opencode-orchestrator",
-    "version": "0.1.8",
+    "version": "0.1.9",
     "description": "6-Agent collaborative architecture for OpenCode - Make any model reliable",
     "author": "agnusdei1207",
     "license": "MIT",
     "repository": {
         "type": "git",
-        "url": "https://github.com/agnusdei1207/opencode-orchestrator"
+        "url": "git+https://github.com/agnusdei1207/opencode-orchestrator.git"
     },
     "homepage": "https://github.com/agnusdei1207/opencode-orchestrator#readme",
     "bugs": {
@@ -25,9 +25,6 @@
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
     "type": "module",
-    "bin": {
-        "opencode-orchestrator": "./bin/orchestrator"
-    },
     "exports": {
         ".": {
             "types": "./dist/index.d.ts",
@@ -37,36 +34,27 @@
     "files": [
         "dist",
         "bin",
-        "src",
-        "scripts",
         "README.md",
         "LICENSE"
     ],
     "scripts": {
-        "// === BUILD: Individual Steps ===": "",
         "build:rust": "docker compose run --rm dev",
         "build:rust:copy": "docker compose run --rm dev sh -c 'cp /app/target/release/orchestrator /app/bin/' && chmod +x bin/orchestrator",
         "build:ts": "bun build src/index.ts --outdir dist --target bun --format esm && tsc --emitDeclarationOnly",
         "build:scripts": "mkdir -p dist/scripts && bun build scripts/postinstall.ts --outdir dist/scripts --target node",
-        "// === BUILD: Combined ===": "",
         "build": "bun run build:ts && bun run build:scripts",
         "build:full": "bun run build:rust && bun run build:rust:copy && bun run build",
-        "// === TEST ===": "",
         "test": "docker compose run --rm test",
         "test:local": "cargo test",
-        "// === PUBLISH: Steps ===": "",
         "version:patch": "npm version patch --no-git-tag-version",
         "version:minor": "npm version minor --no-git-tag-version",
         "version:major": "npm version major --no-git-tag-version",
-        "// === PUBLISH: Combined ===": "",
         "prepublishOnly": "bun run build",
         "publish:npm": "npm publish --access public",
-        "// === RELEASE: Full Workflow ===": "",
         "release:patch": "bun run build:full && bun run test && bun run version:patch && bun run publish:npm && bun run release:git",
         "release:minor": "bun run build:full && bun run test && bun run version:minor && bun run publish:npm && bun run release:git",
         "release:major": "bun run build:full && bun run test && bun run version:major && bun run publish:npm && bun run release:git",
         "release:git": "git add -A && git commit -m \"Release v$(node -p \"require('./package.json').version\")\" && git tag \"v$(node -p \"require('./package.json').version\")\" && git push && git push --tags",
-        "// === INSTALL HOOKS ===": "",
         "postinstall": "node dist/scripts/postinstall.js 2>/dev/null || true"
     },
     "dependencies": {

package/scripts/postinstall.ts

@@ -1,73 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * OpenCode Orchestrator - Post-install script
- * Automatically registers the plugin with OpenCode
- */
-
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
-import { join } from "path";
-import { homedir } from "os";
-
-const CONFIG_DIR = join(homedir(), ".config", "opencode");
-const CONFIG_FILE = join(CONFIG_DIR, "opencode.json");
-const PLUGIN_NAME = "opencode-orchestrator";
-
-function getPluginPath() {
-    // Find where this package is installed
-    try {
-        const packagePath = new URL(".", import.meta.url).pathname;
-        return packagePath.replace(/\/$/, "");
-    } catch {
-        return PLUGIN_NAME;
-    }
-}
-
-function install() {
-    console.log("🦀 OpenCode Orchestrator - Installing...");
-
-    // Ensure config directory exists
-    if (!existsSync(CONFIG_DIR)) {
-        mkdirSync(CONFIG_DIR, { recursive: true });
-    }
-
-    // Load or create config
-    let config: Record<string, any> = {};
-    if (existsSync(CONFIG_FILE)) {
-        try {
-            config = JSON.parse(readFileSync(CONFIG_FILE, "utf-8"));
-        } catch {
-            config = {};
-        }
-    }
-
-    // Add plugin if not already present
-    if (!config.plugin) {
-        config.plugin = [];
-    }
-
-    const pluginPath = getPluginPath();
-    const hasPlugin = config.plugin.some((p: string) =>
-        p === PLUGIN_NAME || p === pluginPath || p.includes("opencode-orchestrator")
-    );
-
-    if (!hasPlugin) {
-        config.plugin.push(PLUGIN_NAME);
-        writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
-        console.log("✅ Plugin registered!");
-        console.log(`   Config: ${CONFIG_FILE}`);
-    } else {
-        console.log("✅ Plugin already registered.");
-    }
-
-    console.log("");
-    console.log("🚀 Ready! Restart OpenCode to use.");
-    console.log("");
-    console.log("Commands:");
-    console.log("  /auto \"task\"   - Autonomous execution");
-    console.log("  /plan \"task\"   - Decompose into atomic tasks");
-    console.log("  /review        - Quality check");
-    console.log("");
-}
-
-install();

package/src/index.ts

@@ -1,791 +0,0 @@
-/**
- * OpenCode Orchestrator Plugin
- *
- * 6-Agent Collaborative Architecture for OpenCode
- * 
- * Philosophy: Cheap models (GLM-4.7, Gemma, Phi) can outperform
- * expensive models through intelligent task decomposition and
- * team collaboration with quality gates.
- */
-
-import { spawn } from "child_process";
-import { join, dirname } from "path";
-import { fileURLToPath } from "url";
-import { existsSync, writeFileSync, readFileSync, mkdirSync } from "fs";
-import { platform, arch } from "os";
-import { tool } from "@opencode-ai/plugin";
-import type { PluginInput } from "@opencode-ai/plugin";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-
-// ============================================================================
-// 6-Agent Collaborative Architecture
-// ============================================================================
-
-interface AgentDefinition {
-    id: string;
-    description: string;
-    systemPrompt: string;
-    canWrite: boolean;
-    canBash: boolean;
-}
-
-const AGENTS: Record<string, AgentDefinition> = {
-    // ═══════════════════════════════════════════════════════════════
-    // ORCHESTRATOR - Team Leader & Decision Maker
-    // ═══════════════════════════════════════════════════════════════
-    orchestrator: {
-        id: "orchestrator",
-        description: "Team leader - delegates atomic tasks, tracks progress, adapts on failure",
-        systemPrompt: `You are the Orchestrator - the team leader.
-
-## Mission
-Coordinate agents to complete user tasks with ZERO errors.
-Keep iterating until the task is 100% complete and working.
-
-## Your Team
-- **planner**: Decomposes complex tasks into atomic units
-- **coder**: Implements single atomic task
-- **reviewer**: Quality gate - catches ALL errors
-- **fixer**: Repairs specific errors
-- **searcher**: Finds context before coding
-
-## Workflow (Self-Correcting Loop)
-1. ANALYZE: Understand user request fully
-2. PLAN: Call planner for complex tasks → get atomic task list
-3. FOR EACH atomic task:
-   a. CONTEXT: Call searcher if context needed
-   b. CODE: Call coder with single atomic task
-   c. VERIFY: Call reviewer (MANDATORY after every code change)
-   d. FIX: If reviewer finds error → call fixer → verify again
-   e. LOOP: Repeat fix/verify until PASS (max 3 attempts)
-4. NEXT: Move to next task only after current passes
-5. COMPLETE: All tasks done with all reviews passed
-
-## Atomic Task Examples
-✅ "Add validateEmail function to src/utils/validation.ts"
-✅ "Fix syntax error in LoginForm.tsx line 42"
-✅ "Update import statement in api/routes.ts"
-✅ "Add error handling to fetchUser function"
-❌ "Refactor the entire auth module" (too big)
-❌ "Fix all bugs" (not atomic)
-
-## Error Recovery Protocol
-- Error from reviewer → Call fixer with EXACT error details
-- Same error 3 times → STOP, report to user, suggest alternatives
-- Coder confused → Provide more context from searcher
-- Stuck on approach → Try different strategy
-
-## Progress Tracking (show after each step)
-📋 Task: [current task]
-✅ Completed: [list]
-⏳ Remaining: [list]
-🔄 Retry: [X/3] if applicable
-
-## Critical Rules
-- NEVER skip reviewer after code changes
-- One atomic task at a time
-- Stop if same error persists 3 times
-- Always show progress`,
-        canWrite: false,
-        canBash: false,
-    },
-
-    // ═══════════════════════════════════════════════════════════════
-    // PLANNER - Atomic Task Decomposition
-    // ═══════════════════════════════════════════════════════════════
-    planner: {
-        id: "planner",
-        description: "Task decomposition - creates atomic, verifiable units of work",
-        systemPrompt: `You are the Planner - atomic task decomposition expert.
-
-## Your Job
-Break complex tasks into the SMALLEST possible units that:
-1. Can be completed independently
-2. Can be verified by reviewer
-3. Have clear success criteria
-
-## Atomic Task Format
-\`\`\`
-[TASK-001] <action verb> + <specific target>
-├── File: <exact path>
-├── Action: <what to do>
-├── Success: <how to verify it worked>
-└── Depends: none | TASK-XXX
-\`\`\`
-
-## What Makes a Task "Atomic"
-- Touches ONE file (or one specific location)
-- Does ONE thing (add function, fix error, update import)
-- Can be reviewed in isolation
-- Has clear pass/fail criteria
-
-## Good Atomic Tasks
-✅ "Add validateEmail function to utils/validation.ts"
-✅ "Import bcrypt in auth/password.ts"
-✅ "Fix missing closing brace in UserForm.tsx line 58"
-✅ "Add try-catch to fetchData function in api.ts"
-✅ "Update Button component props interface"
-
-## Bad Tasks (too large/vague)
-❌ "Implement authentication" → break into 5-10 atomic tasks
-❌ "Fix all errors" → list specific errors as separate tasks
-❌ "Refactor module" → identify specific changes needed
-
-## Example Decomposition
-Complex task: "Add user login feature"
-
-[TASK-001] Create password hashing utility
-├── File: src/utils/password.ts
-├── Action: Add hashPassword and verifyPassword functions
-├── Success: Functions exported and callable
-└── Depends: none
-
-[TASK-002] Create User type definition
-├── File: src/types/User.ts
-├── Action: Add User interface with id, email, passwordHash
-├── Success: Type exported and importable
-└── Depends: none
-
-[TASK-003] Create login API handler
-├── File: src/api/login.ts
-├── Action: Add POST handler that validates credentials
-├── Success: Handler returns token on valid login
-└── Depends: TASK-001, TASK-002
-
-## Output Format
-List tasks in dependency order. Independent tasks first.`,
-        canWrite: false,
-        canBash: false,
-    },
-
-    // ═══════════════════════════════════════════════════════════════
-    // CODER - Single Task Implementation
-    // ═══════════════════════════════════════════════════════════════
-    coder: {
-        id: "coder",
-        description: "Implementation - executes one atomic task with complete, working code",
-        systemPrompt: `You are the Coder - implementation specialist.
-
-## Your Job
-Execute the ONE atomic task you're given. Produce complete, working code.
-
-## Before Writing Code
-- Understand exactly what the task asks
-- Check context provided for patterns to follow
-- Plan the implementation mentally first
-
-## Code Quality Checklist
-Before submitting, verify your code:
-- [ ] All brackets { } ( ) [ ] properly paired
-- [ ] All quotes " ' \` properly closed
-- [ ] All statements terminated correctly
-- [ ] All imports included at top
-- [ ] No undefined variables
-- [ ] Types match (if TypeScript)
-- [ ] Follows existing code style
-
-## Output Requirements
-Provide COMPLETE code that:
-1. Accomplishes the task fully
-2. Compiles/runs without errors
-3. Matches project style
-4. Includes necessary imports
-
-## Common Mistakes to Avoid
-- Forgetting closing brackets
-- Missing imports
-- Using wrong variable names
-- Type mismatches
-- Breaking existing code
-
-## If Unsure
-- Ask for more context
-- Request searcher to find patterns
-- Keep implementation simple
-
-## Output Format
-\`\`\`<language>
-// Full code implementation
-\`\`\`
-
-Brief explanation if needed.`,
-        canWrite: true,
-        canBash: true,
-    },
-
-    // ═══════════════════════════════════════════════════════════════
-    // REVIEWER - Quality Gate
-    // ═══════════════════════════════════════════════════════════════
-    reviewer: {
-        id: "reviewer",
-        description: "Quality gate - comprehensive error detection with specific fix instructions",
-        systemPrompt: `You are the Reviewer - quality assurance gate.
-
-## Your Job
-Find ALL issues in the code. Be thorough but specific.
-
-## Review Checklist
-
-### 1. Syntax (Critical)
-- All brackets paired: { } ( ) [ ]
-- All quotes closed: " ' \`
-- All statements terminated
-- Valid language syntax
-
-### 2. Imports & Dependencies
-- All used modules imported
-- Import paths correct
-- No unused imports (warning only)
-
-### 3. Types (if applicable)
-- Types match declarations
-- No implicit any (warning)
-- Generics correct
-
-### 4. Logic
-- Code does what task asked
-- Edge cases handled
-- No infinite loops possible
-
-### 5. Style
-- Matches project conventions
-- Consistent naming
-- Proper indentation
-
-### 6. Security (if applicable)
-- No hardcoded secrets
-- Input validation present
-
-## Output Format
-
-### If NO errors:
-\`\`\`
-✅ PASS
-
-Reviewed: [what was checked]
-Status: All checks passed
-\`\`\`
-
-### If errors found:
-\`\`\`
-❌ FAIL
-
-[ERROR-001] <category>
-├── File: <path>
-├── Line: <number>
-├── Issue: <specific problem>
-├── Found: \`<problematic code>\`
-├── Expected: \`<correct code>\`
-└── Fix: <exact fix instruction>
-
-[ERROR-002] ...
-\`\`\`
-
-## Rules
-- List ALL errors found (not just first one)
-- Be SPECIFIC about location and fix
-- Prioritize: Syntax > Types > Logic > Style
-- For each error, provide exact fix instruction`,
-        canWrite: false,
-        canBash: true,
-    },
-
-    // ═══════════════════════════════════════════════════════════════
-    // FIXER - Error Resolution
-    // ═══════════════════════════════════════════════════════════════
-    fixer: {
-        id: "fixer",
-        description: "Error resolution - applies targeted fixes based on reviewer feedback",
-        systemPrompt: `You are the Fixer - error resolution specialist.
-
-## Your Job
-Fix the SPECIFIC errors reported by reviewer.
-
-## Input Format
-You receive error reports like:
-\`\`\`
-[ERROR-001] <category>
-├── File: <path>
-├── Line: <number>
-├── Issue: <problem>
-├── Found: \`<bad code>\`
-├── Expected: \`<good code>\`
-└── Fix: <instruction>
-\`\`\`
-
-## Fixing Process
-1. Read each error carefully
-2. Understand root cause
-3. Apply minimal fix
-4. Verify fix addresses the issue
-
-## Rules
-- Fix ALL reported errors
-- Make MINIMAL changes
-- Don't "improve" unrelated code
-- Don't refactor while fixing
-- Keep existing style
-
-## Output Format
-\`\`\`<language>
-// Fixed code with all errors addressed
-\`\`\`
-
-### Changes Made
-- [ERROR-001]: <what was fixed>
-- [ERROR-002]: <what was fixed>
-
-## If Fix Unclear
-- Ask for clarification
-- Show what you understand
-- Propose alternative fix`,
-        canWrite: true,
-        canBash: true,
-    },
-
-    // ═══════════════════════════════════════════════════════════════
-    // SEARCHER - Context Provider
-    // ═══════════════════════════════════════════════════════════════
-    searcher: {
-        id: "searcher",
-        description: "Context provider - finds patterns, examples, and project conventions",
-        systemPrompt: `You are the Searcher - context provider.
-
-## Your Job
-Find relevant patterns and context BEFORE coder starts working.
-
-## Tools
-- grep_search: Find text/code patterns
-- glob_search: Find files by name
-
-## What to Find
-1. Similar implementations in codebase
-2. Import patterns and style
-3. Type definitions being used
-4. Existing utility functions
-5. Project conventions
-
-## Output Format
-\`\`\`
-### Found Patterns
-
-[PATTERN-1] <name>
-File: <path>
-Relevant code:
-\`\`\`<lang>
-<code snippet>
-\`\`\`
-
-[PATTERN-2] ...
-
-### Recommendations for Coder
-- Use <pattern> from <file>
-- Follow <convention>
-- Import from <path>
-\`\`\`
-
-## Guidelines
-- Show actual code, not just file paths
-- Focus on most relevant 3-5 findings
-- Note project conventions
-- Warn about gotchas`,
-        canWrite: false,
-        canBash: false,
-    },
-};
-
-// ============================================================================
-// Binary Management
-// ============================================================================
-
-function getBinaryPath(): string {
-    const binDir = join(__dirname, "..", "bin");
-    const os = platform();
-    const cpu = arch();
-
-    let binaryName: string;
-    if (os === "win32") {
-        binaryName = "orchestrator-windows-x64.exe";
-    } else if (os === "darwin") {
-        binaryName = cpu === "arm64" ? "orchestrator-macos-arm64" : "orchestrator-macos-x64";
-    } else {
-        binaryName = cpu === "arm64" ? "orchestrator-linux-arm64" : "orchestrator-linux-x64";
-    }
-
-    let binaryPath = join(binDir, binaryName);
-    if (!existsSync(binaryPath)) {
-        binaryPath = join(binDir, os === "win32" ? "orchestrator.exe" : "orchestrator");
-    }
-
-    return binaryPath;
-}
-
-async function callRustTool(name: string, args: Record<string, unknown>): Promise<string> {
-    const binary = getBinaryPath();
-    if (!existsSync(binary)) {
-        return JSON.stringify({ error: `Binary not found: ${binary}` });
-    }
-
-    return new Promise((resolve) => {
-        const proc = spawn(binary, ["serve"], { stdio: ["pipe", "pipe", "pipe"] });
-        let stdout = "";
-
-        proc.stdout.on("data", (data) => { stdout += data.toString(); });
-
-        const request = JSON.stringify({
-            jsonrpc: "2.0",
-            id: 1,
-            method: "tools/call",
-            params: { name, arguments: args },
-        });
-
-        proc.stdin.write(request + "\n");
-        proc.stdin.end();
-
-        const timeout = setTimeout(() => { proc.kill(); resolve(JSON.stringify({ error: "Timeout" })); }, 60000);
-
-        proc.on("close", () => {
-            clearTimeout(timeout);
-            try {
-                const lines = stdout.trim().split("\n");
-                const response = JSON.parse(lines[lines.length - 1]);
-                const text = response?.result?.content?.[0]?.text;
-                resolve(text || JSON.stringify(response.result));
-            } catch {
-                resolve(stdout || "No output");
-            }
-        });
-    });
-}
-
-// ============================================================================
-// State Management
-// ============================================================================
-
-const state = {
-    autoEnabled: false,
-    maxIterations: 100,
-    maxRetries: 3,
-    sessions: new Map<string, {
-        enabled: boolean;
-        iterations: number;
-        taskRetries: Map<string, number>;
-        currentTask: string;
-    }>(),
-};
-
-// ============================================================================
-// call_agent Tool
-// ============================================================================
-
-const callAgentTool = tool({
-    description: `Call a team member to perform specific work.
-
-## Team
-- **planner**: Decompose complex task into atomic units
-- **coder**: Implement single atomic task
-- **reviewer**: Quality check (ALWAYS after coder)
-- **fixer**: Fix specific errors from reviewer
-- **searcher**: Find patterns and context
-
-## Self-Correcting Workflow
-1. planner → atomic tasks
-2. For each task:
-   - searcher (if needed)
-   - coder
-   - reviewer (mandatory)
-   - fixer (if errors) → reviewer again
-3. Continue until all pass`,
-    args: {
-        agent: tool.schema
-            .enum(["planner", "coder", "reviewer", "fixer", "searcher"])
-            .describe("Team member to call"),
-        task: tool.schema.string().describe("Atomic task or specific error to address"),
-        context: tool.schema.string().optional().describe("Relevant context from previous steps"),
-    },
-    async execute(args) {
-        const agentDef = AGENTS[args.agent];
-        if (!agentDef) {
-            return `Error: Unknown agent: ${args.agent}`;
-        }
-
-        const prompt = `
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-${agentDef.id.toUpperCase()} AGENT
-${agentDef.description}
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-<system>
-${agentDef.systemPrompt}
-</system>
-
-<task>
-${args.task}
-</task>
-
-${args.context ? `<context>\n${args.context}\n</context>` : ""}
-
-Execute according to your role. Be thorough and precise.
-`;
-
-        return prompt;
-    },
-});
-
-// ============================================================================
-// Slash Commands
-// ============================================================================
-
-const COMMANDS: Record<string, { description: string; template: string; argumentHint?: string }> = {
-    "auto": {
-        description: "Autonomous execution with self-correcting loop",
-        template: `<command-instruction>
-🚀 AUTO MODE - Self-Correcting Agent Loop
-
-## Protocol
-1. Call planner to decompose into atomic tasks
-2. For EACH atomic task:
-   - Call searcher if context needed
-   - Call coder to implement
-   - Call reviewer to verify (MANDATORY)
-   - If FAIL: Call fixer → reviewer again (max 3 retries)
-   - If PASS: Move to next task
-3. Continue until all tasks complete with PASS
-
-## Error Recovery
-- Same error 3x → Stop and ask user
-- New error → Apply fix and retry
-- Stuck → Try different approach
-
-## Goal
-Complete "$ARGUMENTS" with zero errors.
-Keep iterating until done.
-</command-instruction>
-
-<user-task>
-$ARGUMENTS
-</user-task>`,
-        argumentHint: '"task description"',
-    },
-    "plan": {
-        description: "Decompose task into atomic units",
-        template: `<agent-prompt agent="planner">
-Decompose into atomic tasks:
-$ARGUMENTS
-</agent-prompt>`,
-        argumentHint: '"complex task"',
-    },
-    "review": {
-        description: "Quality check with error detection",
-        template: `<agent-prompt agent="reviewer">
-Review for ALL issues:
-$ARGUMENTS
-</agent-prompt>`,
-        argumentHint: '"code to review"',
-    },
-    "fix": {
-        description: "Fix specific errors",
-        template: `<agent-prompt agent="fixer">
-Fix these errors:
-$ARGUMENTS
-</agent-prompt>`,
-        argumentHint: '"error details"',
-    },
-    "search": {
-        description: "Find patterns and context",
-        template: `<agent-prompt agent="searcher">
-Find patterns for:
-$ARGUMENTS
-</agent-prompt>`,
-        argumentHint: '"what to find"',
-    },
-    "agents": {
-        description: "Show agent team",
-        template: `## 6-Agent Collaborative Architecture
-
-| Agent | Role |
-|-------|------|
-| planner | Decompose into atomic tasks |
-| coder | Implement single task |
-| reviewer | Quality gate (mandatory) |
-| fixer | Apply specific fixes |
-| searcher | Find context |
-
-## Self-Correcting Loop
-\`\`\`
-plan → (search → code → review → fix?) → repeat
-\`\`\``,
-    },
-    "cancel-auto": {
-        description: "Stop auto mode",
-        template: `Auto mode stopped.`,
-    },
-};
-
-// ============================================================================
-// Slash Command Tool
-// ============================================================================
-
-function createSlashcommandTool() {
-    const commandList = Object.entries(COMMANDS)
-        .map(([name, cmd]) => {
-            const hint = cmd.argumentHint ? ` ${cmd.argumentHint}` : "";
-            return `- /${name}${hint}: ${cmd.description}`;
-        })
-        .join("\n");
-
-    return tool({
-        description: `Commands\n\n${commandList}`,
-        args: {
-            command: tool.schema.string().describe("Command (without slash)"),
-        },
-        async execute(args) {
-            const cmdName = (args.command || "").replace(/^\//, "").split(/\s+/)[0].toLowerCase();
-            const cmdArgs = (args.command || "").replace(/^\/?\\S+\s*/, "");
-
-            if (!cmdName) return `Commands:\n${commandList}`;
-
-            const command = COMMANDS[cmdName];
-            if (!command) return `Unknown: /${cmdName}\n\n${commandList}`;
-
-            return command.template.replace(/\$ARGUMENTS/g, cmdArgs || "continue");
-        },
-    });
-}
-
-// ============================================================================
-// Search Tools
-// ============================================================================
-
-const grepSearchTool = (directory: string) => tool({
-    description: "Search code patterns",
-    args: {
-        pattern: tool.schema.string().describe("Regex pattern"),
-        dir: tool.schema.string().optional().describe("Directory"),
-    },
-    async execute(args) {
-        return callRustTool("grep_search", {
-            pattern: args.pattern,
-            directory: args.dir || directory,
-        });
-    },
-});
-
-const globSearchTool = (directory: string) => tool({
-    description: "Find files by pattern",
-    args: {
-        pattern: tool.schema.string().describe("Glob pattern"),
-        dir: tool.schema.string().optional().describe("Directory"),
-    },
-    async execute(args) {
-        return callRustTool("glob_search", {
-            pattern: args.pattern,
-            directory: args.dir || directory,
-        });
-    },
-});
-
-// ============================================================================
-// Utilities
-// ============================================================================
-
-function detectSlashCommand(text: string): { command: string; args: string } | null {
-    const match = text.trim().match(/^\/([a-zA-Z0-9_-]+)(?:\s+(.*))?$/);
-    if (!match) return null;
-    return { command: match[1], args: match[2] || "" };
-}
-
-// ============================================================================
-// Plugin
-// ============================================================================
-
-const OrchestratorPlugin = async (input: PluginInput) => {
-    const { directory } = input;
-
-    return {
-        tool: {
-            call_agent: callAgentTool,
-            slashcommand: createSlashcommandTool(),
-            grep_search: grepSearchTool(directory),
-            glob_search: globSearchTool(directory),
-        },
-
-        "chat.message": async (input: any, output: any) => {
-            const parts = output.parts as Array<{ type: string; text?: string }>;
-            const textPartIndex = parts.findIndex(p => p.type === "text" && p.text);
-            if (textPartIndex === -1) return;
-
-            const originalText = parts[textPartIndex].text || "";
-            const parsed = detectSlashCommand(originalText);
-
-            if (parsed) {
-                const command = COMMANDS[parsed.command];
-                if (command) {
-                    parts[textPartIndex].text = command.template.replace(/\$ARGUMENTS/g, parsed.args || "continue");
-
-                    if (parsed.command === "auto") {
-                        const sessionID = input.sessionID;
-                        state.sessions.set(sessionID, {
-                            enabled: true,
-                            iterations: 0,
-                            taskRetries: new Map(),
-                            currentTask: "",
-                        });
-                        state.autoEnabled = true;
-                    } else if (parsed.command === "cancel-auto") {
-                        state.sessions.delete(input.sessionID);
-                        state.autoEnabled = false;
-                    }
-                }
-            }
-        },
-
-        "tool.execute.after": async (
-            input: { tool: string; sessionID: string; callID: string },
-            output: { title: string; output: string; metadata: any }
-        ) => {
-            if (!state.autoEnabled) return;
-
-            const session = state.sessions.get(input.sessionID);
-            if (!session?.enabled) return;
-
-            session.iterations++;
-
-            // Circuit breaker: max iterations
-            if (session.iterations >= state.maxIterations) {
-                session.enabled = false;
-                output.output += `\n\n━━━━━━━━━━━━\n⚠️ ITERATION LIMIT (${state.maxIterations})\nReview progress and continue manually.`;
-                return;
-            }
-
-            // Detect errors and track retries
-            const errorMatch = output.output.match(/\[ERROR-(\d+)\]/);
-            if (errorMatch) {
-                const errorId = `error-${session.currentTask || 'unknown'}`;
-                const retries = (session.taskRetries.get(errorId) || 0) + 1;
-                session.taskRetries.set(errorId, retries);
-
-                if (retries >= state.maxRetries) {
-                    session.enabled = false;
-                    output.output += `\n\n━━━━━━━━━━━━\n🛑 RETRY LIMIT (${state.maxRetries}x same error)\nReview manually or try different approach.`;
-                    return;
-                }
-
-                output.output += `\n\n━━━━━━━━━━━━\n🔄 RETRY ${retries}/${state.maxRetries}\nApply fix and verify again.`;
-                return;
-            }
-
-            // Clear retries on PASS
-            if (output.output.includes("✅ PASS")) {
-                session.taskRetries.clear();
-                output.output += `\n\n━━━━━━━━━━━━\n✅ VERIFIED - Continue to next task\n[${session.iterations}/${state.maxIterations}]`;
-                return;
-            }
-
-            output.output += `\n\n━━━━━━━━━━━━\n[${session.iterations}/${state.maxIterations}]`;
-        },
-    };
-};
-
-export default OrchestratorPlugin;