opencode-orchestrator 1.5.1 → 1.5.4

package/dist/shared/notification/os-notify/constants.d.ts

@@ -0,0 +1,30 @@
+/**
+ * OS notification constants (consolidated)
+ */
+import type { NotificationConfig } from "./types.js";
+/**
+ * OS Notification Command Keys
+ */
+export declare const NOTIFICATION_COMMAND_KEYS: {
+    readonly OSASCRIPT: "osascript";
+    readonly NOTIFY_SEND: "notifySend";
+    readonly POWERSHELL: "powershell";
+    readonly AFPLAY: "afplay";
+    readonly PAPLAY: "paplay";
+    readonly APLAY: "aplay";
+};
+/**
+ * OS Notification Commands
+ */
+export declare const NOTIFICATION_COMMANDS: {
+    readonly OSASCRIPT: "osascript";
+    readonly NOTIFY_SEND: "notify-send";
+    readonly POWERSHELL: "powershell";
+    readonly AFPLAY: "afplay";
+    readonly PAPLAY: "paplay";
+    readonly APLAY: "aplay";
+};
+/**
+ * OS Notification Default Constants
+ */
+export declare const NOTIFICATION_DEFAULTS: Required<NotificationConfig>;

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

@@ -1,6 +1,5 @@
 /**
  * OS Notification Shared Module
  */
-export * from "./types/index.js";
-export * from "./interfaces/index.js";
-export * from "./constants/index.js";
+export * from "./types.js";
+export * from "./constants.js";

package/dist/shared/notification/os-notify/types.d.ts

@@ -0,0 +1,36 @@
+/**
+ * OS notification types (consolidated)
+ */
+import { NOTIFICATION_COMMAND_KEYS } from "./constants.js";
+/**
+ * Notification Config Interface
+ */
+export interface NotificationConfig {
+    /** Notification title (default: "OpenCode Orchestrator") */
+    title?: string;
+    /** Notification message (default: "Task completed") */
+    message?: string;
+    /** Play sound with notification (default: true) */
+    playSound?: boolean;
+    /** Custom sound file path */
+    soundPath?: string;
+    /** Maximum number of sessions to track before cleanup (default: 100) */
+    maxTrackedSessions?: number;
+}
+/**
+ * Notification State Interface
+ */
+export interface NotificationState {
+    /** Sessions that have already been notified */
+    notifiedSessions: Set<string>;
+    /** Pending notification timers */
+    pendingTimers: Map<string, ReturnType<typeof setTimeout>>;
+    /** Version tracking for race condition handling */
+    notificationVersions: Map<string, number>;
+    /** Sessions currently executing notification */
+    executingNotifications: Set<string>;
+}
+/**
+ * OS Notification Command Types
+ */
+export type NotificationCommandKey = typeof NOTIFICATION_COMMAND_KEYS[keyof typeof NOTIFICATION_COMMAND_KEYS];

