/**
 * Auto-Optimizer — dynamic convergence-aid activation
 *
 * Makes `uap deliver` self-optimizing: every instruction is classified for
 * complexity and the convergence aids (exploration, critic, practices,
 * escalation, ideation, HALO, coordination) are enabled to match — no flags
 * required. Trivial requests keep the cheap single-shot loop; non-trivial
 * requests always get the aids that improve outcomes.
 *
 * The classifier is the dependency-free utils scorer with thresholds owned
 * HERE: this mapping gates a cost cliff (moderate ≈ 4-5× model calls per
 * turn once judge/critic are counted), so retuning the memory system's
 * retrieval thresholds must never silently change delivery's bill.
 */
import { type ComplexityThresholds, type QueryComplexity } from '../utils/query-complexity.js';
export type DeliveryComplexity = QueryComplexity;
/** Delivery-owned cost-tier boundaries (see module doc). */
export declare const DELIVERY_COMPLEXITY_THRESHOLDS: ComplexityThresholds;
export interface AutoPlan {
    complexity: DeliveryComplexity;
    /** Best-of-N exploration size; undefined keeps single-candidate turns */
    candidates?: number;
    critic: boolean;
    practices: boolean;
    escalate: boolean;
    ideate: boolean;
    halo: boolean;
    coordinate: boolean;
    /** Human-readable summary of what auto mode enabled */
    summary: string;
}
/**
 * Map instruction complexity to a convergence-aid plan.
 *
 *  - simple   → plain single-shot loop (aids would only add cost)
 *  - moderate → exploration ×3 + critic + practices + HALO + coordination
 *  - complex  → the full stack (= --optimize): exploration ×4, critic,
 *               practices, escalation, ideation, HALO, coordination
 *
 * The classifier is injectable for tests and future model-based upgrades.
 */
export declare function planAutoOptimization(instruction: string, classify?: (query: string) => DeliveryComplexity): AutoPlan;
//# sourceMappingURL=auto-optimizer.d.ts.map