opencode-orchestrator 0.2.3 → 0.4.0

package/README.md

@@ -28,13 +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 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 Tasking** — Architect splits work into concurrent DAG groups.
+- **🏗️ 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 powered by Rust for blazing-fast codebase analysis.
 
 ---
 
@@ -79,6 +83,26 @@ The Commander will:
 > **💡 Tip:** Using the `/task` command makes Commander mode run **2x longer**.
 > Use `/task` for complex tasks that need extended processing!
 
+### ⚡ Example: Parallel Execution
+
+Trigger parallel agent execution with prompts like:
+
+```
+"Build and test in parallel"
+"Implement feature X while reviewing module Y"
+"Run linting, tests, and build at the same time"
+```
+
+Commander will automatically use `delegate_task` with `background: true` for independent tasks.
+
+Monitor parallel tasks in the terminal:
+```
+[parallel] 🚀 SPAWNED task_a1b2 → builder: Implement feature X
+[parallel] 🚀 SPAWNED task_c3d4 → inspector: Review module Y
+[parallel] ✅ COMPLETED task_c3d4 → inspector: Review module Y (45s)
+[parallel] 🗑️ CLEANED task_c3d4 (session deleted)
+```
+
 ---
 
 ## Agents (5-Agent Architecture)
@@ -123,6 +147,8 @@ npm uninstall -g opencode-orchestrator
 
 - [Architecture & Design](docs/ARCHITECTURE.md) — Detailed system design and agent protocols
 - [Plugin Troubleshooting](docs/PLUGIN_TROUBLESHOOTING.md) — Setup and common issues
+- [Changelog](CHANGELOG.md) — Version history and updates
+- [Changelogs](changelogs/) — Detailed implementation notes per release
 
 ---
 

package/dist/core/async-agent.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Parallel Agent Manager - Session-based async agent execution
+ *
+ * Key safety features:
+ * - Concurrency control per agent type (queue-based)
+ * - Batched notifications (notify when ALL complete)
+ * - Automatic memory cleanup (5 min after completion)
+ * - TTL enforcement (30 min timeout)
+ * - Output validation before completion
+ * - Process-safe polling (unref)
+ */
+import type { PluginInput } from "@opencode-ai/plugin";
+type OpencodeClient = PluginInput["client"];
+export interface ParallelTask {
+    id: string;
+    sessionID: string;
+    parentSessionID: string;
+    description: string;
+    agent: string;
+    status: "pending" | "running" | "completed" | "error" | "timeout";
+    startedAt: Date;
+    completedAt?: Date;
+    error?: string;
+    result?: string;
+    concurrencyKey?: string;
+}
+interface LaunchInput {
+    description: string;
+    prompt: string;
+    agent: string;
+    parentSessionID: string;
+}
+export declare class ParallelAgentManager {
+    private static _instance;
+    private tasks;
+    private pendingByParent;
+    private notifications;
+    private client;
+    private directory;
+    private concurrency;
+    private pollingInterval?;
+    private constructor();
+    static getInstance(client?: OpencodeClient, directory?: string): ParallelAgentManager;
+    /**
+     * Launch an agent in a new session (async, non-blocking)
+     */
+    launch(input: LaunchInput): Promise<ParallelTask>;
+    /**
+     * Get task by ID
+     */
+    getTask(id: string): ParallelTask | undefined;
+    /**
+     * Get all running tasks
+     */
+    getRunningTasks(): ParallelTask[];
+    /**
+     * Get all tasks
+     */
+    getAllTasks(): ParallelTask[];
+    /**
+     * Get tasks by parent session
+     */
+    getTasksByParent(parentSessionID: string): ParallelTask[];
+    /**
+     * Cancel a running task
+     */
+    cancelTask(taskId: string): Promise<boolean>;
+    /**
+     * Get result from completed task
+     */
+    getResult(taskId: string): Promise<string | null>;
+    /**
+     * Set concurrency limit for agent type
+     */
+    setConcurrencyLimit(agentType: string, limit: number): void;
+    /**
+     * Get pending notification count
+     */
+    getPendingCount(parentSessionID: string): number;
+    /**
+     * Cleanup all state
+     */
+    cleanup(): void;
+    private trackPending;
+    private untrackPending;
+    private handleTaskError;
+    private startPolling;
+    private stopPolling;
+    private pollRunningTasks;
+    private validateSessionHasOutput;
+    private pruneExpiredTasks;
+    private scheduleCleanup;
+    private queueNotification;
+    private notifyParentIfAllComplete;
+    formatDuration(start: Date, end?: Date): string;
+}
+export declare const parallelAgentManager: {
+    getInstance: typeof ParallelAgentManager.getInstance;
+};
+export {};

