opencode-orchestrator 1.2.34 → 1.2.35

package/dist/core/recovery/retry.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Session Retry Utilities
+ *
+ * Provides sophisticated retry logic for API errors including:
+ * - retry-after header parsing
+ * - Exponential backoff
+ * - Retryable error detection
+ *
+ * Inspired by OpenCode's SessionRetry system.
+ */
+/** Initial delay for retries (ms) */
+export declare const RETRY_INITIAL_DELAY = 2000;
+/** Backoff multiplier */
+export declare const RETRY_BACKOFF_FACTOR = 2;
+/** Max delay when no headers (30 seconds) */
+export declare const RETRY_MAX_DELAY_NO_HEADERS = 30000;
+/** Absolute max delay for setTimeout (max 32-bit signed int) */
+export declare const RETRY_MAX_DELAY = 2147483647;
+/** Max retry attempts */
+export declare const MAX_RETRY_ATTEMPTS = 5;
+export interface APIErrorData {
+    isRetryable?: boolean;
+    message?: string;
+    responseHeaders?: Record<string, string>;
+    status?: number;
+}
+export interface RetryConfig {
+    maxAttempts?: number;
+    initialDelay?: number;
+    maxDelay?: number;
+    backoffFactor?: number;
+}
+/**
+ * Sleep with abort signal support
+ */
+export declare function sleep(ms: number, signal?: AbortSignal): Promise<void>;
+/**
+ * Calculate retry delay from attempt number and optional error data
+ *
+ * Priority:
+ * 1. retry-after-ms header
+ * 2. retry-after header (seconds or HTTP date)
+ * 3. Exponential backoff
+ */
+export declare function calculateDelay(attempt: number, errorData?: APIErrorData): number;
+/**
+ * Check if an error is retryable
+ *
+ * Returns a human-readable reason if retryable, undefined otherwise.
+ */
+export declare function isRetryable(error: unknown): string | undefined;
+/**
+ * Retry an async operation with exponential backoff
+ */
+export declare function withRetry<T>(operation: () => Promise<T>, config?: RetryConfig, signal?: AbortSignal): Promise<T>;
+/**
+ * Format delay for human readability
+ */
+export declare function formatDelay(ms: number): string;

package/dist/core/recovery/session-recovery.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Session Recovery Event Handler
+ *
+ * Integrates with the OpenCode event system to automatically recover from session errors.
+ *
+ * Supported error types:
+ * - tool_result_missing: Tool crashed, inject error message
+ * - thinking_block_order: Thinking block ordering issue
+ * - rate_limit: API rate limiting
+ * - context_overflow: Token limit exceeded
+ */
+import type { PluginInput } from "@opencode-ai/plugin";
+type OpencodeClient = PluginInput["client"];
+/**
+ * Handle session error event and attempt recovery
+ */
+export declare function handleSessionError(client: OpencodeClient, sessionID: string, error: unknown, properties?: Record<string, unknown>): Promise<boolean>;
+/**
+ * Mark that recovery is complete for a session
+ */
+export declare function markRecoveryComplete(sessionID: string): void;
+/**
+ * Clean up session recovery state
+ */
+export declare function cleanupSessionRecovery(sessionID: string): void;
+/**
+ * Check if session is currently recovering
+ */
+export declare function isSessionRecovering(sessionID: string): boolean;
+export {};

package/dist/core/session/interfaces/context-stats.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Context Stats Interface
+ */
+export interface ContextStats {
+    totalContexts: number;
+    totalDocuments: number;
+    totalFindings: number;
+    totalDecisions: number;
+}

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

@@ -0,0 +1,8 @@
+/**
+ * Session Interfaces - Index
+ */
+export type { SharedDocument } from "./shared-document.js";
+export type { SharedFinding } from "./shared-finding.js";
+export type { SharedDecision } from "./shared-decision.js";
+export type { SharedContext } from "./shared-context.js";
+export type { ContextStats } from "./context-stats.js";

package/dist/core/session/interfaces/shared-context.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Shared Context Interface
+ */
+import type { SharedDocument } from "./shared-document.js";
+import type { SharedFinding } from "./shared-finding.js";
+import type { SharedDecision } from "./shared-decision.js";
+export interface SharedContext {
+    sessionId: string;
+    parentId?: string;
+    documents: Map<string, SharedDocument>;
+    findings: SharedFinding[];
+    decisions: Map<string, SharedDecision>;
+    createdAt: Date;
+    updatedAt: Date;
+}

