opencode-orchestrator 1.2.34 → 1.2.36

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

@@ -0,0 +1,11 @@
+export declare class CleanupScheduler {
+    private intervals;
+    private directory;
+    constructor(directory: string);
+    start(): void;
+    private schedule;
+    stop(): void;
+    compactWAL(): Promise<void>;
+    cleanDocs(): Promise<void>;
+    rotateHistory(): Promise<void>;
+}

package/dist/core/context/context-window-monitor.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Context Window Monitor
+ *
+ * Monitors context window usage and alerts when thresholds are exceeded.
+ *
+ * Thresholds:
+ * - 70%: Info alert - "Still plenty of headroom"
+ * - 85%: Warning - Consider compaction
+ * - 95%: Critical - Immediate action needed
+ */
+export declare const CONTEXT_THRESHOLDS: {
+    /** Info level - remind agent there's still room */
+    readonly INFO: 0.7;
+    /** Warning level - consider compaction soon */
+    readonly WARNING: 0.85;
+    /** Critical level - immediate action needed */
+    readonly CRITICAL: 0.95;
+};
+export declare const CONTEXT_MONITOR_CONFIG: {
+    /** Default max tokens for most models */
+    readonly DEFAULT_MAX_TOKENS: 200000;
+    /** Check interval in milliseconds */
+    readonly CHECK_INTERVAL_MS: 30000;
+    /** Minimum time between alerts (ms) */
+    readonly ALERT_COOLDOWN_MS: 60000;
+};
+export interface MonitorState {
+    lastAlertTime: number;
+    lastAlertLevel: "info" | "warning" | "critical" | null;
+    isMonitoring: boolean;
+    intervalId?: ReturnType<typeof setInterval>;
+}
+export declare function getMonitorState(sessionID: string): MonitorState;
+/**
+ * Calculate context usage percentage
+ */
+export declare function calculateUsage(usedTokens: number, maxTokens: number): number;
+/**
+ * Get alert level based on usage
+ */
+export declare function getAlertLevel(usage: number): "info" | "warning" | "critical" | null;
+/**
+ * Format usage for display
+ */
+export declare function formatUsage(usage: number, usedTokens: number, maxTokens: number): string;
+/**
+ * Check context window usage and alert if needed
+ */
+export declare function checkContextWindow(sessionID: string, usedTokens: number, maxTokens?: number): void;
+/**
+ * Get injection prompt for context-aware agents
+ * This reminds agents about context status when usage is high
+ */
+export declare function getContextInjection(usedTokens: number, maxTokens?: number): string | null;
+/**
+ * Cleanup session state
+ */
+export declare function cleanupSession(sessionID: string): void;
+/**
+ * Get current monitor status for debugging
+ */
+export declare function getMonitorStatus(sessionID: string): {
+    lastAlertTime: number;
+    lastAlertLevel: string | null;
+    isMonitoring: boolean;
+} | null;

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

@@ -0,0 +1,6 @@
+/**
+ * Context Module
+ *
+ * Context window monitoring and management utilities.
+ */
+export { checkContextWindow, getContextInjection, cleanupSession, getMonitorStatus, calculateUsage, getAlertLevel, formatUsage, CONTEXT_THRESHOLDS, CONTEXT_MONITOR_CONFIG, } from "./context-window-monitor.js";

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

@@ -0,0 +1,17 @@
+/**
+ * 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
+ * Enforces parallel dispatch when multiple independent tasks exist
+ */
+export declare function generateContinuationPrompt(todos: Todo[]): string;
+/**
+ * Generate completion message
+ */
+export declare function generateCompletionMessage(todos: Todo[]): string;

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

@@ -0,0 +1,5 @@
+/**
+ * Loop Interfaces - Index
+ */
+export type { Todo } from "./todo.js";
+export type { TodoStats } from "./todo-stats.js";

package/dist/core/loop/interfaces/todo-stats.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Todo Stats Interface
+ */
+export interface TodoStats {
+    total: number;
+    pending: number;
+    inProgress: number;
+    completed: number;
+    cancelled: number;
+    percentComplete: number;
+}

package/dist/core/loop/interfaces/todo.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Todo Interface
+ */
+import type { TodoStatus, TodoPriority } from "../types/index.js";
+export interface Todo {
+    id: string;
+    content: string;
+    status: TodoStatus;
+    priority: TodoPriority;
+    parentId?: string;
+    createdAt: Date;
+    completedAt?: Date;
+}

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