package/dist/core/background.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Background Task Manager for OpenCode Orchestrator
+ *
+ * Enables running commands in the background and checking their status later.
+ * This allows the AI to continue working while long-running tasks execute.
+ */
+import { ChildProcess } from "child_process";
+export type TaskStatus = "pending" | "running" | "done" | "error" | "timeout";
+export interface BackgroundTask {
+    id: string;
+    command: string;
+    args: string[];
+    cwd: string;
+    label?: string;
+    status: TaskStatus;
+    output: string;
+    errorOutput: string;
+    exitCode: number | null;
+    startTime: number;
+    endTime?: number;
+    timeout: number;
+    process?: ChildProcess;
+}
+export interface RunBackgroundOptions {
+    command: string;
+    cwd?: string;
+    timeout?: number;
+    label?: string;
+}
+declare class BackgroundTaskManager {
+    private static _instance;
+    private tasks;
+    private debugMode;
+    private constructor();
+    static get instance(): BackgroundTaskManager;
+    /**
+     * Generate a unique task ID in the format job_xxxxxxxx
+     */
+    private generateId;
+    /**
+     * Debug logging helper
+     */
+    private debug;
+    /**
+     * Run a command in the background
+     */
+    run(options: RunBackgroundOptions): BackgroundTask;
+    /**
+     * Get task by ID
+     */
+    get(taskId: string): BackgroundTask | undefined;
+    /**
+     * Get all tasks
+     */
+    getAll(): BackgroundTask[];
+    /**
+     * Get tasks by status
+     */
+    getByStatus(status: TaskStatus): BackgroundTask[];
+    /**
+     * Clear completed/failed tasks
+     */
+    clearCompleted(): number;
+    /**
+     * Kill a running task
+     */
+    kill(taskId: string): boolean;
+    /**
+     * Format duration for display
+     */
+    formatDuration(task: BackgroundTask): string;
+    /**
+     * Get status emoji
+     */
+    getStatusEmoji(status: TaskStatus): string;
+}
+export declare const backgroundTaskManager: BackgroundTaskManager;
+export {};

package/dist/index.d.ts

@@ -62,6 +62,68 @@ declare const OrchestratorPlugin: (input: PluginInput) => Promise<{
                 dir?: string | undefined;
             }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
         };
+        mgrep: {
+            description: string;
+            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: {
+            description: string;
+            args: {
+                command: import("zod").ZodString;
+                cwd: import("zod").ZodOptional<import("zod").ZodString>;
+                timeout: import("zod").ZodOptional<import("zod").ZodNumber>;
+                label: import("zod").ZodOptional<import("zod").ZodString>;
+            };
+            execute(args: {
+                command: string;
+                cwd?: string | undefined;
+                timeout?: number | undefined;
+                label?: string | undefined;
+            }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+        };
+        check_background: {
+            description: string;
+            args: {
+                taskId: import("zod").ZodString;
+                tailLines: import("zod").ZodOptional<import("zod").ZodNumber>;
+            };
+            execute(args: {
+                taskId: string;
+                tailLines?: number | undefined;
+            }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+        };
+        list_background: {
+            description: string;
+            args: {
+                status: import("zod").ZodOptional<import("zod").ZodEnum<{
+                    error: "error";
+                    running: "running";
+                    done: "done";
+                    all: "all";
+                }>>;
+            };
+            execute(args: {
+                status?: "error" | "running" | "done" | "all" | undefined;
+            }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+        };
+        kill_background: {
+            description: string;
+            args: {
+                taskId: import("zod").ZodString;
+            };
+            execute(args: {
+                taskId: string;
+            }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+        };
     };
     config: (config: Record<string, unknown>) => Promise<void>;
     "chat.message": (msgInput: any, msgOutput: any) => Promise<void>;