package/dist/core/session/interfaces/shared-decision.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Shared Decision Interface
+ */
+export interface SharedDecision {
+    id: string;
+    question: string;
+    answer: string;
+    rationale: string;
+    decidedAt: Date;
+}

package/dist/core/session/interfaces/shared-document.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Shared Document Interface
+ */
+export interface SharedDocument {
+    url: string;
+    filename: string;
+    title: string;
+    cachedAt: Date;
+}

package/dist/core/session/interfaces/shared-finding.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Shared Finding Interface
+ */
+export interface SharedFinding {
+    id: string;
+    content: string;
+    source: string;
+    timestamp: Date;
+    category: "pattern" | "api" | "config" | "warning" | "decision";
+}

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

@@ -0,0 +1,6 @@
+/**
+ * Shared Context Interfaces
+ *
+ * Re-exports for backward compatibility.
+ */
+export * from "./interfaces/index.js";

package/dist/core/session/shared-context.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Session Shared Context
+ *
+ * Enables context sharing between parent and child sessions
+ */
+export type { SharedDocument, SharedFinding, SharedDecision, SharedContext, ContextStats, } from "./interfaces.js";
+export { create, get, getMerged, addDocument, addFinding, addDecision, getChildren, clear, clearAll, getStats, } from "./store.js";
+export { getSummary } from "./summary.js";

package/dist/core/session/store.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Context Store - Session context data management
+ */
+import type { SharedContext, SharedDocument, SharedFinding, SharedDecision, ContextStats } from "./interfaces.js";
+/**
+ * Create a new shared context for a session
+ */
+export declare function create(sessionId: string, parentId?: string): SharedContext;
+/**
+ * Get shared context for a session
+ */
+export declare function get(sessionId: string): SharedContext | undefined;
+/**
+ * Get merged context (includes parent context)
+ */
+export declare function getMerged(sessionId: string): SharedContext | undefined;
+/**
+ * Add a document to the shared context
+ */
+export declare function addDocument(sessionId: string, doc: SharedDocument): void;
+/**
+ * Add a finding to the shared context
+ */
+export declare function addFinding(sessionId: string, finding: Omit<SharedFinding, "id" | "timestamp">): void;
+/**
+ * Record a decision
+ */
+export declare function addDecision(sessionId: string, decision: Omit<SharedDecision, "id" | "decidedAt">): void;
+/**
+ * Get all child session IDs
+ */
+export declare function getChildren(parentId: string): string[];
+/**
+ * Clear context for a session
+ */
+export declare function clear(sessionId: string): void;
+/**
+ * Clear all contexts
+ */
+export declare function clearAll(): void;
+/**
+ * Get stats
+ */
+export declare function getStats(): ContextStats;

package/dist/core/session/summary.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Context Summary - Generate prompt summaries
+ */
+/**
+ * Get context summary for injection into prompts
+ */
+export declare function getSummary(sessionId: string): string;

package/dist/core/sync/todo-parser.d.ts

@@ -0,0 +1,5 @@
+import { type Todo } from "../../shared/index.js";
+/**
+ * Parses markdown content into Todo objects
+ */
+export declare function parseTodoMd(content: string): Todo[];

package/dist/core/sync/todo-sync-service.d.ts

@@ -0,0 +1,35 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+type OpencodeClient = PluginInput["client"];
+interface TrackedTaskTodo {
+    id: string;
+    description: string;
+    status: string;
+    agent: string;
+    isBackground: boolean;
+    parentSessionID?: string;
+}
+export declare class TodoSyncService {
+    private client;
+    private directory;
+    private todoPath;
+    private fileTodos;
+    private taskTodos;
+    private updateTimeout;
+    private watcher;
+    private activeSessions;
+    constructor(client: OpencodeClient, directory: string);
+    start(): Promise<void>;
+    registerSession(sessionID: string): void;
+    unregisterSession(sessionID: string): void;
+    private reloadFileTodos;
+    /**
+     * Called by TaskToastManager when tasks change
+     */
+    updateTaskStatus(task: TrackedTaskTodo): void;
+    removeTask(taskId: string): void;
+    private broadcastUpdate;
+    private scheduleUpdate;
+    private sendTodosToSession;
+    stop(): void;
+}
+export {};

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

