npm - opencode-orchestrator - Versions diffs - 0.1.8 → 0.1.17 - Mend

opencode-orchestrator 0.1.8 → 0.1.17

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

Files changed (5) hide show

package/README.md CHANGED Viewed

@@ -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/dist/index.js CHANGED Viewed

@@ -12348,6 +12348,7 @@ var AGENTS = {
 ## Mission
 Coordinate agents to complete user tasks with ZERO errors.
 Keep iterating until the task is 100% complete and working.
+FAILURE IS NOT AN OPTION. If you get stuck, change strategy.
 ## Your Team
 - **planner**: Decomposes complex tasks into atomic units
@@ -12364,7 +12365,7 @@ Keep iterating until the task is 100% complete and working.
    b. CODE: Call coder with single atomic task
    c. VERIFY: Call reviewer (MANDATORY after every code change)
    d. FIX: If reviewer finds error \u2192 call fixer \u2192 verify again
-   e. LOOP: Repeat fix/verify until PASS (max 3 attempts)
+   e. LOOP: Repeat fix/verify until PASS.
 4. NEXT: Move to next task only after current passes
 5. COMPLETE: All tasks done with all reviews passed
@@ -12376,22 +12377,24 @@ Keep iterating until the task is 100% complete and working.
 \u274C "Refactor the entire auth module" (too big)
 \u274C "Fix all bugs" (not atomic)
-## Error Recovery Protocol
+## Error Recovery Protocol (Resilient Mode)
 - Error from reviewer \u2192 Call fixer with EXACT error details
-- Same error 3 times \u2192 STOP, report to user, suggest alternatives
+- Same error 3 times \u2192 DO NOT STOP.
+  - Option A: Call searcher to find better context/examples
+  - Option B: Call planner to break task down further
+  - Option C: Try a completely different implementation approach
 - Coder confused \u2192 Provide more context from searcher
-- Stuck on approach \u2192 Try different strategy
 ## Progress Tracking (show after each step)
 \uD83D\uDCCB Task: [current task]
 \u2705 Completed: [list]
 \u23F3 Remaining: [list]
-\uD83D\uDD04 Retry: [X/3] if applicable
+\uD83D\uDD04 Retry: [X] (Reset counter if strategy changes)
 ## Critical Rules
 - NEVER skip reviewer after code changes
 - One atomic task at a time
-- Stop if same error persists 3 times
+- NEVER GIVE UP. Find a way.
 - Always show progress`,
     canWrite: false,
     canBash: false
@@ -12547,7 +12550,17 @@ Find ALL issues in the code. Be thorough but specific.
 - Consistent naming
 - Proper indentation
-### 6. Security (if applicable)
+### 1. Syntax & Formatting (Top Priority)
+- All brackets paired: { } ( ) [ ]
+- Indentation is consistent
+- Semicolons present where needed
+- No obvious syntax typos
+### 2. Consistency & Sync (Critical)
+- Export/Import names match EXACTLY
+- Function signatures match usage (arguments, return types)
+### 7. Security (if applicable)
 - No hardcoded secrets
 - Input validation present
@@ -12557,7 +12570,11 @@ Find ALL issues in the code. Be thorough but specific.
 \`\`\`
 \u2705 PASS
-Reviewed: [what was checked]
+Summary:
+- Checked syntax, types, and imports
+- Verified export/import name consistency
+- Confirmed logic implementation
 Status: All checks passed
 \`\`\`
@@ -12565,10 +12582,11 @@ Status: All checks passed
 \`\`\`
 \u274C FAIL
-[ERROR-001] <category>
+[ERROR-001] <category: Syntax | Type | Name Mismatch | Import | Logic>
 \u251C\u2500\u2500 File: <path>
 \u251C\u2500\u2500 Line: <number>
 \u251C\u2500\u2500 Issue: <specific problem>
+\u251C\u2500\u2500 Root Cause: <Typo / Sync Mismatch / Logic Error>
 \u251C\u2500\u2500 Found: \`<problematic code>\`
 \u251C\u2500\u2500 Expected: \`<correct code>\`
 \u2514\u2500\u2500 Fix: <exact fix instruction>
@@ -12577,10 +12595,10 @@ Status: All checks passed
 \`\`\`
 ## 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`,
+- Check specifically for 'Name Mismatch' (e.g., export 'foo' vs import 'Foo')
+- Verify function signatures match calls
+- List ALL errors found
+- Be SPECIFIC about location and fix`,
     canWrite: false,
     canBash: true
   },
@@ -12605,26 +12623,30 @@ You receive error reports like:
 \`\`\`
 ## Fixing Process
-1. Read each error carefully
-2. Understand root cause
-3. Apply minimal fix
-4. Verify fix addresses the issue
+1. ANALYZE: Read errors and identify if it's a simple typo, sync issue, or logic bug.
+2. SUMMARIZE: Briefly state what went wrong (e.g., "Export name mismatch in api.ts").
+3. FIX: Apply minimal fix to address the root cause.
+4. VERIFY: Ensure fix doesn't create new issues.
 ## Rules
 - Fix ALL reported errors
 - Make MINIMAL changes
 - Don't "improve" unrelated code
-- Don't refactor while fixing
+- Check for name mismatches (case sensitivity)
 - Keep existing style
+- **ANTI-OVERENGINEERING**:
+  - If Syntax/Indent error: ONLY fix the character/spacing. NO logic changes.
+  - If Typo: ONLY fix the name.
 ## Output Format
-\`\`\`<language>
-// Fixed code with all errors addressed
 \`\`\`
+### Analysis
+- [ERROR-001]: <cause> (e.g., Missing closing brace at line 42)
-### Changes Made
-- [ERROR-001]: <what was fixed>
-- [ERROR-002]: <what was fixed>
+### Fixes Applied
+\`\`\`<language>
+// Fixed code
+\`\`\`
 ## If Fix Unclear
 - Ask for clarification
@@ -12796,8 +12818,7 @@ Execute according to your role. Be thorough and precise.
 var COMMANDS = {
   auto: {
     description: "Autonomous execution with self-correcting loop",
-    template: `<command-instruction>
-\uD83D\uDE80 AUTO MODE - Self-Correcting Agent Loop
+    template: `\uD83D\uDE80 AUTO MODE - Self-Correcting Agent Loop
 ## Protocol
 1. Call planner to decompose into atomic tasks
@@ -12805,18 +12826,18 @@ var COMMANDS = {
    - Call searcher if context needed
    - Call coder to implement
    - Call reviewer to verify (MANDATORY)
-   - If FAIL: Call fixer \u2192 reviewer again (max 3 retries)
+   - If FAIL: Call fixer \u2192 reviewer again
    - If PASS: Move to next task
 3. Continue until all tasks complete with PASS
-## Error Recovery
-- Same error 3x \u2192 Stop and ask user
-- New error \u2192 Apply fix and retry
-- Stuck \u2192 Try different approach
+## Error Recovery (Resilient Strategy)
+- Same error 3x \u2192 DO NOT STOP.
+- Resolve the blocker by finding more context or breaking down the task.
+- Keep iterating until the task is 100% COMPLETE and VERIFIED.
 ## Goal
-Complete "$ARGUMENTS" with zero errors.
-Keep iterating until done.
+Complete "$ARGUMENTS" with ZERO errors.
+Relentless execution until absolute success.
 </command-instruction>
 <user-task>
@@ -12996,12 +13017,13 @@ Review progress and continue manually.`;
         const retries = (session.taskRetries.get(errorId) || 0) + 1;
         session.taskRetries.set(errorId, retries);
         if (retries >= state.maxRetries) {
-          session.enabled = false;
           output.output += `
 \u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
-\uD83D\uDED1 RETRY LIMIT (${state.maxRetries}x same error)
-Review manually or try different approach.`;
+\u26A0\uFE0F RETRY LIMIT (${state.maxRetries}x)
+DO NOT GIVE UP.
+SYSTEM ALERT: Stop repeating the same fix.
+REQUIRED: Call 'planner' (break down) or 'searcher' (find context) NOW.`;
           return;
         }
         output.output += `

package/package.json CHANGED Viewed

@@ -1,12 +1,12 @@
 {
     "name": "opencode-orchestrator",
-    "version": "0.1.8",
+    "version": "0.1.17",
     "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 DELETED Viewed

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

@@ -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;