@@ -0,0 +1,7 @@
+/**
+ * Loop Interfaces
+ *
+ * Re-exports for backward compatibility.
+ */
+export type { TodoStatus, TodoPriority } from "./types/index.js";
+export type { Todo, TodoStats } from "./interfaces/index.js";

package/dist/core/loop/mission-loop-handler.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Mission Loop Handler
+ *
+ * Monitors session events and ensures the mission loop continues
+ * until all verification requirements are met.
+ */
+import type { PluginInput } from "@opencode-ai/plugin";
+type OpencodeClient = PluginInput["client"];
+/**
+ * Handle session.idle event for mission loop
+ */
+export declare function handleMissionIdle(client: OpencodeClient, directory: string, sessionID: string, mainSessionID?: string): Promise<void>;
+/**
+ * Handle user message - cancel countdown
+ */
+export declare function handleUserMessage(sessionID: string): void;
+/**
+ * Handle abort
+ */
+export declare function handleAbort(sessionID: string): void;
+/**
+ * Clean up session state
+ */
+export declare function cleanupSession(sessionID: string): void;
+export {};

package/dist/core/loop/mission-loop.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Mission Loop - Persistent Execution System
+ *
+ * Ensures the mission continues until all TODO items are complete.
+ * This system moves away from explicit signaling (seals) and relies
+ * strictly on file-based state verification.
+ */
+import type { MissionLoopState, MissionLoopOptions } from "../../shared/loop/interfaces/mission-loop.js";
+/**
+ * Read loop state from disk
+ */
+export declare function readLoopState(directory: string): MissionLoopState | null;
+/**
+ * Write loop state to disk
+ */
+export declare function writeLoopState(directory: string, state: MissionLoopState): boolean;
+/**
+ * Clear loop state (delete file)
+ */
+export declare function clearLoopState(directory: string): boolean;
+/**
+ * Increment iteration counter
+ */
+export declare function incrementIteration(directory: string): MissionLoopState | null;
+/**
+ * Start a mission loop
+ */
+export declare function startMissionLoop(directory: string, sessionID: string, prompt: string, options?: MissionLoopOptions): boolean;
+/**
+ * Cancel an active mission loop
+ */
+export declare function cancelMissionLoop(directory: string, sessionID: string): boolean;
+/**
+ * Check if loop is active for session
+ */
+export declare function isLoopActive(directory: string, sessionID: string): boolean;
+/**
+ * Generate continuation prompt for mission loop
+ */
+export declare function generateMissionContinuationPrompt(state: MissionLoopState, verificationSummary?: string): string;
+/**
+ * Generate completion notification
+ */
+export declare function generateCompletionNotification(state: MissionLoopState): string;
+/**
+ * Generate max iterations reached notification
+ */
+export declare function generateMaxIterationsNotification(state: MissionLoopState): string;

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

@@ -0,0 +1,8 @@
+/**
+ * Todo Parser - Parse todo data from session
+ */
+import type { Todo } from "./interfaces.js";
+/**
+ * Parse todos from session todo list
+ */
+export declare function parseTodos(todoData: unknown): Todo[];

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

@@ -0,0 +1,24 @@
+/**
+ * Todo Stats - Statistics and queries
+ */
+import type { Todo, TodoStats } from "./interfaces.js";
+/**
+ * Get count of incomplete todos
+ */
+export declare function getIncompleteCount(todos: Todo[]): number;
+/**
+ * Check if there's remaining work
+ */
+export declare function hasRemainingWork(todos: Todo[]): boolean;
+/**
+ * Get next pending todo (highest priority first)
+ */
+export declare function getNextPending(todos: Todo[]): Todo | undefined;
+/**
+ * Calculate todo statistics
+ */
+export declare function getStats(todos: Todo[]): TodoStats;
+/**
+ * Check if mission is complete based on todos
+ */
+export declare function isMissionComplete(todos: Todo[]): boolean;