@@ -0,0 +1,8 @@
+/**
+ * Task Interfaces - Index
+ */
+export type { TaskNode, TaskStatus } from "./task-node.js";
+export type { TaskHierarchy } from "./task-hierarchy.js";
+export type { TaskProgress } from "./task-progress.js";
+export type { TaskInput } from "./task-input.js";
+export { TASK_STATUS } from "../../../shared/index.js";

package/dist/core/task/interfaces/task-hierarchy.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Task Hierarchy Interface
+ */
+import type { TaskNode } from "./task-node.js";
+export interface TaskHierarchy {
+    rootId: string;
+    nodes: Map<string, TaskNode>;
+    parallelGroups: Map<string, string[]>;
+}

package/dist/core/task/interfaces/task-input.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Task Input Interface
+ */
+export interface TaskInput {
+    description: string;
+    level: number;
+    parentId?: string;
+    agent?: string;
+    parallelGroup?: string;
+    dependsOn?: string[];
+}

package/dist/core/task/interfaces/task-node.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Task Node Interface
+ */
+import type { ParallelTaskStatus } from "../../../shared/task/types/index.js";
+export type TaskStatus = ParallelTaskStatus;
+export interface TaskNode {
+    id: string;
+    description: string;
+    level: number;
+    parent?: string;
+    children: string[];
+    status: TaskStatus;
+    agent?: string;
+    parallelGroup?: string;
+    dependsOn: string[];
+    createdAt: Date;
+    startedAt?: Date;
+    completedAt?: Date;
+    result?: string;
+}

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

@@ -0,0 +1,11 @@
+/**
+ * Task Progress Interface
+ */
+export interface TaskProgress {
+    total: number;
+    pending: number;
+    running: number;
+    completed: number;
+    failed: number;
+    percentage: number;
+}

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

@@ -0,0 +1,6 @@
+/**
+ * Task Decomposer Interfaces
+ *
+ * Re-exports for backward compatibility.
+ */
+export * from "./interfaces/index.js";

package/dist/core/task/parser.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Task Parser - Parse hierarchy from Planner output
+ */
+import type { TaskHierarchy } from "./interfaces.js";
+/**
+ * Parse task hierarchy from text (Planner output)
+ */
+export declare function parseFromText(sessionId: string, text: string): TaskHierarchy;

package/dist/core/task/scheduler.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Task Scheduler - Execution order and dependencies
+ */
+import type { TaskNode } from "./interfaces.js";
+/**
+ * Get next executable tasks (respecting dependencies)
+ */
+export declare function getNextTasks(sessionId: string): TaskNode[];
+/**
+ * Get parallel group tasks that can run together
+ */
+export declare function getParallelBatch(sessionId: string, groupId: string): TaskNode[];

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

@@ -0,0 +1,32 @@
+/**
+ * Task Store - Hierarchy data management
+ */
+import type { TaskNode, TaskHierarchy, TaskInput, TaskStatus, TaskProgress } from "./interfaces.js";
+/**
+ * Create a new task hierarchy
+ */
+export declare function create(sessionId: string, rootDescription: string): TaskHierarchy;
+/**
+ * Get hierarchy for session
+ */
+export declare function getHierarchy(sessionId: string): TaskHierarchy | undefined;
+/**
+ * Add a task node
+ */
+export declare function addTask(sessionId: string, task: TaskInput): TaskNode;
+/**
+ * Update task status
+ */
+export declare function updateStatus(sessionId: string, taskId: string, status: TaskStatus, result?: string): void;
+/**
+ * Clear hierarchy
+ */
+export declare function clear(sessionId: string): void;
+/**
+ * Check if all tasks are complete
+ */
+export declare function isComplete(sessionId: string): boolean;
+/**
+ * Get progress statistics
+ */
+export declare function getProgress(sessionId: string): TaskProgress;

package/dist/core/task/summary.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Task Summary - Generate prompt summaries
+ */
+/**
+ * Get hierarchy summary for prompts
+ */
+export declare function getSummary(sessionId: string): string;

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

