opencode-orchestrator 0.1.43 → 0.1.48

package/README.md

@@ -1,21 +1,25 @@
-#OpenCode Orchestrator Plugin
+# OpenCode Orchestrator Plugin
 
 > **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)
 [![npm downloads](https://img.shields.io/npm/dt/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>
+
+[English](README.md)
 
 ---
 
+<p align="center">
+  <img src="assets/logo.png" width="600" />
+</p>
+
 ## What is this?
 
-A 6-agent collaborative system that turns any LLM into a reliable coding team.
+**OpenCode Orchestrator** is a multi-agent orchestration framework that **abstracts the generative intelligence of LLMs into a structured and reliable computing resource**. It is designed to extract **Ultimate Decision Quality** from affordable, lower-performance models by treating LLM inference as a precision engineering component.
 
-**Core idea**: Break complex tasks into atomic units, verify each step, fix errors automatically.
+**Core Philosophy**: We don't just "chat" with AI. We architect **deterministic execution flows** by decomposing complex missions into atomic, verifiable tasks. By orchestrating specialized agents through a rigorous **PDCA (Plan-Do-Check-Act)** cycle, we maximize the utility of LLM intelligence while ensuring every step is validated by a dedicated Quality Gate.
 
 ---
 
@@ -23,48 +27,50 @@ A 6-agent collaborative system that turns any LLM into a reliable coding team.
 
 | 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 | **Relentless execution until success** |
+| Expensive "Smart" Model required | **Affordable Model + Smart Process** |
+| High Token Costs (Huge Context) | **Token Efficient** (Filtered Context) |
+| Linear, Slow Execution | **Parallel, Fast Execution** |
+| Errors compound silently | **Self-Correcting Verification Loops** |
+| "Hope it works" | **Strategic Micro-Tasking** |
 
 ---
 
-## Features
-
-- **🦀 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
-- **🛡️ Resilient Execution** — Never stops on errors. Pivots strategy (Plan/Search) until success.
-- **⚡ Full Autonomy** — `/auto` is all you need. Relentless execution until 100% complete.
-- **🏗️ Rust-Powered Core** — Critical logic written in Rust for **peak performance** and **memory efficiency**.
-- **🪶 Thin TS Wrapper** — Minimal JavaScript overhead. The heavy lifting happens in the native binary.
+- **🧩 Strategic Organization** — Maximizing output through intelligent role distribution
+- **📉 Token Economy** — Filtering noise to reduce costs and increase focus
+- **⚡ Parallel DAG** — Concurrent execution for speed and efficiency
+- **🔍 Micro-Tasking** — Atomic decomposition to prevent hallucinations
+- **🛡️ Style Guardian** — Strict AST-based linting and consistency checks
+- **🔄 Self-Healing** — Autonomous pivot strategies for complex errors
+- **🏗️ Rust Core** — Native performance for heavy lifting
 
 ---
 
-## How It Works
+## How It Works (Parallel DAG)
+
+Instead of a linear sequence, we use a **Directed Acyclic Graph (DAG)** to model your mission.
 
 ```
-User Request
-     │
-     ▼
-┌─────────┐
-│ PLANNER │ → Break into atomic tasks
-└────┬────┘
-     │
-     ▼
-┌──────────────────────────────────────────┐
-│  For each task:                          │
-│                                          │
-│   Search → Code → Review → Fix           │
-│       ↑                      │           │
-│       └──────────────────────┘           │
-│           (Never gives up)               │
-└──────────────────────────────────────────┘
-     │
-     ▼
-✅ Done
+      Mission Start (/task)
+              │
+              ▼
+      ┌───────────────┐
+      │   PLANNER     │ (Architect)
+      └───────┬───────┘
+              │
+      ┌───────┴───────┐
+      │               │ (Parallel Streams)
+      ▼               ▼
+┌───────────┐   ┌───────────┐
+│ Tasks (A) │   │ Tasks (B) │
+└─────┬─────┘   └─────┬─────┘
+      │               │
+      └───────┬───────┘
+              ▼
+      ┌───────────────┐
+      │   REVIEWER    │ (Style Guardian)
+      └───────┬───────┘
+              ▼
+          ✅ MISSION COMPLETE
 ```
 
 ---
@@ -87,7 +93,7 @@ bun install -g opencode-orchestrator
 > The plugin will automatically register itself in `~/.config/opencode/opencode.json` with its absolute path.
 
 ### Troubleshooting
-If the command `/auto` does not appear:
+If the command `/task` does not appear:
 1. Uninstall: `npm uninstall -g opencode-orchestrator` (or `bun remove -g`)
 2. Clear config: `rm -rf ~/.config/opencode` (Warning: resets all plugins)
 3. Reinstall: `npm install -g opencode-orchestrator`
@@ -95,23 +101,19 @@ If the command `/auto` does not appear:
 
 ---
 
-## Usage
+**The only command you need:**
 
-**Just type one command:**
-
-```
-/auto "Implement user authentication with JWT"
+```bash
+/task "Implement user authentication with JWT"
 ```
 
 The Orchestrator will:
-1. **Plan** the architecture
-2. **Search** for context
-3. **Write** the code
-4. **Review** for errors
-5. **Fix** any issues
-6. **Repeat** until 100% verified.
-
-**This is the only command you need.**
+1. **Decompose** the mission into a JSON Task DAG
+2. **Parallel Execute** independent streams
+3. **Search** proactively for patterns
+4. **Code** with atomic precision
+5. **Verify** via the Style Guardian (MANDATORY)
+6. **Self-Heal** if errors occur
 
 ---
 
@@ -128,10 +130,8 @@ The Orchestrator will:
 
 ---
 
-## Documentation
-
-- [Architecture](docs/ARCHITECTURE.md) — Detailed workflow
-- [Configuration](examples/orchestrator.jsonc) — Customize settings
+- **[System Architecture (Deep Dive)](docs/ARCHITECTURE.md)**: Explore the Distributed Cognitive Architecture (DCA), PDCA Loop, and Actor Model internals.
+- **[Configuration](docs/CONFIGURATION.md)**: `opencode.toml` setup guide.
 
 ---
 
@@ -143,21 +143,59 @@ MIT License. No telemetry. No backdoors.
 
 ---
 
-## Author's Note
+## License
 
-> 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)
+MIT License. NO WARRANTY.
+
+[MIT](LICENSE)
 
 ---
 
-## License
+## 🏛️ The Architecture: The PDCA & Distributed Cognitive Loop
 
-MIT License. NO WARRANTY.
+We have moved beyond simple "chatbots". **OpenCode Orchestrator** implements a **Deterministic Engineering Layer** built on top of the stochastic nature of LLMs,
+- **Strict PDCA Loop**: Guarantees quality via Plan-Do-Check-Act cycle.
+- **🔍 Micro-tasking**: Atomic decomposition to prevent hallucinations.
+- **🛡️ Style Guardian**: Strict AST-based linting and consistency checks by the Reviewer.
+- **🔄 Self-healing**: Autonomous pivoting strategies for complex errors.
+- **Distributed Cognitive System**: Intelligence layer acting like an OS Kernel.
+- **File-Based State**: Uses physical filesystem as RAM, ignoring context limits.
+We treat agents as **Semantic Compute Units**. By applying rigorous Computer Science principles, we achieve a level of reliability that no single model can match.
 
-[MIT](LICENSE)
+### 🧬 The "Grand Fusion" of Methodologies
+We explicitly fused three massive domains into one seamless workflow:
+
+1.  **PDCA Methodology (Quality Assurance)**:
+    *   **Plan (Planner)**: Recursively decomposes mission into atomic tasks ($O(log n)$).
+    *   **Do (Coder)**: Executes the atomic tasks in parallel (Distributed Actions).
+    *   **Check (Reviewer)**: Acts as a **Byzantine Fault Tolerance** node, strictly validating code against requirements.
+    *   **Act (Orchestrator)**: Merges successful states or **Pivots** (Dynamic Programming) if failures occur.
+
+2.  **Distributed Systems Theory (Actor Model)**:
+    *   Each agent operates as an independent **Actor** with isolated state.
+    *   **Context Sharding**: We treat context windows like RAM, paging data in/out via `temp_context` files to simulate **Infinite Context**.
+
+3.  **Algorithmic Efficiency**:
+    *   **Divide & Conquer**: Breaking complex problems into trivial $O(1)$ sub-problems.
+    *   **Dynamic Programming**: Storing intermediate results (State) to avoid redundant computation and allow for intelligent backtracking.
+
+### 🚀 The Command: `/task`
+
+The interface to this system is a single, powerful command:
+
+```bash
+/task "Refactor the authentication middleware and implement JWT rotation"
+```
+
+This triggers the **Distributed Task Loop**. It's not just a chat; it's a mission commitment.
+
+### The 5-Phase Efficiency Workflow
+
+1.  **🧠 Phase 1: Filtered Analysis**: The **Searcher** reads docs but filters out noise. We only feed the "critical path" to the Planner.
+2.  **🌲 Phase 2: Strategic Planning**: The **Planner** creates a JSON DAG. This is our roadmap. No token is wasted on aimless wandering.
+3.  **🚀 Phase 3: Parallel Execution**: The **Orchestrator** identifies independent tasks and runs them concurrently.
+4.  **🛡️ Phase 4: Sync & Verify**: The **Reviewer** acts as the gatekeeper. It checks syntax, logic, and *cross-file consistency*.
+5.  **💰 Phase 5: Cost-Effective Completion**: We achieve "Senior Developer" results at "Junior Intern" prices.
 
 ---
 

package/dist/cli.d.ts

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

package/dist/cli.js

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { spawn } from "child_process";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import { platform, arch } from "os";
+import { existsSync } from "fs";
+var __dirname2 = dirname(fileURLToPath(import.meta.url));
+function getBinaryPath() {
+  const binDir = join(__dirname2, "..", "bin");
+  const os = platform();
+  const cpu = arch();
+  let binaryName;
+  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;
+}
+var binary = getBinaryPath();
+var args = process.argv.slice(2);
+if (!existsSync(binary)) {
+  console.error(`Error: Orchestrator binary not found for your platform (${platform()} ${arch()})`);
+  console.error(`Expected at: ${binary}`);
+  process.exit(1);
+}
+var child = spawn(binary, args, { stdio: "inherit" });
+child.on("close", (code) => {
+  process.exit(code || 0);
+});
+child.on("error", (err) => {
+  console.error("Failed to start orchestrator binary:", err);
+  process.exit(1);
+});

package/dist/index.d.ts

@@ -67,6 +67,7 @@ declare const OrchestratorPlugin: (input: PluginInput) => Promise<{
         tool: string;
         sessionID: string;
         callID: string;
+        arguments?: any;
     }, output: {
         title: string;
         output: string;

package/dist/index.js

@@ -12337,129 +12337,193 @@ function tool(input) {
   return input;
 }
 tool.schema = exports_external;
+// src/tasks.ts
+class TaskGraph {
+  tasks = new Map;
+  constructor(tasks) {
+    if (tasks) {
+      tasks.forEach((t) => this.addTask(t));
+    }
+  }
+  addTask(task) {
+    this.tasks.set(task.id, { ...task, status: "pending", retryCount: 0 });
+  }
+  getTask(id) {
+    return this.tasks.get(id);
+  }
+  updateTask(id, updates) {
+    const task = this.tasks.get(id);
+    if (task) {
+      this.tasks.set(id, { ...task, ...updates });
+    }
+  }
+  getReadyTasks() {
+    return Array.from(this.tasks.values()).filter((task) => {
+      if (task.status !== "pending")
+        return false;
+      return task.dependencies.every((depId) => {
+        const dep = this.tasks.get(depId);
+        return dep && dep.status === "completed";
+      });
+    });
+  }
+  isCompleted() {
+    return Array.from(this.tasks.values()).every((t) => t.status === "completed");
+  }
+  hasFailed() {
+    return Array.from(this.tasks.values()).some((t) => t.status === "failed" && t.retryCount >= 3);
+  }
+  getTaskSummary() {
+    const tasks = Array.from(this.tasks.values());
+    const completed = tasks.filter((t) => t.status === "completed");
+    const notCompleted = tasks.filter((t) => t.status !== "completed");
+    let summary = `\uD83D\uDCCB **Mission Status**
+`;
+    if (completed.length > 0) {
+      summary += `\u2705 Completed: ${completed.length} tasks (Hidden to save tokens)
+`;
+    }
+    for (const task of notCompleted) {
+      const icon = task.status === "running" ? "\u23F3" : task.status === "failed" ? "\u274C" : "\uD83D\uDCA4";
+      summary += `${icon} [${task.id}] ${task.description}
+`;
+    }
+    return summary;
+  }
+  toJSON() {
+    return JSON.stringify(Array.from(this.tasks.values()), null, 2);
+  }
+  static fromJSON(json2) {
+    try {
+      const tasks = JSON.parse(json2);
+      return new TaskGraph(tasks);
+    } catch (e) {
+      console.error("Failed to parse TaskGraph JSON:", e);
+      return new TaskGraph;
+    }
+  }
+}
+
 // src/index.ts
 var __dirname2 = dirname(fileURLToPath(import.meta.url));
 var AGENTS = {
   orchestrator: {
     id: "orchestrator",
-    description: "Team leader - delegates atomic tasks, tracks progress, adapts on failure",
-    systemPrompt: `You are the Orchestrator - the team leader.
+    description: "Team leader - manages the Mission and parallel work streams",
+    systemPrompt: `You are the Orchestrator - the mission commander.
 
-## 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.
+## Core Philosophy: Micro-Tasking & Quality Gates
+- Even small models (Phi, Gemma) succeed when tasks are tiny and verified.
+- Your job is to manage the **Task Mission** (Directed Acyclic Graph).
+- NEVER proceed to a task if its dependencies are not 100% VERIFIED.
+
+## Operational SOP (Standard Operating Procedure)
+1. **PHASE 0: TRADE-OFF ANALYSIS**:
+   - **Cost vs. Value**: Is the DAG overhead justified?
+   - **Complexity**: If task is trivial, execute linearly (1-Node DAG).
+   - Only engage full DAG if complexity > 3 or multiple files involved.
+2. **ANALYSIS PHASE (THINK FIRST)**: 
+   - Call **searcher** to read docs.
+## Operational SOP
+1. PHASE 0: COMPLEXITY AUDIT. Hotfix (Linear) vs System Overhaul (Flow)?
+2. ANALYSIS: MapReduce data. Shard huge context.
+3. CONTRACT: Define Interface Agreement (\`_interface_contract.md\`) if parallel dependencies exist.
+4. PLAN: Decompose & Alloc. Assign Agents/Tools dynamically.
+5. SCHEDULE: Identify ready tasks.
+6. EXECUTE: search -> code -> review.
+7. GLOBAL SYNC GATE: Reviewer must verify cross-task consistency against Contract.
+8. **CLEANUP**: Automatically delete the temporary mission state file (*.mission.md) AND all \`temp_context_*.md\` shards upon completion.
 
-## 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
+## Verification
+- Ensure you are not "guessing" libraries.
+- If a function signature is needed for a parallel task, READ \`_interface_contract.md\`.
+- If no contract exists, CREATE one.
 
-## Workflow (Self-Correcting Loop)
-1. ANALYZE: Understand user request fully
-2. PLAN: Call planner for complex tasks \u2192 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 \u2192 call fixer \u2192 verify again
-   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
+## Global Consistency Rules (Mandatory)
+- **State Persistence**: Independent nodes MUST communicate via files, not memory.
+- **Import Sync**: Any export change MUST trigger an update in all importing files.
+- **Signature Sync**: Function signature changes MUST be propagated to all callers in the same DAG layer.
+- **Type Sync**: Shared types MUST be modified in isolation before logic implementation.
+- **Atomic Integrity**: Parallel tasks MUST NOT modify the same line of code in the same file.
 
-## Atomic Task Examples
-\u2705 "Add validateEmail function to src/utils/validation.ts"
-\u2705 "Fix syntax error in LoginForm.tsx line 42"
-\u2705 "Update import statement in api/routes.ts"
-\u2705 "Add error handling to fetchUser function"
-\u274C "Refactor the entire auth module" (too big)
-\u274C "Fix all bugs" (not atomic)
+## Memory Management Strategy (Infinite Context Simulation)
+- **Sharding**: Never hold raw code in context. Write it to a file, keep the reference.
+- **Garbage Collection**: If a task is done, summarize its outcome ("Task A: Success, Output at /file/path") and FORGET the details.
+- **Value Judgment**: Do not summarize "process". Summarize "state changes".
 
-## Error Recovery Protocol (Resilient Mode)
-- Error from reviewer \u2192 Call fixer with EXACT error details
-- 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
+## Safety & Boundary SOP
+- **Safety Gate**: Verify alignment with project core before any execution.
+- **Sync Sentinel**: You are responsible for cross-task logic consistency. If tasks drift, HALT and re-sync.
 
-## Progress Tracking (show after each step)
-\uD83D\uDCCB Task: [current task]
-\u2705 Completed: [list]
-\u23F3 Remaining: [list]
-\uD83D\uDD04 Retry: [X] (Reset counter if strategy changes)
+## Failure Recovery SOP
+- **Error 1-2**: Call fixer as usual.
+- **Error 3**: Pivot. Call searcher for similar fixes or planner to split the task further.
+- **Syntax Error**: Fixer MUST only fix syntax, no logic changes.
 
-## Critical Rules
-- NEVER skip reviewer after code changes
-- One atomic task at a time
-- NEVER GIVE UP. Find a way.
-- Always show progress`,
+## Reliable Execution with Fixed Models
+- This system is optimized for fixed, low-performance models (Phi, Gemma, etc.).
+- Performance is achieved through granularity, not model upgrades.
+
+## Progress Status
+Always show the Mission status at the end of your turns:
+\uD83D\uDCCB Mission Status:
+[TASK-001] \u2705 Completed
+[TASK-002] \u23F3 Running
+[TASK-003] \uD83D\uDCA4 Pending`,
     canWrite: false,
     canBash: false
   },
   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>
-\u251C\u2500\u2500 File: <exact path>
-\u251C\u2500\u2500 Action: <what to do>
-\u251C\u2500\u2500 Success: <how to verify it worked>
-\u2514\u2500\u2500 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
+    description: "Architect - decomposes work into a JSON Mission",
+    systemPrompt: `You are the Planner - the master architect.
 
-## Good Atomic Tasks
-\u2705 "Add validateEmail function to utils/validation.ts"
-\u2705 "Import bcrypt in auth/password.ts"
-\u2705 "Fix missing closing brace in UserForm.tsx line 58"
-\u2705 "Add try-catch to fetchData function in api.ts"
-\u2705 "Update Button component props interface"
+## Your Mission
+1. **Understand & Filter**: Read documentation, but **FILTER** out irrelevant parts. determine what is truly important.
+2. **Hierarchical Decomposition**: Decompose the mission from high-level modules down to sub-atomic micro-tasks.
+3. **Mission Generation**: Create a JSON-based Directed Acyclic Graph.
 
-## Bad Tasks (too large/vague)
-\u274C "Implement authentication" \u2192 break into 5-10 atomic tasks
-\u274C "Fix all errors" \u2192 list specific errors as separate tasks
-\u274C "Refactor module" \u2192 identify specific changes needed
+## SOP: Atomic Task Creation
+- **Thinking Phase**: Summarize *essential* findings only. Discard noise.
+- **Documentation Alignment**: Read ALL .md files to define project boundaries.
+- **State Management**: If Task B needs Task A's output, Task A MUST write to a file.
+- **Single File**: A task should only touch ONE file.
+- **Single Responsibility**: A task should do ONE thing.
+- **Verification Ready**: Every task MUST have clear "Success Criteria".
 
-## Example Decomposition
-Complex task: "Add user login feature"
+## Boundary Enforcement
+- Tasks MUST NOT violate established architectural patterns found in docs.
+- If a request contradicts documentation, your plan must first address the conflict.
 
-[TASK-001] Create password hashing utility
-\u251C\u2500\u2500 File: src/utils/password.ts
-\u251C\u2500\u2500 Action: Add hashPassword and verifyPassword functions
-\u251C\u2500\u2500 Success: Functions exported and callable
-\u2514\u2500\u2500 Depends: none
-
-[TASK-002] Create User type definition
-\u251C\u2500\u2500 File: src/types/User.ts
-\u251C\u2500\u2500 Action: Add User interface with id, email, passwordHash
-\u251C\u2500\u2500 Success: Type exported and importable
-\u2514\u2500\u2500 Depends: none
-
-[TASK-003] Create login API handler
-\u251C\u2500\u2500 File: src/api/login.ts
-\u251C\u2500\u2500 Action: Add POST handler that validates credentials
-\u251C\u2500\u2500 Success: Handler returns token on valid login
-\u2514\u2500\u2500 Depends: TASK-001, TASK-002
+## Output Format (MANDATORY JSON)
+Produce a JSON array of tasks:
+\`\`\`json
+[
+  {
+    "id": "TASK-001",
+    "description": "Create User interface",
+    "action": "Add Interface",
+    "file": "src/types/user.ts",
+    "dependencies": [],
+    "type": "infrastructure",
+    "complexity": 2
+  },
+  {
+    "id": "TASK-002",
+    "description": "Implement User save logic",
+    "action": "Add function saveUser",
+    "file": "src/lib/user.ts",
+    "dependencies": ["TASK-001"],
+    "type": "logic",
+    "complexity": 5
+  }
+]
+\`\`\`
 
-## Output Format
-List tasks in dependency order. Independent tasks first.`,
+## Safety Rules
+- Break circular dependencies.
+- Ensure all files are identified by absolute or relative path from project root.
+- Keep complexity < 7. If higher, split the task.`,
     canWrite: false,
     canBash: false
   },
@@ -12492,6 +12556,7 @@ Provide COMPLETE code that:
 2. Compiles/runs without errors
 3. Matches project style
 4. Includes necessary imports
+5. **Persists State**: If this logic is needed by others, ensure it is exposed (exported) or saved to a file.
 
 ## Common Mistakes to Avoid
 - Forgetting closing brackets
@@ -12499,6 +12564,7 @@ Provide COMPLETE code that:
 - Using wrong variable names
 - Type mismatches
 - Breaking existing code
+- **Silent Failures**: Failing to handle errors in state persistence (file writes).
 
 ## If Unsure
 - Ask for more context
@@ -12516,89 +12582,38 @@ Brief explanation if needed.`,
   },
   reviewer: {
     id: "reviewer",
-    description: "Quality gate - comprehensive error detection with specific fix instructions",
-    systemPrompt: `You are the Reviewer - quality assurance gate.
+    description: "Style Guardian & Sync Sentinel - ensures total code consistency",
+    systemPrompt: `You are the Reviewer - the Style Guardian and Sync Sentinel.
 
 ## Your Job
-Find ALL issues in the code. Be thorough but specific.
-
-## Review Checklist
+1. **Task Review**: Verify individual code changes (Syntax, Style, Logic).
+2. **Global Sync Check**: After parallel changes, verify that all files are in sync.
+   - Do imports match the new exports?
+   - Do function calls match revised signatures?
+   - Is there any logic drift between parallel streams?
 
-### 1. Syntax (Critical)
-- All brackets paired: { } ( ) [ ]
-- All quotes closed: " ' \`
-- All statements terminated
-- Valid language syntax
+## SOP: The 5-Point Check + Sync
+1. **SYNTAX**: 100% valid.
+2. **STYLE**: Consistent naming and indentation.
+3. **LOGIC**: Addresses the task.
+4. **INTEGRITY (Sync)**: Cross-file name and signature matching.
+5. **DATA FLOW**: Verifies that state persistence (File I/O) is implemented if needed.
+6. **SECURITY**: No secrets.
 
-### 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
-
-### 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
-
-## Output Format
-
-### If NO errors:
+## Review Results (MANDATORY Format)
+### If PASS:
 \`\`\`
-\u2705 PASS
-
-Summary:
-- Checked syntax, types, and imports
-- Verified export/import name consistency
-- Confirmed logic implementation
-
-Status: All checks passed
+\u2705 PASS (Confidence: 100%)
+- All individual checks passed.
+- Global Sync Check: NO drift detected.
 \`\`\`
 
-### If errors found:
+### If FAIL:
 \`\`\`
-\u274C FAIL
-
-[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>
-
-[ERROR-002] ...
+\u274C FAIL [SYNC-ERROR | STYLE | LOGIC]
+...
 \`\`\`
-
-## Rules
-- 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
   },
@@ -12619,7 +12634,7 @@ You receive error reports like:
 \u251C\u2500\u2500 Issue: <problem>
 \u251C\u2500\u2500 Found: \`<bad code>\`
 \u251C\u2500\u2500 Expected: \`<good code>\`
-\u2514\u2500\u2500 Fix: <instruction>
+\u251C\u2500\u2500 Fix: <instruction>
 \`\`\`
 
 ## Fixing Process
@@ -12657,47 +12672,33 @@ You receive error reports like:
   },
   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.
+    description: "Context provider - finds documentation and codebase patterns",
+    systemPrompt: `You are the Searcher - the context oracle.
 
-## Tools
-- grep_search: Find text/code patterns
-- glob_search: Find files by name
+## Mission
+Your primary job is to find the **Truth** in the codebase.
+In 'Context First' mode, you MUST prioritize reading all .md documentation files.
 
 ## 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>
-\`\`\`
+1. **Boundaries**: Read README.md, ARCHITECTURE.md to understand what NOT to do.
+2. **Patterns**: Find existing code that solves similar problems.
+3. **Types & Interfaces**: Identify the data structures to follow.
+4. **Project Style**: Detect naming and formatting conventions.
 
-[PATTERN-2] ...
+## SOP
+1. Start with \`find_by_name\` for *.md files.
+2. Use \`grep_search\` for specific logic patterns.
+3. **Value Judgment**: Before reporting, ask "Is this relevant to the CURRENT task step?".
+4. **Context Sharding**: If findings are huge, WRITE them to \`temp_context_findings.md\` and only report the path.
+5. **Recursive Summarization**: If reading an existing context file, condense it further based on current progress.
 
-### 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`,
+## Output Format
+Produce a clear summary or a file pointer:
+"\u26A0\uFE0F Large context detected. Written to \`temp_context_auth_logic.md\`."
+OR
+### 1. Architectural Boundaries (from docs)
+### 2. Relevant Patterns (code snippets)
+### 3. Recommendations`,
     canWrite: false,
     canBash: false
   }
@@ -12759,8 +12760,8 @@ async function callRustTool(name, args) {
   });
 }
 var state = {
-  autoEnabled: false,
-  maxIterations: 100,
+  missionActive: false,
+  maxIterations: 1000,
   maxRetries: 3,
   sessions: new Map
 };
