@mmnto/totem 1.67.0 → 1.68.0

package/dist/spine/ledgers.d.ts

@@ -0,0 +1,1102 @@
+import { z } from 'zod';
+/** Routing off the classifier gate: structural → `compile`, behavioral → `rag-only` (never compiled). */
+export declare const RoutingSchema: z.ZodEnum<["compile", "rag-only"]>;
+export type Routing = z.infer<typeof RoutingSchema>;
+/**
+ * Provenance of a classifier-ledger disposition: a genuine classifier judgment
+ * (`classified`) vs a safe-default forced by classifier failure (`error-default`,
+ * always `behavioral`/RAG-only). Reported in the §8 done-criterion so a flaky
+ * classifier's error rate is a NAMED third cause of behavioral-heavy output —
+ * never conflated with "lc structural signal is sparse" (a valid HONEST-NEGATIVE)
+ * or "the classifier mis-routed everything" (Tenet 19). It is NOT a falsifying
+ * condition (no FM clause) — a done-criterion diagnostic, like `stage4Confirmed`.
+ */
+export declare const DispositionSourceSchema: z.ZodEnum<["classified", "error-default"]>;
+export type DispositionSource = z.infer<typeof DispositionSourceSchema>;
+/**
+ * Compile + Stage-4 disposition of a compile-routed (structural) candidate (slice 4).
+ * Recorded additively on the classifier ledger so the §8 done-criterion (which reads
+ * the LEDGER, not the compiled `rule.status`) can distinguish the verify-stage outcomes
+ * rather than collapse them onto the `stage4Confirmed` boolean:
+ *   - `confirmed`             — Stage-4 found positive in-scope evidence (active rule).
+ *   - `untested-no-matches`   — Stage-4 ran, zero hits (neutral/inconclusive).
+ *   - `archived-out-of-scope` — the §4 backstop ACTIVELY rejected a mis-structural
+ *                               candidate (fired on the baseline) — a classifier-over-eager
+ *                               signal, NOT the same as `no-matches` (Tenet 19, the
+ *                               compile-stage twin of `dispositionSource`).
+ *   - `compile-rejected`      — the pattern parsed but failed per-engine safety
+ *                               validation (e.g. ReDoS); never produced as a rule.
+ * Absent on entries the compile stage never touched (behavioral/rag-only, or a
+ * classify-only run). NOT a falsifying condition (no FM clause) — a done-criterion
+ * diagnostic; the harness only locks its consistency with `stage4Confirmed`.
+ */
+export declare const Stage4LedgerOutcomeSchema: z.ZodEnum<["confirmed", "untested-no-matches", "archived-out-of-scope", "compile-rejected"]>;
+export type Stage4LedgerOutcome = z.infer<typeof Stage4LedgerOutcomeSchema>;
+export declare const EmissionLedgerEntrySchema: z.ZodObject<{
+    candidateRef: z.ZodEffects<z.ZodString, string, string>;
+    provenance: z.ZodObject<{
+        mergedPr: z.ZodNumber;
+        reviewThread: z.ZodEffects<z.ZodString, string, string>;
+        commitSha: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        mergedPr: number;
+        reviewThread: string;
+        commitSha: string;
+    }, {
+        mergedPr: number;
+        reviewThread: string;
+        commitSha: string;
+    }>;
+    classifierDisposition: z.ZodEnum<["structural", "behavioral"]>;
+    routing: z.ZodEnum<["compile", "rag-only"]>;
+    classifierLedgerRef: z.ZodEffects<z.ZodString, string, string>;
+    unverified: z.ZodLiteral<true>;
+}, "strip", z.ZodTypeAny, {
+    provenance: {
+        mergedPr: number;
+        reviewThread: string;
+        commitSha: string;
+    };
+    unverified: true;
+    classifierDisposition: "structural" | "behavioral";
+    classifierLedgerRef: string;
+    candidateRef: string;
+    routing: "compile" | "rag-only";
+}, {
+    provenance: {
+        mergedPr: number;
+        reviewThread: string;
+        commitSha: string;
+    };
+    unverified: true;
+    classifierDisposition: "structural" | "behavioral";
+    classifierLedgerRef: string;
+    candidateRef: string;
+    routing: "compile" | "rag-only";
+}>;
+export type EmissionLedgerEntry = z.infer<typeof EmissionLedgerEntrySchema>;
+export declare const EmissionLedgerSchema: z.ZodObject<{
+    entries: z.ZodArray<z.ZodObject<{
+        candidateRef: z.ZodEffects<z.ZodString, string, string>;
+        provenance: z.ZodObject<{
+            mergedPr: z.ZodNumber;
+            reviewThread: z.ZodEffects<z.ZodString, string, string>;
+            commitSha: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            mergedPr: number;
+            reviewThread: string;
+            commitSha: string;
+        }, {
+            mergedPr: number;
+            reviewThread: string;
+            commitSha: string;
+        }>;
+        classifierDisposition: z.ZodEnum<["structural", "behavioral"]>;
+        routing: z.ZodEnum<["compile", "rag-only"]>;
+        classifierLedgerRef: z.ZodEffects<z.ZodString, string, string>;
+        unverified: z.ZodLiteral<true>;
+    }, "strip", z.ZodTypeAny, {
+        provenance: {
+            mergedPr: number;
+            reviewThread: string;
+            commitSha: string;
+        };
+        unverified: true;
+        classifierDisposition: "structural" | "behavioral";
+        classifierLedgerRef: string;
+        candidateRef: string;
+        routing: "compile" | "rag-only";
+    }, {
+        provenance: {
+            mergedPr: number;
+            reviewThread: string;
+            commitSha: string;
+        };
+        unverified: true;
+        classifierDisposition: "structural" | "behavioral";
+        classifierLedgerRef: string;
+        candidateRef: string;
+        routing: "compile" | "rag-only";
+    }>, "many">;
+    /**
+     * Run-level seed-blindness attestation (§7). `false` = no seed class was
+     * supplied to any extraction/classification stage; `true` falsifies FM(f).
+     */
+    extractionInputsAttestation: z.ZodObject<{
+        seedClassesProvided: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        seedClassesProvided: boolean;
+    }, {
+        seedClassesProvided: boolean;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    entries: {
+        provenance: {
+            mergedPr: number;
+            reviewThread: string;
+            commitSha: string;
+        };
+        unverified: true;
+        classifierDisposition: "structural" | "behavioral";
+        classifierLedgerRef: string;
+        candidateRef: string;
+        routing: "compile" | "rag-only";
+    }[];
+    extractionInputsAttestation: {
+        seedClassesProvided: boolean;
+    };
+}, {
+    entries: {
+        provenance: {
+            mergedPr: number;
+            reviewThread: string;
+            commitSha: string;
+        };
+        unverified: true;
+        classifierDisposition: "structural" | "behavioral";
+        classifierLedgerRef: string;
+        candidateRef: string;
+        routing: "compile" | "rag-only";
+    }[];
+    extractionInputsAttestation: {
+        seedClassesProvided: boolean;
+    };
+}>;
+export type EmissionLedger = z.infer<typeof EmissionLedgerSchema>;
+export declare const DropReasonCodeSchema: z.ZodEnum<["unreachable", "truncated", "unparseable", "incomplete-provenance", "resolved-rejected"]>;
+export type DropReasonCode = z.infer<typeof DropReasonCodeSchema>;
+export declare const DropLedgerEntrySchema: z.ZodObject<{
+    /**
+     * Source PR of the dropped candidate. REQUIRED — the funnel always knows which
+     * train PR it is processing (it iterates the train slice), even for an
+     * `incomplete-provenance` drop where the review-thread/SHA is missing. An
+     * unrecorded source would make the drop uncreditable and open an undetectable
+     * FM(i) train-skip gap.
+     */
+    sourcePr: z.ZodNumber;
+    reasonCode: z.ZodEnum<["unreachable", "truncated", "unparseable", "incomplete-provenance", "resolved-rejected"]>;
+    detail: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    reasonCode: "unparseable" | "unreachable" | "truncated" | "incomplete-provenance" | "resolved-rejected";
+    sourcePr: number;
+    detail?: string | undefined;
+}, {
+    reasonCode: "unparseable" | "unreachable" | "truncated" | "incomplete-provenance" | "resolved-rejected";
+    sourcePr: number;
+    detail?: string | undefined;
+}>;
+export type DropLedgerEntry = z.infer<typeof DropLedgerEntrySchema>;
+export declare const DropLedgerSchema: z.ZodObject<{
+    entries: z.ZodArray<z.ZodObject<{
+        /**
+         * Source PR of the dropped candidate. REQUIRED — the funnel always knows which
+         * train PR it is processing (it iterates the train slice), even for an
+         * `incomplete-provenance` drop where the review-thread/SHA is missing. An
+         * unrecorded source would make the drop uncreditable and open an undetectable
+         * FM(i) train-skip gap.
+         */
+        sourcePr: z.ZodNumber;
+        reasonCode: z.ZodEnum<["unreachable", "truncated", "unparseable", "incomplete-provenance", "resolved-rejected"]>;
+        detail: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        reasonCode: "unparseable" | "unreachable" | "truncated" | "incomplete-provenance" | "resolved-rejected";
+        sourcePr: number;
+        detail?: string | undefined;
+    }, {
+        reasonCode: "unparseable" | "unreachable" | "truncated" | "incomplete-provenance" | "resolved-rejected";
+        sourcePr: number;
+        detail?: string | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    entries: {
+        reasonCode: "unparseable" | "unreachable" | "truncated" | "incomplete-provenance" | "resolved-rejected";
+        sourcePr: number;
+        detail?: string | undefined;
+    }[];
+}, {
+    entries: {
+        reasonCode: "unparseable" | "unreachable" | "truncated" | "incomplete-provenance" | "resolved-rejected";
+        sourcePr: number;
+        detail?: string | undefined;
+    }[];
+}>;
+export type DropLedger = z.infer<typeof DropLedgerSchema>;
+export declare const ClassifierLedgerEntrySchema: z.ZodObject<{
+    /**
+     * This classifier-ledger entry's own ref — the JOIN KEY that an emission entry's
+     * `classifierLedgerRef` points to (not necessarily the candidate's own
+     * `candidateRef`). Slice 1 joins on this ref + checks disposition consistency; a
+     * stricter same-candidate identity assertion is deferred to slice 2.
+     */
+    candidateRef: z.ZodEffects<z.ZodString, string, string>;
+    disposition: z.ZodEnum<["structural", "behavioral"]>;
+    /**
+     * Stage-4 Verify-Against-Codebase confirmation — the deterministic backstop.
+     * NON-CERTIFYING IN SLICE 1: Stage-4 is wired in slice 4, so the harness does NOT
+     * yet require `stage4Confirmed === true` for compile-routed candidates (it checks
+     * disposition consistency only). The field is carried now so slice 4 can enforce
+     * it without a schema change.
+     */
+    stage4Confirmed: z.ZodBoolean;
+    /**
+     * Whether `disposition` is a genuine classifier judgment or a safe-default on
+     * classifier failure (always `behavioral`). Present-and-`'classified'` in normal
+     * runs; set `'error-default'` on the safe-default path (slice 3). Read by the §8
+     * terminal report (slice 5) to keep a flaky-classifier error rate from
+     * masquerading as structural-signal sparsity (Tenet 19, panel flag-5). Not an FM
+     * condition — a diagnostic, like `stage4Confirmed`.
+     */
+    dispositionSource: z.ZodEnum<["classified", "error-default"]>;
+    /**
+     * Compile + Stage-4 outcome (slice 4), set by `runCompileStage` on the matched
+     * compile-routed entry. OPTIONAL — absent until the compile stage runs (and
+     * never set on behavioral/rag-only entries, which are never compiled). When
+     * present it MUST be consistent with `stage4Confirmed`: `confirmed` ⟺
+     * `stage4Confirmed === true`; the other three outcomes ⟺ `false`. The §8 harness
+     * locks that consistency (no new FM clause) — see `Stage4LedgerOutcomeSchema`.
+     */
+    stage4Outcome: z.ZodOptional<z.ZodEnum<["confirmed", "untested-no-matches", "archived-out-of-scope", "compile-rejected"]>>;
+}, "strip", z.ZodTypeAny, {
+    candidateRef: string;
+    disposition: "structural" | "behavioral";
+    stage4Confirmed: boolean;
+    dispositionSource: "classified" | "error-default";
+    stage4Outcome?: "confirmed" | "untested-no-matches" | "archived-out-of-scope" | "compile-rejected" | undefined;
+}, {
+    candidateRef: string;
+    disposition: "structural" | "behavioral";
+    stage4Confirmed: boolean;
+    dispositionSource: "classified" | "error-default";
+    stage4Outcome?: "confirmed" | "untested-no-matches" | "archived-out-of-scope" | "compile-rejected" | undefined;
+}>;
+export type ClassifierLedgerEntry = z.infer<typeof ClassifierLedgerEntrySchema>;
+export declare const ClassifierLedgerSchema: z.ZodObject<{
+    entries: z.ZodArray<z.ZodObject<{
+        /**
+         * This classifier-ledger entry's own ref — the JOIN KEY that an emission entry's
+         * `classifierLedgerRef` points to (not necessarily the candidate's own
+         * `candidateRef`). Slice 1 joins on this ref + checks disposition consistency; a
+         * stricter same-candidate identity assertion is deferred to slice 2.
+         */
+        candidateRef: z.ZodEffects<z.ZodString, string, string>;
+        disposition: z.ZodEnum<["structural", "behavioral"]>;
+        /**
+         * Stage-4 Verify-Against-Codebase confirmation — the deterministic backstop.
+         * NON-CERTIFYING IN SLICE 1: Stage-4 is wired in slice 4, so the harness does NOT
+         * yet require `stage4Confirmed === true` for compile-routed candidates (it checks
+         * disposition consistency only). The field is carried now so slice 4 can enforce
+         * it without a schema change.
+         */
+        stage4Confirmed: z.ZodBoolean;
+        /**
+         * Whether `disposition` is a genuine classifier judgment or a safe-default on
+         * classifier failure (always `behavioral`). Present-and-`'classified'` in normal
+         * runs; set `'error-default'` on the safe-default path (slice 3). Read by the §8
+         * terminal report (slice 5) to keep a flaky-classifier error rate from
+         * masquerading as structural-signal sparsity (Tenet 19, panel flag-5). Not an FM
+         * condition — a diagnostic, like `stage4Confirmed`.
+         */
+        dispositionSource: z.ZodEnum<["classified", "error-default"]>;
+        /**
+         * Compile + Stage-4 outcome (slice 4), set by `runCompileStage` on the matched
+         * compile-routed entry. OPTIONAL — absent until the compile stage runs (and
+         * never set on behavioral/rag-only entries, which are never compiled). When
+         * present it MUST be consistent with `stage4Confirmed`: `confirmed` ⟺
+         * `stage4Confirmed === true`; the other three outcomes ⟺ `false`. The §8 harness
+         * locks that consistency (no new FM clause) — see `Stage4LedgerOutcomeSchema`.
+         */
+        stage4Outcome: z.ZodOptional<z.ZodEnum<["confirmed", "untested-no-matches", "archived-out-of-scope", "compile-rejected"]>>;
+    }, "strip", z.ZodTypeAny, {
+        candidateRef: string;
+        disposition: "structural" | "behavioral";
+        stage4Confirmed: boolean;
+        dispositionSource: "classified" | "error-default";
+        stage4Outcome?: "confirmed" | "untested-no-matches" | "archived-out-of-scope" | "compile-rejected" | undefined;
+    }, {
+        candidateRef: string;
+        disposition: "structural" | "behavioral";
+        stage4Confirmed: boolean;
+        dispositionSource: "classified" | "error-default";
+        stage4Outcome?: "confirmed" | "untested-no-matches" | "archived-out-of-scope" | "compile-rejected" | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    entries: {
+        candidateRef: string;
+        disposition: "structural" | "behavioral";
+        stage4Confirmed: boolean;
+        dispositionSource: "classified" | "error-default";
+        stage4Outcome?: "confirmed" | "untested-no-matches" | "archived-out-of-scope" | "compile-rejected" | undefined;
+    }[];
+}, {
+    entries: {
+        candidateRef: string;
+        disposition: "structural" | "behavioral";
+        stage4Confirmed: boolean;
+        dispositionSource: "classified" | "error-default";
+        stage4Outcome?: "confirmed" | "untested-no-matches" | "archived-out-of-scope" | "compile-rejected" | undefined;
+    }[];
+}>;
+export type ClassifierLedger = z.infer<typeof ClassifierLedgerSchema>;
+export declare const SplitLedgerSchema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
+    split: z.ZodEffects<z.ZodObject<{
+        asOfCommit: z.ZodString;
+        trainPrs: z.ZodArray<z.ZodNumber, "many">;
+        heldOutPrs: z.ZodArray<z.ZodNumber, "many">;
+        excludedPrs: z.ZodArray<z.ZodNumber, "many">;
+        positiveControlPrs: z.ZodArray<z.ZodNumber, "many">;
+        negativeControlPrs: z.ZodArray<z.ZodNumber, "many">;
+        splitRule: z.ZodObject<{
+            predicate: z.ZodEffects<z.ZodString, string, string>;
+            cutIndex: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            predicate: string;
+            cutIndex: number;
+        }, {
+            predicate: string;
+            cutIndex: number;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        asOfCommit: string;
+        trainPrs: number[];
+        heldOutPrs: number[];
+        excludedPrs: number[];
+        positiveControlPrs: number[];
+        negativeControlPrs: number[];
+        splitRule: {
+            predicate: string;
+            cutIndex: number;
+        };
+    }, {
+        asOfCommit: string;
+        trainPrs: number[];
+        heldOutPrs: number[];
+        excludedPrs: number[];
+        positiveControlPrs: number[];
+        negativeControlPrs: number[];
+        splitRule: {
+            predicate: string;
+            cutIndex: number;
+        };
+    }>, {
+        asOfCommit: string;
+        trainPrs: number[];
+        heldOutPrs: number[];
+        excludedPrs: number[];
+        positiveControlPrs: number[];
+        negativeControlPrs: number[];
+        splitRule: {
+            predicate: string;
+            cutIndex: number;
+        };
+    }, {
+        asOfCommit: string;
+        trainPrs: number[];
+        heldOutPrs: number[];
+        excludedPrs: number[];
+        positiveControlPrs: number[];
+        negativeControlPrs: number[];
+        splitRule: {
+            predicate: string;
+            cutIndex: number;
+        };
+    }>;
+    /** The frozen corpus = `selectionRule(asOfCommit)` the cover is checked against. */
+    corpus: z.ZodArray<z.ZodNumber, "many">;
+    /** PR → merge-commit, for the disjoint-by-merge-commit check (rebuilds the map). */
+    corpusMergeCommits: z.ZodArray<z.ZodObject<{
+        pr: z.ZodNumber;
+        mergeCommit: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        pr: number;
+        mergeCommit: string;
+    }, {
+        pr: number;
+        mergeCommit: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    split: {
+        asOfCommit: string;
+        trainPrs: number[];
+        heldOutPrs: number[];
+        excludedPrs: number[];
+        positiveControlPrs: number[];
+        negativeControlPrs: number[];
+        splitRule: {
+            predicate: string;
+            cutIndex: number;
+        };
+    };
+    corpus: number[];
+    corpusMergeCommits: {
+        pr: number;
+        mergeCommit: string;
+    }[];
+}, {
+    split: {
+        asOfCommit: string;
+        trainPrs: number[];
+        heldOutPrs: number[];
+        excludedPrs: number[];
+        positiveControlPrs: number[];
+        negativeControlPrs: number[];
+        splitRule: {
+            predicate: string;
+            cutIndex: number;
+        };
+    };
+    corpus: number[];
+    corpusMergeCommits: {
+        pr: number;
+        mergeCommit: string;
+    }[];
+}>, {
+    split: {
+        asOfCommit: string;
+        trainPrs: number[];
+        heldOutPrs: number[];
+        excludedPrs: number[];
+        positiveControlPrs: number[];
+        negativeControlPrs: number[];
+        splitRule: {
+            predicate: string;
+            cutIndex: number;
+        };
+    };
+    corpus: number[];
+    corpusMergeCommits: {
+        pr: number;
+        mergeCommit: string;
+    }[];
+}, {
+    split: {
+        asOfCommit: string;
+        trainPrs: number[];
+        heldOutPrs: number[];
+        excludedPrs: number[];
+        positiveControlPrs: number[];
+        negativeControlPrs: number[];
+        splitRule: {
+            predicate: string;
+            cutIndex: number;
+        };
+    };
+    corpus: number[];
+    corpusMergeCommits: {
+        pr: number;
+        mergeCommit: string;
+    }[];
+}>, {
+    split: {
+        asOfCommit: string;
+        trainPrs: number[];
+        heldOutPrs: number[];
+        excludedPrs: number[];
+        positiveControlPrs: number[];
+        negativeControlPrs: number[];
+        splitRule: {
+            predicate: string;
+            cutIndex: number;
+        };
+    };
+    corpus: number[];
+    corpusMergeCommits: {
+        pr: number;
+        mergeCommit: string;
+    }[];
+}, {
+    split: {
+        asOfCommit: string;
+        trainPrs: number[];
+        heldOutPrs: number[];
+        excludedPrs: number[];
+        positiveControlPrs: number[];
+        negativeControlPrs: number[];
+        splitRule: {
+            predicate: string;
+            cutIndex: number;
+        };
+    };
+    corpus: number[];
+    corpusMergeCommits: {
+        pr: number;
+        mergeCommit: string;
+    }[];
+}>;
+export type SplitLedger = z.infer<typeof SplitLedgerSchema>;
+export declare const ApiFetchSliceSchema: z.ZodEnum<["train", "heldOut"]>;
+export type ApiFetchSlice = z.infer<typeof ApiFetchSliceSchema>;
+export declare const ApiUsageLedgerEntrySchema: z.ZodObject<{
+    targetPr: z.ZodNumber;
+    slice: z.ZodEnum<["train", "heldOut"]>;
+    fetchKind: z.ZodEffects<z.ZodString, string, string>;
+}, "strip", z.ZodTypeAny, {
+    slice: "train" | "heldOut";
+    targetPr: number;
+    fetchKind: string;
+}, {
+    slice: "train" | "heldOut";
+    targetPr: number;
+    fetchKind: string;
+}>;
+export type ApiUsageLedgerEntry = z.infer<typeof ApiUsageLedgerEntrySchema>;
+export declare const ApiUsageLedgerSchema: z.ZodObject<{
+    entries: z.ZodArray<z.ZodObject<{
+        targetPr: z.ZodNumber;
+        slice: z.ZodEnum<["train", "heldOut"]>;
+        fetchKind: z.ZodEffects<z.ZodString, string, string>;
+    }, "strip", z.ZodTypeAny, {
+        slice: "train" | "heldOut";
+        targetPr: number;
+        fetchKind: string;
+    }, {
+        slice: "train" | "heldOut";
+        targetPr: number;
+        fetchKind: string;
+    }>, "many">;
+    /** MUST be 0 — any held-out/control content fetch during mining falsifies FM(h). */
+    heldOutFetchCount: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    entries: {
+        slice: "train" | "heldOut";
+        targetPr: number;
+        fetchKind: string;
+    }[];
+    heldOutFetchCount: number;
+}, {
+    entries: {
+        slice: "train" | "heldOut";
+        targetPr: number;
+        fetchKind: string;
+    }[];
+    heldOutFetchCount: number;
+}>;
+export type ApiUsageLedger = z.infer<typeof ApiUsageLedgerSchema>;
+export declare const MinerLedgersSchema: z.ZodObject<{
+    emission: z.ZodObject<{
+        entries: z.ZodArray<z.ZodObject<{
+            candidateRef: z.ZodEffects<z.ZodString, string, string>;
+            provenance: z.ZodObject<{
+                mergedPr: z.ZodNumber;
+                reviewThread: z.ZodEffects<z.ZodString, string, string>;
+                commitSha: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                mergedPr: number;
+                reviewThread: string;
+                commitSha: string;
+            }, {
+                mergedPr: number;
+                reviewThread: string;
+                commitSha: string;
+            }>;
+            classifierDisposition: z.ZodEnum<["structural", "behavioral"]>;
+            routing: z.ZodEnum<["compile", "rag-only"]>;
+            classifierLedgerRef: z.ZodEffects<z.ZodString, string, string>;
+            unverified: z.ZodLiteral<true>;
+        }, "strip", z.ZodTypeAny, {
+            provenance: {
+                mergedPr: number;
+                reviewThread: string;
+                commitSha: string;
+            };
+            unverified: true;
+            classifierDisposition: "structural" | "behavioral";
+            classifierLedgerRef: string;
+            candidateRef: string;
+            routing: "compile" | "rag-only";
+        }, {
+            provenance: {
+                mergedPr: number;
+                reviewThread: string;
+                commitSha: string;
+            };
+            unverified: true;
+            classifierDisposition: "structural" | "behavioral";
+            classifierLedgerRef: string;
+            candidateRef: string;
+            routing: "compile" | "rag-only";
+        }>, "many">;
+        /**
+         * Run-level seed-blindness attestation (§7). `false` = no seed class was
+         * supplied to any extraction/classification stage; `true` falsifies FM(f).
+         */
+        extractionInputsAttestation: z.ZodObject<{
+            seedClassesProvided: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            seedClassesProvided: boolean;
+        }, {
+            seedClassesProvided: boolean;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        entries: {
+            provenance: {
+                mergedPr: number;
+                reviewThread: string;
+                commitSha: string;
+            };
+            unverified: true;
+            classifierDisposition: "structural" | "behavioral";
+            classifierLedgerRef: string;
+            candidateRef: string;
+            routing: "compile" | "rag-only";
+        }[];
+        extractionInputsAttestation: {
+            seedClassesProvided: boolean;
+        };
+    }, {
+        entries: {
+            provenance: {
+                mergedPr: number;
+                reviewThread: string;
+                commitSha: string;
+            };
+            unverified: true;
+            classifierDisposition: "structural" | "behavioral";
+            classifierLedgerRef: string;
+            candidateRef: string;
+            routing: "compile" | "rag-only";
+        }[];
+        extractionInputsAttestation: {
+            seedClassesProvided: boolean;
+        };
+    }>;
+    drop: z.ZodObject<{
+        entries: z.ZodArray<z.ZodObject<{
+            /**
+             * Source PR of the dropped candidate. REQUIRED — the funnel always knows which
+             * train PR it is processing (it iterates the train slice), even for an
+             * `incomplete-provenance` drop where the review-thread/SHA is missing. An
+             * unrecorded source would make the drop uncreditable and open an undetectable
+             * FM(i) train-skip gap.
+             */
+            sourcePr: z.ZodNumber;
+            reasonCode: z.ZodEnum<["unreachable", "truncated", "unparseable", "incomplete-provenance", "resolved-rejected"]>;
+            detail: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            reasonCode: "unparseable" | "unreachable" | "truncated" | "incomplete-provenance" | "resolved-rejected";
+            sourcePr: number;
+            detail?: string | undefined;
+        }, {
+            reasonCode: "unparseable" | "unreachable" | "truncated" | "incomplete-provenance" | "resolved-rejected";
+            sourcePr: number;
+            detail?: string | undefined;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        entries: {
+            reasonCode: "unparseable" | "unreachable" | "truncated" | "incomplete-provenance" | "resolved-rejected";
+            sourcePr: number;
+            detail?: string | undefined;
+        }[];
+    }, {
+        entries: {
+            reasonCode: "unparseable" | "unreachable" | "truncated" | "incomplete-provenance" | "resolved-rejected";
+            sourcePr: number;
+            detail?: string | undefined;
+        }[];
+    }>;
+    classifier: z.ZodObject<{
+        entries: z.ZodArray<z.ZodObject<{
+            /**
+             * This classifier-ledger entry's own ref — the JOIN KEY that an emission entry's
+             * `classifierLedgerRef` points to (not necessarily the candidate's own
+             * `candidateRef`). Slice 1 joins on this ref + checks disposition consistency; a
+             * stricter same-candidate identity assertion is deferred to slice 2.
+             */
+            candidateRef: z.ZodEffects<z.ZodString, string, string>;
+            disposition: z.ZodEnum<["structural", "behavioral"]>;
+            /**
+             * Stage-4 Verify-Against-Codebase confirmation — the deterministic backstop.
+             * NON-CERTIFYING IN SLICE 1: Stage-4 is wired in slice 4, so the harness does NOT
+             * yet require `stage4Confirmed === true` for compile-routed candidates (it checks
+             * disposition consistency only). The field is carried now so slice 4 can enforce
+             * it without a schema change.
+             */
+            stage4Confirmed: z.ZodBoolean;
+            /**
+             * Whether `disposition` is a genuine classifier judgment or a safe-default on
+             * classifier failure (always `behavioral`). Present-and-`'classified'` in normal
+             * runs; set `'error-default'` on the safe-default path (slice 3). Read by the §8
+             * terminal report (slice 5) to keep a flaky-classifier error rate from
+             * masquerading as structural-signal sparsity (Tenet 19, panel flag-5). Not an FM
+             * condition — a diagnostic, like `stage4Confirmed`.
+             */
+            dispositionSource: z.ZodEnum<["classified", "error-default"]>;
+            /**
+             * Compile + Stage-4 outcome (slice 4), set by `runCompileStage` on the matched
+             * compile-routed entry. OPTIONAL — absent until the compile stage runs (and
+             * never set on behavioral/rag-only entries, which are never compiled). When
+             * present it MUST be consistent with `stage4Confirmed`: `confirmed` ⟺
+             * `stage4Confirmed === true`; the other three outcomes ⟺ `false`. The §8 harness
+             * locks that consistency (no new FM clause) — see `Stage4LedgerOutcomeSchema`.
+             */
+            stage4Outcome: z.ZodOptional<z.ZodEnum<["confirmed", "untested-no-matches", "archived-out-of-scope", "compile-rejected"]>>;
+        }, "strip", z.ZodTypeAny, {
+            candidateRef: string;
+            disposition: "structural" | "behavioral";
+            stage4Confirmed: boolean;
+            dispositionSource: "classified" | "error-default";
+            stage4Outcome?: "confirmed" | "untested-no-matches" | "archived-out-of-scope" | "compile-rejected" | undefined;
+        }, {
+            candidateRef: string;
+            disposition: "structural" | "behavioral";
+            stage4Confirmed: boolean;
+            dispositionSource: "classified" | "error-default";
+            stage4Outcome?: "confirmed" | "untested-no-matches" | "archived-out-of-scope" | "compile-rejected" | undefined;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        entries: {
+            candidateRef: string;
+            disposition: "structural" | "behavioral";
+            stage4Confirmed: boolean;
+            dispositionSource: "classified" | "error-default";
+            stage4Outcome?: "confirmed" | "untested-no-matches" | "archived-out-of-scope" | "compile-rejected" | undefined;
+        }[];
+    }, {
+        entries: {
+            candidateRef: string;
+            disposition: "structural" | "behavioral";
+            stage4Confirmed: boolean;
+            dispositionSource: "classified" | "error-default";
+            stage4Outcome?: "confirmed" | "untested-no-matches" | "archived-out-of-scope" | "compile-rejected" | undefined;
+        }[];
+    }>;
+    split: z.ZodEffects<z.ZodEffects<z.ZodObject<{
+        split: z.ZodEffects<z.ZodObject<{
+            asOfCommit: z.ZodString;
+            trainPrs: z.ZodArray<z.ZodNumber, "many">;
+            heldOutPrs: z.ZodArray<z.ZodNumber, "many">;
+            excludedPrs: z.ZodArray<z.ZodNumber, "many">;
+            positiveControlPrs: z.ZodArray<z.ZodNumber, "many">;
+            negativeControlPrs: z.ZodArray<z.ZodNumber, "many">;
+            splitRule: z.ZodObject<{
+                predicate: z.ZodEffects<z.ZodString, string, string>;
+                cutIndex: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                predicate: string;
+                cutIndex: number;
+            }, {
+                predicate: string;
+                cutIndex: number;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            asOfCommit: string;
+            trainPrs: number[];
+            heldOutPrs: number[];
+            excludedPrs: number[];
+            positiveControlPrs: number[];
+            negativeControlPrs: number[];
+            splitRule: {
+                predicate: string;
+                cutIndex: number;
+            };
+        }, {
+            asOfCommit: string;
+            trainPrs: number[];
+            heldOutPrs: number[];
+            excludedPrs: number[];
+            positiveControlPrs: number[];
+            negativeControlPrs: number[];
+            splitRule: {
+                predicate: string;
+                cutIndex: number;
+            };
+        }>, {
+            asOfCommit: string;
+            trainPrs: number[];
+            heldOutPrs: number[];
+            excludedPrs: number[];
+            positiveControlPrs: number[];
+            negativeControlPrs: number[];
+            splitRule: {
+                predicate: string;
+                cutIndex: number;
+            };
+        }, {
+            asOfCommit: string;
+            trainPrs: number[];
+            heldOutPrs: number[];
+            excludedPrs: number[];
+            positiveControlPrs: number[];
+            negativeControlPrs: number[];
+            splitRule: {
+                predicate: string;
+                cutIndex: number;
+            };
+        }>;
+        /** The frozen corpus = `selectionRule(asOfCommit)` the cover is checked against. */
+        corpus: z.ZodArray<z.ZodNumber, "many">;
+        /** PR → merge-commit, for the disjoint-by-merge-commit check (rebuilds the map). */
+        corpusMergeCommits: z.ZodArray<z.ZodObject<{
+            pr: z.ZodNumber;
+            mergeCommit: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            pr: number;
+            mergeCommit: string;
+        }, {
+            pr: number;
+            mergeCommit: string;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        split: {
+            asOfCommit: string;
+            trainPrs: number[];
+            heldOutPrs: number[];
+            excludedPrs: number[];
+            positiveControlPrs: number[];
+            negativeControlPrs: number[];
+            splitRule: {
+                predicate: string;
+                cutIndex: number;
+            };
+        };
+        corpus: number[];
+        corpusMergeCommits: {
+            pr: number;
+            mergeCommit: string;
+        }[];
+    }, {
+        split: {
+            asOfCommit: string;
+            trainPrs: number[];
+            heldOutPrs: number[];
+            excludedPrs: number[];
+            positiveControlPrs: number[];
+            negativeControlPrs: number[];
+            splitRule: {
+                predicate: string;
+                cutIndex: number;
+            };
+        };
+        corpus: number[];
+        corpusMergeCommits: {
+            pr: number;
+            mergeCommit: string;
+        }[];
+    }>, {
+        split: {
+            asOfCommit: string;
+            trainPrs: number[];
+            heldOutPrs: number[];
+            excludedPrs: number[];
+            positiveControlPrs: number[];
+            negativeControlPrs: number[];
+            splitRule: {
+                predicate: string;
+                cutIndex: number;
+            };
+        };
+        corpus: number[];
+        corpusMergeCommits: {
+            pr: number;
+            mergeCommit: string;
+        }[];
+    }, {
+        split: {
+            asOfCommit: string;
+            trainPrs: number[];
+            heldOutPrs: number[];
+            excludedPrs: number[];
+            positiveControlPrs: number[];
+            negativeControlPrs: number[];
+            splitRule: {
+                predicate: string;
+                cutIndex: number;
+            };
+        };
+        corpus: number[];
+        corpusMergeCommits: {
+            pr: number;
+            mergeCommit: string;
+        }[];
+    }>, {
+        split: {
+            asOfCommit: string;
+            trainPrs: number[];
+            heldOutPrs: number[];
+            excludedPrs: number[];
+            positiveControlPrs: number[];
+            negativeControlPrs: number[];
+            splitRule: {
+                predicate: string;
+                cutIndex: number;
+            };
+        };
+        corpus: number[];
+        corpusMergeCommits: {
+            pr: number;
+            mergeCommit: string;
+        }[];
+    }, {
+        split: {
+            asOfCommit: string;
+            trainPrs: number[];
+            heldOutPrs: number[];
+            excludedPrs: number[];
+            positiveControlPrs: number[];
+            negativeControlPrs: number[];
+            splitRule: {
+                predicate: string;
+                cutIndex: number;
+            };
+        };
+        corpus: number[];
+        corpusMergeCommits: {
+            pr: number;
+            mergeCommit: string;
+        }[];
+    }>;
+    apiUsage: z.ZodObject<{
+        entries: z.ZodArray<z.ZodObject<{
+            targetPr: z.ZodNumber;
+            slice: z.ZodEnum<["train", "heldOut"]>;
+            fetchKind: z.ZodEffects<z.ZodString, string, string>;
+        }, "strip", z.ZodTypeAny, {
+            slice: "train" | "heldOut";
+            targetPr: number;
+            fetchKind: string;
+        }, {
+            slice: "train" | "heldOut";
+            targetPr: number;
+            fetchKind: string;
+        }>, "many">;
+        /** MUST be 0 — any held-out/control content fetch during mining falsifies FM(h). */
+        heldOutFetchCount: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        entries: {
+            slice: "train" | "heldOut";
+            targetPr: number;
+            fetchKind: string;
+        }[];
+        heldOutFetchCount: number;
+    }, {
+        entries: {
+            slice: "train" | "heldOut";
+            targetPr: number;
+            fetchKind: string;
+        }[];
+        heldOutFetchCount: number;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    split: {
+        split: {
+            asOfCommit: string;
+            trainPrs: number[];
+            heldOutPrs: number[];
+            excludedPrs: number[];
+            positiveControlPrs: number[];
+            negativeControlPrs: number[];
+            splitRule: {
+                predicate: string;
+                cutIndex: number;
+            };
+        };
+        corpus: number[];
+        corpusMergeCommits: {
+            pr: number;
+            mergeCommit: string;
+        }[];
+    };
+    emission: {
+        entries: {
+            provenance: {
+                mergedPr: number;
+                reviewThread: string;
+                commitSha: string;
+            };
+            unverified: true;
+            classifierDisposition: "structural" | "behavioral";
+            classifierLedgerRef: string;
+            candidateRef: string;
+            routing: "compile" | "rag-only";
+        }[];
+        extractionInputsAttestation: {
+            seedClassesProvided: boolean;
+        };
+    };
+    drop: {
+        entries: {
+            reasonCode: "unparseable" | "unreachable" | "truncated" | "incomplete-provenance" | "resolved-rejected";
+            sourcePr: number;
+            detail?: string | undefined;
+        }[];
+    };
+    classifier: {
+        entries: {
+            candidateRef: string;
+            disposition: "structural" | "behavioral";
+            stage4Confirmed: boolean;
+            dispositionSource: "classified" | "error-default";
+            stage4Outcome?: "confirmed" | "untested-no-matches" | "archived-out-of-scope" | "compile-rejected" | undefined;
+        }[];
+    };
+    apiUsage: {
+        entries: {
+            slice: "train" | "heldOut";
+            targetPr: number;
+            fetchKind: string;
+        }[];
+        heldOutFetchCount: number;
+    };
+}, {
+    split: {
+        split: {
+            asOfCommit: string;
+            trainPrs: number[];
+            heldOutPrs: number[];
+            excludedPrs: number[];
+            positiveControlPrs: number[];
+            negativeControlPrs: number[];
+            splitRule: {
+                predicate: string;
+                cutIndex: number;
+            };
+        };
+        corpus: number[];
+        corpusMergeCommits: {
+            pr: number;
+            mergeCommit: string;
+        }[];
+    };
+    emission: {
+        entries: {
+            provenance: {
+                mergedPr: number;
+                reviewThread: string;
+                commitSha: string;
+            };
+            unverified: true;
+            classifierDisposition: "structural" | "behavioral";
+            classifierLedgerRef: string;
+            candidateRef: string;
+            routing: "compile" | "rag-only";
+        }[];
+        extractionInputsAttestation: {
+            seedClassesProvided: boolean;
+        };
+    };
+    drop: {
+        entries: {
+            reasonCode: "unparseable" | "unreachable" | "truncated" | "incomplete-provenance" | "resolved-rejected";
+            sourcePr: number;
+            detail?: string | undefined;
+        }[];
+    };
+    classifier: {
+        entries: {
+            candidateRef: string;
+            disposition: "structural" | "behavioral";
+            stage4Confirmed: boolean;
+            dispositionSource: "classified" | "error-default";
+            stage4Outcome?: "confirmed" | "untested-no-matches" | "archived-out-of-scope" | "compile-rejected" | undefined;
+        }[];
+    };
+    apiUsage: {
+        entries: {
+            slice: "train" | "heldOut";
+            targetPr: number;
+            fetchKind: string;
+        }[];
+        heldOutFetchCount: number;
+    };
+}>;
+export type MinerLedgers = z.infer<typeof MinerLedgersSchema>;
+//# sourceMappingURL=ledgers.d.ts.map