package/dist/core/loop/todo-continuation.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Todo Continuation Handler
+ *
+ * Monitors session.idle events and automatically continues execution
+ * if there are incomplete todos remaining.
+ *
+ * Features:
+ * - Countdown toast before resuming (gives user chance to cancel)
+ * - Skips if background tasks are running
+ * - Respects abort/cancel from user
+ */
+import type { PluginInput } from "@opencode-ai/plugin";
+type OpencodeClient = PluginInput["client"];
+/**
+ * Handle session.idle event - start countdown if todos remain
+ */
+export declare function handleSessionIdle(client: OpencodeClient, directory: string, sessionID: string, mainSessionID?: string): Promise<void>;
+/**
+ * Handle user message - cancel countdown (user is interacting)
+ * Uses grace period to avoid cancelling countdown from our own injected messages
+ */
+export declare function handleUserMessage(sessionID: string): void;
+/**
+ * Handle session error - detect abort/cancel
+ */
+export declare function handleSessionError(sessionID: string, error: unknown): void;
+/**
+ * Handle abort/cancel - prevent automatic continuation
+ */
+export declare function handleAbort(sessionID: string): void;
+/**
+ * Clean up session state
+ */
+export declare function cleanupSession(sessionID: string): void;
+/**
+ * Check if there's a pending continuation countdown
+ */
+export declare function hasPendingContinuation(sessionID: string): boolean;
+export {};

package/dist/core/loop/todo-enforcer.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Todo Enforcer
+ *
+ * Ensures all todos are completed before stopping
+ */
+export type { Todo, TodoStats, TodoStatus, TodoPriority } from "./interfaces.js";
+export { parseTodos } from "./parser.js";
+export { getIncompleteCount, hasRemainingWork, getNextPending, getStats, isMissionComplete, } from "./stats.js";
+export { formatProgress, generateContinuationPrompt, generateCompletionMessage, } from "./formatters.js";

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

@@ -0,0 +1,22 @@
+/**
+ * TodoManager - Legacy Wrapper for the new MVCC-based TodoManager
+ */
+/**
+ * @deprecated Use src/core/todo/todo-manager.js instead.
+ * This class is maintained for partial backward compatibility.
+ */
+export declare class TodoManager {
+    private static instance;
+    private newManager;
+    private constructor();
+    static getInstance(): TodoManager;
+    setDirectory(dir: string): void;
+    /**
+     * Update a specific TODO item by its text content
+     */
+    updateItem(searchText: string, newStatus: string): Promise<boolean>;
+    /**
+     * Add a new sub-task under a parent task
+     */
+    addSubTask(parentText: string, subTaskText: string): Promise<boolean>;
+}

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

@@ -0,0 +1,5 @@
+/**
+ * Loop Types - Index
+ */
+export type { TodoStatus } from "./todo-status.js";
+export type { TodoPriority } from "./todo-priority.js";

package/dist/core/loop/types/todo-priority.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Todo Priority Type
+ */
+export type TodoPriority = "high" | "medium" | "low";

package/dist/core/loop/types/todo-status.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Todo Status Type
+ */
+export type TodoStatus = "pending" | "in_progress" | "completed" | "cancelled";

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

@@ -0,0 +1,22 @@
+/**
+ * Verification Checklist Module
+ *
+ * Provides a structured checklist system for mission completion verification.
+ *
+ * The LLM creates and checks items in .opencode/mission/verification-checklist.md
+ * The hook system verifies all items are checked before allowing CONCLUDE.
+ */
+import { type ChecklistCategory, type ChecklistItem, type ChecklistVerificationResult, type VerificationResult } from "../../shared/index.js";
+export type { ChecklistItem, ChecklistCategory, ChecklistVerificationResult, VerificationResult };
+export declare const CHECKLIST_FILE: ".opencode/mission/verification-checklist.md";
+export declare function parseChecklist(content: string): ChecklistItem[];
+export declare function readChecklist(directory: string): ChecklistItem[];
+export declare function verifyChecklist(directory: string): ChecklistVerificationResult;
+export declare function hasValidChecklist(directory: string): boolean;
+export declare function getChecklistSummary(directory: string): string;
+export declare function buildChecklistFailurePrompt(result: ChecklistVerificationResult): string;
+export declare function getChecklistCreationInstructions(): string;
+export declare function verifyMissionCompletion(directory: string): VerificationResult;
+export declare function buildVerificationFailurePrompt(result: VerificationResult): string;
+export declare function buildTodoIncompletePrompt(result: VerificationResult): string;
+export declare function buildVerificationSummary(result: VerificationResult): string;

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