@@ -0,0 +1,10 @@
+/**
+ * Task Decomposer
+ *
+ * Automatically decomposes complex tasks into hierarchical subtasks
+ */
+export type { TaskStatus, TaskNode, TaskHierarchy, TaskProgress, TaskInput, } from "./interfaces.js";
+export { create, getHierarchy, addTask, updateStatus, clear, isComplete, getProgress, } from "./store.js";
+export { getNextTasks, getParallelBatch, } from "./scheduler.js";
+export { parseFromText } from "./parser.js";
+export { getSummary } from "./summary.js";

package/dist/core/todo/todo-manager.d.ts

@@ -0,0 +1,36 @@
+/**
+ * TodoManager - MVCC-based Optimistic Locking with Mutex for TODO Synchronization
+ */
+export interface TodoVersion {
+    version: number;
+    timestamp: number;
+    author: string;
+}
+export interface TodoData {
+    content: string;
+    version: TodoVersion;
+}
+export declare class TodoManager {
+    private static _instance;
+    private directory;
+    private todoPath;
+    private versionPath;
+    private historyPath;
+    private updateMutex;
+    private constructor();
+    static getInstance(directory?: string): TodoManager;
+    setDirectory(dir: string): void;
+    readWithVersion(): Promise<TodoData>;
+    /**
+     * Update TODO with both MVCC (for logical consistency) and Mutex (for atomicity)
+     */
+    update(expectedVersion: number, updater: (content: string) => string, author: string): Promise<{
+        success: boolean;
+        currentVersion: number;
+        conflict?: boolean;
+    }>;
+    private _internalUpdate;
+    updateItem(searchText: string, newStatus: string, author?: string): Promise<boolean>;
+    addSubTask(parentText: string, subTaskText: string, author?: string): Promise<boolean>;
+    private logChange;
+}

package/dist/hooks/compatibility/external-plugin.d.ts

@@ -0,0 +1,10 @@
+/**
+ * External Plugin Compatibility Hook
+ *
+ * Detects if other major plugins are present and ensures orchestrator plays nicely.
+ */
+import type { ChatMessageHook, AssistantDoneHook, HookContext } from "../types.js";
+export declare class ExternalPluginCompatHook implements ChatMessageHook, AssistantDoneHook {
+    name: string;
+    execute(ctx: HookContext, input: any): Promise<any>;
+}

package/dist/hooks/constants.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Hook Constants
+ * Defines strict constant values for hook actions and statuses.
+ */
+export declare const HOOK_ACTIONS: {
+    readonly CONTINUE: "continue";
+    readonly STOP: "stop";
+    readonly ALLOW: "allow";
+    readonly BLOCK: "block";
+    readonly MODIFY: "modify";
+    readonly INJECT: "inject";
+    readonly PROCESS: "process";
+    readonly INTERCEPT: "intercept";
+};
+export declare const HOOK_NAMES: {
+    readonly MEMORY_GATE: "MemoryGate";
+    readonly METRICS_TELEMETRY: "MetricsTelemetry";
+    readonly SANITY_CHECK: "SanityCheck";
+    readonly MISSION_LOOP: "MissionLoop";
+    readonly MISSION_CONTROL: "MissionControl";
+    readonly STRICT_ROLE_GUARD: "StrictRoleGuard";
+    readonly SECRET_SCANNER: "SecretScanner";
+    readonly AGENT_UI: "AgentUI";
+    readonly RESOURCE_CONTROL: "ResourceControl";
+    readonly USER_ACTIVITY: "UserActivity";
+    readonly SLASH_COMMAND: "SlashCommandDispatcher";
+};

package/dist/hooks/custom/agent-ui.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Agent UI Hook
+ *
+ * Decorates tool outputs with UI elements:
+ * - Agent headers (e.g. [P] PLANNER Working...)
+ * - Task ID tracking
+ */
+import type { PostToolUseHook, HookContext } from "../types.js";
+export declare class AgentUIHook implements PostToolUseHook {
+    name: "AgentUI";
+    execute(ctx: HookContext, tool: string, input: any, output: {
+        title: string;
+        output: string;
+        metadata: any;
+    }): Promise<{
+        output?: undefined;
+    } | {
+        output: string;
+    }>;
+}

package/dist/hooks/custom/memory-gate.d.ts

