import type { AgentEvent } from "../providers/ProviderTypes.js";
import type { ContextBundle, ContextResearchEvidence, ContextResearchToolUsage, EvidenceGateAssessment, Plan, CriticResult, LaneScope, ContextRefreshTerminationReason, RuntimePhase, VerificationReport } from "./Types.js";
import { ContextAssembler, type ResearchToolExecution } from "./ContextAssembler.js";
import { type DeepInvestigationBudgetConfig, type DeepInvestigationEvidenceConfig, type DeepInvestigationToolQuotaConfig } from "../config/Config.js";
import { ArchitectPlanner } from "./ArchitectPlanner.js";
import { BuilderRunner, type BuilderRunResult } from "./BuilderRunner.js";
import { CriticEvaluator } from "./CriticEvaluator.js";
import { MemoryWriteback } from "./MemoryWriteback.js";
import type { RunLogger } from "../runtime/RunLogger.js";
import type { ContextManager } from "./ContextManager.js";
export interface PhaseProviderFailureContext {
    phase: "librarian" | "architect" | "builder" | "critic" | "interpreter";
    attempt: number;
    error: Error;
}
export type PhaseProviderFailureResult = boolean | {
    switched: boolean;
    note?: string;
};
export interface SmartPipelineOptions {
    contextAssembler: ContextAssembler;
    architectPlanner: ArchitectPlanner;
    builderRunner: BuilderRunner;
    criticEvaluator: CriticEvaluator;
    memoryWriteback: MemoryWriteback;
    maxRetries: number;
    maxContextRefreshes?: number;
    maxContextRefreshMs?: number;
    initialContext?: ContextBundle;
    fastPath?: (request: string) => boolean;
    deepMode?: boolean;
    deepScanPreset?: boolean;
    deepInvestigation?: {
        toolQuota?: DeepInvestigationToolQuotaConfig;
        investigationBudget?: DeepInvestigationBudgetConfig;
        evidenceGate?: DeepInvestigationEvidenceConfig;
    };
    getTouchedFiles?: () => string[];
    logger?: RunLogger;
    contextManager?: ContextManager;
    laneScope?: Omit<LaneScope, "role" | "ephemeral">;
    verificationPolicyName?: string;
    minimumVerificationChecks?: number;
    enforceVerificationHighConfidence?: boolean;
    onEvent?: (event: AgentEvent) => void;
    onPhaseProviderFailure?: (context: PhaseProviderFailureContext) => Promise<PhaseProviderFailureResult> | PhaseProviderFailureResult;
}
export interface ResearchPhaseResult {
    status: "skipped" | "completed";
    startedAt?: number;
    endedAt?: number;
    durationMs?: number;
    cycles?: number;
    budget?: {
        status: "met" | "unmet";
        minCycles: number;
        minSeconds: number;
        maxCycles: number;
        elapsedMs: number;
        cycles: number;
    };
    warnings: string[];
    notes?: string[];
    toolRuns: ResearchToolExecution["toolRuns"];
    outputs?: ResearchToolExecution["outputs"];
    evidence?: ContextResearchEvidence;
    toolUsage?: ContextResearchToolUsage;
    evidenceGate?: EvidenceGateAssessment;
}
export interface SmartPipelineResult {
    context: ContextBundle;
    research?: ResearchPhaseResult;
    plan: Plan;
    builderResult: BuilderRunResult;
    criticResult: CriticResult;
    verification?: VerificationReport;
    attempts: number;
    contextRefreshTerminationReason?: ContextRefreshTerminationReason;
    phaseTrace: RuntimePhase[];
}
export declare class SmartPipeline {
    private options;
    private phaseTracker;
    constructor(options: SmartPipelineOptions);
    private resetPhaseTracker;
    private transitionPhase;
    run(request: string): Promise<SmartPipelineResult>;
    private runPhase;
    private emitStatus;
    private phaseStatus;
}
//# sourceMappingURL=SmartPipeline.d.ts.map