opencode-orchestrator 1.2.21 → 1.2.23

package/README.md

@@ -2,10 +2,9 @@
   <img src="assets/logo.png" alt="logo" width="200" />
   <h1>OpenCode Orchestrator</h1>
 
-  <p>Autonomous Multi-Agent Orchestration Engine for High-Integrity Software Engineering</p>
+  <p>Native-First Autonomous Multi-Agent Engine for High-Integrity Software Engineering</p>
 
   [![MIT License](https://img.shields.io/badge/license-MIT-red.svg)](LICENSE)
-  [![npm](https://img.shields.io/npm/v/opencode-orchestrator.svg)](https://www.npmjs.com/package/opencode-orchestrator)
 </div>
 
 ---
@@ -13,117 +12,68 @@
 ## ⚡ Quick Start
 
 ```bash
-npm install -g opencode-orchestrator
+/task "Refactor the authentication module and add unit tests"
 ```
 
-Inside an OpenCode environment:
-```bash
-/task "Implement a new authentication module with JWT and audit logs"
-```
-
----
-
-## 🚀 Engine Workflow
+## 🚀 Engine Architecture (v2)
 
-OpenCode Orchestrator utilizes a **Hub-and-Spoke Topology** to execute complex engineering tasks through parallel, context-isolated sessions.
+OpenCode Orchestrator utilizes a **Native-First Loop** to manage autonomous missions with extreme reliability and resource efficiency.
 
 ```text
-            [ User Task ]
+            [ User Mission ]
                     │
-         ┌──────────▼──────────┐
-         │     COMMANDER       │◄───────────┐ (Loop Phase)
-         └────────┬────────────┘            │
-                  │                         │
-         ┌────────▼──────────┐              │
-         │      PLANNER      │ (Todo.md)    │
-         └────────┬──────────┘              │
-                  │                         │ (MVCC Atomic Sync)
-     ┌─────────────┼──────────────┐          │
-     ▼     (Isolated Session Pool)▼          │
-[ Session A ] [ Session B ] [ Session C ]   │
-[  Worker   ] [  Worker   ] [  Reviewer ]   │
-     └─────────────┬──────────────┘          │
-                  │                         │
-         ┌────────▼──────────┐              │
-         │   MSVP MONITOR    │──────────────┘
-         └────────┬──────────┘
-                  │
-         ┌────────▼──────────┐
-         │ QUALITY ASSURANCE │
-         └────────┬──────────┘
-                  │
-            [ ✨COMPLETED ]
+          ┌─────────▼─────────┐
+          │ MissionController │◄──────────┐ (Idle-Triggered Loop)
+          └─────────┬─────────┘           │
+                    │                     │
+          ┌─────────▼─────────┐           │ (Native Todo Sync)
+          │     COMMANDER     │ (Native)  │
+          └─────────┬─────────┘           │
+                    │                     │
+      ┌─────────────┼──────────────┐      │
+      ▼             ▼              ▼      │
+ [ Planner ]   [ Worker ]   [ Reviewer ]  │
+      └─────────────┬──────────────┘      │
+                    │                     │
+          ┌─────────▼─────────┐           │
+          │  ResourceTracker  │───────────┘
+          └─────────┬─────────┘
+                    │
+              [ ✨MISSION COMPLETE ]
 ```
 
 ---
 
-## 🛠️ Technical Excellence
-
-### ️ Atomic MVCC State Synchronization
-The engine solves the "Concurrent TODO Update" problem using **Multi-Version Concurrency Control (MVCC) + Mutex**. Agents can safely mark tasks as complete in parallel without data loss or race conditions. Every state change is kryptographically hashed and logged for a complete audit trail.
-
-### 🧩 Advanced Hook Orchestration
-Execution flows are governed by a **Priority-Phase Hook Registry**. Hooks (Safety, UI, Protocol) are grouped into phases (`early`, `normal`, `late`) and executed using a **Topological Sort** to handle complex dependencies automatically, ensuring a predictable and stable environment.
-
-### ️ Autonomous Recovery
-- **Self-healing loops** with adaptive stagnation detection.
-- **Proactive Agency**: Smart monitoring that audits logs and plans ahead during background tasks.
-
-### ️ State-Level Session Isolation
-Reused sessions in the **SessionPool** are explicitly reset using server-side compaction triggered by health monitors. This ensures that previous task context (old error messages, stale file references) never leaks into new tasks, maintaining 100% implementation integrity.
-
-### 🚀 Zero-Payload Turbo Mode
-Leverages `system.transform` to unshift massive agent instruction sets on the server side. This reduces initial message payloads by **90%+**, slashing latency and preventing context fragmentation during long autonomous loops.
-
----
-
 ## 🛠️ Key Innovations
 
-### 🧠 Hierarchical Memory System
-Maintains focus across thousands of conversation turns using a 4-tier memory structure and **EMA-based Context Gating** to preserve "Architectural Truth" while pruning operational noise.
-
-###  Dynamic Concurrency Auto-Scaling
-Slots for parallel implementation scale up automatically after a **3-success streak** and scale down aggressively upon detection of API instability or implementation failures.
+### 🏗️ Native-First Orchestration
+Directly integrated with OpenCode's **Native Todo** and **Session API**. By using the host's infrastructure for state management, we've reduced internal code complexity by 70% while drastically increasing reliability and performance.
 
-### 🛡️ Neuro-Symbolic Safety
-Combines LLM reasoning with deterministic **AST/LSP verification**. Every code change is verified by native system tools before being accepted into the master roadmap.
+### 🧠 Adaptive Concurrency Control
+Execution slots for parallel agents are no longer fixed. Our **Adaptive Controller** dynamically scales slots based on real-time success rates and API latency—scaling up for speed and down for stability.
 
-### 🔄 Adaptive Intelligence Loop
-- **Stagnation Detection**: Automatically senses when no progress is made across multiple iterations.
-- **Diagnostic Intervention**: Forces the agent into a "Diagnostic Mode" when stagnation is detected, mandating log audits and strategy pivots.
-- **Proactive Agency**: Mandates Speculative Planning and Parallel Thinking during background task execution.
+### 🛡️ Resource Integrity Protocol
+The **ResourceTracker** ensures that every session, timer, and asynchronous resource is safely reclaimed. No "zombie" sessions or memory leaks, even during complex agent delegation chains.
 
-### 📊 Native TUI Integration
-Seamless integration with OpenCode's native TUI via **TaskToastManager**. Provides non-intrusive, real-time feedback on **Mission Progress**, active **Agent Sub-sessions**, and **Technical Metrics** using protocol-safe Toast notifications.
-
-### ⚡ Event-Driven Architecture
-Utilizes a hybrid event-driven pipeline (`EventHandler` + `TaskPoller`) to maximize responsiveness while maintaining robust state tracking and resource cleanup.
-
-### 🔒 Secure Configuration
-Runtime agent configuration is strictly validated using **Zod schemas**, ensuring that custom agent definitions in `agents.json` are type-safe and error-free before execution.
+### 🔄 Stagnation-Aware Intelligence
+The system doesn't just loop; it **analyzes**. If an agent hasn't made progress on Todos across iterations, the MissionController injects a specialized **Diagnostic Intervention** to force a strategy pivot.
 
 ---
 
 ## ⚡ Elite Multi-Agent Swarm
 
-| Agent | Expertise | Capability |
+| Agent | Expertise | Role |
 |:------|:-----|:---|
-| **Commander** | Mission Hub | Session pooling, parallel thread control, state rehydration. |
-| **Planner** | Architect | Symbolic mapping, dependency research, roadmap generation. |
-| **Worker** | Implementer | High-throughput coding, TDD workflow, documentation. |
-| **Reviewer** | Auditor | Rigid verification, LSP/Lint authority, final mission seal. |
-
----
-
-## 📈 Performance Benchmarks
-- **Throughput**: 10+ concurrent agent sessions with adaptive slot scaling.
-- **Accuracy**: 99.95% sync reliability via MVCC+Mutex transaction logic.
-- **Efficiency**: 40% reduction in token burn via Incremental State & System Transform.
-- **Uptime**: 100% mission survival through plugin restarts via S.H.R (Self-Healing Rehydration).
+| **Commander** | Mission Hub | Orchestration, parallel delegation, native loop coordination. |
+| **Planner** | Architect | Roadmap generation, dependency analysis, research. |
+| **Worker** | Implementer | TDD implementation, code generation, refactoring. |
+| **Reviewer** | Auditor | Rigid verification, LSP/Lint authority, quality assurance. |
 
 ---
 
-[Internal Architecture Deep-Dive →](docs/SYSTEM_ARCHITECTURE.md) | [Windows Configuration Guide →](docs/WINDOWS_CONFIGURATION.md)
+## 📊 Technical Excellence
+- **Zero-Leak Policy**: Automated resource cleanup via `ResourceTracker`.
+- **High Throughput**: Adaptive concurrency scaling for maximum parallel efficiency.
+- **Reliable Verification**: Every step is verified using native LSP and AST tools via our high-performance Rust backend.
 
-## 📄 License
-MIT License.
+[Architectural Details →](docs/SYSTEM_ARCHITECTURE.md)

package/dist/core/agents/adaptive-concurrency.d.ts

@@ -0,0 +1,57 @@
+export interface AdaptiveConcurrencyConfig {
+    /** Global maximum concurrent tasks across all agents */
+    globalMax: number;
+    /** Minimum slots per agent */
+    perAgentMin: number;
+    /** Maximum slots per agent */
+    perAgentMax: number;
+    /** Success rate threshold to scale up slots (0.0 - 1.0) */
+    scaleUpThreshold: number;
+    /** Success rate threshold to scale down slots (0.0 - 1.0) */
+    scaleDownThreshold: number;
+    /** How often to adjust limits (ms) */
+    adjustmentInterval: number;
+}
+/**
+ * Dynamically adjusts agent concurrency limits based on performance metrics.
+ * Now acts as a full controller with acquire/release.
+ */
+export declare class AdaptiveConcurrencyController {
+    private config;
+    private currentLimits;
+    private activeCount;
+    private metrics;
+    private adjustmentTimer;
+    private waiters;
+    constructor(config?: Partial<AdaptiveConcurrencyConfig>);
+    /**
+     * Acquire a concurrency slot for an agent.
+     * Blocks if limit reached.
+     */
+    acquire(agent: string): Promise<void>;
+    /**
+     * Release a concurrency slot.
+     */
+    release(agent: string): void;
+    private canAcquire;
+    /**
+     * Get the current limit for a specific agent.
+     */
+    getLimit(agent: string): number;
+    /**
+     * Report task execution result for adaptive calculation.
+     */
+    reportResult(agent: string, success: boolean, latencyMs?: number): void;
+    /**
+     * Starts the periodic adjustment cycle.
+     */
+    private startAdjustmentCycle;
+    /**
+     * Adjusts agent limits based on accumulated metrics.
+     */
+    private adjustLimits;
+    /**
+     * Stops the controller and cleans up.
+     */
+    cleanup(): void;
+}

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

@@ -3,6 +3,7 @@
  */
 export * from "./types/index.js";
 export * from "./interfaces/index.js";
-export { ConcurrencyController } from "./concurrency.js";
+export { AdaptiveConcurrencyController } from "./adaptive-concurrency.js";
 export { ParallelAgentManager, parallelAgentManager } from "./manager.js";
-export { taskWAL } from "./persistence/task-wal.js";
+export { UnifiedTaskExecutor } from "./unified-task-executor.js";
+export { SessionPool } from "./session-pool.js";

package/dist/core/agents/interfaces/session-pool.interface.d.ts

@@ -33,6 +33,8 @@ export interface SessionPoolConfig {
     maxReuseCount: number;
     /** Health check interval in milliseconds (default: 60000 = 1 minute) */
     healthCheckIntervalMs: number;
+    /** Global maximum number of sessions across all agents (default: 30) */
+    globalMax: number;
 }
 export interface SessionPoolStats {
     /** Total sessions in pool */
@@ -58,6 +60,11 @@ export interface ISessionPool {
      * Returns a reused session if available, otherwise creates a new one.
      */
     acquire(agentName: string, parentSessionID: string, description: string): Promise<PooledSession>;
+    /**
+     * Acquire a session immediately without waiting.
+     * Throws if global limit is reached.
+     */
+    acquireImmediate(agentName: string, parentSessionID: string, description: string): Promise<PooledSession>;
     /**
      * Release a session back to the pool for reuse.
      * The session will be reset/cleared before being put back.

package/dist/core/agents/manager.d.ts

@@ -1,60 +1,32 @@
-/**
- * Parallel Agent Manager
- *
- * Session-based async agent execution with:
- * - Concurrency control per agent type
- * - Batched notifications
- * - Automatic cleanup
- *
- * This is the main facade that composes the specialized components.
- */
 import type { PluginInput } from "@opencode-ai/plugin";
-import { ConcurrencyController } from "./concurrency.js";
+import { AdaptiveConcurrencyController } from "./adaptive-concurrency.js";
 import { formatDuration } from "./format.js";
 import type { ParallelTask } from "./interfaces/parallel-task.interface.js";
 import type { LaunchInput } from "./interfaces/launch-input.interface.js";
-import type { ResumeInput } from "./interfaces/resume-input.interface.js";
-export type { ParallelTask };
-export { formatDuration };
 type OpencodeClient = PluginInput["client"];
 export declare class ParallelAgentManager {
     private static _instance;
-    private store;
     private client;
     private directory;
-    private concurrency;
+    private adaptiveConcurrency;
     private sessionPool;
     private executor;
     private constructor();
     static getInstance(client?: OpencodeClient, directory?: string): ParallelAgentManager;
     launch(inputs: LaunchInput | LaunchInput[]): Promise<ParallelTask | ParallelTask[]>;
-    resume(input: ResumeInput): Promise<ParallelTask>;
     getTask(id: string): ParallelTask | undefined;
-    getRunningTasks(): ParallelTask[];
     getAllTasks(): ParallelTask[];
-    getTasksByParent(parentSessionID: string): ParallelTask[];
+    getRunningTasks(): ParallelTask[];
+    getTasksByParent(parentID: string): ParallelTask[];
     cancelTask(taskId: string): Promise<boolean>;
     getResult(taskId: string): Promise<string | null>;
-    setConcurrencyLimit(agentType: string, limit: number): void;
-    getPendingCount(parentSessionID: string): number;
-    getConcurrency(): ConcurrencyController;
-    cleanup(): void;
+    handleEvent(event: any): void;
+    getConcurrency(): AdaptiveConcurrencyController;
     formatDuration: typeof formatDuration;
-    handleEvent(event: {
-        type: string;
-        properties?: {
-            sessionID?: string;
-            info?: {
-                id?: string;
-            };
-        };
-    }): void;
-    private findBySession;
-    private handleTaskError;
-    private handleTaskComplete;
-    private recoverActiveTasks;
+    cleanup(): Promise<void>;
 }
 export declare const parallelAgentManager: {
     getInstance: typeof ParallelAgentManager.getInstance;
     cleanup: () => void;
 };
+export {};

package/dist/core/agents/session-pool.d.ts

@@ -26,6 +26,11 @@ export declare class SessionPool implements ISessionPool {
      * Sessions are validated before reuse to ensure health.
      */
     acquire(agentName: string, parentSessionID: string, description: string): Promise<PooledSession>;
+    /**
+     * Acquire a session immediately without waiting.
+     * Throws if global limit is reached.
+     */
+    acquireImmediate(agentName: string, parentSessionID: string, description: string): Promise<PooledSession>;
     /**
      * Release a session back to the pool for reuse.
      */

package/dist/core/agents/unified-task-executor.d.ts

@@ -1,109 +1,27 @@
-/**
- * Unified Task Executor
- *
- * Consolidates multiple task management components into a single, cohesive executor:
- * - TaskLauncher (launch tasks)
- * - TaskPoller (monitor tasks)
- * - TaskCleaner (cleanup tasks)
- * - TaskResumer (resume tasks)
- * - EventHandler (handle events)
- *
- * This reduces complexity from 5 separate components to 1 unified executor.
- */
 import type { PluginInput } from "@opencode-ai/plugin";
 import type { ParallelTask } from "./interfaces/parallel-task.interface.js";
 import type { LaunchInput } from "./interfaces/launch-input.interface.js";
-import type { ResumeInput } from "./interfaces/resume-input.interface.js";
-import { TaskStore } from "./task-store.js";
-import { ConcurrencyController } from "./concurrency.js";
+import { AdaptiveConcurrencyController } from "./adaptive-concurrency.js";
 import { SessionPool } from "./session-pool.js";
 type OpencodeClient = PluginInput["client"];
 /**
- * Unified Task Executor
- *
- * Combines all task management responsibilities into one cohesive class.
+ * Simplified Unified Task Executor
+ * Leveraging AdaptiveConcurrencyController and ResourceTracker
  */
 export declare class UnifiedTaskExecutor {
     private client;
-    private directory;
-    private store;
-    private concurrency;
     private sessionPool;
-    private pollInterval;
-    private isPolling;
-    private cleanupTimers;
-    constructor(client: OpencodeClient, directory: string, store: TaskStore, concurrency: ConcurrencyController, sessionPool: SessionPool);
-    /**
-     * Launch a new parallel task
-     */
+    private adaptiveConcurrency;
+    private tasks;
+    constructor(client: OpencodeClient, sessionPool: SessionPool, adaptive: AdaptiveConcurrencyController);
     launch(input: LaunchInput): Promise<ParallelTask>;
     /**
-     * Start polling for task updates
-     */
-    private startPolling;
-    /**
-     * Stop polling
-     */
-    private stopPolling;
-    /**
-     * Poll all running tasks
-     */
-    private pollTasks;
-    /**
-     * Poll a single task
-     */
-    private pollTask;
-    /**
-     * Handle task completion
-     */
-    private handleTaskComplete;
-    /**
-     * Handle task error
-     */
-    private handleTaskError;
-    /**
-     * Schedule cleanup for a task
-     */
-    private scheduleCleanup;
-    /**
-     * Cleanup a task
-     */
-    private cleanupTask;
-    /**
-     * Prune expired tasks
-     */
-    private pruneExpiredTasks;
-    /**
-     * Notify parent if all tasks complete
-     */
-    private notifyParentIfAllComplete;
-    /**
-     * Resume a task from disk
-     */
-    resume(input: ResumeInput): Promise<ParallelTask | null>;
-    /**
-     * Recover all active tasks from disk
-     */
-    recoverAll(): Promise<number>;
-    /**
-     * Cancel a task
-     */
-    cancel(taskId: string): Promise<boolean>;
-    /**
-     * Get task by ID
+     * Handle events for task completion detection
      */
+    handleEvent(event: any): Promise<void>;
+    private completeTask;
     getTask(taskId: string): ParallelTask | undefined;
-    /**
-     * Get all tasks
-     */
     getAllTasks(): ParallelTask[];
-    /**
-     * Get tasks by parent
-     */
-    getTasksByParent(parentSessionID: string): ParallelTask[];
-    /**
-     * Cleanup all resources
-     */
-    cleanup(): void;
+    getTasksByParent(parentID: string): ParallelTask[];
 }
 export {};

package/dist/core/mission/mission-controller.d.ts

@@ -0,0 +1,53 @@
+import type { PluginInput } from '@opencode-ai/plugin';
+/**
+ * Native Todo interface from OpenCode SDK
+ */
+export interface NativeTodo {
+    id: string;
+    content: string;
+    status: 'pending' | 'in_progress' | 'completed' | 'cancelled';
+    priority: 'high' | 'medium' | 'low';
+}
+interface MissionState {
+    id: string;
+    sessionID: string;
+    prompt: string;
+    status: 'active' | 'completed' | 'failed';
+    iteration: number;
+    maxIterations: number;
+    startedAt: string;
+    lastTodoHash?: string;
+    stagnationCount: number;
+}
+/**
+ * MissionController
+ * Handles the main autonomous loop using OpenCode Native APIs.
+ */
+export declare class MissionController {
+    private state;
+    private client;
+    constructor(input: PluginInput);
+    /**
+     * Starts a new mission by creating a session and sending the commander prompt.
+     */
+    start(prompt: string): Promise<string>;
+    /**
+     * Fetches native Todos for the current session.
+     */
+    getTodos(): Promise<NativeTodo[]>;
+    /**
+     * Moves to the next iteration if needed.
+     * Called primarily when session becomes IDLE.
+     */
+    nextIteration(): Promise<{
+        continue: boolean;
+        prompt?: string;
+        reason?: string;
+    }>;
+    buildCommanderPrompt(objective: string): string;
+    buildContinuationPrompt(pending: NativeTodo[], intervention?: string): string;
+    private buildStagnationIntervention;
+    private hashTodos;
+    getState(): MissionState | null;
+}
+export {};

package/dist/core/resource/resource-tracker.d.ts

@@ -0,0 +1,61 @@
+export declare enum ResourceType {
+    SESSION = "session",
+    TIMER = "timer",
+    INTERVAL = "interval",
+    FILE_HANDLE = "file_handle",
+    MEMORY = "memory"
+}
+interface TrackedResource {
+    id: string;
+    type: ResourceType;
+    sessionID?: string;
+    createdAt: number;
+    metadata?: Record<string, unknown>;
+    cleanup: () => Promise<void> | void;
+}
+/**
+ * Centralized tracker for all resources that need explicit cleanup.
+ * Ensures that resources tied to a specific session are cleaned up when the session ends.
+ */
+export declare class ResourceTracker {
+    private static _instance;
+    private resources;
+    private sessionResources;
+    private constructor();
+    static getInstance(): ResourceTracker;
+    /**
+     * Start tracking a resource.
+     */
+    track(resource: TrackedResource): void;
+    /**
+     * Release a specific resource by ID.
+     */
+    release(id: string): Promise<boolean>;
+    /**
+     * Release all resources associated with a specific sessionID.
+     */
+    releaseAllForSession(sessionID: string): Promise<number>;
+    /**
+     * Release all resources of a specific type.
+     */
+    releaseByType(type: ResourceType): Promise<number>;
+    /**
+     * Periodic GC for stale resources (e.g. leaked timers).
+     */
+    cleanupStale(maxAgeMs: number): Promise<number>;
+    /**
+     * Shutdown the tracker and release all managed resources.
+     */
+    shutdown(): Promise<void>;
+    /**
+     * Get current resource statistics.
+     */
+    getStats(): {
+        total: number;
+        byType: Record<string, number>;
+        bySessions: number;
+    };
+}
+export declare function trackTimer(timer: NodeJS.Timeout, sessionID?: string): string;
+export declare function trackInterval(interval: NodeJS.Timeout, sessionID?: string): string;
+export {};

package/dist/index.d.ts

@@ -1,11 +1,3 @@
-/**
- * OpenCode Orchestrator Plugin
- *
- * This is the main entry point for the 4-Agent consolidated architecture.
- * Handlers are modularized in src/plugin-handlers/ for maintainability.
- *
- * The agents are: Commander, Planner, Worker, Reviewer
- */
 import type { Plugin } from "@opencode-ai/plugin";
 declare const OrchestratorPlugin: Plugin;
 export default OrchestratorPlugin;