@@ -0,0 +1,21 @@
+/**
+ * MemoryGate Hook - Intercepts tool usage and turn completion to maintain memory.
+ */
+import { PostToolUseHook, AssistantDoneHook, HookContext } from "../types.js";
+export declare class MemoryGateHook implements PostToolUseHook, AssistantDoneHook {
+    name: "MemoryGate";
+    private memoryManager;
+    execute(context: HookContext, toolOrText: string, input?: any, output?: {
+        title: string;
+        output: string;
+        metadata: any;
+    }): Promise<any>;
+    /**
+     * Post-Tool: Capture tool outputs to TASK memory
+     */
+    private handlePostTool;
+    /**
+     * Assistant Done: Capture turn summary to MISSION memory if important
+     */
+    private handleAssistantDone;
+}

package/dist/hooks/custom/metrics.d.ts

@@ -0,0 +1,14 @@
+/**
+ * MetricsHook - Collects telemetry during mission execution
+ */
+import { PreToolUseHook, PostToolUseHook, AssistantDoneHook, HookContext } from "../types.js";
+export declare class MetricsHook implements PreToolUseHook, PostToolUseHook, AssistantDoneHook {
+    name: "MetricsTelemetry";
+    private startTimes;
+    private metrics;
+    execute(context: HookContext, toolOrText: string, input?: any, output?: {
+        title: string;
+        output: string;
+        metadata: any;
+    }): Promise<any>;
+}

package/dist/hooks/custom/resource-control.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Resource Control Hook
+ *
+ * Unifies resource tracking, monitoring, and active memory compaction.
+ * Replaces separate ResourceUsageHook and MemoryCompactionHook.
+ */
+import type { PostToolUseHook, AssistantDoneHook, HookContext } from "../types.js";
+export declare class ResourceControlHook implements PostToolUseHook, AssistantDoneHook {
+    name: "ResourceControl";
+    private lastCompactionTime;
+    execute(ctx: HookContext, toolOrText: string, input?: any, output?: any): Promise<any>;
+    private checkMemoryHealth;
+}

package/dist/hooks/custom/secret-scanner.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Secret Scanner Hook
+ *
+ * Scans tool outputs for potential secrets (API Keys, etc) and masks them.
+ * This prevents leaking secrets into the context window or logs.
+ */
+import type { PostToolUseHook, HookContext } from "../types.js";
+export declare class SecretScannerHook implements PostToolUseHook {
+    name: "SecretScanner";
+    execute(ctx: HookContext, tool: string, input: any, output: {
+        title: string;
+        output: string;
+        metadata: any;
+    }): Promise<{
+        output: string;
+    } | {
+        output?: undefined;
+    }>;
+}

package/dist/hooks/custom/strict-role-guard.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Strict Role Guard Hook
+ *
+ * Enforces role-based access control (RBAC) for agents.
+ * - Planner: Cannot write code or run commands.
+ * - Reviewer: Cannot write code (only review).
+ */
+import type { PreToolUseHook, HookContext } from "../types.js";
+export declare class StrictRoleGuardHook implements PreToolUseHook {
+    name: "StrictRoleGuard";
+    execute(ctx: HookContext, tool: string, args: any): Promise<{
+        action: "block";
+        reason: "Fork bomb detected.";
+    } | {
+        action: "block";
+        reason: "Root deletion blocked.";
+    } | {
+        action: "allow";
+        reason?: undefined;
+    }>;
+}

package/dist/hooks/custom/user-activity.d.ts

@@ -0,0 +1,11 @@
+/**
+ * User Activity Hook
+ *
+ * Tracks user interaction (chat messages) to pause auto-continuation/loops
+ * and update activity timestamps.
+ */
+import type { ChatMessageHook, HookContext } from "../types.js";
+export declare class UserActivityHook implements ChatMessageHook {
+    name: "UserActivity";
+    execute(ctx: HookContext, message: string): Promise<any>;
+}

package/dist/hooks/features/mission-loop.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Mission Loop Hook
+ *
+ * Handles:
+ * - Persistent execution until all TODOs are verified
+ * - Auto-continuation injection (Loop)
+ * - User cancellation detection
+ */
+import type { AssistantDoneHook, ChatMessageHook, HookContext } from "../types.js";
+export declare class MissionControlHook implements AssistantDoneHook, ChatMessageHook {
+    name: "MissionLoop";
+    execute(ctx: HookContext, text: string): Promise<any>;
+    private handleChatCommand;
+    private handleMissionProgress;
+    private buildContinuationResponse;
+    private handleMissionComplete;
+    private sendCompletionNotification;
+}