/**
 * Engine Layer Types
 *
 * Core types for the Execution Engine (Layer 2) that manages
 * task queueing, concurrency, and multi-agent execution.
 *
 * @module execution/engine/types
 */
import { ProcessConfig } from "../process/types.js";
/**
 * ExecutionTask - Represents a unit of work to be executed by a Claude Code agent
 */
export interface ExecutionTask {
    id: string;
    type: "issue" | "spec" | "custom";
    entityId?: string;
    prompt: string;
    workDir: string;
    priority: number;
    dependencies: string[];
    createdAt: Date;
    config: {
        timeout?: number;
        maxRetries?: number;
        env?: Record<string, string>;
    };
    metadata?: Record<string, any>;
}
/**
 * ExecutionResult - The outcome of executing a task
 */
export interface ExecutionResult {
    taskId: string;
    executionId: string;
    success: boolean;
    exitCode: number;
    output: string;
    error?: string;
    startedAt: Date;
    completedAt: Date;
    duration: number;
    metadata?: {
        toolsUsed?: string[];
        filesChanged?: string[];
        tokensUsed?: number;
        cost?: number;
    };
}
/**
 * EngineMetrics - Real-time engine performance statistics
 */
export interface EngineMetrics {
    maxConcurrent: number;
    currentlyRunning: number;
    availableSlots: number;
    queuedTasks: number;
    completedTasks: number;
    failedTasks: number;
    averageDuration: number;
    successRate: number;
    throughput: number;
    totalProcessesSpawned: number;
    activeProcesses: number;
}
/**
 * TaskStatus - Discriminated union for task state tracking
 */
export type TaskStatus = {
    state: "queued";
    position: number;
} | {
    state: "running";
    processId: string;
    startedAt: Date;
} | {
    state: "completed";
    result: ExecutionResult;
} | {
    state: "failed";
    error: string;
} | {
    state: "cancelled";
    cancelledAt: Date;
};
/**
 * TaskCompleteHandler - Callback for task completion events
 */
export type TaskCompleteHandler = (result: ExecutionResult) => void;
/**
 * TaskFailedHandler - Callback for task failure events
 */
export type TaskFailedHandler = (taskId: string, error: Error) => void;
/**
 * EngineConfig - Configuration options for execution engines
 */
export interface EngineConfig {
    /**
     * Maximum number of concurrent processes (default: 3)
     */
    maxConcurrent?: number;
    /**
     * DEPRECATED: Use defaultProcessConfig instead
     * Path to Claude executable (default: 'claude')
     */
    claudePath?: string;
    /**
     * REQUIRED: Default process configuration to use for all tasks
     * This should be built using an agent adapter (e.g., ClaudeCodeAdapter.buildProcessConfig())
     *
     * Required fields:
     * - executablePath: Path to the CLI executable
     * - args: Command-line arguments array
     *
     * Optional fields:
     * - workDir: Default working directory (overridden by task.workDir)
     * - env: Environment variables (merged with task.config.env)
     * - timeout: Default timeout (overridden by task.config.timeout)
     */
    defaultProcessConfig?: Partial<ProcessConfig>;
    /**
     * Optional output handler for real-time processing of stdout/stderr
     */
    onOutput?: (data: Buffer, type: "stdout" | "stderr") => void;
}
/**
 * RunningTask - Internal tracking for currently executing tasks
 */
export interface RunningTask {
    task: ExecutionTask;
    process: any;
    startedAt: Date;
    attempt: number;
}
/**
 * TaskResolver - Promise resolver for async task waiting
 */
export interface TaskResolver {
    resolve: (result: ExecutionResult) => void;
    reject: (error: Error) => void;
}
//# sourceMappingURL=types.d.ts.map