/**
 * ◆ MELETE PRIME — the Red Diamond. The heart of the system: one brain that is smart about everything at
 * once. Every other module is a specialist lens — how good (efficiency), how reachable (achievability), how
 * many knobs really matter (sloppiness), where the cliffs are, is it drifting, is it converged. Brilliant
 * individually, and overwhelming together: a human staring at twelve panels still doesn't know what to DO.
 *
 * PRIME is the conductor. It runs every lens, then does the thing no competitor's tool does: it TRIAGES
 * them by leverage and danger into a single decisive verdict, the way a senior engineer would. Safety
 * outranks ambition (an optimum on a cliff edge is overruled no matter how high it scores); a physically
 * unreachable target is called before you waste a month; a fragile peak is sent back to be made robust; only
 * a clean, converged, robust, trustworthy result is cleared to ship. It also reports a single PROCESS
 * INTELLIGENCE score — how well-understood, optimized, safe, robust and trustworthy your process is, in one
 * number — and a three-sentence briefing a CEO can read.
 *
 * Honest by construction (DIAKRISIS): PRIME invents no new measurement — every input is one of the
 * independently-tested lenses, each derived from your real data. Its contribution, and its rarity, is the
 * SYNTHESIS: a deterministic, safety-first prioritisation that turns a wall of analytics into one decision.
 * The gauntlet proves the triage is correct (the right concern wins in each scenario) and that the
 * intelligence score tracks genuinely better runs. It abstains when the data is too thin to reason over.
 */
import { type Space } from "./space.js";
import { type Observation, type Goal } from "./engine.js";
export type PrimeKind = "safety" | "feasibility" | "breakthrough" | "trust" | "refine" | "ship" | "more-data" | "unknown";
/**
 * The Melete Φ formula — Process Intelligence. A single, principled score for how good a discovery run is,
 * across every axis at once. Defined as:
 *
 *     Φ  =  100 · ∛(O · R · T) · ½(1 + C) · U · S · F
 *
 *   O optimized, R robust, T trustworthy   — the CORE qualities, combined as a GEOMETRIC mean: conjunctive,
 *                                            so any one collapsing toward 0 collapses Φ (you can't fake it).
 *   C confident   — modulates by how sure we can stop (½(1+C) keeps a thin-data run from scoring full marks).
 *   U understood, S safe, F feasible        — multiplicative gates ∈ (0,1] that can only PENALISE a known
 *                                            deficiency (an optimum on a cliff, a target out of reach).
 *
 * Provable properties (the gauntlet checks all four, so the headline number is sound, not a hunch):
 *   • BOUNDED   Φ ∈ [0, 100]              (every factor ∈ [0,1])
 *   • IDENTITY  all factors = 1  ⇒  Φ = 100
 *   • CONJUNCTIVE  any core factor = 0  ⇒  Φ = 0
 *   • MONOTONE  ∂Φ/∂(any factor) ≥ 0     (more of any good thing never lowers the score)
 *
 * Complexity of the whole PRIME pass: O(n²·D + n·D² + D³) for n measurements over D variables — the n²·D from
 * the near-neighbour scans (cliffs/surprise/efficiency), n·D² from the quadratic curvature fits, D³ from the
 * sloppiness eigen-decomposition. Linear in the number of lenses; well under a second for realistic runs.
 */
export interface PiqFactors {
    optimized: number;
    robust: number;
    trustworthy: number;
    confident: number;
    understood: number;
    safe: number;
    feasible: number;
}
export declare function processIntelligence(f: PiqFactors): number;
export interface PrimeInsight {
    kind: PrimeKind;
    severity: number;
    headline: string;
}
export interface PrimeVerdict {
    processIQ: number;
    grade: "world-class" | "strong" | "developing" | "fragile" | "unknown";
    decisive: PrimeInsight;
    insights: PrimeInsight[];
    briefing: string;
    recipe: Array<{
        name: string;
        value: number;
    }>;
    expected: number;
}
/** ◆ The Red Diamond: compose every lens and return one safety-first decision + a process-intelligence score. */
export declare function meletePrime(obs: ReadonlyArray<Observation>, space: Space, goal?: Goal, opts?: {
    target?: number;
}): PrimeVerdict;
export declare function primeGauntlet(): {
    score: 0 | 100;
    checks: Array<{
        name: string;
        pass: boolean;
        detail: string;
    }>;
};
//# sourceMappingURL=prime.d.ts.map