@@ -0,0 +1,33 @@
+/**
+ * Hierarchical Memory System Interfaces
+ */
+export declare enum MemoryLevel {
+    /** Core rules, identity, and system instructions (Highest permanence) */
+    SYSTEM = "system",
+    /** Project architecture, tech stack, and long-term findings (High permanence) */
+    PROJECT = "project",
+    /** Mission goals, TODO progress, and mid-term decisions (Medium permanence) */
+    MISSION = "mission",
+    /** Current task details, short-term findings, and tool outputs (Low permanence) */
+    TASK = "task"
+}
+export interface MemoryEntry {
+    id: string;
+    level: MemoryLevel;
+    content: string;
+    timestamp: number;
+    metadata?: Record<string, any>;
+    importance: number;
+}
+export interface MemorySnapshot {
+    [MemoryLevel.SYSTEM]: MemoryEntry[];
+    [MemoryLevel.PROJECT]: MemoryEntry[];
+    [MemoryLevel.MISSION]: MemoryEntry[];
+    [MemoryLevel.TASK]: MemoryEntry[];
+}
+export interface MemoryConfig {
+    /** Token budget per level (approximate or percentage) */
+    tokenBudgets: Record<MemoryLevel, number>;
+    /** Enable dynamic relevance filtering */
+    enableRelevanceFiltering: boolean;
+}

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

@@ -0,0 +1,40 @@
+/**
+ * MemoryManager - Core component of the Hierarchical Memory System
+ */
+import { MemoryLevel, MemorySnapshot } from "./interfaces.js";
+export declare class MemoryManager {
+    private static instance;
+    private memories;
+    private storage;
+    private config;
+    private constructor();
+    static getInstance(): MemoryManager;
+    /**
+     * Add a memory entry
+     */
+    add(level: MemoryLevel, content: string, importance?: number, metadata?: Record<string, any>): string;
+    /**
+     * Retrieve memory for prompt construction
+     */
+    getContext(query?: string): string;
+    /**
+     * Simple keyword-based relevance check
+     */
+    private isRelevant;
+    /**
+     * Prune memory based on token budget (simplified)
+     */
+    prune(level: MemoryLevel): void;
+    /**
+     * Clear task memory (Short-term)
+     */
+    clearTaskMemory(): void;
+    /**
+     * Export full memory state (for persistence)
+     */
+    export(): MemorySnapshot;
+    /**
+     * Import memory state
+     */
+    import(snapshot: MemorySnapshot): void;
+}

package/dist/core/metrics/collector.d.ts

@@ -0,0 +1,27 @@
+/**
+ * MetricsCollector - Tracks system performance and token usage
+ */
+export interface PerformanceStats {
+    avgAgentLatency: Record<string, number>;
+    avgToolLatency: Record<string, number>;
+    tokenUsage: number;
+    efficiency: number;
+    totalTasks: number;
+    successRate: number;
+}
+export declare class MetricsCollector {
+    private static instance;
+    private agentLatencies;
+    private toolLatencies;
+    private tokenUsage;
+    private lineCount;
+    private tasks;
+    private constructor();
+    static getInstance(): MetricsCollector;
+    recordAgentExecution(agent: string, duration: number): void;
+    recordToolExecution(tool: string, duration: number): void;
+    recordTokenUsage(tokens: number): void;
+    recordTaskResult(id: string, success: boolean): void;
+    recordLinesProduced(lines: number): void;
+    getStats(): PerformanceStats;
+}

package/dist/core/notification/os-notify/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * OS Native Notification Module
+ */
+export * from "../../../shared/notification/os-notify/index.js";
+export { sendNotification } from "./notifier.js";
+export { playSound } from "./sound-player.js";
+export { detectPlatform, getDefaultSoundPath } from "./platform.js";

package/dist/core/notification/os-notify/notifier.d.ts

@@ -0,0 +1,7 @@
+/**
+ * OS Notification Sender
+ *
+ * Low-level logic for sending native notifications.
+ */
+import { type Platform } from "../../../shared/os/index.js";
+export declare function sendNotification(platform: Platform, title: string, message: string): Promise<void>;

package/dist/core/notification/os-notify/platform-resolver.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Platform Command Resolver
+ *
+ * Logic for discovering native command paths on the system.
+ */
+import { type NotificationCommandKey } from "../../../shared/notification/os-notify/index.js";
+export declare function resolveCommandPath(key: NotificationCommandKey, commandName: string): Promise<string | null>;

package/dist/core/notification/os-notify/platform.d.ts

@@ -0,0 +1,7 @@
+/**
+ * OS Platform Utils
+ */
+import { type Platform } from "../../../shared/os/index.js";
+export declare function detectPlatform(): Platform;
+export declare function getDefaultSoundPath(p: Platform): string;
+export declare function preloadPlatformCommands(platform: Platform): void;