@@ -12792,6 +12793,8 @@ var callAgentTool = tool({
     if (!agentDef) {
       return `Error: Unknown agent: ${args.agent}`;
     }
+    const taskIdMatch = args.task.match(/\[(TASK-\d+)\]/i);
+    if (taskIdMatch) {}
     const prompt = `
 \u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
 ${agentDef.id.toUpperCase()} AGENT
@@ -12816,34 +12819,53 @@ Execute according to your role. Be thorough and precise.
   }
 });
 var COMMANDS = {
-  auto: {
-    description: "Autonomous execution with self-correcting loop",
-    template: `\uD83D\uDE80 AUTO MODE - Self-Correcting Agent Loop
+  task: {
+    description: "Execute a mission using Distributed Cognitive Architecture (PDCA Cycle)",
+    template: `\uD83D\uDE80 MISSION: DISTRIBUTED TASK EXECUTION (PDCA Methodology)
+<command-instruction>
+You are the **Kernel** of this operation. You employ **Dynamic Programming** and **Divide & Conquer**.
+
+## Phase 0: Cost/Benefit & Complexity Analysis
+- **Assess**: Is this a quick "hotfix" (Linear) or a "System Overhaul" (Distributed Task)?
+- **Allocating Strategy**: If complex, activate the **Swarm**.
+
+## Phase 1: Deep Analysis & State Initialization (Plan)
+- BEFORE planning, call **searcher** to read all .md docs.
+- Create a temporary \`.opencode_mission.md\` as your **Shared Memory Segment**.
+- **State Strategy**: Define how independent nodes will share data (e.g., File I/O, config files).
+
+## Phase 1.5: Sync Contract Deal (Interface Agreement)
+- **CRITICAL**: If parallel tasks interact (e.g., A calls B), you MUST define the **Interface Contract** first.
+- Create \`_interface_contract.md\` containing:
+  - Exact Function Signatures & Types.
+  - API Routes & Parameter Structures.
+  - File Paths for shared data.
+- All Agents MUST read this contract before writing code.
 
-## 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 \u2192 reviewer again
-   - If PASS: Move to next task
-3. Continue until all tasks complete with PASS
+## Phase 2: Hierarchical Planning (Do - Step 1)
+- Call **planner** to Map the mission into atomic tasks ($O(1)$ complexity).
+- **Divide & Conquer**: Break down the problem recursively.
+- **Resource Binding**: Bind specific agents/tools to tasks.
 
-## 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.
+## Phase 3: Parallel Execution & Verification (Do - Step 2 & Check)
+- Execute READY tasks in parallel. Each agent acts as an independent Actor.
+- **PDCA Cycle**: Plan -> Do (Code) -> Check (Review) -> Act (Fix/Merge).
+- Route implementation to the **reviewer** (Byzantine Fault Tolerance check).
+
+## Phase 4: Global Sync Gate (Act)
+- Once all tasks are \u2705 Completed, call **reviewer** for a **Global Consistency Check**.
+- verify imports, exports, and cross-file logic patterns.
+- DELETE \`.opencode_mission.md\` after final SUCCESS.
 
 ## Goal
-Complete "$ARGUMENTS" with ZERO errors.
-Relentless execution until absolute success.
+Achieve **Architectural Superiority**. Complete "$ARGUMENTS" with ZERO regressions.
+We do NOT stop for time. We stop when it is DONE.
 </command-instruction>
 
 <user-task>
 $ARGUMENTS
 </user-task>`,
-    argumentHint: '"task description"'
+    argumentHint: '"mission goal"'
   },
   plan: {
     description: "Decompose task into atomic units",
@@ -12994,7 +13016,7 @@ var OrchestratorPlugin = async (input) => {
         const command = COMMANDS[parsed.command];
         if (command) {
           parts[textPartIndex].text = command.template.replace(/\$ARGUMENTS/g, parsed.args || "continue");
-          if (parsed.command === "auto") {
+          if (parsed.command === "task" || parsed.command === "flow" || parsed.command === "dag" || parsed.command === "auto" || parsed.command === "ignite") {
             const sessionID = input2.sessionID;
             state.sessions.set(sessionID, {
               enabled: true,
@@ -13002,21 +13024,28 @@ var OrchestratorPlugin = async (input) => {
               taskRetries: new Map,
               currentTask: ""
             });
-            state.autoEnabled = true;
-          } else if (parsed.command === "cancel-auto") {
+            state.missionActive = true;
+          } else if (parsed.command === "stop" || parsed.command === "cancel") {
             state.sessions.delete(input2.sessionID);
-            state.autoEnabled = false;
+            state.missionActive = false;
           }
         }
       }
     },
     "tool.execute.after": async (input2, output) => {
-      if (!state.autoEnabled)
+      if (!state.missionActive)
         return;
       const session = state.sessions.get(input2.sessionID);
       if (!session?.enabled)
         return;
       session.iterations++;
+      if (input2.tool === "call_agent" && input2.arguments?.task) {
+        const taskIdMatch = input2.arguments.task.match(/\[(TASK-\d+)\]/i);
+        if (taskIdMatch) {
+          session.currentTask = taskIdMatch[1].toUpperCase();
+          session.graph?.updateTask(session.currentTask, { status: "running" });
+        }
+      }
       if (session.iterations >= state.maxIterations) {
         session.enabled = false;
         output.output += `
@@ -13026,41 +13055,98 @@ var OrchestratorPlugin = async (input) => {
 Review progress and continue manually.`;
         return;
       }
-      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) {
-          output.output += `
+      if (output.output.includes("[") && output.output.includes("]") && output.output.includes("{") && input2.tool === "call_agent") {
+        const jsonMatch = output.output.match(/```json\n([\s\S]*?)\n```/) || output.output.match(/\[\s+\{[\s\S]*?\}\s+\]/);
+        if (jsonMatch) {
+          try {
+            const tasks = JSON.parse(jsonMatch[1] || jsonMatch[0]);
+            if (Array.isArray(tasks) && tasks.length > 0) {
+              session.graph = new TaskGraph(tasks);
+              output.output += `
+
+\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
+\u2705 MISSION INITIALIZED
+${session.graph.getTaskSummary()}`;
+            }
+          } catch (e) {}
+        }
+      }
+      if (session.graph) {
+        if (output.output.includes("\u2705 PASS")) {
+          const taskId = session.currentTask;
+          if (taskId) {
+            session.graph.updateTask(taskId, { status: "completed" });
+            session.taskRetries.clear();
+            output.output += `
+
+\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
+\u2705 TASK ${taskId} VERIFIED
+${session.graph.getTaskSummary()}`;
+          }
+        } else if (output.output.includes("\u274C FAIL")) {
+          const taskId = session.currentTask;
+          if (taskId) {
+            const errorId = `error-${taskId}`;
+            const retries = (session.taskRetries.get(errorId) || 0) + 1;
+            session.taskRetries.set(errorId, retries);
+            if (retries >= state.maxRetries) {
+              session.graph.updateTask(taskId, { status: "failed" });
+              output.output += `
+
+\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
+\u26A0\uFE0F TASK ${taskId} FAILED (Retry Limit)
+PIVOT REQUIRED: Re-plan or seek context.`;
+            } else {
+              output.output += `
+
+\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
+\uD83D\uDD04 RETRY ${retries}/${state.maxRetries} for ${taskId}`;
+            }
+          }
+        }
+      } else {
+        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) {
+            output.output += `
 
 \u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
 \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.`;
+PIVOT REQUIRED.`;
+            return;
+          }
+          output.output += `
+
+\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
+\uD83D\uDD04 RETRY ${retries}/${state.maxRetries}`;
           return;
         }
-        output.output += `
+        if (output.output.includes("\u2705 PASS")) {
+          session.taskRetries.clear();
+          output.output += `
 
 \u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
-\uD83D\uDD04 RETRY ${retries}/${state.maxRetries}
-Apply fix and verify again.`;
-        return;
+\u2705 VERIFIED`;
+          return;
+        }
       }
-      if (output.output.includes("\u2705 PASS")) {
-        session.taskRetries.clear();
+      if (session.graph) {
+        const readyTasks = session.graph.getReadyTasks();
+        const guidance = readyTasks.length > 0 ? `
+\uD83D\uDC49 **READY TO EXECUTE**: ${readyTasks.map((t) => `[${t.id}]`).join(", ")}` : `
+\u26A0\uFE0F NO READY TASKS. Check dependencies or completion.`;
         output.output += `
 
 \u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
-\u2705 VERIFIED - Continue to next task
-[${session.iterations}/${state.maxIterations}]`;
-        return;
+${session.graph.getTaskSummary()}${guidance}`;
       }
       output.output += `
 
 \u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
-[${session.iterations}/${state.maxIterations}]`;
+[DAG STEP: ${session.iterations}/${state.maxIterations}]`;
     }
   };
 };