package/dist/shared/notification/presets.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Task Lifecycle Presets
+ */
+export declare const taskStarted: (taskId: string, agent: string) => import("./types.js").ToastMessage;
+export declare const taskCompleted: (taskId: string, agent: string) => import("./types.js").ToastMessage;
+export declare const taskFailed: (taskId: string, error: string) => import("./types.js").ToastMessage;
+export declare const allTasksComplete: (count: number) => import("./types.js").ToastMessage;
+/**
+ * Session Management Presets
+ */
+export declare const sessionCreated: (sessionId: string, agent: string) => import("./types.js").ToastMessage;
+export declare const sessionResumed: (sessionId: string, agent: string) => import("./types.js").ToastMessage;
+export declare const sessionCompleted: (sessionId: string, duration: string) => import("./types.js").ToastMessage;
+/**
+ * Parallel Processing Presets
+ */
+export declare const parallelTasksLaunched: (count: number, agents: string[]) => import("./types.js").ToastMessage;
+export declare const concurrencyAcquired: (agent: string, slot: string) => import("./types.js").ToastMessage;
+export declare const concurrencyReleased: (agent: string) => import("./types.js").ToastMessage;
+/**
+ * Mission & Progress Presets
+ */
+export declare const missionComplete: (summary: string) => import("./types.js").ToastMessage;
+export declare const missionStarted: (description: string) => import("./types.js").ToastMessage;
+/**
+ * Tools & Research Presets
+ */
+export declare const toolExecuted: (toolName: string, target: string) => import("./types.js").ToastMessage;
+export declare const documentCached: (filename: string) => import("./types.js").ToastMessage;
+export declare const researchStarted: (topic: string) => import("./types.js").ToastMessage;
+/**
+ * Warnings & Errors Presets
+ */
+export declare const warningRateLimited: () => import("./types.js").ToastMessage;
+export declare const errorRecovery: (action: string) => import("./types.js").ToastMessage;
+export declare const warningMaxDepth: (depth: number) => import("./types.js").ToastMessage;
+export declare const warningMaxRetries: () => import("./types.js").ToastMessage;

package/dist/shared/notification/types.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Notification types and interfaces (consolidated)
+ */
+import type { TaskStatus } from "../core/index.js";
+/**
+ * Toast variant type
+ */
+export type ToastVariant = "info" | "success" | "warning" | "error";
+/**
+ * Toast display options
+ */
+export interface ToastOptions {
+    title: string;
+    message: string;
+    variant?: ToastVariant;
+    duration?: number;
+}
+/**
+ * Toast message with metadata
+ */
+export interface ToastMessage {
+    id: string;
+    title: string;
+    message: string;
+    variant: ToastVariant;
+    timestamp: Date;
+    duration: number;
+    dismissed: boolean;
+}
+export interface TrackedTask {
+    id: string;
+    description: string;
+    agent: string;
+    status: TaskStatus;
+    startedAt: Date;
+    isBackground: boolean;
+    parentSessionID?: string;
+    sessionID?: string;
+}
+export interface TaskCompletionInfo {
+    id: string;
+    description: string;
+    duration: string;
+    status: TaskStatus;
+    error?: string;
+}

package/dist/shared/os/{constants/platform.d.ts → constants.d.ts}