package/dist/core/notification/os-notify/sound-player.d.ts

@@ -0,0 +1,7 @@
+/**
+ * OS Sound Player
+ *
+ * Low-level logic for playing sounds on different platforms.
+ */
+import { type Platform } from "../../../shared/os/index.js";
+export declare function playSound(platform: Platform, soundPath: string): Promise<void>;

package/dist/core/notification/os-notify/todo-checker.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Todo Status Checker
+ */
+import type { PluginInput } from "@opencode-ai/plugin";
+export declare function hasIncompleteTodos(client: PluginInput["client"], sessionID: string): Promise<boolean>;

package/dist/core/notification/task-toast-manager.d.ts

@@ -0,0 +1,127 @@
+/**
+ * Task Toast Manager
+ *
+ * Manages toast notifications for parallel/background tasks.
+ * Provides consolidated view of running and queued tasks.
+ *
+ * Features:
+ * - Real-time task status display
+ * - Concurrency info (e.g., "2/5 slots")
+ * - New task highlighting
+ * - Completion summaries
+ */
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { ConcurrencyController } from "../agents/concurrency.js";
+import { type TaskStatus, type TrackedTask, type TaskCompletionInfo } from "../../shared/index.js";
+import type { TodoSyncService } from "../sync/todo-sync-service.js";
+export type { TaskStatus, TrackedTask, TaskCompletionInfo } from "../../shared/index.js";
+type OpencodeClient = PluginInput["client"];
+export declare class TaskToastManager {
+    private tasks;
+    private client;
+    private concurrency;
+    private todoSync;
+    /**
+     * Initialize the manager with OpenCode client
+     */
+    init(client: OpencodeClient, concurrency?: ConcurrencyController): void;
+    /**
+     * Set concurrency controller (can be set after init)
+     */
+    setConcurrencyController(concurrency: ConcurrencyController): void;
+    /**
+     * Set TodoSyncService for TUI status synchronization
+     */
+    setTodoSync(service: TodoSyncService): void;
+    /**
+     * Add a new task and show consolidated toast
+     */
+    addTask(task: {
+        id: string;
+        description: string;
+        agent: string;
+        isBackground: boolean;
+        parentSessionID?: string;
+        sessionID?: string;
+        status?: TaskStatus;
+    }): void;
+    /**
+     * Update task status
+     */
+    updateTask(id: string, status: TaskStatus): void;
+    /**
+     * Remove a task
+     */
+    removeTask(id: string): void;
+    /**
+     * Get all running tasks (newest first)
+     */
+    getRunningTasks(): TrackedTask[];
+    /**
+     * Get all queued tasks (oldest first - FIFO)
+     */
+    getQueuedTasks(): TrackedTask[];
+    /**
+     * Get tasks by parent session
+     */
+    getTasksByParent(parentSessionID: string): TrackedTask[];
+    /**
+     * Format duration since task started
+     */
+    private formatDuration;
+    /**
+     * Get concurrency info string (e.g., " [2/5]")
+     */
+    /**
+     * Get concurrency info string (e.g., " [2/5]")
+     */
+    private getConcurrencyInfo;
+    /**
+     * Build consolidated task list message
+     */
+    private buildTaskListMessage;
+    /**
+     * Show consolidated toast with all running/queued tasks
+     */
+    private showTaskListToast;
+    /**
+     * Show task completion toast
+     */
+    showCompletionToast(info: TaskCompletionInfo): void;
+    /**
+     * Show all-tasks-complete summary toast
+     */
+    showAllCompleteToast(parentSessionID: string, completedTasks: TaskCompletionInfo[]): void;
+    /**
+     * Show Mission Complete toast (Grand Finale)
+     */
+    showMissionCompleteToast(title?: string, message?: string): void;
+    /**
+     * Show progress toast (for long-running tasks)
+     */
+    showProgressToast(taskId: string, progress: {
+        current: number;
+        total: number;
+        message?: string;
+    }): void;
+    /**
+     * Clear all tracked tasks
+     */
+    clear(): void;
+    /**
+     * Get task count stats
+     */
+    getStats(): {
+        running: number;
+        queued: number;
+        total: number;
+    };
+}
+/**
+ * Get the global TaskToastManager instance
+ */
+export declare function getTaskToastManager(): TaskToastManager | null;
+/**
+ * Initialize the global TaskToastManager
+ */
+export declare function initTaskToastManager(client: OpencodeClient, concurrency?: ConcurrencyController): TaskToastManager;