opencode-orchestrator 0.5.12 → 0.5.17

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

@@ -6,12 +6,8 @@
  * - 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>;
-}
+import type { ConcurrencyConfig } from "./interfaces/concurrency-config.interface.js";
+export type { ConcurrencyConfig } from "./interfaces/concurrency-config.interface.js";
 export declare class ConcurrencyController {
     private counts;
     private queues;

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

@@ -5,5 +5,5 @@ export declare const CONFIG: {
     readonly TASK_TTL_MS: number;
     readonly CLEANUP_DELAY_MS: number;
     readonly MIN_STABILITY_MS: number;
-    readonly POLL_INTERVAL_MS: 2000;
+    readonly POLL_INTERVAL_MS: 1000;
 };

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

@@ -0,0 +1,4 @@
+/**
+ * Agents Consts Index
+ */
+export { TASK_STATUS } from "./task-status.const.js";

package/dist/core/agents/consts/task-status.const.d.ts

@@ -0,0 +1,12 @@
+/**
+ * TASK_STATUS - Task status constants
+ */
+export declare const TASK_STATUS: {
+    readonly PENDING: "pending";
+    readonly RUNNING: "running";
+    readonly COMPLETED: "completed";
+    readonly FAILED: "failed";
+    readonly ERROR: "error";
+    readonly TIMEOUT: "timeout";
+    readonly CANCELLED: "cancelled";
+};

package/dist/core/agents/interfaces/concurrency-config.interface.d.ts

@@ -0,0 +1,9 @@
+/**
+ * ConcurrencyConfig Interface
+ */
+export interface ConcurrencyConfig {
+    defaultConcurrency?: number;
+    agentConcurrency?: Record<string, number>;
+    providerConcurrency?: Record<string, number>;
+    modelConcurrency?: Record<string, number>;
+}

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

@@ -1,5 +1,8 @@
 /**
- * Parallel Module Interfaces Index
+ * Agents Interfaces Index
  */
-export { ParallelTask } from "./parallel-task.js";
-export { LaunchInput } from "./launch-input.js";
+export type { ParallelTask } from "./parallel-task.interface.js";
+export type { TaskProgress } from "./task-progress.interface.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/interfaces/{parallel-task.d.ts → parallel-task.interface.d.ts}

@@ -1,18 +1,14 @@
 /**
- * ParallelTask - Represents a task running in a parallel session
+ * ParallelTask Interface - 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;
-}
+import type { ParallelTaskStatus } from "../types/parallel-task-status.type.js";
+import type { TaskProgress } from "./task-progress.interface.js";
 export interface ParallelTask {
     id: string;
     sessionID: string;
     parentSessionID: string;
     description: string;
+    prompt: string;
     agent: string;
     status: ParallelTaskStatus;
     startedAt: Date;

package/dist/core/agents/interfaces/resume-input.interface.d.ts

@@ -0,0 +1,17 @@
+/**
+ * ResumeInput - Input for resuming an existing parallel task session
+ *
+ * This allows continuing work in an existing session, preserving all context.
+ * Useful for:
+ * - Retry after failure (don't start from scratch)
+ * - Follow-up questions to previous work
+ * - Token efficiency (reuse context)
+ */
+export interface ResumeInput {
+    /** Session ID to resume (from previous task.sessionID) */
+    sessionId: string;
+    /** New prompt to send to the resumed session */
+    prompt: string;
+    /** New parent session ID for notifications */
+    parentSessionID: string;
+}

package/dist/core/agents/interfaces/task-progress.interface.d.ts

@@ -0,0 +1,9 @@
+/**
+ * TaskProgress Interface
+ */
+export interface TaskProgress {
+    toolCalls: number;
+    lastTool?: string;
+    lastMessage?: string;
+    lastUpdate: Date;
+}

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

@@ -0,0 +1,34 @@
+/**
+ * Event Handler - Handles OpenCode session events
+ */
+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";
+type OpencodeClient = PluginInput["client"];
+export declare class EventHandler {
+    private client;
+    private store;
+    private concurrency;
+    private findBySession;
+    private notifyParentIfAllComplete;
+    private scheduleCleanup;
+    private validateSessionHasOutput;
+    constructor(client: OpencodeClient, store: TaskStore, concurrency: ConcurrencyController, findBySession: (sessionID: string) => ParallelTask | undefined, notifyParentIfAllComplete: (parentSessionID: string) => Promise<void>, scheduleCleanup: (taskId: string) => void, validateSessionHasOutput: (sessionID: string) => Promise<boolean>);
+    /**
+     * Handle OpenCode session events for proper resource cleanup.
+     * Call this from your plugin's event hook.
+     */
+    handle(event: {
+        type: string;
+        properties?: {
+            sessionID?: string;
+            info?: {
+                id?: string;
+            };
+        };
+    }): void;
+    private handleSessionIdle;
+    private handleSessionDeleted;
+}
+export {};

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

@@ -0,0 +1,10 @@
+/**
+ * Manager Module Index
+ *
+ * Re-exports all manager components
+ */
+export { TaskLauncher } from "./task-launcher.js";
+export { TaskResumer } from "./task-resumer.js";
+export { TaskPoller } from "./task-poller.js";
+export { TaskCleaner } from "./task-cleaner.js";
+export { EventHandler } from "./event-handler.js";

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

@@ -0,0 +1,17 @@
+/**
+ * Task Cleaner - Handles cleanup and expiration of tasks
+ */
+import type { PluginInput } from "@opencode-ai/plugin";
+import { TaskStore } from "../task-store.js";
+import { ConcurrencyController } from "../concurrency.js";
+type OpencodeClient = PluginInput["client"];
+export declare class TaskCleaner {
+    private client;
+    private store;
+    private concurrency;
+    constructor(client: OpencodeClient, store: TaskStore, concurrency: ConcurrencyController);
+    pruneExpiredTasks(): void;
+    scheduleCleanup(taskId: string): void;
+    notifyParentIfAllComplete(parentSessionID: string): Promise<void>;
+}
+export {};

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

@@ -0,0 +1,20 @@
+/**
+ * Task Launcher - Handles launching new parallel tasks
+ */
+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 { LaunchInput } from "../interfaces/launch-input.interface.js";
+type OpencodeClient = PluginInput["client"];
+export declare class TaskLauncher {
+    private client;
+    private directory;
+    private store;
+    private concurrency;
+    private onTaskError;
+    private startPolling;
+    constructor(client: OpencodeClient, directory: string, store: TaskStore, concurrency: ConcurrencyController, onTaskError: (taskId: string, error: unknown) => void, startPolling: () => void);
+    launch(input: LaunchInput): Promise<ParallelTask>;
+}
+export {};

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

@@ -0,0 +1,26 @@
+/**
+ * Task Poller - Handles polling and completion detection for running tasks
+ */
+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";
+type OpencodeClient = PluginInput["client"];
+export declare class TaskPoller {
+    private client;
+    private store;
+    private concurrency;
+    private notifyParentIfAllComplete;
+    private scheduleCleanup;
+    private pruneExpiredTasks;
+    private pollingInterval?;
+    constructor(client: OpencodeClient, store: TaskStore, concurrency: ConcurrencyController, notifyParentIfAllComplete: (parentSessionID: string) => Promise<void>, scheduleCleanup: (taskId: string) => void, pruneExpiredTasks: () => void);
+    start(): void;
+    stop(): void;
+    isRunning(): boolean;
+    poll(): Promise<void>;
+    validateSessionHasOutput(sessionID: string): Promise<boolean>;
+    completeTask(task: ParallelTask): Promise<void>;
+    private updateTaskProgress;
+}
+export {};

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

@@ -0,0 +1,18 @@
+/**
+ * Task Resumer - Handles resuming existing parallel task sessions
+ */
+import type { PluginInput } from "@opencode-ai/plugin";
+import { TaskStore } from "../task-store.js";
+import type { ParallelTask } from "../interfaces/parallel-task.interface.js";
+import type { ResumeInput } from "../interfaces/resume-input.interface.js";
+type OpencodeClient = PluginInput["client"];
+export declare class TaskResumer {
+    private client;
+    private store;
+    private findBySession;
+    private startPolling;
+    private notifyParentIfAllComplete;
+    constructor(client: OpencodeClient, store: TaskStore, findBySession: (sessionID: string) => ParallelTask | undefined, startPolling: () => void, notifyParentIfAllComplete: (parentSessionID: string) => Promise<void>);
+    resume(input: ResumeInput): Promise<ParallelTask>;
+}
+export {};

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

@@ -5,11 +5,14 @@
  * - 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 { formatDuration } from "./format.js";
-import type { ParallelTask } from "./interfaces/parallel-task.js";
-import type { LaunchInput } from "./interfaces/launch-input.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"];
@@ -19,10 +22,15 @@ export declare class ParallelAgentManager {
     private client;
     private directory;
     private concurrency;
-    private pollingInterval?;
+    private launcher;
+    private resumer;
+    private poller;
+    private cleaner;
+    private eventHandler;
     private constructor();
     static getInstance(client?: OpencodeClient, directory?: string): ParallelAgentManager;
     launch(input: LaunchInput): Promise<ParallelTask>;
+    resume(input: ResumeInput): Promise<ParallelTask>;
     getTask(id: string): ParallelTask | undefined;
     getRunningTasks(): ParallelTask[];
     getAllTasks(): ParallelTask[];
@@ -33,10 +41,6 @@ export declare class ParallelAgentManager {
     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?: {
@@ -46,30 +50,8 @@ export declare class ParallelAgentManager {
             };
         };
     }): 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

