opencode-orchestrator 0.5.3 → 0.5.5

package/README.md

@@ -28,16 +28,17 @@ A **5-agent autonomous architecture** designed to solve complex engineering task
 
 **Core Philosophy**: Intelligence is a resource. We orchestrate that resource through **Phase-based Workflows** and **Mandatory Environment Scans** to ensure code always fits the project's infrastructure.
 
+> 🦀 **Powered by Rust** — Background tasks and parallel searches run on native Rust binaries for maximum performance.
+
 ### Key Features
-- **🎯 Autonomous Loop** — Commander runs relentlessly until mission is complete.
+- **🎯 Autonomous Loop** — Commander runs relentlessly until the mission is complete.
 - **🔍 Environment Scan** — Mandatory analysis of Infra (Docker/OS), Stack, and Domain before any code change.
 - **🔨 Smart Implementation** — Builder matches existing codebase patterns exactly.
 - **🛡️ Rigorous Audit** — Inspector proves success with environment-specific evidence (Builds/Tests/Logs).
 - **💾 Persistent Context** — Recorder saves session state to disk, enabling resume at any time.
 - **🏗️ Parallel Agents** — Delegated agent execution (`delegate_task`) with sync/async modes.
 - **⏳ Background Tasks** — Run long commands (builds, tests) in background and check results later.
- - **🔎 mgrep** — Multi-pattern parallel search for fast codebase analysis.
-- **🎯 Smart Batch** — Centralized validation and retry for efficient parallel processing. Dynamic concurrency limits with intelligent failure handling.
+- **🔎 mgrep** — Multi-pattern parallel search powered by Rust for blazing-fast codebase analysis.
 
 ---
 
@@ -58,8 +59,8 @@ Restart OpenCode after installation.
 In OpenCode, press `Tab` to open the Agent selection menu. Select **Commander** and type your mission!
 
 <div align="center">
-   <img src="assets/commander-screenshot.png" alt="Commander Screenshot" width="600" />
-   <p><em>Press Tab to select Commander</em></p>
+  <img src="assets/commander-screenshot.png" alt="Commander Screenshot" width="600" />
+  <p><em>Press Tab to select Commander</em></p>
 </div>
 
 ```
@@ -94,8 +95,7 @@ Trigger parallel agent execution with prompts like:
 
 Commander will automatically use `delegate_task` with `background: true` for independent tasks.
 
-Monitor parallel tasks in terminal:
-
+Monitor parallel tasks in the terminal:
 ```
 [parallel] 🚀 SPAWNED task_a1b2 → builder: Implement feature X
 [parallel] 🚀 SPAWNED task_c3d4 → inspector: Review module Y
@@ -103,63 +103,6 @@ Monitor parallel tasks in terminal:
 [parallel] 🗑️ CLEANED task_c3d4 (session deleted)
 ```
 
-### 🎯 Smart Batch — Centralized Validation and Retry
-
-For processing many microtasks efficiently, use the Smart Batch approach:
-
-```bash
-# Use Smart Batch to process many tasks with intelligent validation
-process_batch({
-  concurrency: "10",
-  maxRetries: "2",
-  tasks: [
-    { id: "task1", agent: "builder", description: "Write API handler", prompt: "..." },
-    { id: "task2", agent: "inspector", description: "Review API code", prompt: "..." },
-    { id: "task3", agent: "architect", description: "Design database schema", prompt: "..." },
-    { id: "task4", agent: "recorder", description: "Document API", prompt: "..." }
-  ]
-})
-```
-
-**Smart Batch Benefits**:
-| Benefit | Description |
-|---------|-------------|
-| **Speed** | 50% faster (1000 tasks: 200min → 150min) |
-| **Efficiency** | 30% fewer API calls (only retry failures) |
-| **Quality** | Centralized validation identifies all failures at once |
-| **Adaptive** | Dynamic concurrency (up to 10, unlimited with validation) |
-
-**Smart Batch Tools**:
-- `process_batch()` — Execute multiple tasks with intelligent validation
-- `export_failed_tasks()` — Export failed tasks for manual review
-- `compare_strategies()` — Compare naive vs smart batch performance
-
-### 🔧 Configuration Management
-
-Dynamic configuration for runtime tuning:
-
-```bash
-# View current configuration
-show_config()
-
-# Update concurrency limits
-set_concurrency({ agent: "builder", limit: 10 })
-
-# Update timeouts
-set_timeout({ taskTtlMinutes: 45, cleanupDelayMinutes: 2 })
-
-# Toggle debug logging
-set_debug({ component: "parallel_agent", enable: true })
-```
-
-**Environment Variables**:
-- `OPENCODE_TASK_TTL_MS` — Task timeout (default: 30min)
-- `OPENCODE_CLEANUP_DELAY_MS` — Cleanup delay (default: 5min)
-- `OPENCODE_DEFAULT_CONCURRENCY` — Default parallelism (default: 3)
-- `OPENCODE_MAX_CONCURRENCY` — Max parallelism (default: 10)
-- `OPENCODE_DEBUG_PARALLEL` — Enable debug logs
-- `OPENCODE_DEBUG_BACKGROUND` — Enable debug logs
-
 ---
 
 ## Agents (5-Agent Architecture)
@@ -258,13 +201,13 @@ npm run dev:test
 ### Release Scripts
 
 ```bash
