import { z } from "zod";
/**
 * Per-run access-memory record: a deterministic, artifact-derived summary of
 * which files (and, later, symbols) earlier steps actually covered or edited,
 * used to bias later packet composition toward continuity (files earlier steps
 * touched are likelier relevant and cheaper to re-include).
 *
 * Invariants (single-sourced here so both orchestrators conform):
 * - **Deterministic, content-derived serialization.** `paths` is path-sorted and
 *   `lenses` lexically sorted; counters are values, never an access-ordered
 *   array — so the artifact's content hash is stable across re-derivation and
 *   never churns the staleness DAG on iteration incidentals.
 * - **Recency lives in STEP-ORDINAL space, never wall-clock.** `last_ordinal` is
 *   a result's position in the ingested ledger (a step index), so the recency
 *   signal is stable across machines/agents and clock skew.
 * - **Raw counters persisted; continuity SCORES derived JIT at dispatch.** This
 *   record carries only the raw frequency/recency counters; the personalized
 *   ranking that consumes them is computed at dispatch and never persisted.
 */
export declare const ACCESS_MEMORY_VERSION = 1;
/**
 * Reserved for the `path::symbol` granularity increment. Unpopulated by the
 * audit-side path-level harvest (AuditResult.file_coverage carries no symbol
 * information); a later increment fills it from the extractors' symbol spans.
 */
export declare const AccessMemorySymbolRecordSchema: z.ZodObject<{
    symbol: z.ZodString;
    covered_count: z.ZodNumber;
    last_ordinal: z.ZodNumber;
}, "strict", z.ZodTypeAny, {
    symbol: string;
    covered_count: number;
    last_ordinal: number;
}, {
    symbol: string;
    covered_count: number;
    last_ordinal: number;
}>;
export type AccessMemorySymbolRecord = z.infer<typeof AccessMemorySymbolRecordSchema>;
export declare const AccessMemoryPathRecordSchema: z.ZodObject<{
    path: z.ZodString;
    /** How many ingested results covered this path (audit-side frequency). */
    covered_count: z.ZodNumber;
    /** How many resolved remediate items declared this path in their edit surface (parity harvest). */
    edited_count: z.ZodNumber;
    /** Ledger-position (step) ordinal of the most recent touch — recency seed. */
    last_ordinal: z.ZodNumber;
    /** Distinct lenses that covered this path, lexically sorted. */
    lenses: z.ZodArray<z.ZodString, "many">;
    symbols: z.ZodOptional<z.ZodArray<z.ZodObject<{
        symbol: z.ZodString;
        covered_count: z.ZodNumber;
        last_ordinal: z.ZodNumber;
    }, "strict", z.ZodTypeAny, {
        symbol: string;
        covered_count: number;
        last_ordinal: number;
    }, {
        symbol: string;
        covered_count: number;
        last_ordinal: number;
    }>, "many">>;
}, "strict", z.ZodTypeAny, {
    path: string;
    covered_count: number;
    last_ordinal: number;
    edited_count: number;
    lenses: string[];
    symbols?: {
        symbol: string;
        covered_count: number;
        last_ordinal: number;
    }[] | undefined;
}, {
    path: string;
    covered_count: number;
    last_ordinal: number;
    edited_count: number;
    lenses: string[];
    symbols?: {
        symbol: string;
        covered_count: number;
        last_ordinal: number;
    }[] | undefined;
}>;
export type AccessMemoryPathRecord = z.infer<typeof AccessMemoryPathRecordSchema>;
export declare const AccessMemorySchema: z.ZodObject<{
    version: z.ZodLiteral<1>;
    run_id: z.ZodOptional<z.ZodString>;
    /** Total ordinals in scope (= ledger length), so a scorer can normalize recency. */
    total_ordinals: z.ZodNumber;
    /** Path records, sorted by path. */
    paths: z.ZodArray<z.ZodObject<{
        path: z.ZodString;
        /** How many ingested results covered this path (audit-side frequency). */
        covered_count: z.ZodNumber;
        /** How many resolved remediate items declared this path in their edit surface (parity harvest). */
        edited_count: z.ZodNumber;
        /** Ledger-position (step) ordinal of the most recent touch — recency seed. */
        last_ordinal: z.ZodNumber;
        /** Distinct lenses that covered this path, lexically sorted. */
        lenses: z.ZodArray<z.ZodString, "many">;
        symbols: z.ZodOptional<z.ZodArray<z.ZodObject<{
            symbol: z.ZodString;
            covered_count: z.ZodNumber;
            last_ordinal: z.ZodNumber;
        }, "strict", z.ZodTypeAny, {
            symbol: string;
            covered_count: number;
            last_ordinal: number;
        }, {
            symbol: string;
            covered_count: number;
            last_ordinal: number;
        }>, "many">>;
    }, "strict", z.ZodTypeAny, {
        path: string;
        covered_count: number;
        last_ordinal: number;
        edited_count: number;
        lenses: string[];
        symbols?: {
            symbol: string;
            covered_count: number;
            last_ordinal: number;
        }[] | undefined;
    }, {
        path: string;
        covered_count: number;
        last_ordinal: number;
        edited_count: number;
        lenses: string[];
        symbols?: {
            symbol: string;
            covered_count: number;
            last_ordinal: number;
        }[] | undefined;
    }>, "many">;
}, "strict", z.ZodTypeAny, {
    paths: {
        path: string;
        covered_count: number;
        last_ordinal: number;
        edited_count: number;
        lenses: string[];
        symbols?: {
            symbol: string;
            covered_count: number;
            last_ordinal: number;
        }[] | undefined;
    }[];
    version: 1;
    total_ordinals: number;
    run_id?: string | undefined;
}, {
    paths: {
        path: string;
        covered_count: number;
        last_ordinal: number;
        edited_count: number;
        lenses: string[];
        symbols?: {
            symbol: string;
            covered_count: number;
            last_ordinal: number;
        }[] | undefined;
    }[];
    version: 1;
    total_ordinals: number;
    run_id?: string | undefined;
}>;
export type AccessMemory = z.infer<typeof AccessMemorySchema>;
//# sourceMappingURL=accessMemory.d.ts.map