/**
 * src/constitution/gate.ts
 *
 * HardGate — constitutional hard-stop rules evaluated before cycle execution.
 * Each rule is explicit, isolated, and maps to a single axiom.
 *
 * Rules are evaluated deterministically and synchronously.
 * Any `block` violation causes `pass: false` in the result.
 *
 * @module constitution/gate
 */
import type { CycleSnapshot, GateViolation } from "./types.js";
export interface ParentCycleContext {
    /** Maximum budget the parent was authorised to spend (in USD). */
    budgetUsdMax: number;
    /** Scope IDs the child is allowed to operate in. */
    allowed_scope_ids?: string[];
}
export interface GateResult {
    /** True only when zero violations are detected. */
    pass: boolean;
    /** All detected violations (may be empty). */
    violations: GateViolation[];
}
/**
 * HardGate evaluates a fixed set of hard-stop rules against a CycleSnapshot.
 *
 * Rules (in evaluation order):
 *   1. Child budget > parent budget              → Profitable / block
 *   2. Secret in step output                     → Robuste / block
 *   3. Scope dépassé (scope_id ∉ allowed)        → Robuste / block
 *   4. PII without redacted flag                 → Institutionnel / block
 *   5. RSO veto                                  → Institutionnel / block
 */
export declare class HardGate {
    /**
     * Evaluate all hard-gate rules against the cycle.
     *
     * @param cycle   - The cycle to evaluate (validated via Zod before checks).
     * @param parent  - Optional parent context for budget + scope checks.
     * @returns GateResult with pass flag and list of violations.
     */
    evaluate(cycle: CycleSnapshot, parent?: ParentCycleContext): GateResult;
}
/** Default singleton HardGate instance. */
export declare const hardGate: HardGate;
//# sourceMappingURL=gate.d.ts.map