import type { HoldRequest, HoldDecision, HoldDecider, HoldReason, ExecuteRequest, ExecutionControlConfig, LegalHoldConfig, LegalPreFlightResults } from '../types/index.js';
export declare class HoldManager {
    private pendingHolds;
    private holdHistory;
    private config;
    private legalConfig;
    private onHoldCreated?;
    private onHoldDecided?;
    private onLegalHoldEscalation?;
    constructor(config?: Partial<ExecutionControlConfig>, legalConfig?: Partial<LegalHoldConfig>);
    /**
     * Update execution control configuration.
     * This is the operator's "knob" for controlling hold behavior.
     */
    setConfig(config: Partial<ExecutionControlConfig>): void;
    /**
     * Get current configuration.
     */
    getConfig(): ExecutionControlConfig;
    /**
     * Update legal hold configuration.
     */
    setLegalConfig(config: Partial<LegalHoldConfig>): void;
    /**
     * Get current legal hold configuration.
     */
    getLegalConfig(): LegalHoldConfig;
    /**
     * Set callback for when a hold is created (for MCP notification).
     */
    setOnHoldCreated(callback: (hold: HoldRequest) => void): void;
    /**
     * Set callback for legal hold escalation (deadline missed, privilege stale).
     */
    setOnLegalHoldEscalation(callback: (hold: HoldRequest, reason: string) => void): void;
    /**
     * Set callback for when a hold is decided.
     */
    setOnHoldDecided(callback: (decision: HoldDecision) => void): void;
    /**
     * Create a hold request for human review.
     *
     * @param customExpiryMs - Optional custom expiry time in ms (used for deadline_risk)
     *                         Pass Infinity for holds that should NEVER expire (privilege_risk)
     */
    createHold(request: ExecuteRequest, reason: HoldReason, severity: 'low' | 'medium' | 'high' | 'critical', evidence: Record<string, unknown>, customExpiryMs?: number): HoldRequest;
    /**
     * Check if a request should be held based on configuration.
     * Returns null if no hold needed, or the reason if hold required.
     */
    shouldHold(request: ExecuteRequest, preFlightResults: {
        circuitBreakerBlocked?: boolean;
        circuitBreakerReason?: string;
        predictedDriftScore?: number;
        baselineDeviation?: number;
        confidenceScore?: number;
        isForbidden?: boolean;
        requiresMcpValidation?: boolean;
    }): {
        reason: HoldReason;
        severity: 'low' | 'medium' | 'high' | 'critical';
        evidence: Record<string, unknown>;
    } | null;
    /**
     * Check if frame is in legal domain (◇).
     */
    isLegalDomainFrame(frame: string): boolean;
    /**
     * Calculate deadline hold severity based on time remaining.
     * Severity escalates as deadline approaches.
     */
    private calculateDeadlineSeverity;
    /**
     * Calculate custom expiry for deadline holds.
     * Expires 2 hours before deadline (minimum 15 minutes).
     */
    private calculateDeadlineHoldExpiry;
    /**
     * Check if a legal domain request should be held.
     * Called for frames containing ◇ (legal domain symbol).
     *
     * Checks are ordered by severity (critical first):
     * 1. privilege_risk (NEVER auto-expires)
     * 2. deadline_risk (dynamic severity)
     * 3. fabrication_flag
     * 4. citation_unverified
     * 5. jurisdiction_mismatch
     * 6. judge_preference_unknown
     *
     * @returns null if no legal hold needed, otherwise hold details with optional custom expiry
     */
    shouldHoldLegal(request: ExecuteRequest, legalResults: LegalPreFlightResults): {
        reason: HoldReason;
        severity: 'low' | 'medium' | 'high' | 'critical';
        evidence: Record<string, unknown>;
        customExpiryMs?: number;
    } | null;
    /**
     * Approve a held request (human decision).
     */
    approveHold(holdId: string, decidedBy?: HoldDecider, reason?: string, modifiedFrame?: string, modifiedArgs?: Record<string, unknown>): HoldDecision | null;
    /**
     * Reject a held request (human decision).
     */
    rejectHold(holdId: string, decidedBy?: HoldDecider, reason?: string): HoldDecision | null;
    /**
     * Check for expired holds and auto-reject them.
     *
     * SPECIAL HANDLING:
     * - legal_privilege_risk holds NEVER auto-expire (expiresAt = Infinity)
     * - Stale privilege holds (>24 hours) trigger escalation notifications
     * - legal_deadline_risk holds may have custom expiry times
     */
    processExpiredHolds(): HoldDecision[];
    /**
     * Update deadline hold severities as deadlines approach.
     * Should be called periodically (e.g., every minute).
     */
    updateDeadlineHoldSeverities(): void;
    /**
     * Get a pending hold by ID.
     */
    getHold(holdId: string): HoldRequest | undefined;
    /**
     * Get all pending holds.
     */
    getPendingHolds(): HoldRequest[];
    /**
     * Get pending holds for an agent.
     */
    getAgentPendingHolds(agentId: string): HoldRequest[];
    /**
     * Get hold decision history.
     */
    getHoldHistory(limit?: number): HoldDecision[];
    /**
     * Get hold statistics.
     */
    getStats(): {
        pending: number;
        approved: number;
        rejected: number;
        expired: number;
        byReason: Record<HoldReason, number>;
        legalHolds: {
            total: number;
            privilegeRisk: number;
            deadlineRisk: number;
            fabricationFlag: number;
            citationUnverified: number;
            jurisdictionMismatch: number;
            judgePreferenceUnknown: number;
        };
    };
    /**
     * Get legal holds only.
     */
    getLegalHolds(): HoldRequest[];
    /**
     * Get critical legal holds requiring immediate attention.
     * Returns privilege_risk holds and deadline_risk holds with < 24 hours remaining.
     */
    getCriticalLegalHolds(): HoldRequest[];
    /**
     * Check if a tool requires MCP validation.
     */
    requiresMcpValidation(toolName: string): boolean;
    /**
     * Clear all holds.
     */
    clearAll(): void;
}
export declare const holdManager: HoldManager;
//# sourceMappingURL=hold-manager.d.ts.map