-# Release patch version (0.4.7 → 0.4.8)
+# Release patch version (0.4.1 → 0.4.2)
 npm run release:patch
 
-# Release minor version (0.4.7 → 0.5.0)
+# Release minor version (0.4.1 → 0.5.0)
 npm run release:minor
 
-# Release major version (0.4.7 → 1.0.0)
+# Release major version (0.4.1 → 1.0.0)
 npm run release:major
 ```
 

package/dist/agents/definitions.d.ts

@@ -1,2 +1,2 @@
-import { AgentDefinition } from "../shared/contracts/interfaces.js";
+import { AgentDefinition } from "../shared/agent.js";
 export declare const AGENTS: Record<string, AgentDefinition>;

package/dist/agents/orchestrator.d.ts

@@ -1,2 +1,2 @@
-import { AgentDefinition } from "../shared/contracts/interfaces.js";
+import { AgentDefinition } from "../shared/agent.js";
 export declare const orchestrator: AgentDefinition;

package/dist/agents/subagents/architect.d.ts

@@ -1,2 +1,2 @@
-import { AgentDefinition } from "../../shared/contracts/interfaces.js";
+import { AgentDefinition } from "../../shared/agent.js";
 export declare const architect: AgentDefinition;

package/dist/agents/subagents/builder.d.ts

@@ -1,2 +1,2 @@
-import { AgentDefinition } from "../../shared/contracts/interfaces.js";
+import { AgentDefinition } from "../../shared/agent.js";
 export declare const builder: AgentDefinition;

package/dist/agents/subagents/inspector.d.ts

@@ -1,2 +1,2 @@
-import { AgentDefinition } from "../../shared/contracts/interfaces.js";
+import { AgentDefinition } from "../../shared/agent.js";
 export declare const inspector: AgentDefinition;

package/dist/agents/subagents/recorder.d.ts

@@ -1,2 +1,2 @@
-import { AgentDefinition } from "../../shared/contracts/interfaces.js";
+import { AgentDefinition } from "../../shared/agent.js";
 export declare const recorder: AgentDefinition;

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

@@ -0,0 +1,36 @@
+/**
+ * Concurrency Controller
+ *
+ * Queue-based rate limiting with support for:
+ * - Agent-specific limits
+ * - Provider-specific limits (e.g., anthropic/*, openai/*)
+ * - Model-specific limits (e.g., anthropic/claude-3-5-sonnet)
+ */
+export interface ConcurrencyConfig {
+    defaultConcurrency?: number;
+    agentConcurrency?: Record<string, number>;
+    providerConcurrency?: Record<string, number>;
+    modelConcurrency?: Record<string, number>;
+}
+export declare class ConcurrencyController {
+    private counts;
+    private queues;
+    private limits;
+    private config;
+    constructor(config?: ConcurrencyConfig);
+    setLimit(key: string, limit: number): void;
+    /**
+     * Get concurrency limit for a key.
+     * Priority: explicit limit > model > provider > agent > default
+     */
+    getConcurrencyLimit(key: string): number;
+    getLimit(key: string): number;
+    acquire(key: string): Promise<void>;
+    release(key: string): void;
+    getQueueLength(key: string): number;
+    getActiveCount(key: string): number;
+    /**
+     * Get formatted concurrency info string (e.g., "2/5 slots")
+     */
+    getConcurrencyInfo(key: string): string;
+}

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

@@ -0,0 +1,9 @@
+/**
+ * Parallel Manager Configuration
+ */
+export declare const CONFIG: {
+    readonly TASK_TTL_MS: number;
+    readonly CLEANUP_DELAY_MS: number;
+    readonly MIN_STABILITY_MS: number;
+    readonly POLL_INTERVAL_MS: 2000;
+};

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

@@ -0,0 +1,9 @@
+/**
+ * Format utilities for parallel tasks
+ */
+export declare function formatDuration(start: Date, end?: Date): string;
+export declare function buildNotificationMessage(tasks: Array<{
+    id: string;
+    description: string;
+    status: string;
+}>): string;

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

@@ -0,0 +1,7 @@
+/**
+ * Parallel Module - Agent parallel execution
+ */
+export * from "./types/index.js";
+export * from "./interfaces/index.js";
+export { ConcurrencyController } from "./concurrency.js";
+export { ParallelAgentManager, parallelAgentManager } from "./manager.js";

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

@@ -0,0 +1,5 @@
+/**
+ * Parallel Module Interfaces Index
+ */
+export { ParallelTask } from "./parallel-task.js";
+export { LaunchInput } from "./launch-input.js";

package/dist/core/agents/interfaces/launch-input.d.ts

@@ -0,0 +1,9 @@
+/**
+ * LaunchInput - Input for launching a parallel task
+ */
+export interface LaunchInput {
+    description: string;
+    prompt: string;
+    agent: string;
+    parentSessionID: string;
+}

package/dist/core/agents/interfaces/parallel-task.d.ts

@@ -0,0 +1,26 @@
+/**
+ * ParallelTask - Represents a task running in a parallel session
+ */
+import { ParallelTaskStatus } from "../types/parallel-task-status.js";
+export interface TaskProgress {
+    toolCalls: number;
+    lastTool?: string;
+    lastMessage?: string;
+    lastUpdate: Date;
+}
+export interface ParallelTask {
+    id: string;
+    sessionID: string;
+    parentSessionID: string;
+    description: string;
+    agent: string;
+    status: ParallelTaskStatus;
+    startedAt: Date;
+    completedAt?: Date;
+    error?: string;
+    result?: string;
+    concurrencyKey?: string;
+    lastMsgCount?: number;
+    stablePolls?: number;
+    progress?: TaskProgress;
+}

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

@@ -0,0 +1,4 @@
+/**
+ * Debug logger for parallel agent
+ */
+export declare function log(...args: unknown[]): void;

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

@@ -0,0 +1,76 @@
+/**
+ * Parallel Agent Manager
+ *
+ * Session-based async agent execution with:
+ * - Concurrency control per agent type
+ * - Batched notifications
+ * - Automatic cleanup
+ */
+import type { PluginInput } from "@opencode-ai/plugin";
+import { formatDuration } from "./format.js";
+import type { ParallelTask } from "./interfaces/parallel-task.js";
+import type { LaunchInput } from "./interfaces/launch-input.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 pollingInterval?;
+    private constructor();
+    static getInstance(client?: OpencodeClient, directory?: string): ParallelAgentManager;
+    launch(input: LaunchInput): Promise<ParallelTask>;
+    getTask(id: string): ParallelTask | undefined;
+    getRunningTasks(): ParallelTask[];
+    getAllTasks(): ParallelTask[];
+    getTasksByParent(parentSessionID: string): ParallelTask[];
+    cancelTask(taskId: string): Promise<boolean>;
+    getResult(taskId: string): Promise<string | null>;
+    setConcurrencyLimit(agentType: string, limit: number): void;
+    getPendingCount(parentSessionID: string): number;
+    cleanup(): void;
+    formatDuration: typeof formatDuration;
+    /**
+     * Handle OpenCode session events for proper resource cleanup.
+     * Call this from your plugin's event hook.
+     */
+    handleEvent(event: {
+        type: string;
+        properties?: {
+            sessionID?: string;
+            info?: {
+                id?: string;
+            };
+        };
+    }): void;
+    /**
+     * Find task by session ID
+     */
+    private findBySession;
+    /**
+     * Handle session.idle event - validate and complete task
+     */
+    private handleSessionIdle;
+    private handleTaskError;
+    private startPolling;
+    private stopPolling;
+    private pollRunningTasks;
+    /**
+     * Update task progress and stability tracking
+     */
+    private updateTaskProgress;
+    /**
+     * Complete a task and cleanup
+     */
+    private completeTask;
+    private validateSessionHasOutput;
+    private pruneExpiredTasks;
+    private scheduleCleanup;
+    private notifyParentIfAllComplete;
+}
+export declare const parallelAgentManager: {
+    getInstance: typeof ParallelAgentManager.getInstance;
+};

package/dist/core/agents/task-store.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Task Store - Stores and manages parallel tasks
+ */
+import type { ParallelTask } from "./interfaces/parallel-task.js";
+export declare class TaskStore {
+    private tasks;
+    private pendingByParent;
+    private notifications;
+    set(id: string, task: ParallelTask): void;
+    get(id: string): ParallelTask | undefined;
+    getAll(): ParallelTask[];
+    getRunning(): ParallelTask[];
+    getByParent(parentSessionID: string): ParallelTask[];
+    delete(id: string): boolean;
+    clear(): void;
+    trackPending(parentSessionID: string, taskId: string): void;
+    untrackPending(parentSessionID: string, taskId: string): void;
+    getPendingCount(parentSessionID: string): number;
+    hasPending(parentSessionID: string): boolean;
+    queueNotification(task: ParallelTask): void;
+    getNotifications(parentSessionID: string): ParallelTask[];
+    clearNotifications(parentSessionID: string): void;
+    cleanEmptyNotifications(): void;
+    /**
+     * Remove a specific task from all notification queues
+     */
+    clearNotificationsForTask(taskId: string): void;
+}

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

@@ -0,0 +1,4 @@
+/**
+ * Parallel Module Types Index
+ */
+export { ParallelTaskStatus } from "./parallel-task-status.js";

package/dist/core/agents/types/parallel-task-status.d.ts

@@ -0,0 +1,4 @@
+/**
+ * ParallelTaskStatus - Task status union type
+ */
+export type ParallelTaskStatus = "pending" | "running" | "completed" | "error" | "timeout";

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

@@ -0,0 +1,6 @@
+/**
+ * Background Task Module
+ */
+export * from "./types/index.js";
+export * from "./interfaces/index.js";
+export { backgroundTaskManager } from "./manager.js";

package/dist/core/commands/interfaces/background-task.d.ts

@@ -0,0 +1,20 @@
+/**
+ * BackgroundTask - Represents a shell command running in background
+ */
+import { ChildProcess } from "child_process";
+import { BackgroundTaskStatus } from "../types/background-task-status.js";
+export interface BackgroundTask {
+    id: string;
+    command: string;
+    args: string[];
+    cwd: string;
+    label?: string;
+    status: BackgroundTaskStatus;
+    output: string;
+    errorOutput: string;
+    exitCode: number | null;
+    startTime: number;
+    endTime?: number;
+    timeout: number;
+    process?: ChildProcess;
+}

package/dist/core/commands/interfaces/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Background Task Interfaces Index
+ */
+export { BackgroundTask } from "./background-task.js";
+export { RunBackgroundOptions } from "./run-background-options.js";

package/dist/core/commands/interfaces/run-background-options.d.ts

@@ -0,0 +1,9 @@
+/**
+ * RunBackgroundOptions - Options for running a background task
+ */
+export interface RunBackgroundOptions {
+    command: string;
+    cwd?: string;
+    timeout?: number;
+    label?: string;
+}

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

@@ -0,0 +1,27 @@
+/**
+ * Background Task Manager
+ *
+ * Runs shell commands in the background and tracks their output.
+ */
+import type { BackgroundTask } from "./interfaces/background-task.js";
+import type { BackgroundTaskStatus } from "./types/background-task-status.js";
+import type { RunBackgroundOptions } from "./interfaces/run-background-options.js";
+declare class BackgroundTaskManager {
+    private static _instance;
+    private tasks;
+    private debugMode;
+    private constructor();
+    static get instance(): BackgroundTaskManager;
+    private generateId;
+    private debug;
+    run(options: RunBackgroundOptions): BackgroundTask;
+    get(taskId: string): BackgroundTask | undefined;
+    getAll(): BackgroundTask[];
+    getByStatus(status: BackgroundTaskStatus): BackgroundTask[];
+    clearCompleted(): number;
+    kill(taskId: string): boolean;
+    formatDuration(task: BackgroundTask): string;
+    getStatusEmoji(status: BackgroundTaskStatus): string;
+}
+export declare const backgroundTaskManager: BackgroundTaskManager;
+export {};

package/dist/core/commands/types/background-task-status.d.ts

@@ -0,0 +1,4 @@
+/**
+ * BackgroundTaskStatus - Task status union type
+ */
+export type BackgroundTaskStatus = "pending" | "running" | "done" | "error" | "timeout";

package/dist/core/commands/types/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Background Task Types Index
+ */
+export { BackgroundTaskStatus } from "./background-task-status.js";

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

@@ -0,0 +1,7 @@
+/**
+ * Session Module - State and Task management
+ */
+export * from "./types/index.js";
+export * from "./interfaces/index.js";
+export { TaskGraph } from "./task-graph.js";
+export { state } from "./state.js";

package/dist/core/orchestrator/interfaces/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Session Interfaces Index
+ */
+export { Task } from "./task.js";
+export { SessionState } from "./session-state.js";

package/dist/core/{state.d.ts → orchestrator/interfaces/session-state.d.ts}

@@ -1,4 +1,7 @@
-import { TaskGraph } from "./tasks.js";
+/**
+ * SessionState - State for a single orchestration session
+ */
+import type { TaskGraph } from "../task-graph.js";
 export interface SessionState {
     enabled: boolean;
     iterations: number;
@@ -8,9 +11,3 @@ export interface SessionState {
     anomalyCount: number;
     lastHealthyOutput?: string;
 }
-export declare const state: {
-    missionActive: boolean;
-    maxIterations: number;
-    maxRetries: number;
-    sessions: Map<string, SessionState>;
-};

package/dist/core/orchestrator/interfaces/task.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Task - A single task in the orchestration DAG
+ */
+import { TaskStatus } from "../types/task-status.js";
+import { TaskType } from "../types/task-type.js";
+export interface Task {
+    id: string;
+    description: string;
+    action: string;
+    file: string;
+    dependencies: string[];
+    status: TaskStatus;
+    result?: string;
+    retryCount: number;
+    complexity: number;
+    type: TaskType;
+}

package/dist/core/orchestrator/state.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Global State - Orchestration state manager
+ */
+import { SessionState } from "./interfaces/session-state.js";
+export declare const state: {
+    missionActive: boolean;
+    maxIterations: number;
+    maxRetries: number;
+    sessions: Map<string, SessionState>;
+};

package/dist/core/orchestrator/task-graph.d.ts

@@ -0,0 +1,17 @@
+/**
+ * TaskGraph - DAG for task orchestration
+ */
+import { Task } from "./interfaces/task.js";
+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/dist/core/orchestrator/types/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Orchestrator Types Index
+ */
+export { TaskStatus } from "./task-status.js";
+export { TaskType } from "./task-type.js";

package/dist/core/orchestrator/types/task-status.d.ts

@@ -0,0 +1,4 @@
+/**
+ * TaskStatus - Status of a task in the DAG
+ */
+export type TaskStatus = "pending" | "running" | "completed" | "failed";

package/dist/core/orchestrator/types/task-type.d.ts

@@ -0,0 +1,4 @@
+/**
+ * TaskType - Type of task in the orchestration DAG
+ */
+export type TaskType = "infrastructure" | "logic" | "integration";

package/dist/index.d.ts

@@ -13,24 +13,6 @@
 import type { PluginInput } from "@opencode-ai/plugin";
 declare const OrchestratorPlugin: (input: PluginInput) => Promise<{
     tool: {
-        git_branch: {
-            description: string;
-            args: {
-                action: import("zod").ZodEnum<{
-                    status: "status";
-                    diff: "diff";
-                    current: "current";
-                    list: "list";
-                    recent: "recent";
-                    all: "all";
-                }>;
-                baseBranch: import("zod").ZodOptional<import("zod").ZodString>;
-            };
-            execute(args: {
-                action: "status" | "diff" | "current" | "list" | "recent" | "all";
-                baseBranch?: string | undefined;
-            }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
-        };
         call_agent: {
             description: string;
             args: {
@@ -85,12 +67,10 @@ declare const OrchestratorPlugin: (input: PluginInput) => Promise<{
             args: {
                 patterns: import("zod").ZodArray<import("zod").ZodString>;
                 dir: import("zod").ZodOptional<import("zod").ZodString>;
-                max_results_per_pattern: import("zod").ZodOptional<import("zod").ZodNumber>;
             };
             execute(args: {
                 patterns: string[];
                 dir?: string | undefined;
-                max_results_per_pattern?: number | undefined;
             }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
         };
         run_background: {
@@ -100,14 +80,12 @@ declare const OrchestratorPlugin: (input: PluginInput) => Promise<{
                 cwd: import("zod").ZodOptional<import("zod").ZodString>;
                 timeout: import("zod").ZodOptional<import("zod").ZodNumber>;
                 label: import("zod").ZodOptional<import("zod").ZodString>;
-                sessionID: import("zod").ZodOptional<import("zod").ZodString>;
             };
             execute(args: {
                 command: string;
                 cwd?: string | undefined;
                 timeout?: number | undefined;
                 label?: string | undefined;
-                sessionID?: string | undefined;
             }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
         };
         check_background: {
@@ -126,13 +104,13 @@ declare const OrchestratorPlugin: (input: PluginInput) => Promise<{
             args: {
                 status: import("zod").ZodOptional<import("zod").ZodEnum<{
                     running: "running";
-                    all: "all";
                     done: "done";
                     error: "error";
+                    all: "all";
                 }>>;
             };
             execute(args: {
-                status?: "running" | "all" | "done" | "error" | undefined;
+                status?: "running" | "done" | "error" | "all" | undefined;
             }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
         };
         kill_background: {