/**
 * CORTEX BRIDGE — share a discovery across agents (the Mneme tie).
 *
 * Mneme ships a Cognitive Cortex: a local, signed, cross-vendor shared memory every AI agent contributes
 * to and recalls from. Melete produces discoveries with signed provenance. This bridge turns a finished
 * discovery into a **cortex-compatible capsule** (a key, a value, and the trace's digest as proof) that
 * any agent can recall — so one agent's hard-won discovery becomes another's prior. And it turns the
 * collective memory into an **oracle**: `f(x) = the best score memory has ever recorded near x`, so a new
 * run can warm-start from everything previously discovered.
 *
 * Decoupled by design: Melete does NOT hard-depend on Mneme. You inject the contribute/recall callbacks
 * (e.g. Mneme's `cortex.contribute` / `cortex.recall` over MCP, HTTP, or the matrix rail). The capsule
 * shape is plain JSON so any memory bus can carry it.
 */
import { type Space, type Experiment } from "./space.js";
import { type DiscoveryResult } from "./engine.js";
import { type SignedTrace } from "./trace.js";
export interface DiscoveryCapsule {
    key: string;
    value: {
        best: Experiment;
        score: number;
        engine?: string;
        evaluations: number;
    };
    provenance: {
        traceDigest: string;
        frames: number;
        publicKeyPem: string;
    };
    kind: "discovery";
}
/** Stable problem signature: the dimensions + goal, canonicalised (so the same problem hashes the same). */
export declare function problemKey(space: Space, goal: string): string;
/** Package a finished discovery as a cortex-shareable, provenance-bearing capsule. */
export declare function discoveryCapsule(space: Space, result: DiscoveryResult, trace: SignedTrace, engine?: string): DiscoveryCapsule;
/** Contribute a capsule to a shared memory via an injected sink (e.g. Mneme cortex.contribute). */
export declare function contributeToCortex(capsule: DiscoveryCapsule, sink: (key: string, value: unknown, kind: string) => unknown | Promise<unknown>): Promise<unknown>;
/**
 * Turn collective memory into an oracle: `f(x)` = the best recorded score among prior discoveries near x
 * (within `radius` normalised distance). Lets a new run warm-start from what other agents already found.
 * `recall(key)` returns prior records: [{ experiment, score }].
 */
export declare function cortexOracle(space: Space, goal: string, recall: (key: string) => Promise<Array<{
    experiment: Experiment;
    score: number;
}>>, radius?: number): (e: Experiment) => Promise<number | null>;
export declare function cortexGauntlet(): {
    score: 0 | 100;
    checks: Array<{
        name: string;
        pass: boolean;
        detail: string;
    }>;
};
//# sourceMappingURL=cortex.d.ts.map