@@ -1,5 +1,5 @@
 /**
- * OS Platform Constants
+ * OS constants
  */
 export declare const PLATFORM: {
     readonly DARWIN: "darwin";

package/dist/shared/os/index.d.ts

@@ -1,5 +1,5 @@
 /**
  * OS Shared Domain
  */
-export * from "./constants/index.js";
-export * from "./types/index.js";
+export * from "./constants.js";
+export * from "./types.js";

package/dist/shared/os/types.d.ts

@@ -0,0 +1,5 @@
+/**
+ * OS types
+ */
+import { PLATFORM } from "./constants.js";
+export type Platform = (typeof PLATFORM)[keyof typeof PLATFORM];

package/dist/shared/prompt/constants.d.ts

@@ -0,0 +1,449 @@
+/**
+ * Architecture Rules - Core system behavior constants
+ *
+ * These define the immutable rules about agent hierarchy and spawning.
+ * Used by prompts to ensure consistent messaging across all agents.
+ */
+/**
+ * Agent hierarchy roles
+ */
+export declare const AGENT_ROLES: {
+    /** Only Commander can spawn other agents */
+    readonly SPAWNER: "Commander";
+    /** Terminal agents cannot spawn any sub-agents */
+    readonly TERMINAL_AGENTS: readonly ["Planner", "Worker", "Reviewer"];
+};
+/**
+ * Terminal node messaging - used in forbidden actions
+ */
+export declare const TERMINAL_NODE: {
+    /** Label for terminal node concept */
+    readonly LABEL: "TERMINAL node";
+    /** Reason why terminal nodes can't spawn */
+    readonly REASON: "prevents infinite recursion";
+    /** What to do instead of spawning */
+    readonly ALTERNATIVE: "Report back to Commander with specific blockers";
+};
+/**
+ * Spawning restriction messages
+ */
+export declare const SPAWNING_RULES: {
+    /** Who can spawn */
+    readonly SPAWNER_ONLY: "Commander is the ONLY agent who can spawn other agents";
+    /** What terminal nodes should do */
+    readonly TERMINAL_BEHAVIOR: "Complete your assigned task directly without delegation";
+    /** Error message for blocked spawn attempts */
+    readonly BLOCKED_MESSAGE: "You are a TERMINAL node - prevents infinite recursion";
+};
+/**
+ * Core architecture rules as a single exportable constant
+ */
+export declare const ARCHITECTURE_RULES: {
+    readonly AGENT_ROLES: {
+        /** Only Commander can spawn other agents */
+        readonly SPAWNER: "Commander";
+        /** Terminal agents cannot spawn any sub-agents */
+        readonly TERMINAL_AGENTS: readonly ["Planner", "Worker", "Reviewer"];
+    };
+    readonly TERMINAL_NODE: {
+        /** Label for terminal node concept */
+        readonly LABEL: "TERMINAL node";
+        /** Reason why terminal nodes can't spawn */
+        readonly REASON: "prevents infinite recursion";
+        /** What to do instead of spawning */
+        readonly ALTERNATIVE: "Report back to Commander with specific blockers";
+    };
+    readonly SPAWNING_RULES: {
+        /** Who can spawn */
+        readonly SPAWNER_ONLY: "Commander is the ONLY agent who can spawn other agents";
+        /** What terminal nodes should do */
+        readonly TERMINAL_BEHAVIOR: "Complete your assigned task directly without delegation";
+        /** Error message for blocked spawn attempts */
+        readonly BLOCKED_MESSAGE: "You are a TERMINAL node - prevents infinite recursion";
+    };
+};
+/**
+ * Architectural Mandates - Immutable Core Logic
+ *
+ * These constants define the non-negotiable architectural requirements
+ * that ensure the orchestrator operates according to the verified diagram.
+ */
+/**
+ * Phase 0: Direct Discovery
+ */
+export declare const PHASE_0_DIRECT_DISCOVERY: string;
+/**
+ * Phase 1: THINK (Strategic Mandate)
+ */
+export declare const PHASE_1_THINK_ANALYSIS = "### 1.1 ANALYZE & SCOPE\n- **Define FULL scope** based on user request and discovered context.\n- **Hierarchical Breakdown**: Milestones -> Tasks -> Sub-tasks.\n\n### 1.2 STRATEGIC DECOMPOSITION\n- **Independent Items**: Identify what can run in parallel.\n- **Dependency Map**: Clearly define `depends:` links.\n\n### 1.3 DELEGATION\n- **Parallel Workers**: Assign workers for independent branches.\n- **Granular Review**: Assign reviewers for verification.";
+/**
+ * Phase 5: MSVP (Multi-Stage Verification Pipeline)
+ */
+export declare const PHASE_5_MSVP: string;
+/**
+ * HPFA (Hyper-Parallel Fractal Architecture) Rules
+ */
+export declare const HPFA_RULES = "1. **Commander-Only Spawning**: All agents are spawned by the Commander.\n2. **Parallel Branches**: Execute non-dependent milestones/tasks simultaneously.\n3. **Recursive Breakdown**: Continue subdividing until tasks are atomic.\n4. **Autonomous Termination**: You only finish when the verification checklist and TODOs are 100% complete.";
+/**
+ * Autonomous Completion Mandate
+ */
+export declare const AUTONOMOUS_MANDATE = "\n## AUTONOMOUS COMPLETION MANDATE (MANDATORY)\n1. **ZERO TOLERANCE**: Finishing with incomplete `[ ]` items is a FAILURE.\n2. **FORCED CONTINUATION**: If you stop prematurely, the system will inject a \"CONTINUE\" prompt and iteration count.\n3. **HIERARCHICAL PROOF**: You must provide evidence (tool output) for every `[x]` mark.\n4. **NO PERMISSION**: Do not ask \"Should I continue?\". The answer is always YES until `.opencode/todo.md` is 100% checked.\n";
+/**
+ * Core Philosophy Phases
+ *
+ * The 4-phase cycle: Explore → Learn → Adapt → Act
+ */
+export declare const PHILOSOPHY_PHASES: {
+    readonly EXPLORE: "EXPLORE";
+    readonly LEARN: "LEARN";
+    readonly ADAPT: "ADAPT";
+    readonly ACT: "ACT";
+};
+/**
+ * Execution Cycle Phases
+ *
+ * The 4-step execution pattern: THINK → ACT → OBSERVE → ADJUST
+ */
+export declare const EXECUTION_CYCLE: {
+    readonly THINK: "THINK";
+    readonly ACT: "ACT";
+    readonly OBSERVE: "OBSERVE";
+    readonly ADJUST: "ADJUST";
+};
+export declare const EXECUTION_CYCLE_STEPS: string;
+/**
+ * Core philosophy tagline
+ */
+export declare const PHILOSOPHY_TAGLINE = "Explore \u2192 Learn \u2192 Adapt \u2192 Act";
+export declare const PHILOSOPHY_QUOTE = "Like an astronaut landing on unknown planets \u2014 never assume, always discover.";
+export declare const PHILOSOPHY_LEARN_PRINCIPLE = "LEARN = DOCUMENT: What you discover, you record. Your learnings become the team's knowledge.";
+/**
+ * Discovery Scouters - Phase 0 Specialized Roles
+ */
+/**
+ * Basic identifier for discovery agents
+ */
+export declare const SCOUT_LABEL = "Scout";
+export declare const SCOUT_STRUCTURE: {
+    readonly ID: "STRUCTURE";
+    readonly NAME: "Scout: Structure";
+    readonly PROMPT: "Analyze the project folder structure. Locate source code (src, lib), tests, and documentation directories. Map out the tree at depth 2-3.";
+};
+export declare const SCOUT_STACK: {
+    readonly ID: "STACK";
+    readonly NAME: "Scout: Stack";
+    readonly PROMPT: "Identify the technology stack. Parse package.json, Cargo.toml, go.mod, or pyproject.toml. Determine build and test commands.";
+};
+export declare const SCOUT_DOCS: {
+    readonly ID: "DOCS";
+    readonly NAME: "Scout: Docs";
+    readonly PROMPT: "Digest the project documentation. Read README.md, CONTRIBUTING.md, and any files in docs/ to understand the core architecture and mission.";
+};
+export declare const SCOUT_INFRA: {
+    readonly ID: "INFRA";
+    readonly NAME: "Scout: Infra";
+    readonly PROMPT: "Detect infrastructure and environment configs. Search for Dockerfiles, CI/CD workflows (.github, .gitlab), and environment variable templates.";
+};
+export declare const SCOUT_INTEGRATION: {
+    readonly ID: "INTEGRATION";
+    readonly NAME: "Scout: Integration";
+    readonly PROMPT: "Read all modified files and their cross-module dependencies in parallel. Map the actual integration surface and identify potential consistency issues.";
+};
+/**
+ * Work Status Constants
+ *
+ * All status values used in work-log.md, todo.md, sync-issues.md, status.md.
+ */
+export declare const WORK_STATUS: {
+    readonly ACTION: {
+        readonly CREATE: "CREATE";
+        readonly MODIFY: "MODIFY";
+        readonly DELETE: "DELETE";
+        readonly FIX: "FIX";
+    };
+    readonly STATUS: {
+        readonly PENDING: "pending";
+        readonly IN_PROGRESS: "in_progress";
+        readonly DONE: "done";
+        readonly FAILED: "failed";
+    };
+    readonly TEST_RESULT: {
+        readonly PASS: "pass";
+        readonly FAIL: "fail";
+        readonly SKIP: "skip";
+    };
+    readonly E2E_STATUS: {
+        readonly NOT_STARTED: "NOT_STARTED";
+        readonly RUNNING: "running";
+        readonly PASS: "pass";
+        readonly FAIL: "fail";
+    };
+    readonly PHASE: {
+        readonly PLANNING: "PLANNING";
+        readonly IMPLEMENTATION: "IMPLEMENTATION";
+        readonly E2E: "E2E";
+        readonly FIXING: "FIXING";
+        readonly VERIFYING: "VERIFYING";
+    };
+    readonly SEVERITY: {
+        readonly HIGH: "HIGH";
+        readonly MEDIUM: "MEDIUM";
+        readonly LOW: "LOW";
+    };
+    readonly CONFIDENCE: {
+        readonly HIGH: "HIGH";
+        readonly MEDIUM: "MEDIUM";
+        readonly LOW: "LOW";
+    };
+    readonly SESSION: {
+        readonly STARTED: "pending";
+        readonly COMPLETED: "done";
+        readonly CANCELLED: "cancelled";
+    };
+    readonly TRIAGE: {
+        readonly TYPE: {
+            readonly SIMPLE: "Simple";
+            readonly MEDIUM: "Medium";
+            readonly COMPLEX: "Complex";
+        };
+        readonly SIGNAL: {
+            readonly ONE_FILE: "One file";
+            readonly MULTI_FILE: "Multi-file";
+            readonly LARGE_SCOPE: "Large scope";
+        };
+        readonly APPROACH: {
+            readonly DIRECT: "Direct action";
+            readonly PLAN_EXECUTE_VERIFY: "Plan - Execute - Verify";
+            readonly RESEARCH_PLAN_PARALLEL: "Research - Plan - Parallel Execute";
+        };
+    };
+    readonly TODO_STATUS: {
+        readonly PENDING: "pending";
+        readonly IN_PROGRESS: "in_progress";
+        readonly COMPLETE: "completed";
+        readonly BLOCKED: "blocked";
+        readonly DONE: "done";
+        readonly VERIFIED: "verified";
+    };
+    readonly TASK_SIZE: {
+        readonly XS: "XS";
+        readonly S: "S";
+        readonly M: "M";
+        readonly L: "L";
+    };
+};
+/**
+ * Prompt XML Tags
+ *
+ * All XML tags used in agent prompts MUST be defined here.
+ * Tags come in pairs: open and close.
+ */
+export declare const PROMPT_TAGS: {
+    readonly ROLE: {
+        readonly open: "<role>";
+        readonly close: "</role>";
+    };
+    readonly IDENTITY: {
+        readonly open: "<identity>";
+        readonly close: "</identity>";
+    };
+    readonly FORBIDDEN_ACTIONS: {
+        readonly open: "<forbidden_actions>";
+        readonly close: "</forbidden_actions>";
+    };
+    readonly REQUIRED_ACTIONS: {
+        readonly open: "<required_actions>";
+        readonly close: "</required_actions>";
+    };
+    readonly VERIFICATION: {
+        readonly open: "<verification>";
+        readonly close: "</verification>";
+    };
+    readonly ENVIRONMENT_DISCOVERY: {
+        readonly open: "<environment_discovery>";
+        readonly close: "</environment_discovery>";
+    };
+    readonly ANTI_HALLUCINATION: {
+        readonly open: "<anti_hallucination>";
+        readonly close: "</anti_hallucination>";
+    };
+    readonly TODO_RULES: {
+        readonly open: "<todo_rules>";
+        readonly close: "</todo_rules>";
+    };
+    readonly COMPLETE_SIGNAL: {
+        readonly open: "<complete_signal>";
+        readonly close: "</complete_signal>";
+    };
+    readonly SHARED_WORKSPACE: {
+        readonly open: "<shared_workspace>";
+        readonly close: "</shared_workspace>";
+    };
+    readonly CORE_PHILOSOPHY: {
+        readonly open: "<core_philosophy>";
+        readonly close: "</core_philosophy>";
+    };
+    readonly SYSTEM: {
+        readonly open: "<system>";
+        readonly close: "</system>";
+    };
+    readonly TASK: {
+        readonly open: "<task>";
+        readonly close: "</task>";
+    };
+    readonly CONTEXT: {
+        readonly open: "<context>";
+        readonly close: "</context>";
+    };
+    readonly EXECUTION: {
+        readonly open: "<execution>";
+        readonly close: "</execution>";
+    };
+    readonly MODE: {
+        readonly open: "<mode>";
+        readonly close: "</mode>";
+    };
+    readonly RESUME: {
+        readonly open: "<resume>";
+        readonly close: "</resume>";
+    };
+    readonly SAFETY: {
+        readonly open: "<safety>";
+        readonly close: "</safety>";
+    };
+    readonly AST_TOOLS: {
+        readonly open: "<ast_tools>";
+        readonly close: "</ast_tools>";
+    };
+    readonly LSP_TOOLS: {
+        readonly open: "<lsp_tools>";
+        readonly close: "</lsp_tools>";
+    };
+    readonly SKILLS_CAPABILITIES: {
+        readonly open: "<skills_capabilities>";
+        readonly close: "</skills_capabilities>";
+    };
+    readonly DECOMPOSITION_RULES: {
+        readonly open: "<decomposition_rules>";
+        readonly close: "</decomposition_rules>";
+    };
+    readonly EXECUTION_ASSURANCE: {
+        readonly open: "<execution_assurance>";
+        readonly close: "</execution_assurance>";
+    };
+    readonly TOOLS: {
+        readonly open: "<tools>";
+        readonly close: "</tools>";
+    };
+    readonly AGENTS: {
+        readonly open: "<agents>";
+        readonly close: "</agents>";
+    };
+    readonly EXECUTION_RULES: {
+        readonly open: "<execution_rules>";
+        readonly close: "</execution_rules>";
+    };
+    readonly EXECUTION_STRATEGY: {
+        readonly open: "<execution_strategy>";
+        readonly close: "</execution_strategy>";
+    };
+    readonly PARALLEL_EXECUTION: {
+        readonly open: "<parallel_execution>";
+        readonly close: "</parallel_execution>";
+    };
+    readonly TODO_FORMAT: {
+        readonly open: "<todo_format>";
+        readonly close: "</todo_format>";
+    };
+    readonly SYNC_ISSUE_HANDLING: {
+        readonly open: "<sync_issue_handling>";
+        readonly close: "</sync_issue_handling>";
+    };
+    readonly LOOP_CONTINUATION: {
+        readonly open: "<loop_continuation>";
+        readonly close: "</loop_continuation>";
+    };
+    readonly RECOVERY: {
+        readonly open: "<recovery>";
+        readonly close: "</recovery>";
+    };
+    readonly FILE_LEVEL_PLANNING: {
+        readonly open: "<file_level_planning>";
+        readonly close: "</file_level_planning>";
+    };
+    readonly TODO_SYNC: {
+        readonly open: "<todo_sync>";
+        readonly close: "</todo_sync>";
+    };
+    readonly PLANNING_FORMAT: {
+        readonly open: "<planning_format>";
+        readonly close: "</planning_format>";
+    };
+    readonly RESEARCH_WORKFLOW: {
+        readonly open: "<research_workflow>";
+        readonly close: "</research_workflow>";
+    };
+    readonly FILE_ASSIGNMENT: {
+        readonly open: "<file_assignment>";
+        readonly close: "</file_assignment>";
+    };
+    readonly TDD_WORKFLOW: {
+        readonly open: "<tdd_workflow>";
+        readonly close: "</tdd_workflow>";
+    };
+    readonly ISOLATION_TESTING: {
+        readonly open: "<isolation_testing>";
+        readonly close: "</isolation_testing>";
+    };
+    readonly WORKFLOW: {
+        readonly open: "<workflow>";
+        readonly close: "</workflow>";
+    };
+    readonly QUALITY_CHECKLIST: {
+        readonly open: "<quality_checklist>";
+        readonly close: "</quality_checklist>";
+    };
+    readonly SYNC_VERIFICATION: {
+        readonly open: "<sync_verification>";
+        readonly close: "</sync_verification>";
+    };
+    readonly ASYNC_MONITORING: {
+        readonly open: "<async_monitoring>";
+        readonly close: "</async_monitoring>";
+    };
+    readonly INTEGRATION_TESTING: {
+        readonly open: "<integration_testing>";
+        readonly close: "</integration_testing>";
+    };
+    readonly VERIFICATION_PROCESS: {
+        readonly open: "<verification_process>";
+        readonly close: "</verification_process>";
+    };
+    readonly TODO_MANAGEMENT: {
+        readonly open: "<todo_management>";
+        readonly close: "</todo_management>";
+    };
+    readonly OUTPUT_FORMAT: {
+        readonly open: "<output_format>";
+        readonly close: "</output_format>";
+    };
+    readonly MISSION_LOOP: {
+        readonly open: "<mission_loop>";
+        readonly close: "</mission_loop>";
+    };
+    readonly TODO_CONTINUATION: {
+        readonly open: "<todo_continuation>";
+        readonly close: "</todo_continuation>";
+    };
+    readonly AUTONOMOUS_MODE: {
+        readonly open: "<autonomous_mode>";
+        readonly close: "</autonomous_mode>";
+    };
+};
+/**
+ * Helper to wrap content in tags
+ */
+export declare const wrapTag: (tag: {
+    open: string;
+    close: string;
+}, content: string) => string;

package/dist/shared/prompt/index.d.ts

@@ -1,4 +1,4 @@
 /**
  * Prompt Domain
  */
-export * from "./constants/index.js";
+export * from "./constants.js";

package/dist/shared/recovery/constants.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Recovery Configuration Constants
+ */
+export declare const RECOVERY: {
+    /** Maximum recovery attempts per session */
+    readonly MAX_ATTEMPTS: 3;
+    /** Minimum time between recovery attempts */
+    readonly MIN_INTERVAL_MS: number;
+    /** Base delay for retry backoff calculation */
+    readonly BASE_DELAY_MS: number;
+    /** Maximum retry multiplier */
+    readonly MAX_RETRY_MULTIPLIER: 5;
+};
+/**
+ * History & Storage Limits
+ */
+export declare const HISTORY: {
+    /** Recovery history max entries */
+    readonly MAX_RECOVERY: 100;
+    /** Toast history max entries */
+    readonly MAX_TOAST: 50;
+    /** Progress store max entries */
+    readonly MAX_PROGRESS: 100;
+};
+/**
+ * Recovery Level Constants
+ *
+ * Escalation levels for agent failure handling.
+ */
+export declare const RECOVERY_LEVEL: {
+    /** Level 1: Split task into smaller units */
+    readonly DECOMPOSE: "DECOMPOSE";
+    /** Level 2: Step back and create new strategy */
+    readonly RE_PLAN: "RE-PLAN";
+    /** Level 3: Ask user for direction */
+    readonly ASK_USER: "ASK USER";
+};
+export declare const RECOVERY_PRINCIPLE = "DECOMPOSE \u2192 RE-PLAN \u2192 ASK. Never give up silently.";
+export type RecoveryLevel = (typeof RECOVERY_LEVEL)[keyof typeof RECOVERY_LEVEL];