@@ -1,11 +1,17 @@
 /**
  * Task Store - Stores and manages parallel tasks
+ *
+ * Features:
+ * - Automatic garbage collection
+ * - Memory-safe storage with limits
+ * - Completed task archiving
  */
-import type { ParallelTask } from "./interfaces/parallel-task.js";
+import type { ParallelTask } from "./interfaces/parallel-task.interface.js";
 export declare class TaskStore {
     private tasks;
     private pendingByParent;
     private notifications;
+    private archivedCount;
     set(id: string, task: ParallelTask): void;
     get(id: string): ParallelTask | undefined;
     getAll(): ParallelTask[];
@@ -21,8 +27,28 @@ export declare class TaskStore {
     getNotifications(parentSessionID: string): ParallelTask[];
     clearNotifications(parentSessionID: string): void;
     cleanEmptyNotifications(): void;
+    clearNotificationsForTask(taskId: string): void;
     /**
-     * Remove a specific task from all notification queues
+     * Get memory statistics
      */
-    clearNotificationsForTask(taskId: string): void;
+    getStats(): {
+        tasksInMemory: number;
+        runningTasks: number;
+        archivedTasks: number;
+        notificationQueues: number;
+        pendingParents: number;
+    };
+    /**
+     * Garbage collect completed tasks
+     * Archives old completed tasks to disk
+     */
+    gc(): Promise<number>;
+    /**
+     * Archive tasks to disk for later analysis
+     */
+    private archiveTasks;
+    /**
+     * Force cleanup of all completed tasks
+     */
+    forceCleanup(): number;
 }

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

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

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

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

package/dist/core/bus/event-bus.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Event Bus Implementation
+ *
+ * Core pub/sub system for communication between sessions and agents
+ */
+import type { EventType } from "./types.js";
+import type { BusEvent, EventHandler } from "./interfaces.js";
+export declare class EventBusImpl {
+    private subscriptions;
+    private eventHistory;
+    private maxHistorySize;
+    private subscriptionCounter;
+    /**
+     * Subscribe to an event type
+     * Returns unsubscribe function
+     */
+    subscribe(type: EventType, handler: EventHandler): () => void;
+    /**
+     * Subscribe to an event type, auto-unsubscribe after first event
+     */
+    once(type: EventType, handler: EventHandler): () => void;
+    /**
+     * Unsubscribe from an event
+     */
+    private unsubscribe;
+    /**
+     * Publish an event
+     */
+    publish(type: EventType, properties?: Record<string, unknown>, options?: {
+        source?: string;
+        sessionId?: string;
+    }): Promise<void>;
+    /**
+     * Emit (alias for publish, sync-looking API)
+     */
+    emit(type: EventType, properties?: Record<string, unknown>): void;
+    /**
+     * Get recent event history
+     */
+    getHistory(type?: EventType, limit?: number): BusEvent[];
+    /**
+     * Clear all subscriptions
+     */
+    clear(): void;
+    /**
+     * Get subscription count
+     */
+    getSubscriptionCount(): number;
+    /**
+     * Wait for a specific event (Promise-based)
+     */
+    waitFor(type: EventType, timeout?: number): Promise<BusEvent>;
+}

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

@@ -0,0 +1,19 @@
+/**
+ * Event Bus System
+ *
+ * Pub/Sub system for communication between sessions and agents
+ * Enables loose coupling and async event handling
+ */
+export type { EventType, EventProperties } from "./types.js";
+export type { BusEvent, EventHandler, Subscription, PublishOptions } from "./interfaces.js";
+export { EVENT_TYPES, TASK_EVENTS, TODO_EVENTS, SESSION_EVENTS, DOCUMENT_EVENTS, MISSION_EVENTS, SPECIAL_EVENTS, } from "../../shared/event-types.js";
+import { EventBusImpl } from "./event-bus.js";
+import type { EventType, EventProperties } from "./types.js";
+import type { EventHandler } from "./interfaces.js";
+export declare const EventBus: EventBusImpl;
+export declare function subscribe(type: EventType, handler: EventHandler): () => void;
+export declare function publish(type: EventType, properties?: EventProperties, options?: {
+    source?: string;
+    sessionId?: string;
+}): Promise<void>;
+export declare function emit(type: EventType, properties?: EventProperties): void;

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

@@ -0,0 +1,34 @@
+/**
+ * Event Bus Interfaces
+ */
+import type { EventType, EventProperties } from "./types.js";
+/**
+ * Event payload structure
+ */
+export interface BusEvent {
+    type: EventType;
+    timestamp: Date;
+    source: string;
+    sessionId?: string;
+    properties: EventProperties;
+}
+/**
+ * Event handler function signature
+ */
+export type EventHandler = (event: BusEvent) => void | Promise<void>;
+/**
+ * Internal subscription record
+ */
+export interface Subscription {
+    id: string;
+    type: EventType;
+    handler: EventHandler;
+    once: boolean;
+}
+/**
+ * Publish options
+ */
+export interface PublishOptions {
+    source?: string;
+    sessionId?: string;
+}

package/dist/core/bus/types.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Event Bus Types (Type Aliases Only)
+ */
+import type { EventTypeValue } from "../../shared/event-types.js";
+/**
+ * Event type - allows constants or custom strings
+ */
+export type EventType = EventTypeValue | (string & {});
+/**
+ * Properties payload for events
+ */
+export type EventProperties = Record<string, unknown>;

package/dist/core/cache/constants.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Document Cache Constants
+ */
+export declare const CACHE_DIR = ".cache/docs";
+export declare const METADATA_FILE = ".cache/docs/_metadata.json";
+export declare const DEFAULT_TTL_MS: number;

package/dist/core/cache/document-cache.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Document Cache Module
+ */
+export type { CachedDocument, CacheMetadata, CacheDocumentEntry, CacheListEntry, CacheStats, } from "./interfaces.js";
+export { CACHE_DIR, METADATA_FILE, DEFAULT_TTL_MS } from "./constants.js";
+export { get, getByFilename, set, remove, list, clear, cleanExpired, stats, } from "./operations.js";

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

@@ -0,0 +1,4 @@
+/**
+ * Cache Module Index
+ */
+export * as DocumentCache from "./document-cache.js";

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

@@ -0,0 +1,53 @@
+/**
+ * Document Cache Interfaces
+ */
+/**
+ * Cached document structure
+ */
+export interface CachedDocument {
+    url: string;
+    title: string;
+    content: string;
+    fetchedAt: string;
+    expiresAt: string;
+    size: number;
+}
+/**
+ * Cache metadata structure
+ */
+export interface CacheMetadata {
+    documents: Record<string, CacheDocumentEntry>;
+    lastUpdated: string;
+}
+/**
+ * Individual document entry in metadata
+ */
+export interface CacheDocumentEntry {
+    url: string;
+    title: string;
+    fetchedAt: string;
+    expiresAt: string;
+    size: number;
+}
+/**
+ * Document listing entry
+ */
+export interface CacheListEntry {
+    filename: string;
+    url: string;
+    title: string;
+    fetchedAt: string;
+    expiresAt: string;
+    size: number;
+    expired: boolean;
+}
+/**
+ * Cache statistics
+ */
+export interface CacheStats {
+    totalDocuments: number;
+    totalSize: number;
+    expiredCount: number;
+    oldestDocument: string | null;
+    newestDocument: string | null;
+}

package/dist/core/cache/operations.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Document Cache Operations
+ */
+import type { CachedDocument, CacheListEntry, CacheStats } from "./interfaces.js";
+/**
+ * Get cached document by URL
+ */
+export declare function get(url: string): Promise<CachedDocument | null>;
+/**
+ * Get cached document by filename
+ */
+export declare function getByFilename(filename: string): Promise<CachedDocument | null>;
+/**
+ * Cache a document
+ */
+export declare function set(url: string, content: string, title: string, ttlMs?: number): Promise<string>;
+/**
+ * Remove cached document
+ */
+export declare function remove(url: string): Promise<boolean>;
+/**
+ * List all cached documents
+ */
+export declare function list(): Promise<CacheListEntry[]>;
+/**
+ * Clear all cached documents
+ */
+export declare function clear(): Promise<number>;
+/**
+ * Clean expired documents
+ */
+export declare function cleanExpired(): Promise<number>;
+/**
+ * Get cache statistics
+ */
+export declare function stats(): Promise<CacheStats>;

package/dist/core/cache/utils.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Document Cache Utilities
+ */
+import type { CacheMetadata } from "./interfaces.js";
+/**
+ * Ensure cache directory exists
+ */
+export declare function ensureCacheDir(): Promise<void>;
+/**
+ * Generate safe filename from URL
+ */
+export declare function urlToFilename(url: string): string;
+/**
+ * Read cache metadata
+ */
+export declare function readMetadata(): Promise<CacheMetadata>;
+/**
+ * Write cache metadata
+ */
+export declare function writeMetadata(metadata: CacheMetadata): Promise<void>;

package/dist/core/loop/formatters.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Todo Formatters - Format output strings
+ */
+import type { Todo } from "./interfaces.js";
+/**
+ * Format progress string
+ */
+export declare function formatProgress(todos: Todo[]): string;
+/**
+ * Generate continuation prompt when todos remain
+ */
+export declare function generateContinuationPrompt(todos: Todo[]): string;
+/**
+ * Generate completion message
+ */
+export declare function generateCompletionMessage(todos: Todo[]): string;