opencode-orchestrator 1.2.40 → 1.2.46

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

@@ -0,0 +1,23 @@
+/**
+ * ConcurrencyToken
+ *
+ * RAII-style token for concurrency slot management.
+ * Automatically releases slot if not manually released within timeout.
+ */
+import type { ConcurrencyController } from "./concurrency.js";
+export declare class ConcurrencyToken {
+    private controller;
+    private key;
+    private autoReleaseMs;
+    private released;
+    private autoReleaseTimer;
+    constructor(controller: ConcurrencyController, key: string, autoReleaseMs?: number);
+    /**
+     * Manually release the concurrency slot
+     */
+    release(): void;
+    /**
+     * Check if token has been released
+     */
+    isReleased(): boolean;
+}

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

@@ -1,13 +1,25 @@
 /**
- * Concurrency Controller
+ * Enhanced 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)
+ * Queue-based rate limiting with:
+ * - Priority queue (HIGH/NORMAL/LOW)
+ * - Circuit breaker pattern
+ * - Resource-aware scheduling
+ * - Adaptive auto-scaling
  */
-import type { ConcurrencyConfig } from "./interfaces/concurrency-config.interface.js";
-export type { ConcurrencyConfig } from "./interfaces/concurrency-config.interface.js";
+import type { ConcurrencyConfig } from "../../shared/agent/interfaces/concurrency-config.js";
+import { ConcurrencyToken } from "./concurrency-token.js";
+export type { ConcurrencyConfig } from "../../shared/agent/interfaces/concurrency-config.js";
+export declare enum TaskPriority {
+    HIGH = 0,
+    NORMAL = 1,
+    LOW = 2
+}
+export declare enum CircuitState {
+    CLOSED = "CLOSED",// Normal operation
+    OPEN = "OPEN",// Blocking requests
+    HALF_OPEN = "HALF_OPEN"
+}
 export declare class ConcurrencyController {
     private counts;
     private queues;
@@ -15,24 +27,69 @@ export declare class ConcurrencyController {
     private config;
     private successStreak;
     private failureCount;
+    private circuits;
+    private readonly CIRCUIT_THRESHOLD;
+    private readonly CIRCUIT_TIMEOUT;
+    private readonly HALF_OPEN_SUCCESS;
+    private readonly MAX_MEMORY_PERCENT;
+    private workerPools;
     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>;
+    /**
+     * Acquire slot with priority support
+     */
+    acquire(key: string, priority?: TaskPriority): Promise<void>;
     release(key: string): void;
     /**
-     * Report success/failure to adjust concurrency dynamically
+     * Report result with circuit breaker integration
      */
     reportResult(key: string, success: boolean): void;
+    private handleSuccess;
+    private handleFailure;
+    private isCircuitOpen;
+    private getCircuit;
+    private isUnderResourcePressure;
+    private removeFromQueue;
     getQueueLength(key: string): number;
     getActiveCount(key: string): number;
+    getConcurrencyInfo(key: string): string;
     /**
-     * Get formatted concurrency info string (e.g., "2/5 slots")
+     * Get circuit breaker state for monitoring
      */
-    getConcurrencyInfo(key: string): string;
+    getCircuitState(key: string): CircuitState;
+    /**
+     * Manually reset circuit breaker
+     */
+    resetCircuit(key: string): void;
+    /**
+     * Acquire slot and return RAII token for automatic cleanup
+     * @param key - Concurrency key
+     * @param priority - Task priority
+     * @param autoReleaseMs - Auto-release timeout (default: 10 minutes)
+     * @returns ConcurrencyToken - Call .release() when done
+     */
+    acquireToken(key: string, priority?: TaskPriority, autoReleaseMs?: number): Promise<ConcurrencyToken>;
+    /**
+     * Enable work-stealing for a concurrency key
+     * @param key - Concurrency key
+     * @param workerCount - Number of workers (default: 4)
+     */
+    enableWorkStealing(key: string, workerCount?: number): void;
+    /**
+     * Get work-stealing pool statistics
+     */
+    getWorkStealingStats(key: string): {
+        workers: number;
+        totalExecuted: number;
+        totalStolen: number;
+        stealRate: number;
+        utilizationPercent: number;
+        queuedTasks: number;
+    } | null;
+    /**
+     * Shutdown - stops all worker pools
+     */
+    shutdown(): Promise<void>;
 }

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

@@ -5,4 +5,3 @@ export * from "./types/index.js";
 export * from "./interfaces/index.js";
 export { ConcurrencyController } from "./concurrency.js";
 export { ParallelAgentManager, parallelAgentManager } from "./manager.js";
-export { taskWAL } from "./persistence/task-wal.js";

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

@@ -1,8 +1,9 @@
 /**
  * Agents Interfaces Index
+ * Re-exports from shared to maintain compatibility
  */
-export type { ParallelTask } from "./parallel-task.interface.js";
-export type { TaskProgress } from "./task-progress.interface.js";
+export type { ParallelTask } from "../../../shared/task/interfaces/parallel-task.js";
+export type { TaskProgress } from "../../../shared/task/interfaces/task-progress.js";
+export type { ConcurrencyConfig } from "../../../shared/agent/interfaces/concurrency-config.js";
 export type { LaunchInput } from "./launch-input.interface.js";
 export type { ResumeInput } from "./resume-input.interface.js";
-export type { ConcurrencyConfig } from "./concurrency-config.interface.js";

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

@@ -1,7 +1,8 @@
 /**
  * Debug logger for parallel agent
- * Logs to both console (when DEBUG=true) and file (always)
- * Log file location: /tmp/opencode-orchestrator.log (or OS temp dir)
+ *
+ * DISABLED: File logging removed to eliminate I/O overhead.
+ * All log calls are now no-ops for maximum performance.
  */
-export declare function log(...args: unknown[]): void;
+export declare function log(..._args: unknown[]): void;
 export declare function getLogPath(): string;

package/dist/core/agents/manager/event-handler.d.ts

@@ -4,7 +4,7 @@
 import type { PluginInput } from "@opencode-ai/plugin";
 import { TaskStore } from "../task-store.js";
 import { ConcurrencyController } from "../concurrency.js";
-import type { ParallelTask } from "../interfaces/parallel-task.interface.js";
+import type { ParallelTask } from "../interfaces/index.js";
 type OpencodeClient = PluginInput["client"];
 export declare class EventHandler {
     private client;

package/dist/core/agents/manager/task-launcher.d.ts

@@ -4,7 +4,7 @@
 import type { PluginInput } from "@opencode-ai/plugin";
 import { ConcurrencyController } from "../concurrency.js";
 import { TaskStore } from "../task-store.js";
-import type { ParallelTask } from "../interfaces/parallel-task.interface.js";
+import type { ParallelTask } from "../interfaces/index.js";
 import type { LaunchInput } from "../interfaces/launch-input.interface.js";
 import { SessionPool } from "../session-pool.js";
 type OpencodeClient = PluginInput["client"];

package/dist/core/agents/manager/task-poller.d.ts

@@ -4,7 +4,7 @@
 import type { PluginInput } from "@opencode-ai/plugin";
 import { TaskStore } from "../task-store.js";
 import { ConcurrencyController } from "../concurrency.js";
-import type { ParallelTask } from "../interfaces/parallel-task.interface.js";
+import type { ParallelTask } from "../interfaces/index.js";
 type OpencodeClient = PluginInput["client"];
 export declare class TaskPoller {
     private client;
@@ -16,13 +16,27 @@ export declare class TaskPoller {
     private onTaskComplete?;
     private pollingInterval?;
     private messageCache;
+    private currentPollInterval;
+    private readonly MIN_POLL_INTERVAL;
+    private readonly MAX_POLL_INTERVAL;
     constructor(client: OpencodeClient, store: TaskStore, concurrency: ConcurrencyController, notifyParentIfAllComplete: (parentSessionID: string) => Promise<void>, scheduleCleanup: (taskId: string) => void, pruneExpiredTasks: () => void, onTaskComplete?: ((task: ParallelTask) => void | Promise<void>) | undefined);
     start(): void;
     stop(): void;
     isRunning(): boolean;
+    /**
+     * Schedule next poll with adaptive interval
+     */
+    private scheduleNextPoll;
     poll(): Promise<void>;
     validateSessionHasOutput(sessionID: string, task?: ParallelTask): Promise<boolean>;
     completeTask(task: ParallelTask): Promise<void>;
     private updateTaskProgress;
+    /**
+     * Adjust poll interval based on current load
+     * - No tasks: Exponential backoff to MAX_POLL_INTERVAL
+     * - High utilization (>80%): Speed up to MIN_POLL_INTERVAL
+     * - Medium utilization: Proportional adjustment
+     */
+    private adjustPollInterval;
 }
 export {};

package/dist/core/agents/manager/task-resumer.d.ts

@@ -3,7 +3,7 @@
  */
 import type { PluginInput } from "@opencode-ai/plugin";
 import { TaskStore } from "../task-store.js";
-import type { ParallelTask } from "../interfaces/parallel-task.interface.js";
+import type { ParallelTask } from "../interfaces/index.js";
 import type { ResumeInput } from "../interfaces/resume-input.interface.js";
 type OpencodeClient = PluginInput["client"];
 export declare class TaskResumer {

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

@@ -11,7 +11,7 @@
 import type { PluginInput } from "@opencode-ai/plugin";
 import { ConcurrencyController } from "./concurrency.js";
 import { formatDuration } from "./format.js";
-import type { ParallelTask } from "./interfaces/parallel-task.interface.js";
+import type { ParallelTask } from "./interfaces/index.js";
 import type { LaunchInput } from "./interfaces/launch-input.interface.js";
 import type { ResumeInput } from "./interfaces/resume-input.interface.js";
 export type { ParallelTask };
@@ -43,6 +43,10 @@ export declare class ParallelAgentManager {
     getPendingCount(parentSessionID: string): number;
     getConcurrency(): ConcurrencyController;
     cleanup(): void;
+    /**
+     * Shutdown - alias for cleanup, releases all resources
+     */
+    shutdown(): Promise<void>;
     formatDuration: typeof formatDuration;
     handleEvent(event: {
         type: string;

package/dist/core/agents/persistence/task-wal.d.ts

@@ -1,26 +1,24 @@
 /**
- * Task WAL (Write-Ahead Log)
+ * Task WAL (Write-Ahead Log) - REMOVED
  *
- * Handles append-only logging of task state transitions for crash recovery.
+ * This module is deprecated and provides no-op stubs for backward compatibility.
+ * WAL was removed to reduce I/O overhead and simplify architecture.
  */
-import { WAL_ACTIONS } from "../../../shared/index.js";
-import type { ParallelTask } from "../interfaces/parallel-task.interface.js";
+import type { ParallelTask } from "../interfaces/index.js";
 export interface WALEntry {
     timestamp: string;
-    action: keyof typeof WAL_ACTIONS;
+    action: string;
     taskId: string;
     data: Partial<ParallelTask>;
 }
+/**
+ * No-op WAL - all methods are stubs
+ */
 export declare class TaskWAL {
-    private walPath;
-    private initialized;
-    constructor(customPath?: string);
     init(): Promise<void>;
-    log(action: WALEntry["action"], task: ParallelTask): Promise<void>;
+    log(): Promise<void>;
+    flush(): Promise<void>;
     readAll(): Promise<Map<string, ParallelTask>>;
-    /**
-     * Compact the WAL by writing only the current active tasks
-     */
-    compact(activeTasks: ParallelTask[]): Promise<void>;
+    compact(): Promise<void>;
 }
 export declare const taskWAL: TaskWAL;

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

@@ -9,7 +9,15 @@
  */
 import type { PluginInput } from "@opencode-ai/plugin";
 import type { PooledSession, SessionPoolConfig, SessionPoolStats, ISessionPool } from "./interfaces/session-pool.interface.js";
-type OpencodeClient = PluginInput["client"];
+type OpencodeClient = PluginInput["client"] & {
+    session: {
+        compact?: (opts: {
+            path: {
+                id: string;
+            };
+        }) => Promise<void>;
+    };
+};
 export declare class SessionPool implements ISessionPool {
     private static _instance;
     private pool;

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

@@ -6,7 +6,7 @@
  * - Memory-safe storage with limits
  * - Completed task archiving
  */
-import type { ParallelTask } from "./interfaces/parallel-task.interface.js";
+import type { ParallelTask } from "./interfaces/index.js";
 export declare class TaskStore {
     private tasks;
     private pendingByParent;
@@ -51,4 +51,28 @@ export declare class TaskStore {
      * Force cleanup of all completed tasks
      */
     forceCleanup(): number;
+    /**
+     * Get pooling statistics
+     */
+    getPoolStats(): {
+        taskPool: {
+            created: number;
+            available: number;
+            inUse: number;
+            acquires: number;
+            releases: number;
+            hits: number;
+            misses: number;
+            disposed: number;
+            hitRate: number;
+        };
+        stringPool: {
+            interns: number;
+            hits: number;
+            misses: number;
+            skipped: number;
+            hitRate: number;
+            poolSize: number;
+        };
+    };
 }

package/dist/core/cleanup/cleanup-scheduler.d.ts

@@ -8,4 +8,20 @@ export declare class CleanupScheduler {
     compactWAL(): Promise<void>;
     cleanDocs(): Promise<void>;
     rotateHistory(): Promise<void>;
+    /**
+     * Clean old session files (>7 days)
+     */
+    cleanOldSessions(): Promise<void>;
+    /**
+     * Remove node_modules from .opencode directory
+     */
+    cleanNodeModules(): Promise<void>;
+    /**
+     * Enforce file count limit (500 files max)
+     */
+    enforceFileLimit(): Promise<void>;
+    /**
+     * Recursively list all files in a directory
+     */
+    private listAllFiles;
 }

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

@@ -17,4 +17,5 @@ export interface BackgroundTask {
     endTime?: number;
     timeout: number;
     process?: ChildProcess;
+    timeoutHandle?: NodeJS.Timeout;
 }

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

@@ -22,6 +22,10 @@ declare class BackgroundTaskManager {
     kill(taskId: string): boolean;
     formatDuration(task: BackgroundTask): string;
     getStatusEmoji(status: BackgroundTaskStatus): string;
+    /**
+     * Shutdown - kills all running processes and clears tasks
+     */
+    shutdown(): Promise<void>;
 }
 export declare const backgroundTaskManager: BackgroundTaskManager;
 export {};

package/dist/core/lifecycle/shutdown-manager.d.ts

@@ -0,0 +1,29 @@
+/**
+ * ShutdownManager
+ *
+ * Coordinates graceful shutdown of all subsystems.
+ * Ensures resources are properly cleaned up when the plugin is unloaded.
+ */
+export type CleanupFunction = () => void | Promise<void>;
+export declare class ShutdownManager {
+    private cleanupHandlers;
+    private isShuttingDown;
+    private shutdownPromise;
+    /**
+     * Register a cleanup handler
+     * @param name - Identifier for logging
+     * @param fn - Cleanup function to execute
+     * @param priority - Lower numbers run first (0-100). Default: 100
+     */
+    register(name: string, fn: CleanupFunction, priority?: number): void;
+    /**
+     * Execute all cleanup handlers in priority order
+     * Each handler gets 5 seconds max
+     */
+    shutdown(): Promise<void>;
+    private _executeShutdown;
+    /**
+     * Check if shutdown is in progress
+     */
+    isShutdown(): boolean;
+}

package/dist/core/plugins/interfaces.d.ts

@@ -24,6 +24,10 @@ export interface CustomPlugin {
      * Initialization logic
      */
     init?: (context: PluginContext) => Promise<void>;
+    /**
+     * Cleanup logic (called on shutdown)
+     */
+    cleanup?: () => Promise<void>;
 }
 export interface PluginContext {
     directory: string;

package/dist/core/plugins/plugin-manager.d.ts

@@ -18,4 +18,8 @@ export declare class PluginManager {
      * Get all dynamically registered tools
      */
     getDynamicTools(): Record<string, any>;
+    /**
+     * Shutdown - cleanup all plugins
+     */
+    shutdown(): Promise<void>;
 }

package/dist/core/pool/buffer-pool.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Buffer Pool
+ *
+ * Pools ArrayBuffers for efficient memory reuse.
+ * Sizes: 1KB, 4KB, 16KB, 64KB
+ */
+export declare class BufferPool {
+    private pools;
+    private readonly sizes;
+    private readonly maxPerSize;
+    private stats;
+    constructor();
+    /**
+     * Acquire a buffer of at least minSize
+     * Returns the buffer and its actual size
+     */
+    acquire(minSize: number): {
+        buffer: ArrayBuffer;
+        poolSize: number;
+    };
+    /**
+     * Release a buffer back to the pool
+     */
+    release(buffer: ArrayBuffer): void;
+    /**
+     * Get pool statistics
+     */
+    getStats(): {
+        acquires: number;
+        releases: number;
+        hits: number;
+        misses: number;
+        hitRate: number;
+        poolSizes: Record<number, number>;
+    };
+    /**
+     * Clear all pools
+     */
+    clear(): void;
+    /**
+     * Prewarm pools with buffers
+     */
+    prewarm(countPerSize?: number): void;
+}
+/**
+ * Global buffer pool
+ */
+export declare const bufferPool: BufferPool;

package/dist/core/pool/object-pool.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Generic Object Pool
+ *
+ * Reduces GC pressure by reusing objects instead of allocating new ones.
+ * Target: 80% GC reduction, 60% memory usage reduction
+ */
+/**
+ * Poolable interface - objects that can be pooled must implement this
+ */
+export interface Poolable {
+    /**
+     * Reset the object to initial state for reuse
+     */
+    reset(): void;
+}
+/**
+ * Generic Object Pool
+ */
+export declare class ObjectPool<T extends Poolable> {
+    private available;
+    private inUse;
+    private factory;
+    private maxSize;
+    private created;
+    private stats;
+    constructor(factory: () => T, maxSize?: number);
+    /**
+     * Acquire an object from the pool
+     * Reuses existing or creates new if needed
+     */
+    acquire(): T;
+    /**
+     * Release an object back to the pool
+     * Object is reset and made available for reuse
+     */
+    release(obj: T): void;
+    /**
+     * Get pool statistics
+     */
+    getStats(): {
+        created: number;
+        available: number;
+        inUse: number;
+        acquires: number;
+        releases: number;
+        hits: number;
+        misses: number;
+        disposed: number;
+        hitRate: number;
+    };
+    /**
+     * Clear the pool
+     */
+    clear(): void;
+    /**
+     * Prewarm the pool with N objects
+     */
+    prewarm(count: number): void;
+}

package/dist/core/pool/string-pool.d.ts

@@ -0,0 +1,40 @@
+/**
+ * String Interning Pool
+ *
+ * Reduces memory by deduplicating identical strings.
+ * Especially useful for repeated agent names, status values, etc.
+ */
+export declare class StringPool {
+    private pool;
+    private maxLength;
+    private maxSize;
+    private stats;
+    /**
+     * Intern a string - returns the canonical instance
+     * Type-safe version that preserves the input type
+     */
+    intern<T extends string>(str: T): T;
+    /**
+     * Get pool statistics
+     */
+    getStats(): {
+        interns: number;
+        hits: number;
+        misses: number;
+        skipped: number;
+        hitRate: number;
+        poolSize: number;
+    };
+    /**
+     * Clear the pool
+     */
+    clear(): void;
+    /**
+     * Prewarm with common strings
+     */
+    prewarm(strings: string[]): void;
+}
+/**
+ * Global string pool
+ */
+export declare const stringPool: StringPool;

package/dist/core/pool/task-pool.d.ts

@@ -0,0 +1,13 @@
+/**
+ * ParallelTask Object Pool
+ *
+ * Reduces GC pressure by reusing ParallelTask objects.
+ * Pool size: 200 instances (typical max concurrent tasks)
+ */
+import { ObjectPool } from "./object-pool.js";
+import type { ParallelTask } from "../../shared/task/interfaces/parallel-task.js";
+/**
+ * Global ParallelTask pool
+ * Pool size: 200 (typical max concurrent tasks)
+ */
+export declare const taskPool: ObjectPool<ParallelTask>;

package/dist/core/queue/work-stealing-deque.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Chase-Lev Work-Stealing Deque
+ *
+ * Lock-free deque for efficient work-stealing scheduling.
+ * - Owner pushes/pops from bottom (LIFO for cache locality)
+ * - Thieves steal from top (FIFO for fairness)
+ *
+ * Based on: "Dynamic Circular Work-Stealing Deque" (Chase & Lev, 2005)
+ */
+import { TaskPriority } from "../agents/concurrency.js";
+export interface WorkItem<T> {
+    task: T;
+    priority: TaskPriority;
+    enqueuedAt: number;
+}
+/**
+ * Work-Stealing Deque (Chase-Lev)
+ */
+export declare class WorkStealingDeque<T> {
+    private top;
+    private bottom;
+    private array;
+    constructor(initialCapacity?: number);
+    /**
+     * Push item to bottom (owner only)
+     * LIFO for owner = better cache locality
+     */
+    push(item: WorkItem<T>): void;
+    /**
+     * Pop item from bottom (owner only)
+     * LIFO for owner = better cache locality
+     */
+    pop(): WorkItem<T> | null;
+    /**
+     * Steal item from top (thieves)
+     * FIFO for thieves = better fairness
+     */
+    steal(): WorkItem<T> | null;
+    /**
+     * Get current size (approximate, not thread-safe)
+     */
+    size(): number;
+    /**
+     * Check if empty
+     */
+    isEmpty(): boolean;
+}