package/dist/scripts/postinstall.js

@@ -57,7 +57,7 @@ function install() {
   console.log("\uD83D\uDE80 Ready! Restart OpenCode to use.");
   console.log("");
   console.log("Commands:");
-  console.log('  /auto "task"   - Autonomous execution');
+  console.log('  /task "goal"   - Distributed Cognitive Task (PDCA Cycle)');
   console.log('  /plan "task"   - Decompose into atomic tasks');
   console.log("  /review        - Quality check");
   console.log("");

package/dist/tasks.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Task management for DAG-based orchestration
+ */
+export type TaskStatus = "pending" | "running" | "completed" | "failed";
+export interface Task {
+    id: string;
+    description: string;
+    action: string;
+    file: string;
+    dependencies: string[];
+    status: TaskStatus;
+    result?: string;
+    retryCount: number;
+    complexity: number;
+    type: "infrastructure" | "logic" | "integration";
+}
+export declare class TaskGraph {
+    private tasks;
+    constructor(tasks?: Task[]);
+    addTask(task: Task): void;
+    getTask(id: string): Task | undefined;
+    updateTask(id: string, updates: Partial<Task>): void;
+    getReadyTasks(): Task[];
+    isCompleted(): boolean;
+    hasFailed(): boolean;
+    getTaskSummary(): string;
+    toJSON(): string;
+    static fromJSON(json: string): TaskGraph;
+}

package/package.json

@@ -1,7 +1,8 @@
 {
     "name": "opencode-orchestrator",
-    "version": "0.1.43",
-    "description": "6-Agent collaborative architecture for OpenCode - Make any model reliable",
+    "displayName": "OpenCode Orchestrator",
+    "description": "Distributed Cognitive Architecture for OpenCode. Turns simple prompts into specialized multi-agent workflows (Planner, Coder, Reviewer).",
+    "version": "0.1.48",
     "author": "agnusdei1207",
     "license": "MIT",
     "repository": {
@@ -22,6 +23,9 @@
         "plugin",
         "code-generation"
     ],
+    "bin": {
+        "orchestrator": "dist/cli.js"
+    },
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
     "type": "module",
@@ -38,25 +42,19 @@
         "LICENSE"
     ],
     "scripts": {
-        "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 --sourcemap=none && tsc --emitDeclarationOnly",
-        "build:scripts": "mkdir -p dist/scripts && bun build scripts/postinstall.ts --outdir dist/scripts --target node",
-        "build": "bun run build:ts && bun run build:scripts",
-        "build:full": "bun run build:rust && bun run build:rust:copy && bun run build",
+        "build:bin:linux-x64": "docker compose run --rm dev sh -c 'cargo build --release && cp target/release/orchestrator bin/orchestrator-linux-x64' && chmod +x bin/orchestrator-linux-x64",
+        "build:bin:linux-arm64": "docker compose run --rm dev sh -c 'rustup target add aarch64-unknown-linux-gnu && apt-get update && apt-get install -y gcc-aarch64-linux-gnu && CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_LINKER=aarch64-linux-gnu-gcc cargo build --release --target aarch64-unknown-linux-gnu && cp target/aarch64-unknown-linux-gnu/release/orchestrator bin/orchestrator-linux-arm64' && chmod +x bin/orchestrator-linux-arm64",
+        "build:bin": "bun run build:bin:linux-x64 && bun run build:bin:linux-arm64",
+        "build:js": "bun build src/index.ts --outdir dist --target bun --format esm --sourcemap=none && bun build src/cli.ts --outdir dist --target node --format esm --sourcemap=none && tsc --emitDeclarationOnly && mkdir -p dist/scripts && bun build scripts/postinstall.ts --outdir dist/scripts --target node",
+        "build": "bun run build:bin && bun run build:js",
         "test": "docker compose run --rm test",
-        "test:local": "cargo test",
-        "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",
-        "prepublishOnly": "bun run build",
-        "publish:npm": "npm publish --access public",
-        "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",
+        "release:patch": "bun run build && bun run test && npm version patch --no-git-tag-version && bun run release:ship",
+        "release:minor": "bun run build && bun run test && npm version minor --no-git-tag-version && bun run release:ship",
+        "release:major": "bun run build && bun run test && npm version major --no-git-tag-version && bun run release:ship",
+        "release:ship": "npm publish --access public && git add -A && git commit -m \"v$(node -p \"require('./package.json').version\")\" && git tag \"v$(node -p \"require('./package.json').version\")\" && git push && git push --tags",
         "postinstall": "node dist/scripts/postinstall.js 2>/dev/null || true",
-        "stars": "gh api repos/agnusdei1207/opencode-orchestrator/stargazers --jq '.[].login'"
+        "prepublishOnly": "bun run build:js",
+        "util:stars": "gh api repos/agnusdei1207/opencode-orchestrator/stargazers --jq '.[].login'"
     },
     "dependencies": {
         "@opencode-ai/plugin": "^1.1.1",