@mmnto/totem 1.78.0 → 1.80.0

package/dist/compiler-schema.d.ts

@@ -36,6 +36,15 @@ export declare const AstGrepYamlRuleSchema: z.ZodObject<{
     rule: z.ZodRecord<z.ZodString, z.ZodUnknown>;
 }, z.ZodTypeAny, "passthrough">>;
 export type AstGrepYamlRule = NapiConfig;
+/**
+ * True iff `s` is a well-formed ISO-8601 date/timestamp AND a REAL calendar date.
+ * `Date.parse` alone is insufficient: it NORMALIZES day-overflow (`2026-02-31` → Mar 3,
+ * `2026-02-29` non-leap → Mar 1) instead of rejecting it (#2259 CR re-review). The
+ * `Date.UTC` round-trip validates the date HEAD's calendar independently of any timezone
+ * in the time component — a negative offset can legitimately shift the UTC day, so the
+ * head, not the parsed instant, is what must round-trip.
+ */
+export declare function isIso8601CalendarDate(s: string): boolean;
 /**
  * mmnto-ai/totem#2183 — the §3.1 provenance leg of the ADR-110 Gate-1
  * legitimacy bar: the identity of the merged-PR history a regenerated rule was
@@ -45,8 +54,25 @@ export type AstGrepYamlRule = NapiConfig;
  * zero-trust), the single source of truth `deriveRuleClass` reads. Control
  * *evidence* (which PRs/fixtures proved each control) rides the wind-tunnel
  * manifest (ADR-110 §6), not the per-rule marker.
+ *
+ * **ADR-112 — this is the MINED variant of the `ProvenanceRecord` union.** The
+ * wire shape is otherwise UNCHANGED: `kind` is OPTIONAL and absent on every
+ * pre-ADR-112 record, so a legacy mined provenance parses + reserializes
+ * BYTE-IDENTICAL (no added key — `canonicalStringify` omits the undefined
+ * discriminator exactly as it omits an absent `unverified`), preserving the
+ * non-mutating-refine manifest-hash discipline. Absence ⇒ `'mined'` via
+ * `provenanceKind()`; the miner path types its provenance as
+ * `MinedProvenanceRecord` (the documented mining-only boundary), so its readers
+ * of `mergedPr` / `commitSha` stay type-safe without narrowing.
  */
-export declare const ProvenanceRecordSchema: z.ZodObject<{
+export declare const MinedProvenanceWireSchema: z.ZodObject<{
+    /**
+     * ADR-112 discriminator. OPTIONAL on the mined wire so legacy records (which
+     * have no `kind`) round-trip byte-identical; absence is read as `'mined'` by
+     * `provenanceKind()`. A new mined artifact MAY carry `kind: 'mined'` only
+     * where the resulting hash churn is intentional.
+     */
+    kind: z.ZodOptional<z.ZodLiteral<"mined">>;
     /** Merged PR the rule was mined from (positive integer PR number). */
     mergedPr: z.ZodNumber;
     /**
@@ -64,12 +90,865 @@ export declare const ProvenanceRecordSchema: z.ZodObject<{
     mergedPr: number;
     reviewThread: string;
     commitSha: string;
+    kind?: "mined" | undefined;
 }, {
     mergedPr: number;
     reviewThread: string;
     commitSha: string;
+    kind?: "mined" | undefined;
 }>;
+export type MinedProvenanceRecord = z.infer<typeof MinedProvenanceWireSchema>;
+/**
+ * ADR-112 §4 — the preimage-differential SOURCE for one fixture, a discriminated
+ * union on `kind` (declared PER FIXTURE; not a fixed binding to landed commits).
+ * The materializer (slice C/D) fires the matcher on the preimage and asserts it
+ * is SILENT on the postimage — a matcher that fires only on the fixed form is
+ * fix-shaped and is NOT a legitimate positive control (FM(i)):
+ *   - `lesson` (PRIMARY, review-caught repos): the lesson corpus' `badExample`
+ *     (preimage — fire) / `goodExample` (postimage — silent). `lessonRef` is an
+ *     IMMUTABLE lesson id/hash (the `hashLesson` codomain, `LESSON_REF_RE`),
+ *     never a path/mutable alias (§8 identity discipline).
+ *   - `commit` (FALLBACK, land-then-fix repos): the pre-fix parent
+ *     (`preimageCommitSha` — fire) / post-fix merge (`mergeCommitSha` — silent).
+ *
+ * `z.discriminatedUnion` (not `z.union`): both branches carry a REQUIRED literal
+ * `kind`, so Zod routes a parse error to the matched branch instead of emitting
+ * "no union member matched" noise (cf. `cert-corpus-seed.ts`'s `window`). The
+ * OPTIONAL-discriminator round-trip reason `ProvenanceRecordSchema` documents for
+ * its `z.union` does NOT apply — `preimageSource` is a new field with no persisted
+ * authored set. Each branch is `.strict()` so a cross-branch key (e.g. a
+ * `badExample` under `kind:'commit'`) fails LOUD (FM(d) posture) rather than being
+ * silently stripped. All refines are NON-mutating (no `.trim()`) to preserve the
+ * manifest-hash stability discipline.
+ */
+export declare const PreimageSourceSchema: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+    kind: z.ZodLiteral<"lesson">;
+    /** IMMUTABLE lesson id/hash (the 16-hex `hashLesson` codomain) — never a path/mutable alias (§4/§8). */
+    lessonRef: z.ZodString;
+    /**
+     * The defect PREIMAGE exemplar the matcher must FIRE on (§4). This is a lesson
+     * corpus `badExample` — distinct from `CompiledRuleBaseSchema.badExample` (an
+     * optional human-readable code snippet on a compiled rule); here it is the
+     * load-bearing positive-control preimage, so non-empty is required.
+     */
+    badExample: z.ZodEffects<z.ZodString, string, string>;
+    /** The fixed POSTIMAGE exemplar the matcher must stay SILENT on (§4) — a lesson `goodExample`. */
+    goodExample: z.ZodEffects<z.ZodString, string, string>;
+}, "strict", z.ZodTypeAny, {
+    kind: "lesson";
+    lessonRef: string;
+    badExample: string;
+    goodExample: string;
+}, {
+    kind: "lesson";
+    lessonRef: string;
+    badExample: string;
+    goodExample: string;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"commit">;
+    /** The PARENT (pre-fix) commit where the DEFECT is present — the matcher must FIRE on this (ADR-112 §4). */
+    preimageCommitSha: z.ZodString;
+    /** The PR's merge/squash commit — the post-fix (defect-absent) anchor; the matcher must stay SILENT on this. */
+    mergeCommitSha: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    kind: "commit";
+    preimageCommitSha: string;
+    mergeCommitSha: string;
+}, {
+    kind: "commit";
+    preimageCommitSha: string;
+    mergeCommitSha: string;
+}>]>;
+export type PreimageSource = z.infer<typeof PreimageSourceSchema>;
+/**
+ * ADR-112 §3 — one real lc instance an authored rule claims to catch. ALL such
+ * fixtures are TRAIN-side (the §5 leakage guard); the preimage-differential
+ * (§4) is evaluated in slice C/D, but the record CARRIES the declared
+ * `preimageSource` (lesson | commit) + the defect locus here so derivation is
+ * possible. `matchedSpan` + `contentHash` are the line-drift-stable locus
+ * (cf. `firingLabelId`), not just the file.
+ */
+export declare const AuthoredFixtureSchema: z.ZodEffects<z.ZodObject<{
+    /** The PR where the defect was caught/introduced (the in-corpus anchor). */
+    pr: z.ZodNumber;
+    /** The §4 preimage-differential source — lesson-anchored (PRIMARY) or commit-pair (FALLBACK). */
+    preimageSource: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+        kind: z.ZodLiteral<"lesson">;
+        /** IMMUTABLE lesson id/hash (the 16-hex `hashLesson` codomain) — never a path/mutable alias (§4/§8). */
+        lessonRef: z.ZodString;
+        /**
+         * The defect PREIMAGE exemplar the matcher must FIRE on (§4). This is a lesson
+         * corpus `badExample` — distinct from `CompiledRuleBaseSchema.badExample` (an
+         * optional human-readable code snippet on a compiled rule); here it is the
+         * load-bearing positive-control preimage, so non-empty is required.
+         */
+        badExample: z.ZodEffects<z.ZodString, string, string>;
+        /** The fixed POSTIMAGE exemplar the matcher must stay SILENT on (§4) — a lesson `goodExample`. */
+        goodExample: z.ZodEffects<z.ZodString, string, string>;
+    }, "strict", z.ZodTypeAny, {
+        kind: "lesson";
+        lessonRef: string;
+        badExample: string;
+        goodExample: string;
+    }, {
+        kind: "lesson";
+        lessonRef: string;
+        badExample: string;
+        goodExample: string;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"commit">;
+        /** The PARENT (pre-fix) commit where the DEFECT is present — the matcher must FIRE on this (ADR-112 §4). */
+        preimageCommitSha: z.ZodString;
+        /** The PR's merge/squash commit — the post-fix (defect-absent) anchor; the matcher must stay SILENT on this. */
+        mergeCommitSha: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        kind: "commit";
+        preimageCommitSha: string;
+        mergeCommitSha: string;
+    }, {
+        kind: "commit";
+        preimageCommitSha: string;
+        mergeCommitSha: string;
+    }>]>;
+    /** File the defect locus lives in. */
+    filePath: z.ZodEffects<z.ZodString, string, string>;
+    /** Line-range or AST-node path — the defect locus, not just the file. */
+    matchedSpan: z.ZodEffects<z.ZodString, string, string>;
+    /** Span content hash, line-drift-stable (cf. `firingLabelId`). */
+    contentHash: z.ZodEffects<z.ZodString, string, string>;
+}, "strict", z.ZodTypeAny, {
+    pr: number;
+    preimageSource: {
+        kind: "lesson";
+        lessonRef: string;
+        badExample: string;
+        goodExample: string;
+    } | {
+        kind: "commit";
+        preimageCommitSha: string;
+        mergeCommitSha: string;
+    };
+    filePath: string;
+    matchedSpan: string;
+    contentHash: string;
+}, {
+    pr: number;
+    preimageSource: {
+        kind: "lesson";
+        lessonRef: string;
+        badExample: string;
+        goodExample: string;
+    } | {
+        kind: "commit";
+        preimageCommitSha: string;
+        mergeCommitSha: string;
+    };
+    filePath: string;
+    matchedSpan: string;
+    contentHash: string;
+}>, {
+    pr: number;
+    preimageSource: {
+        kind: "lesson";
+        lessonRef: string;
+        badExample: string;
+        goodExample: string;
+    } | {
+        kind: "commit";
+        preimageCommitSha: string;
+        mergeCommitSha: string;
+    };
+    filePath: string;
+    matchedSpan: string;
+    contentHash: string;
+}, {
+    pr: number;
+    preimageSource: {
+        kind: "lesson";
+        lessonRef: string;
+        badExample: string;
+        goodExample: string;
+    } | {
+        kind: "commit";
+        preimageCommitSha: string;
+        mergeCommitSha: string;
+    };
+    filePath: string;
+    matchedSpan: string;
+    contentHash: string;
+}>;
+export type AuthoredFixture = z.infer<typeof AuthoredFixtureSchema>;
+/**
+ * ADR-112 §3 — the AUTHORED variant of the `ProvenanceRecord` union. A
+ * hand-authored rule is anchored to a real historical DEFECT (the pre-image,
+ * NOT its fix — ADR-110 §4 TP-def) via ≥1 train-side `positiveFixtures` entry.
+ * `kind: 'authored'` is REQUIRED (the discriminator), so this can never be
+ * mistaken for a mined record and an authored record can never round-trip as
+ * mined. Attributable (`author` never anonymous); the embargo/ledger
+ * attestations ride the §8 authoring-ledger, not this marker.
+ */
+export declare const AuthoredProvenanceRecordSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"authored">;
+    /** Agent-id or operator handle — attributable, never anonymous. */
+    author: z.ZodEffects<z.ZodString, string, string>;
+    /** ISO-8601 authoring date — a real calendar date (`YYYY-MM-DD`) or a full timestamp. */
+    authoredAt: z.ZodEffects<z.ZodString, string, string>;
+    /** The declared DEFECT the rule targets — the pre-image, not its fix. */
+    targetDefect: z.ZodEffects<z.ZodString, string, string>;
+    /** ≥1 real lc instance the rule claims to catch — ALL train-side (§5). */
+    positiveFixtures: z.ZodArray<z.ZodEffects<z.ZodObject<{
+        /** The PR where the defect was caught/introduced (the in-corpus anchor). */
+        pr: z.ZodNumber;
+        /** The §4 preimage-differential source — lesson-anchored (PRIMARY) or commit-pair (FALLBACK). */
+        preimageSource: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+            kind: z.ZodLiteral<"lesson">;
+            /** IMMUTABLE lesson id/hash (the 16-hex `hashLesson` codomain) — never a path/mutable alias (§4/§8). */
+            lessonRef: z.ZodString;
+            /**
+             * The defect PREIMAGE exemplar the matcher must FIRE on (§4). This is a lesson
+             * corpus `badExample` — distinct from `CompiledRuleBaseSchema.badExample` (an
+             * optional human-readable code snippet on a compiled rule); here it is the
+             * load-bearing positive-control preimage, so non-empty is required.
+             */
+            badExample: z.ZodEffects<z.ZodString, string, string>;
+            /** The fixed POSTIMAGE exemplar the matcher must stay SILENT on (§4) — a lesson `goodExample`. */
+            goodExample: z.ZodEffects<z.ZodString, string, string>;
+        }, "strict", z.ZodTypeAny, {
+            kind: "lesson";
+            lessonRef: string;
+            badExample: string;
+            goodExample: string;
+        }, {
+            kind: "lesson";
+            lessonRef: string;
+            badExample: string;
+            goodExample: string;
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"commit">;
+            /** The PARENT (pre-fix) commit where the DEFECT is present — the matcher must FIRE on this (ADR-112 §4). */
+            preimageCommitSha: z.ZodString;
+            /** The PR's merge/squash commit — the post-fix (defect-absent) anchor; the matcher must stay SILENT on this. */
+            mergeCommitSha: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            kind: "commit";
+            preimageCommitSha: string;
+            mergeCommitSha: string;
+        }, {
+            kind: "commit";
+            preimageCommitSha: string;
+            mergeCommitSha: string;
+        }>]>;
+        /** File the defect locus lives in. */
+        filePath: z.ZodEffects<z.ZodString, string, string>;
+        /** Line-range or AST-node path — the defect locus, not just the file. */
+        matchedSpan: z.ZodEffects<z.ZodString, string, string>;
+        /** Span content hash, line-drift-stable (cf. `firingLabelId`). */
+        contentHash: z.ZodEffects<z.ZodString, string, string>;
+    }, "strict", z.ZodTypeAny, {
+        pr: number;
+        preimageSource: {
+            kind: "lesson";
+            lessonRef: string;
+            badExample: string;
+            goodExample: string;
+        } | {
+            kind: "commit";
+            preimageCommitSha: string;
+            mergeCommitSha: string;
+        };
+        filePath: string;
+        matchedSpan: string;
+        contentHash: string;
+    }, {
+        pr: number;
+        preimageSource: {
+            kind: "lesson";
+            lessonRef: string;
+            badExample: string;
+            goodExample: string;
+        } | {
+            kind: "commit";
+            preimageCommitSha: string;
+            mergeCommitSha: string;
+        };
+        filePath: string;
+        matchedSpan: string;
+        contentHash: string;
+    }>, {
+        pr: number;
+        preimageSource: {
+            kind: "lesson";
+            lessonRef: string;
+            badExample: string;
+            goodExample: string;
+        } | {
+            kind: "commit";
+            preimageCommitSha: string;
+            mergeCommitSha: string;
+        };
+        filePath: string;
+        matchedSpan: string;
+        contentHash: string;
+    }, {
+        pr: number;
+        preimageSource: {
+            kind: "lesson";
+            lessonRef: string;
+            badExample: string;
+            goodExample: string;
+        } | {
+            kind: "commit";
+            preimageCommitSha: string;
+            mergeCommitSha: string;
+        };
+        filePath: string;
+        matchedSpan: string;
+        contentHash: string;
+    }>, "many">;
+    /** Declared near-misses the rule must stay silent on (feeds §6 negative controls). */
+    negativeFixtures: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodObject<{
+        /** The PR where the defect was caught/introduced (the in-corpus anchor). */
+        pr: z.ZodNumber;
+        /** The §4 preimage-differential source — lesson-anchored (PRIMARY) or commit-pair (FALLBACK). */
+        preimageSource: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+            kind: z.ZodLiteral<"lesson">;
+            /** IMMUTABLE lesson id/hash (the 16-hex `hashLesson` codomain) — never a path/mutable alias (§4/§8). */
+            lessonRef: z.ZodString;
+            /**
+             * The defect PREIMAGE exemplar the matcher must FIRE on (§4). This is a lesson
+             * corpus `badExample` — distinct from `CompiledRuleBaseSchema.badExample` (an
+             * optional human-readable code snippet on a compiled rule); here it is the
+             * load-bearing positive-control preimage, so non-empty is required.
+             */
+            badExample: z.ZodEffects<z.ZodString, string, string>;
+            /** The fixed POSTIMAGE exemplar the matcher must stay SILENT on (§4) — a lesson `goodExample`. */
+            goodExample: z.ZodEffects<z.ZodString, string, string>;
+        }, "strict", z.ZodTypeAny, {
+            kind: "lesson";
+            lessonRef: string;
+            badExample: string;
+            goodExample: string;
+        }, {
+            kind: "lesson";
+            lessonRef: string;
+            badExample: string;
+            goodExample: string;
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"commit">;
+            /** The PARENT (pre-fix) commit where the DEFECT is present — the matcher must FIRE on this (ADR-112 §4). */
+            preimageCommitSha: z.ZodString;
+            /** The PR's merge/squash commit — the post-fix (defect-absent) anchor; the matcher must stay SILENT on this. */
+            mergeCommitSha: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            kind: "commit";
+            preimageCommitSha: string;
+            mergeCommitSha: string;
+        }, {
+            kind: "commit";
+            preimageCommitSha: string;
+            mergeCommitSha: string;
+        }>]>;
+        /** File the defect locus lives in. */
+        filePath: z.ZodEffects<z.ZodString, string, string>;
+        /** Line-range or AST-node path — the defect locus, not just the file. */
+        matchedSpan: z.ZodEffects<z.ZodString, string, string>;
+        /** Span content hash, line-drift-stable (cf. `firingLabelId`). */
+        contentHash: z.ZodEffects<z.ZodString, string, string>;
+    }, "strict", z.ZodTypeAny, {
+        pr: number;
+        preimageSource: {
+            kind: "lesson";
+            lessonRef: string;
+            badExample: string;
+            goodExample: string;
+        } | {
+            kind: "commit";
+            preimageCommitSha: string;
+            mergeCommitSha: string;
+        };
+        filePath: string;
+        matchedSpan: string;
+        contentHash: string;
+    }, {
+        pr: number;
+        preimageSource: {
+            kind: "lesson";
+            lessonRef: string;
+            badExample: string;
+            goodExample: string;
+        } | {
+            kind: "commit";
+            preimageCommitSha: string;
+            mergeCommitSha: string;
+        };
+        filePath: string;
+        matchedSpan: string;
+        contentHash: string;
+    }>, {
+        pr: number;
+        preimageSource: {
+            kind: "lesson";
+            lessonRef: string;
+            badExample: string;
+            goodExample: string;
+        } | {
+            kind: "commit";
+            preimageCommitSha: string;
+            mergeCommitSha: string;
+        };
+        filePath: string;
+        matchedSpan: string;
+        contentHash: string;
+    }, {
+        pr: number;
+        preimageSource: {
+            kind: "lesson";
+            lessonRef: string;
+            badExample: string;
+            goodExample: string;
+        } | {
+            kind: "commit";
+            preimageCommitSha: string;
+            mergeCommitSha: string;
+        };
+        filePath: string;
+        matchedSpan: string;
+        contentHash: string;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    kind: "authored";
+    author: string;
+    authoredAt: string;
+    targetDefect: string;
+    positiveFixtures: {
+        pr: number;
+        preimageSource: {
+            kind: "lesson";
+            lessonRef: string;
+            badExample: string;
+            goodExample: string;
+        } | {
+            kind: "commit";
+            preimageCommitSha: string;
+            mergeCommitSha: string;
+        };
+        filePath: string;
+        matchedSpan: string;
+        contentHash: string;
+    }[];
+    negativeFixtures?: {
+        pr: number;
+        preimageSource: {
+            kind: "lesson";
+            lessonRef: string;
+            badExample: string;
+            goodExample: string;
+        } | {
+            kind: "commit";
+            preimageCommitSha: string;
+            mergeCommitSha: string;
+        };
+        filePath: string;
+        matchedSpan: string;
+        contentHash: string;
+    }[] | undefined;
+}, {
+    kind: "authored";
+    author: string;
+    authoredAt: string;
+    targetDefect: string;
+    positiveFixtures: {
+        pr: number;
+        preimageSource: {
+            kind: "lesson";
+            lessonRef: string;
+            badExample: string;
+            goodExample: string;
+        } | {
+            kind: "commit";
+            preimageCommitSha: string;
+            mergeCommitSha: string;
+        };
+        filePath: string;
+        matchedSpan: string;
+        contentHash: string;
+    }[];
+    negativeFixtures?: {
+        pr: number;
+        preimageSource: {
+            kind: "lesson";
+            lessonRef: string;
+            badExample: string;
+            goodExample: string;
+        } | {
+            kind: "commit";
+            preimageCommitSha: string;
+            mergeCommitSha: string;
+        };
+        filePath: string;
+        matchedSpan: string;
+        contentHash: string;
+    }[] | undefined;
+}>;
+export type AuthoredProvenanceRecord = z.infer<typeof AuthoredProvenanceRecordSchema>;
+/**
+ * ADR-112 §3 — `provenance` is a discriminated UNION on `kind`
+ * (`mined | authored`), the first multi-producer attribute on a rule
+ * (Consequence 3). Built as a `z.union` (NOT `z.discriminatedUnion`) on
+ * purpose: the mined wire keeps `kind` OPTIONAL for byte-identical legacy
+ * round-trip, which a required-discriminator schema cannot express. The two
+ * branches are disjoint on their required fields (`authored` requires
+ * `kind:'authored'` + author/targetDefect/fixtures; the mined branch is the
+ * only one a legacy `{mergedPr, reviewThread, commitSha}` record satisfies), so
+ * the union is unambiguous. `Authored` is listed FIRST so a record carrying
+ * `kind:'authored'` never matches the mined branch.
+ */
+export declare const ProvenanceRecordSchema: z.ZodUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"authored">;
+    /** Agent-id or operator handle — attributable, never anonymous. */
+    author: z.ZodEffects<z.ZodString, string, string>;
+    /** ISO-8601 authoring date — a real calendar date (`YYYY-MM-DD`) or a full timestamp. */
+    authoredAt: z.ZodEffects<z.ZodString, string, string>;
+    /** The declared DEFECT the rule targets — the pre-image, not its fix. */
+    targetDefect: z.ZodEffects<z.ZodString, string, string>;
+    /** ≥1 real lc instance the rule claims to catch — ALL train-side (§5). */
+    positiveFixtures: z.ZodArray<z.ZodEffects<z.ZodObject<{
+        /** The PR where the defect was caught/introduced (the in-corpus anchor). */
+        pr: z.ZodNumber;
+        /** The §4 preimage-differential source — lesson-anchored (PRIMARY) or commit-pair (FALLBACK). */
+        preimageSource: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+            kind: z.ZodLiteral<"lesson">;
+            /** IMMUTABLE lesson id/hash (the 16-hex `hashLesson` codomain) — never a path/mutable alias (§4/§8). */
+            lessonRef: z.ZodString;
+            /**
+             * The defect PREIMAGE exemplar the matcher must FIRE on (§4). This is a lesson
+             * corpus `badExample` — distinct from `CompiledRuleBaseSchema.badExample` (an
+             * optional human-readable code snippet on a compiled rule); here it is the
+             * load-bearing positive-control preimage, so non-empty is required.
+             */
+            badExample: z.ZodEffects<z.ZodString, string, string>;
+            /** The fixed POSTIMAGE exemplar the matcher must stay SILENT on (§4) — a lesson `goodExample`. */
+            goodExample: z.ZodEffects<z.ZodString, string, string>;
+        }, "strict", z.ZodTypeAny, {
+            kind: "lesson";
+            lessonRef: string;
+            badExample: string;
+            goodExample: string;
+        }, {
+            kind: "lesson";
+            lessonRef: string;
+            badExample: string;
+            goodExample: string;
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"commit">;
+            /** The PARENT (pre-fix) commit where the DEFECT is present — the matcher must FIRE on this (ADR-112 §4). */
+            preimageCommitSha: z.ZodString;
+            /** The PR's merge/squash commit — the post-fix (defect-absent) anchor; the matcher must stay SILENT on this. */
+            mergeCommitSha: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            kind: "commit";
+            preimageCommitSha: string;
+            mergeCommitSha: string;
+        }, {
+            kind: "commit";
+            preimageCommitSha: string;
+            mergeCommitSha: string;
+        }>]>;
+        /** File the defect locus lives in. */
+        filePath: z.ZodEffects<z.ZodString, string, string>;
+        /** Line-range or AST-node path — the defect locus, not just the file. */
+        matchedSpan: z.ZodEffects<z.ZodString, string, string>;
+        /** Span content hash, line-drift-stable (cf. `firingLabelId`). */
+        contentHash: z.ZodEffects<z.ZodString, string, string>;
+    }, "strict", z.ZodTypeAny, {
+        pr: number;
+        preimageSource: {
+            kind: "lesson";
+            lessonRef: string;
+            badExample: string;
+            goodExample: string;
+        } | {
+            kind: "commit";
+            preimageCommitSha: string;
+            mergeCommitSha: string;
+        };
+        filePath: string;
+        matchedSpan: string;
+        contentHash: string;
+    }, {
+        pr: number;
+        preimageSource: {
+            kind: "lesson";
+            lessonRef: string;
+            badExample: string;
+            goodExample: string;
+        } | {
+            kind: "commit";
+            preimageCommitSha: string;
+            mergeCommitSha: string;
+        };
+        filePath: string;
+        matchedSpan: string;
+        contentHash: string;
+    }>, {
+        pr: number;
+        preimageSource: {
+            kind: "lesson";
+            lessonRef: string;
+            badExample: string;
+            goodExample: string;
+        } | {
+            kind: "commit";
+            preimageCommitSha: string;
+            mergeCommitSha: string;
+        };
+        filePath: string;
+        matchedSpan: string;
+        contentHash: string;
+    }, {
+        pr: number;
+        preimageSource: {
+            kind: "lesson";
+            lessonRef: string;
+            badExample: string;
+            goodExample: string;
+        } | {
+            kind: "commit";
+            preimageCommitSha: string;
+            mergeCommitSha: string;
+        };
+        filePath: string;
+        matchedSpan: string;
+        contentHash: string;
+    }>, "many">;
+    /** Declared near-misses the rule must stay silent on (feeds §6 negative controls). */
+    negativeFixtures: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodObject<{
+        /** The PR where the defect was caught/introduced (the in-corpus anchor). */
+        pr: z.ZodNumber;
+        /** The §4 preimage-differential source — lesson-anchored (PRIMARY) or commit-pair (FALLBACK). */
+        preimageSource: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+            kind: z.ZodLiteral<"lesson">;
+            /** IMMUTABLE lesson id/hash (the 16-hex `hashLesson` codomain) — never a path/mutable alias (§4/§8). */
+            lessonRef: z.ZodString;
+            /**
+             * The defect PREIMAGE exemplar the matcher must FIRE on (§4). This is a lesson
+             * corpus `badExample` — distinct from `CompiledRuleBaseSchema.badExample` (an
+             * optional human-readable code snippet on a compiled rule); here it is the
+             * load-bearing positive-control preimage, so non-empty is required.
+             */
+            badExample: z.ZodEffects<z.ZodString, string, string>;
+            /** The fixed POSTIMAGE exemplar the matcher must stay SILENT on (§4) — a lesson `goodExample`. */
+            goodExample: z.ZodEffects<z.ZodString, string, string>;
+        }, "strict", z.ZodTypeAny, {
+            kind: "lesson";
+            lessonRef: string;
+            badExample: string;
+            goodExample: string;
+        }, {
+            kind: "lesson";
+            lessonRef: string;
+            badExample: string;
+            goodExample: string;
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"commit">;
+            /** The PARENT (pre-fix) commit where the DEFECT is present — the matcher must FIRE on this (ADR-112 §4). */
+            preimageCommitSha: z.ZodString;
+            /** The PR's merge/squash commit — the post-fix (defect-absent) anchor; the matcher must stay SILENT on this. */
+            mergeCommitSha: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            kind: "commit";
+            preimageCommitSha: string;
+            mergeCommitSha: string;
+        }, {
+            kind: "commit";
+            preimageCommitSha: string;
+            mergeCommitSha: string;
+        }>]>;
+        /** File the defect locus lives in. */
+        filePath: z.ZodEffects<z.ZodString, string, string>;
+        /** Line-range or AST-node path — the defect locus, not just the file. */
+        matchedSpan: z.ZodEffects<z.ZodString, string, string>;
+        /** Span content hash, line-drift-stable (cf. `firingLabelId`). */
+        contentHash: z.ZodEffects<z.ZodString, string, string>;
+    }, "strict", z.ZodTypeAny, {
+        pr: number;
+        preimageSource: {
+            kind: "lesson";
+            lessonRef: string;
+            badExample: string;
+            goodExample: string;
+        } | {
+            kind: "commit";
+            preimageCommitSha: string;
+            mergeCommitSha: string;
+        };
+        filePath: string;
+        matchedSpan: string;
+        contentHash: string;
+    }, {
+        pr: number;
+        preimageSource: {
+            kind: "lesson";
+            lessonRef: string;
+            badExample: string;
+            goodExample: string;
+        } | {
+            kind: "commit";
+            preimageCommitSha: string;
+            mergeCommitSha: string;
+        };
+        filePath: string;
+        matchedSpan: string;
+        contentHash: string;
+    }>, {
+        pr: number;
+        preimageSource: {
+            kind: "lesson";
+            lessonRef: string;
+            badExample: string;
+            goodExample: string;
+        } | {
+            kind: "commit";
+            preimageCommitSha: string;
+            mergeCommitSha: string;
+        };
+        filePath: string;
+        matchedSpan: string;
+        contentHash: string;
+    }, {
+        pr: number;
+        preimageSource: {
+            kind: "lesson";
+            lessonRef: string;
+            badExample: string;
+            goodExample: string;
+        } | {
+            kind: "commit";
+            preimageCommitSha: string;
+            mergeCommitSha: string;
+        };
+        filePath: string;
+        matchedSpan: string;
+        contentHash: string;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    kind: "authored";
+    author: string;
+    authoredAt: string;
+    targetDefect: string;
+    positiveFixtures: {
+        pr: number;
+        preimageSource: {
+            kind: "lesson";
+            lessonRef: string;
+            badExample: string;
+            goodExample: string;
+        } | {
+            kind: "commit";
+            preimageCommitSha: string;
+            mergeCommitSha: string;
+        };
+        filePath: string;
+        matchedSpan: string;
+        contentHash: string;
+    }[];
+    negativeFixtures?: {
+        pr: number;
+        preimageSource: {
+            kind: "lesson";
+            lessonRef: string;
+            badExample: string;
+            goodExample: string;
+        } | {
+            kind: "commit";
+            preimageCommitSha: string;
+            mergeCommitSha: string;
+        };
+        filePath: string;
+        matchedSpan: string;
+        contentHash: string;
+    }[] | undefined;
+}, {
+    kind: "authored";
+    author: string;
+    authoredAt: string;
+    targetDefect: string;
+    positiveFixtures: {
+        pr: number;
+        preimageSource: {
+            kind: "lesson";
+            lessonRef: string;
+            badExample: string;
+            goodExample: string;
+        } | {
+            kind: "commit";
+            preimageCommitSha: string;
+            mergeCommitSha: string;
+        };
+        filePath: string;
+        matchedSpan: string;
+        contentHash: string;
+    }[];
+    negativeFixtures?: {
+        pr: number;
+        preimageSource: {
+            kind: "lesson";
+            lessonRef: string;
+            badExample: string;
+            goodExample: string;
+        } | {
+            kind: "commit";
+            preimageCommitSha: string;
+            mergeCommitSha: string;
+        };
+        filePath: string;
+        matchedSpan: string;
+        contentHash: string;
+    }[] | undefined;
+}>, z.ZodObject<{
+    /**
+     * ADR-112 discriminator. OPTIONAL on the mined wire so legacy records (which
+     * have no `kind`) round-trip byte-identical; absence is read as `'mined'` by
+     * `provenanceKind()`. A new mined artifact MAY carry `kind: 'mined'` only
+     * where the resulting hash churn is intentional.
+     */
+    kind: z.ZodOptional<z.ZodLiteral<"mined">>;
+    /** Merged PR the rule was mined from (positive integer PR number). */
+    mergedPr: z.ZodNumber;
+    /**
+     * Reference to the review thread that adjudicated the rule. Rejects empty and
+     * whitespace-only via a NON-MUTATING refinement (greptile/CR #2186): a
+     * `.trim()` transform would silently normalize a padded value on parse, so a
+     * stamped rule's on-disk JSON could differ from its parsed form and churn the
+     * manifest hash on the next `verify-manifest`. `.refine` validates without
+     * mutating, so the stored value round-trips byte-identically.
+     */
+    reviewThread: z.ZodEffects<z.ZodString, string, string>;
+    /** Full 40-hex git commit SHA the rule was frozen at. */
+    commitSha: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    mergedPr: number;
+    reviewThread: string;
+    commitSha: string;
+    kind?: "mined" | undefined;
+}, {
+    mergedPr: number;
+    reviewThread: string;
+    commitSha: string;
+    kind?: "mined" | undefined;
+}>]>;
 export type ProvenanceRecord = z.infer<typeof ProvenanceRecordSchema>;
+/**
+ * ADR-112 — the canonical reader of a provenance record's producer kind. An
+ * absent discriminator (every legacy mined record) reads as `'mined'`. Use this
+ * + the guards below instead of touching `.kind` directly, so the
+ * absent-⇒-mined default lives in exactly one place (Tenet 20).
+ */
+export declare function provenanceKind(p: ProvenanceRecord): 'mined' | 'authored';
+/** ADR-112 — type-narrowing guard for the mined branch (mined-only field reads). */
+export declare function isMinedProvenance(p: ProvenanceRecord): p is MinedProvenanceRecord;
+/** ADR-112 — type-narrowing guard for the authored branch. */
+export declare function isAuthoredProvenance(p: ProvenanceRecord): p is AuthoredProvenanceRecord;
 /**
  * mmnto-ai/totem#2183 — the three **peer** legs of the ADR-110 §3 legitimacy
  * bar, mapping 1:1 onto the strategy#666 Tenet-9 three-check so the Gate-1
@@ -80,7 +959,316 @@ export type ProvenanceRecord = z.infer<typeof ProvenanceRecordSchema>;
  * failed one); the evidence behind each pass lives in the wind-tunnel manifest.
  */
 export declare const LegitimacySchema: z.ZodObject<{
-    provenance: z.ZodObject<{
+    provenance: z.ZodUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"authored">;
+        /** Agent-id or operator handle — attributable, never anonymous. */
+        author: z.ZodEffects<z.ZodString, string, string>;
+        /** ISO-8601 authoring date — a real calendar date (`YYYY-MM-DD`) or a full timestamp. */
+        authoredAt: z.ZodEffects<z.ZodString, string, string>;
+        /** The declared DEFECT the rule targets — the pre-image, not its fix. */
+        targetDefect: z.ZodEffects<z.ZodString, string, string>;
+        /** ≥1 real lc instance the rule claims to catch — ALL train-side (§5). */
+        positiveFixtures: z.ZodArray<z.ZodEffects<z.ZodObject<{
+            /** The PR where the defect was caught/introduced (the in-corpus anchor). */
+            pr: z.ZodNumber;
+            /** The §4 preimage-differential source — lesson-anchored (PRIMARY) or commit-pair (FALLBACK). */
+            preimageSource: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+                kind: z.ZodLiteral<"lesson">;
+                /** IMMUTABLE lesson id/hash (the 16-hex `hashLesson` codomain) — never a path/mutable alias (§4/§8). */
+                lessonRef: z.ZodString;
+                /**
+                 * The defect PREIMAGE exemplar the matcher must FIRE on (§4). This is a lesson
+                 * corpus `badExample` — distinct from `CompiledRuleBaseSchema.badExample` (an
+                 * optional human-readable code snippet on a compiled rule); here it is the
+                 * load-bearing positive-control preimage, so non-empty is required.
+                 */
+                badExample: z.ZodEffects<z.ZodString, string, string>;
+                /** The fixed POSTIMAGE exemplar the matcher must stay SILENT on (§4) — a lesson `goodExample`. */
+                goodExample: z.ZodEffects<z.ZodString, string, string>;
+            }, "strict", z.ZodTypeAny, {
+                kind: "lesson";
+                lessonRef: string;
+                badExample: string;
+                goodExample: string;
+            }, {
+                kind: "lesson";
+                lessonRef: string;
+                badExample: string;
+                goodExample: string;
+            }>, z.ZodObject<{
+                kind: z.ZodLiteral<"commit">;
+                /** The PARENT (pre-fix) commit where the DEFECT is present — the matcher must FIRE on this (ADR-112 §4). */
+                preimageCommitSha: z.ZodString;
+                /** The PR's merge/squash commit — the post-fix (defect-absent) anchor; the matcher must stay SILENT on this. */
+                mergeCommitSha: z.ZodString;
+            }, "strict", z.ZodTypeAny, {
+                kind: "commit";
+                preimageCommitSha: string;
+                mergeCommitSha: string;
+            }, {
+                kind: "commit";
+                preimageCommitSha: string;
+                mergeCommitSha: string;
+            }>]>;
+            /** File the defect locus lives in. */
+            filePath: z.ZodEffects<z.ZodString, string, string>;
+            /** Line-range or AST-node path — the defect locus, not just the file. */
+            matchedSpan: z.ZodEffects<z.ZodString, string, string>;
+            /** Span content hash, line-drift-stable (cf. `firingLabelId`). */
+            contentHash: z.ZodEffects<z.ZodString, string, string>;
+        }, "strict", z.ZodTypeAny, {
+            pr: number;
+            preimageSource: {
+                kind: "lesson";
+                lessonRef: string;
+                badExample: string;
+                goodExample: string;
+            } | {
+                kind: "commit";
+                preimageCommitSha: string;
+                mergeCommitSha: string;
+            };
+            filePath: string;
+            matchedSpan: string;
+            contentHash: string;
+        }, {
+            pr: number;
+            preimageSource: {
+                kind: "lesson";
+                lessonRef: string;
+                badExample: string;
+                goodExample: string;
+            } | {
+                kind: "commit";
+                preimageCommitSha: string;
+                mergeCommitSha: string;
+            };
+            filePath: string;
+            matchedSpan: string;
+            contentHash: string;
+        }>, {
+            pr: number;
+            preimageSource: {
+                kind: "lesson";
+                lessonRef: string;
+                badExample: string;
+                goodExample: string;
+            } | {
+                kind: "commit";
+                preimageCommitSha: string;
+                mergeCommitSha: string;
+            };
+            filePath: string;
+            matchedSpan: string;
+            contentHash: string;
+        }, {
+            pr: number;
+            preimageSource: {
+                kind: "lesson";
+                lessonRef: string;
+                badExample: string;
+                goodExample: string;
+            } | {
+                kind: "commit";
+                preimageCommitSha: string;
+                mergeCommitSha: string;
+            };
+            filePath: string;
+            matchedSpan: string;
+            contentHash: string;
+        }>, "many">;
+        /** Declared near-misses the rule must stay silent on (feeds §6 negative controls). */
+        negativeFixtures: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodObject<{
+            /** The PR where the defect was caught/introduced (the in-corpus anchor). */
+            pr: z.ZodNumber;
+            /** The §4 preimage-differential source — lesson-anchored (PRIMARY) or commit-pair (FALLBACK). */
+            preimageSource: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+                kind: z.ZodLiteral<"lesson">;
+                /** IMMUTABLE lesson id/hash (the 16-hex `hashLesson` codomain) — never a path/mutable alias (§4/§8). */
+                lessonRef: z.ZodString;
+                /**
+                 * The defect PREIMAGE exemplar the matcher must FIRE on (§4). This is a lesson
+                 * corpus `badExample` — distinct from `CompiledRuleBaseSchema.badExample` (an
+                 * optional human-readable code snippet on a compiled rule); here it is the
+                 * load-bearing positive-control preimage, so non-empty is required.
+                 */
+                badExample: z.ZodEffects<z.ZodString, string, string>;
+                /** The fixed POSTIMAGE exemplar the matcher must stay SILENT on (§4) — a lesson `goodExample`. */
+                goodExample: z.ZodEffects<z.ZodString, string, string>;
+            }, "strict", z.ZodTypeAny, {
+                kind: "lesson";
+                lessonRef: string;
+                badExample: string;
+                goodExample: string;
+            }, {
+                kind: "lesson";
+                lessonRef: string;
+                badExample: string;
+                goodExample: string;
+            }>, z.ZodObject<{
+                kind: z.ZodLiteral<"commit">;
+                /** The PARENT (pre-fix) commit where the DEFECT is present — the matcher must FIRE on this (ADR-112 §4). */
+                preimageCommitSha: z.ZodString;
+                /** The PR's merge/squash commit — the post-fix (defect-absent) anchor; the matcher must stay SILENT on this. */
+                mergeCommitSha: z.ZodString;
+            }, "strict", z.ZodTypeAny, {
+                kind: "commit";
+                preimageCommitSha: string;
+                mergeCommitSha: string;
+            }, {
+                kind: "commit";
+                preimageCommitSha: string;
+                mergeCommitSha: string;
+            }>]>;
+            /** File the defect locus lives in. */
+            filePath: z.ZodEffects<z.ZodString, string, string>;
+            /** Line-range or AST-node path — the defect locus, not just the file. */
+            matchedSpan: z.ZodEffects<z.ZodString, string, string>;
+            /** Span content hash, line-drift-stable (cf. `firingLabelId`). */
+            contentHash: z.ZodEffects<z.ZodString, string, string>;
+        }, "strict", z.ZodTypeAny, {
+            pr: number;
+            preimageSource: {
+                kind: "lesson";
+                lessonRef: string;
+                badExample: string;
+                goodExample: string;
+            } | {
+                kind: "commit";
+                preimageCommitSha: string;
+                mergeCommitSha: string;
+            };
+            filePath: string;
+            matchedSpan: string;
+            contentHash: string;
+        }, {
+            pr: number;
+            preimageSource: {
+                kind: "lesson";
+                lessonRef: string;
+                badExample: string;
+                goodExample: string;
+            } | {
+                kind: "commit";
+                preimageCommitSha: string;
+                mergeCommitSha: string;
+            };
+            filePath: string;
+            matchedSpan: string;
+            contentHash: string;
+        }>, {
+            pr: number;
+            preimageSource: {
+                kind: "lesson";
+                lessonRef: string;
+                badExample: string;
+                goodExample: string;
+            } | {
+                kind: "commit";
+                preimageCommitSha: string;
+                mergeCommitSha: string;
+            };
+            filePath: string;
+            matchedSpan: string;
+            contentHash: string;
+        }, {
+            pr: number;
+            preimageSource: {
+                kind: "lesson";
+                lessonRef: string;
+                badExample: string;
+                goodExample: string;
+            } | {
+                kind: "commit";
+                preimageCommitSha: string;
+                mergeCommitSha: string;
+            };
+            filePath: string;
+            matchedSpan: string;
+            contentHash: string;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        kind: "authored";
+        author: string;
+        authoredAt: string;
+        targetDefect: string;
+        positiveFixtures: {
+            pr: number;
+            preimageSource: {
+                kind: "lesson";
+                lessonRef: string;
+                badExample: string;
+                goodExample: string;
+            } | {
+                kind: "commit";
+                preimageCommitSha: string;
+                mergeCommitSha: string;
+            };
+            filePath: string;
+            matchedSpan: string;
+            contentHash: string;
+        }[];
+        negativeFixtures?: {
+            pr: number;
+            preimageSource: {
+                kind: "lesson";
+                lessonRef: string;
+                badExample: string;
+                goodExample: string;
+            } | {
+                kind: "commit";
+                preimageCommitSha: string;
+                mergeCommitSha: string;
+            };
+            filePath: string;
+            matchedSpan: string;
+            contentHash: string;
+        }[] | undefined;
+    }, {
+        kind: "authored";
+        author: string;
+        authoredAt: string;
+        targetDefect: string;
+        positiveFixtures: {
+            pr: number;
+            preimageSource: {
+                kind: "lesson";
+                lessonRef: string;
+                badExample: string;
+                goodExample: string;
+            } | {
+                kind: "commit";
+                preimageCommitSha: string;
+                mergeCommitSha: string;
+            };
+            filePath: string;
+            matchedSpan: string;
+            contentHash: string;
+        }[];
+        negativeFixtures?: {
+            pr: number;
+            preimageSource: {
+                kind: "lesson";
+                lessonRef: string;
+                badExample: string;
+                goodExample: string;
+            } | {
+                kind: "commit";
+                preimageCommitSha: string;
+                mergeCommitSha: string;
+            };
+            filePath: string;
+            matchedSpan: string;
+            contentHash: string;
+        }[] | undefined;
+    }>, z.ZodObject<{
+        /**
+         * ADR-112 discriminator. OPTIONAL on the mined wire so legacy records (which
+         * have no `kind`) round-trip byte-identical; absence is read as `'mined'` by
+         * `provenanceKind()`. A new mined artifact MAY carry `kind: 'mined'` only
+         * where the resulting hash churn is intentional.
+         */
+        kind: z.ZodOptional<z.ZodLiteral<"mined">>;
         /** Merged PR the rule was mined from (positive integer PR number). */
         mergedPr: z.ZodNumber;
         /**
@@ -98,11 +1286,13 @@ export declare const LegitimacySchema: z.ZodObject<{
         mergedPr: number;
         reviewThread: string;
         commitSha: string;
+        kind?: "mined" | undefined;
     }, {
         mergedPr: number;
         reviewThread: string;
         commitSha: string;
-    }>;
+        kind?: "mined" | undefined;
+    }>]>;
     positiveControl: z.ZodBoolean;
     negativeControl: z.ZodBoolean;
 }, "strip", z.ZodTypeAny, {
@@ -110,6 +1300,44 @@ export declare const LegitimacySchema: z.ZodObject<{
         mergedPr: number;
         reviewThread: string;
         commitSha: string;
+        kind?: "mined" | undefined;
+    } | {
+        kind: "authored";
+        author: string;
+        authoredAt: string;
+        targetDefect: string;
+        positiveFixtures: {
+            pr: number;
+            preimageSource: {
+                kind: "lesson";
+                lessonRef: string;
+                badExample: string;
+                goodExample: string;
+            } | {
+                kind: "commit";
+                preimageCommitSha: string;
+                mergeCommitSha: string;
+            };
+            filePath: string;
+            matchedSpan: string;
+            contentHash: string;
+        }[];
+        negativeFixtures?: {
+            pr: number;
+            preimageSource: {
+                kind: "lesson";
+                lessonRef: string;
+                badExample: string;
+                goodExample: string;
+            } | {
+                kind: "commit";
+                preimageCommitSha: string;
+                mergeCommitSha: string;
+            };
+            filePath: string;
+            matchedSpan: string;
+            contentHash: string;
+        }[] | undefined;
     };
     positiveControl: boolean;
     negativeControl: boolean;
@@ -118,6 +1346,44 @@ export declare const LegitimacySchema: z.ZodObject<{
         mergedPr: number;
         reviewThread: string;
         commitSha: string;
+        kind?: "mined" | undefined;
+    } | {
+        kind: "authored";
+        author: string;
+        authoredAt: string;
+        targetDefect: string;
+        positiveFixtures: {
+            pr: number;
+            preimageSource: {
+                kind: "lesson";
+                lessonRef: string;
+                badExample: string;
+                goodExample: string;
+            } | {
+                kind: "commit";
+                preimageCommitSha: string;
+                mergeCommitSha: string;
+            };
+            filePath: string;
+            matchedSpan: string;
+            contentHash: string;
+        }[];
+        negativeFixtures?: {
+            pr: number;
+            preimageSource: {
+                kind: "lesson";
+                lessonRef: string;
+                badExample: string;
+                goodExample: string;
+            } | {
+                kind: "commit";
+                preimageCommitSha: string;
+                mergeCommitSha: string;
+            };
+            filePath: string;
+            matchedSpan: string;
+            contentHash: string;
+        }[] | undefined;
     };
     positiveControl: boolean;
     negativeControl: boolean;
@@ -309,7 +1575,316 @@ export declare const CompiledRuleSchema: z.ZodEffects<z.ZodObject<{
      * signal and preserves pre-#2183 manifest hashes via canonicalStringify.
      */
     legitimacy: z.ZodOptional<z.ZodObject<{
-        provenance: z.ZodObject<{
+        provenance: z.ZodUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"authored">;
+            /** Agent-id or operator handle — attributable, never anonymous. */
+            author: z.ZodEffects<z.ZodString, string, string>;
+            /** ISO-8601 authoring date — a real calendar date (`YYYY-MM-DD`) or a full timestamp. */
+            authoredAt: z.ZodEffects<z.ZodString, string, string>;
+            /** The declared DEFECT the rule targets — the pre-image, not its fix. */
+            targetDefect: z.ZodEffects<z.ZodString, string, string>;
+            /** ≥1 real lc instance the rule claims to catch — ALL train-side (§5). */
+            positiveFixtures: z.ZodArray<z.ZodEffects<z.ZodObject<{
+                /** The PR where the defect was caught/introduced (the in-corpus anchor). */
+                pr: z.ZodNumber;
+                /** The §4 preimage-differential source — lesson-anchored (PRIMARY) or commit-pair (FALLBACK). */
+                preimageSource: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+                    kind: z.ZodLiteral<"lesson">;
+                    /** IMMUTABLE lesson id/hash (the 16-hex `hashLesson` codomain) — never a path/mutable alias (§4/§8). */
+                    lessonRef: z.ZodString;
+                    /**
+                     * The defect PREIMAGE exemplar the matcher must FIRE on (§4). This is a lesson
+                     * corpus `badExample` — distinct from `CompiledRuleBaseSchema.badExample` (an
+                     * optional human-readable code snippet on a compiled rule); here it is the
+                     * load-bearing positive-control preimage, so non-empty is required.
+                     */
+                    badExample: z.ZodEffects<z.ZodString, string, string>;
+                    /** The fixed POSTIMAGE exemplar the matcher must stay SILENT on (§4) — a lesson `goodExample`. */
+                    goodExample: z.ZodEffects<z.ZodString, string, string>;
+                }, "strict", z.ZodTypeAny, {
+                    kind: "lesson";
+                    lessonRef: string;
+                    badExample: string;
+                    goodExample: string;
+                }, {
+                    kind: "lesson";
+                    lessonRef: string;
+                    badExample: string;
+                    goodExample: string;
+                }>, z.ZodObject<{
+                    kind: z.ZodLiteral<"commit">;
+                    /** The PARENT (pre-fix) commit where the DEFECT is present — the matcher must FIRE on this (ADR-112 §4). */
+                    preimageCommitSha: z.ZodString;
+                    /** The PR's merge/squash commit — the post-fix (defect-absent) anchor; the matcher must stay SILENT on this. */
+                    mergeCommitSha: z.ZodString;
+                }, "strict", z.ZodTypeAny, {
+                    kind: "commit";
+                    preimageCommitSha: string;
+                    mergeCommitSha: string;
+                }, {
+                    kind: "commit";
+                    preimageCommitSha: string;
+                    mergeCommitSha: string;
+                }>]>;
+                /** File the defect locus lives in. */
+                filePath: z.ZodEffects<z.ZodString, string, string>;
+                /** Line-range or AST-node path — the defect locus, not just the file. */
+                matchedSpan: z.ZodEffects<z.ZodString, string, string>;
+                /** Span content hash, line-drift-stable (cf. `firingLabelId`). */
+                contentHash: z.ZodEffects<z.ZodString, string, string>;
+            }, "strict", z.ZodTypeAny, {
+                pr: number;
+                preimageSource: {
+                    kind: "lesson";
+                    lessonRef: string;
+                    badExample: string;
+                    goodExample: string;
+                } | {
+                    kind: "commit";
+                    preimageCommitSha: string;
+                    mergeCommitSha: string;
+                };
+                filePath: string;
+                matchedSpan: string;
+                contentHash: string;
+            }, {
+                pr: number;
+                preimageSource: {
+                    kind: "lesson";
+                    lessonRef: string;
+                    badExample: string;
+                    goodExample: string;
+                } | {
+                    kind: "commit";
+                    preimageCommitSha: string;
+                    mergeCommitSha: string;
+                };
+                filePath: string;
+                matchedSpan: string;
+                contentHash: string;
+            }>, {
+                pr: number;
+                preimageSource: {
+                    kind: "lesson";
+                    lessonRef: string;
+                    badExample: string;
+                    goodExample: string;
+                } | {
+                    kind: "commit";
+                    preimageCommitSha: string;
+                    mergeCommitSha: string;
+                };
+                filePath: string;
+                matchedSpan: string;
+                contentHash: string;
+            }, {
+                pr: number;
+                preimageSource: {
+                    kind: "lesson";
+                    lessonRef: string;
+                    badExample: string;
+                    goodExample: string;
+                } | {
+                    kind: "commit";
+                    preimageCommitSha: string;
+                    mergeCommitSha: string;
+                };
+                filePath: string;
+                matchedSpan: string;
+                contentHash: string;
+            }>, "many">;
+            /** Declared near-misses the rule must stay silent on (feeds §6 negative controls). */
+            negativeFixtures: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodObject<{
+                /** The PR where the defect was caught/introduced (the in-corpus anchor). */
+                pr: z.ZodNumber;
+                /** The §4 preimage-differential source — lesson-anchored (PRIMARY) or commit-pair (FALLBACK). */
+                preimageSource: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+                    kind: z.ZodLiteral<"lesson">;
+                    /** IMMUTABLE lesson id/hash (the 16-hex `hashLesson` codomain) — never a path/mutable alias (§4/§8). */
+                    lessonRef: z.ZodString;
+                    /**
+                     * The defect PREIMAGE exemplar the matcher must FIRE on (§4). This is a lesson
+                     * corpus `badExample` — distinct from `CompiledRuleBaseSchema.badExample` (an
+                     * optional human-readable code snippet on a compiled rule); here it is the
+                     * load-bearing positive-control preimage, so non-empty is required.
+                     */
+                    badExample: z.ZodEffects<z.ZodString, string, string>;
+                    /** The fixed POSTIMAGE exemplar the matcher must stay SILENT on (§4) — a lesson `goodExample`. */
+                    goodExample: z.ZodEffects<z.ZodString, string, string>;
+                }, "strict", z.ZodTypeAny, {
+                    kind: "lesson";
+                    lessonRef: string;
+                    badExample: string;
+                    goodExample: string;
+                }, {
+                    kind: "lesson";
+                    lessonRef: string;
+                    badExample: string;
+                    goodExample: string;
+                }>, z.ZodObject<{
+                    kind: z.ZodLiteral<"commit">;
+                    /** The PARENT (pre-fix) commit where the DEFECT is present — the matcher must FIRE on this (ADR-112 §4). */
+                    preimageCommitSha: z.ZodString;
+                    /** The PR's merge/squash commit — the post-fix (defect-absent) anchor; the matcher must stay SILENT on this. */
+                    mergeCommitSha: z.ZodString;
+                }, "strict", z.ZodTypeAny, {
+                    kind: "commit";
+                    preimageCommitSha: string;
+                    mergeCommitSha: string;
+                }, {
+                    kind: "commit";
+                    preimageCommitSha: string;
+                    mergeCommitSha: string;
+                }>]>;
+                /** File the defect locus lives in. */
+                filePath: z.ZodEffects<z.ZodString, string, string>;
+                /** Line-range or AST-node path — the defect locus, not just the file. */
+                matchedSpan: z.ZodEffects<z.ZodString, string, string>;
+                /** Span content hash, line-drift-stable (cf. `firingLabelId`). */
+                contentHash: z.ZodEffects<z.ZodString, string, string>;
+            }, "strict", z.ZodTypeAny, {
+                pr: number;
+                preimageSource: {
+                    kind: "lesson";
+                    lessonRef: string;
+                    badExample: string;
+                    goodExample: string;
+                } | {
+                    kind: "commit";
+                    preimageCommitSha: string;
+                    mergeCommitSha: string;
+                };
+                filePath: string;
+                matchedSpan: string;
+                contentHash: string;
+            }, {
+                pr: number;
+                preimageSource: {
+                    kind: "lesson";
+                    lessonRef: string;
+                    badExample: string;
+                    goodExample: string;
+                } | {
+                    kind: "commit";
+                    preimageCommitSha: string;
+                    mergeCommitSha: string;
+                };
+                filePath: string;
+                matchedSpan: string;
+                contentHash: string;
+            }>, {
+                pr: number;
+                preimageSource: {
+                    kind: "lesson";
+                    lessonRef: string;
+                    badExample: string;
+                    goodExample: string;
+                } | {
+                    kind: "commit";
+                    preimageCommitSha: string;
+                    mergeCommitSha: string;
+                };
+                filePath: string;
+                matchedSpan: string;
+                contentHash: string;
+            }, {
+                pr: number;
+                preimageSource: {
+                    kind: "lesson";
+                    lessonRef: string;
+                    badExample: string;
+                    goodExample: string;
+                } | {
+                    kind: "commit";
+                    preimageCommitSha: string;
+                    mergeCommitSha: string;
+                };
+                filePath: string;
+                matchedSpan: string;
+                contentHash: string;
+            }>, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            kind: "authored";
+            author: string;
+            authoredAt: string;
+            targetDefect: string;
+            positiveFixtures: {
+                pr: number;
+                preimageSource: {
+                    kind: "lesson";
+                    lessonRef: string;
+                    badExample: string;
+                    goodExample: string;
+                } | {
+                    kind: "commit";
+                    preimageCommitSha: string;
+                    mergeCommitSha: string;
+                };
+                filePath: string;
+                matchedSpan: string;
+                contentHash: string;
+            }[];
+            negativeFixtures?: {
+                pr: number;
+                preimageSource: {
+                    kind: "lesson";
+                    lessonRef: string;
+                    badExample: string;
+                    goodExample: string;
+                } | {
+                    kind: "commit";
+                    preimageCommitSha: string;
+                    mergeCommitSha: string;
+                };
+                filePath: string;
+                matchedSpan: string;
+                contentHash: string;
+            }[] | undefined;
+        }, {
+            kind: "authored";
+            author: string;
+            authoredAt: string;
+            targetDefect: string;
+            positiveFixtures: {
+                pr: number;
+                preimageSource: {
+                    kind: "lesson";
+                    lessonRef: string;
+                    badExample: string;
+                    goodExample: string;
+                } | {
+                    kind: "commit";
+                    preimageCommitSha: string;
+                    mergeCommitSha: string;
+                };
+                filePath: string;
+                matchedSpan: string;
+                contentHash: string;
+            }[];
+            negativeFixtures?: {
+                pr: number;
+                preimageSource: {
+                    kind: "lesson";
+                    lessonRef: string;
+                    badExample: string;
+                    goodExample: string;
+                } | {
+                    kind: "commit";
+                    preimageCommitSha: string;
+                    mergeCommitSha: string;
+                };
+                filePath: string;
+                matchedSpan: string;
+                contentHash: string;
+            }[] | undefined;
+        }>, z.ZodObject<{
+            /**
+             * ADR-112 discriminator. OPTIONAL on the mined wire so legacy records (which
+             * have no `kind`) round-trip byte-identical; absence is read as `'mined'` by
+             * `provenanceKind()`. A new mined artifact MAY carry `kind: 'mined'` only
+             * where the resulting hash churn is intentional.
+             */
+            kind: z.ZodOptional<z.ZodLiteral<"mined">>;
             /** Merged PR the rule was mined from (positive integer PR number). */
             mergedPr: z.ZodNumber;
             /**
@@ -327,11 +1902,13 @@ export declare const CompiledRuleSchema: z.ZodEffects<z.ZodObject<{
             mergedPr: number;
             reviewThread: string;
             commitSha: string;
+            kind?: "mined" | undefined;
         }, {
             mergedPr: number;
             reviewThread: string;
             commitSha: string;
-        }>;
+            kind?: "mined" | undefined;
+        }>]>;
         positiveControl: z.ZodBoolean;
         negativeControl: z.ZodBoolean;
     }, "strip", z.ZodTypeAny, {
@@ -339,6 +1916,44 @@ export declare const CompiledRuleSchema: z.ZodEffects<z.ZodObject<{
             mergedPr: number;
             reviewThread: string;
             commitSha: string;
+            kind?: "mined" | undefined;
+        } | {
+            kind: "authored";
+            author: string;
+            authoredAt: string;
+            targetDefect: string;
+            positiveFixtures: {
+                pr: number;
+                preimageSource: {
+                    kind: "lesson";
+                    lessonRef: string;
+                    badExample: string;
+                    goodExample: string;
+                } | {
+                    kind: "commit";
+                    preimageCommitSha: string;
+                    mergeCommitSha: string;
+                };
+                filePath: string;
+                matchedSpan: string;
+                contentHash: string;
+            }[];
+            negativeFixtures?: {
+                pr: number;
+                preimageSource: {
+                    kind: "lesson";
+                    lessonRef: string;
+                    badExample: string;
+                    goodExample: string;
+                } | {
+                    kind: "commit";
+                    preimageCommitSha: string;
+                    mergeCommitSha: string;
+                };
+                filePath: string;
+                matchedSpan: string;
+                contentHash: string;
+            }[] | undefined;
         };
         positiveControl: boolean;
         negativeControl: boolean;
@@ -347,6 +1962,44 @@ export declare const CompiledRuleSchema: z.ZodEffects<z.ZodObject<{
             mergedPr: number;
             reviewThread: string;
             commitSha: string;
+            kind?: "mined" | undefined;
+        } | {
+            kind: "authored";
+            author: string;
+            authoredAt: string;
+            targetDefect: string;
+            positiveFixtures: {
+                pr: number;
+                preimageSource: {
+                    kind: "lesson";
+                    lessonRef: string;
+                    badExample: string;
+                    goodExample: string;
+                } | {
+                    kind: "commit";
+                    preimageCommitSha: string;
+                    mergeCommitSha: string;
+                };
+                filePath: string;
+                matchedSpan: string;
+                contentHash: string;
+            }[];
+            negativeFixtures?: {
+                pr: number;
+                preimageSource: {
+                    kind: "lesson";
+                    lessonRef: string;
+                    badExample: string;
+                    goodExample: string;
+                } | {
+                    kind: "commit";
+                    preimageCommitSha: string;
+                    mergeCommitSha: string;
+                };
+                filePath: string;
+                matchedSpan: string;
+                contentHash: string;
+            }[] | undefined;
         };
         positiveControl: boolean;
         negativeControl: boolean;
@@ -370,13 +2023,13 @@ export declare const CompiledRuleSchema: z.ZodEffects<z.ZodObject<{
     engine: "regex" | "ast" | "ast-grep";
     compiledAt: string;
     status?: "active" | "archived" | "untested-against-codebase" | "pending-verification" | undefined;
+    badExample?: string | undefined;
+    goodExample?: string | undefined;
     astQuery?: string | undefined;
     astGrepPattern?: string | undefined;
     astGrepYamlRule?: z.objectOutputType<{
         rule: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     }, z.ZodTypeAny, "passthrough"> | undefined;
-    badExample?: string | undefined;
-    goodExample?: string | undefined;
     createdAt?: string | undefined;
     fileGlobs?: string[] | undefined;
     category?: "security" | "architecture" | "style" | "performance" | undefined;
@@ -392,6 +2045,44 @@ export declare const CompiledRuleSchema: z.ZodEffects<z.ZodObject<{
             mergedPr: number;
             reviewThread: string;
             commitSha: string;
+            kind?: "mined" | undefined;
+        } | {
+            kind: "authored";
+            author: string;
+            authoredAt: string;
+            targetDefect: string;
+            positiveFixtures: {
+                pr: number;
+                preimageSource: {
+                    kind: "lesson";
+                    lessonRef: string;
+                    badExample: string;
+                    goodExample: string;
+                } | {
+                    kind: "commit";
+                    preimageCommitSha: string;
+                    mergeCommitSha: string;
+                };
+                filePath: string;
+                matchedSpan: string;
+                contentHash: string;
+            }[];
+            negativeFixtures?: {
+                pr: number;
+                preimageSource: {
+                    kind: "lesson";
+                    lessonRef: string;
+                    badExample: string;
+                    goodExample: string;
+                } | {
+                    kind: "commit";
+                    preimageCommitSha: string;
+                    mergeCommitSha: string;
+                };
+                filePath: string;
+                matchedSpan: string;
+                contentHash: string;
+            }[] | undefined;
         };
         positiveControl: boolean;
         negativeControl: boolean;
@@ -405,13 +2096,13 @@ export declare const CompiledRuleSchema: z.ZodEffects<z.ZodObject<{
     engine: "regex" | "ast" | "ast-grep";
     compiledAt: string;
     status?: "active" | "archived" | "untested-against-codebase" | "pending-verification" | undefined;
+    badExample?: string | undefined;
+    goodExample?: string | undefined;
     astQuery?: string | undefined;
     astGrepPattern?: string | undefined;
     astGrepYamlRule?: z.objectInputType<{
         rule: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     }, z.ZodTypeAny, "passthrough"> | undefined;
-    badExample?: string | undefined;
-    goodExample?: string | undefined;
     createdAt?: string | undefined;
     fileGlobs?: string[] | undefined;
     category?: "security" | "architecture" | "style" | "performance" | undefined;
@@ -427,6 +2118,44 @@ export declare const CompiledRuleSchema: z.ZodEffects<z.ZodObject<{
             mergedPr: number;
             reviewThread: string;
             commitSha: string;
+            kind?: "mined" | undefined;
+        } | {
+            kind: "authored";
+            author: string;
+            authoredAt: string;
+            targetDefect: string;
+            positiveFixtures: {
+                pr: number;
+                preimageSource: {
+                    kind: "lesson";
+                    lessonRef: string;
+                    badExample: string;
+                    goodExample: string;
+                } | {
+                    kind: "commit";
+                    preimageCommitSha: string;
+                    mergeCommitSha: string;
+                };
+                filePath: string;
+                matchedSpan: string;
+                contentHash: string;
+            }[];
+            negativeFixtures?: {
+                pr: number;
+                preimageSource: {
+                    kind: "lesson";
+                    lessonRef: string;
+                    badExample: string;
+                    goodExample: string;
+                } | {
+                    kind: "commit";
+                    preimageCommitSha: string;
+                    mergeCommitSha: string;
+                };
+                filePath: string;
+                matchedSpan: string;
+                contentHash: string;
+            }[] | undefined;
         };
         positiveControl: boolean;
         negativeControl: boolean;
@@ -440,13 +2169,13 @@ export declare const CompiledRuleSchema: z.ZodEffects<z.ZodObject<{
     engine: "regex" | "ast" | "ast-grep";
     compiledAt: string;
     status?: "active" | "archived" | "untested-against-codebase" | "pending-verification" | undefined;
+    badExample?: string | undefined;
+    goodExample?: string | undefined;
     astQuery?: string | undefined;
     astGrepPattern?: string | undefined;
     astGrepYamlRule?: z.objectOutputType<{
         rule: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     }, z.ZodTypeAny, "passthrough"> | undefined;
-    badExample?: string | undefined;
-    goodExample?: string | undefined;
     createdAt?: string | undefined;
     fileGlobs?: string[] | undefined;
     category?: "security" | "architecture" | "style" | "performance" | undefined;
@@ -462,6 +2191,44 @@ export declare const CompiledRuleSchema: z.ZodEffects<z.ZodObject<{
             mergedPr: number;
             reviewThread: string;
             commitSha: string;
+            kind?: "mined" | undefined;
+        } | {
+            kind: "authored";
+            author: string;
+            authoredAt: string;
+            targetDefect: string;
+            positiveFixtures: {
+                pr: number;
+                preimageSource: {
+                    kind: "lesson";
+                    lessonRef: string;
+                    badExample: string;
+                    goodExample: string;
+                } | {
+                    kind: "commit";
+                    preimageCommitSha: string;
+                    mergeCommitSha: string;
+                };
+                filePath: string;
+                matchedSpan: string;
+                contentHash: string;
+            }[];
+            negativeFixtures?: {
+                pr: number;
+                preimageSource: {
+                    kind: "lesson";
+                    lessonRef: string;
+                    badExample: string;
+                    goodExample: string;
+                } | {
+                    kind: "commit";
+                    preimageCommitSha: string;
+                    mergeCommitSha: string;
+                };
+                filePath: string;
+                matchedSpan: string;
+                contentHash: string;
+            }[] | undefined;
         };
         positiveControl: boolean;
         negativeControl: boolean;
@@ -475,13 +2242,13 @@ export declare const CompiledRuleSchema: z.ZodEffects<z.ZodObject<{
     engine: "regex" | "ast" | "ast-grep";
     compiledAt: string;
     status?: "active" | "archived" | "untested-against-codebase" | "pending-verification" | undefined;
+    badExample?: string | undefined;
+    goodExample?: string | undefined;
     astQuery?: string | undefined;
     astGrepPattern?: string | undefined;
     astGrepYamlRule?: z.objectInputType<{
         rule: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     }, z.ZodTypeAny, "passthrough"> | undefined;
-    badExample?: string | undefined;
-    goodExample?: string | undefined;
     createdAt?: string | undefined;
     fileGlobs?: string[] | undefined;
     category?: "security" | "architecture" | "style" | "performance" | undefined;
@@ -497,6 +2264,44 @@ export declare const CompiledRuleSchema: z.ZodEffects<z.ZodObject<{
             mergedPr: number;
             reviewThread: string;
             commitSha: string;
+            kind?: "mined" | undefined;
+        } | {
+            kind: "authored";
+            author: string;
+            authoredAt: string;
+            targetDefect: string;
+            positiveFixtures: {
+                pr: number;
+                preimageSource: {
+                    kind: "lesson";
+                    lessonRef: string;
+                    badExample: string;
+                    goodExample: string;
+                } | {
+                    kind: "commit";
+                    preimageCommitSha: string;
+                    mergeCommitSha: string;
+                };
+                filePath: string;
+                matchedSpan: string;
+                contentHash: string;
+            }[];
+            negativeFixtures?: {
+                pr: number;
+                preimageSource: {
+                    kind: "lesson";
+                    lessonRef: string;
+                    badExample: string;
+                    goodExample: string;
+                } | {
+                    kind: "commit";
+                    preimageCommitSha: string;
+                    mergeCommitSha: string;
+                };
+                filePath: string;
+                matchedSpan: string;
+                contentHash: string;
+            }[] | undefined;
         };
         positiveControl: boolean;
         negativeControl: boolean;
@@ -794,7 +2599,316 @@ export declare const CompiledRulesFileSchema: z.ZodObject<{
          * signal and preserves pre-#2183 manifest hashes via canonicalStringify.
          */
         legitimacy: z.ZodOptional<z.ZodObject<{
-            provenance: z.ZodObject<{
+            provenance: z.ZodUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"authored">;
+                /** Agent-id or operator handle — attributable, never anonymous. */
+                author: z.ZodEffects<z.ZodString, string, string>;
+                /** ISO-8601 authoring date — a real calendar date (`YYYY-MM-DD`) or a full timestamp. */
+                authoredAt: z.ZodEffects<z.ZodString, string, string>;
+                /** The declared DEFECT the rule targets — the pre-image, not its fix. */
+                targetDefect: z.ZodEffects<z.ZodString, string, string>;
+                /** ≥1 real lc instance the rule claims to catch — ALL train-side (§5). */
+                positiveFixtures: z.ZodArray<z.ZodEffects<z.ZodObject<{
+                    /** The PR where the defect was caught/introduced (the in-corpus anchor). */
+                    pr: z.ZodNumber;
+                    /** The §4 preimage-differential source — lesson-anchored (PRIMARY) or commit-pair (FALLBACK). */
+                    preimageSource: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+                        kind: z.ZodLiteral<"lesson">;
+                        /** IMMUTABLE lesson id/hash (the 16-hex `hashLesson` codomain) — never a path/mutable alias (§4/§8). */
+                        lessonRef: z.ZodString;
+                        /**
+                         * The defect PREIMAGE exemplar the matcher must FIRE on (§4). This is a lesson
+                         * corpus `badExample` — distinct from `CompiledRuleBaseSchema.badExample` (an
+                         * optional human-readable code snippet on a compiled rule); here it is the
+                         * load-bearing positive-control preimage, so non-empty is required.
+                         */
+                        badExample: z.ZodEffects<z.ZodString, string, string>;
+                        /** The fixed POSTIMAGE exemplar the matcher must stay SILENT on (§4) — a lesson `goodExample`. */
+                        goodExample: z.ZodEffects<z.ZodString, string, string>;
+                    }, "strict", z.ZodTypeAny, {
+                        kind: "lesson";
+                        lessonRef: string;
+                        badExample: string;
+                        goodExample: string;
+                    }, {
+                        kind: "lesson";
+                        lessonRef: string;
+                        badExample: string;
+                        goodExample: string;
+                    }>, z.ZodObject<{
+                        kind: z.ZodLiteral<"commit">;
+                        /** The PARENT (pre-fix) commit where the DEFECT is present — the matcher must FIRE on this (ADR-112 §4). */
+                        preimageCommitSha: z.ZodString;
+                        /** The PR's merge/squash commit — the post-fix (defect-absent) anchor; the matcher must stay SILENT on this. */
+                        mergeCommitSha: z.ZodString;
+                    }, "strict", z.ZodTypeAny, {
+                        kind: "commit";
+                        preimageCommitSha: string;
+                        mergeCommitSha: string;
+                    }, {
+                        kind: "commit";
+                        preimageCommitSha: string;
+                        mergeCommitSha: string;
+                    }>]>;
+                    /** File the defect locus lives in. */
+                    filePath: z.ZodEffects<z.ZodString, string, string>;
+                    /** Line-range or AST-node path — the defect locus, not just the file. */
+                    matchedSpan: z.ZodEffects<z.ZodString, string, string>;
+                    /** Span content hash, line-drift-stable (cf. `firingLabelId`). */
+                    contentHash: z.ZodEffects<z.ZodString, string, string>;
+                }, "strict", z.ZodTypeAny, {
+                    pr: number;
+                    preimageSource: {
+                        kind: "lesson";
+                        lessonRef: string;
+                        badExample: string;
+                        goodExample: string;
+                    } | {
+                        kind: "commit";
+                        preimageCommitSha: string;
+                        mergeCommitSha: string;
+                    };
+                    filePath: string;
+                    matchedSpan: string;
+                    contentHash: string;
+                }, {
+                    pr: number;
+                    preimageSource: {
+                        kind: "lesson";
+                        lessonRef: string;
+                        badExample: string;
+                        goodExample: string;
+                    } | {
+                        kind: "commit";
+                        preimageCommitSha: string;
+                        mergeCommitSha: string;
+                    };
+                    filePath: string;
+                    matchedSpan: string;
+                    contentHash: string;
+                }>, {
+                    pr: number;
+                    preimageSource: {
+                        kind: "lesson";
+                        lessonRef: string;
+                        badExample: string;
+                        goodExample: string;
+                    } | {
+                        kind: "commit";
+                        preimageCommitSha: string;
+                        mergeCommitSha: string;
+                    };
+                    filePath: string;
+                    matchedSpan: string;
+                    contentHash: string;
+                }, {
+                    pr: number;
+                    preimageSource: {
+                        kind: "lesson";
+                        lessonRef: string;
+                        badExample: string;
+                        goodExample: string;
+                    } | {
+                        kind: "commit";
+                        preimageCommitSha: string;
+                        mergeCommitSha: string;
+                    };
+                    filePath: string;
+                    matchedSpan: string;
+                    contentHash: string;
+                }>, "many">;
+                /** Declared near-misses the rule must stay silent on (feeds §6 negative controls). */
+                negativeFixtures: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodObject<{
+                    /** The PR where the defect was caught/introduced (the in-corpus anchor). */
+                    pr: z.ZodNumber;
+                    /** The §4 preimage-differential source — lesson-anchored (PRIMARY) or commit-pair (FALLBACK). */
+                    preimageSource: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+                        kind: z.ZodLiteral<"lesson">;
+                        /** IMMUTABLE lesson id/hash (the 16-hex `hashLesson` codomain) — never a path/mutable alias (§4/§8). */
+                        lessonRef: z.ZodString;
+                        /**
+                         * The defect PREIMAGE exemplar the matcher must FIRE on (§4). This is a lesson
+                         * corpus `badExample` — distinct from `CompiledRuleBaseSchema.badExample` (an
+                         * optional human-readable code snippet on a compiled rule); here it is the
+                         * load-bearing positive-control preimage, so non-empty is required.
+                         */
+                        badExample: z.ZodEffects<z.ZodString, string, string>;
+                        /** The fixed POSTIMAGE exemplar the matcher must stay SILENT on (§4) — a lesson `goodExample`. */
+                        goodExample: z.ZodEffects<z.ZodString, string, string>;
+                    }, "strict", z.ZodTypeAny, {
+                        kind: "lesson";
+                        lessonRef: string;
+                        badExample: string;
+                        goodExample: string;
+                    }, {
+                        kind: "lesson";
+                        lessonRef: string;
+                        badExample: string;
+                        goodExample: string;
+                    }>, z.ZodObject<{
+                        kind: z.ZodLiteral<"commit">;
+                        /** The PARENT (pre-fix) commit where the DEFECT is present — the matcher must FIRE on this (ADR-112 §4). */
+                        preimageCommitSha: z.ZodString;
+                        /** The PR's merge/squash commit — the post-fix (defect-absent) anchor; the matcher must stay SILENT on this. */
+                        mergeCommitSha: z.ZodString;
+                    }, "strict", z.ZodTypeAny, {
+                        kind: "commit";
+                        preimageCommitSha: string;
+                        mergeCommitSha: string;
+                    }, {
+                        kind: "commit";
+                        preimageCommitSha: string;
+                        mergeCommitSha: string;
+                    }>]>;
+                    /** File the defect locus lives in. */
+                    filePath: z.ZodEffects<z.ZodString, string, string>;
+                    /** Line-range or AST-node path — the defect locus, not just the file. */
+                    matchedSpan: z.ZodEffects<z.ZodString, string, string>;
+                    /** Span content hash, line-drift-stable (cf. `firingLabelId`). */
+                    contentHash: z.ZodEffects<z.ZodString, string, string>;
+                }, "strict", z.ZodTypeAny, {
+                    pr: number;
+                    preimageSource: {
+                        kind: "lesson";
+                        lessonRef: string;
+                        badExample: string;
+                        goodExample: string;
+                    } | {
+                        kind: "commit";
+                        preimageCommitSha: string;
+                        mergeCommitSha: string;
+                    };
+                    filePath: string;
+                    matchedSpan: string;
+                    contentHash: string;
+                }, {
+                    pr: number;
+                    preimageSource: {
+                        kind: "lesson";
+                        lessonRef: string;
+                        badExample: string;
+                        goodExample: string;
+                    } | {
+                        kind: "commit";
+                        preimageCommitSha: string;
+                        mergeCommitSha: string;
+                    };
+                    filePath: string;
+                    matchedSpan: string;
+                    contentHash: string;
+                }>, {
+                    pr: number;
+                    preimageSource: {
+                        kind: "lesson";
+                        lessonRef: string;
+                        badExample: string;
+                        goodExample: string;
+                    } | {
+                        kind: "commit";
+                        preimageCommitSha: string;
+                        mergeCommitSha: string;
+                    };
+                    filePath: string;
+                    matchedSpan: string;
+                    contentHash: string;
+                }, {
+                    pr: number;
+                    preimageSource: {
+                        kind: "lesson";
+                        lessonRef: string;
+                        badExample: string;
+                        goodExample: string;
+                    } | {
+                        kind: "commit";
+                        preimageCommitSha: string;
+                        mergeCommitSha: string;
+                    };
+                    filePath: string;
+                    matchedSpan: string;
+                    contentHash: string;
+                }>, "many">>;
+            }, "strip", z.ZodTypeAny, {
+                kind: "authored";
+                author: string;
+                authoredAt: string;
+                targetDefect: string;
+                positiveFixtures: {
+                    pr: number;
+                    preimageSource: {
+                        kind: "lesson";
+                        lessonRef: string;
+                        badExample: string;
+                        goodExample: string;
+                    } | {
+                        kind: "commit";
+                        preimageCommitSha: string;
+                        mergeCommitSha: string;
+                    };
+                    filePath: string;
+                    matchedSpan: string;
+                    contentHash: string;
+                }[];
+                negativeFixtures?: {
+                    pr: number;
+                    preimageSource: {
+                        kind: "lesson";
+                        lessonRef: string;
+                        badExample: string;
+                        goodExample: string;
+                    } | {
+                        kind: "commit";
+                        preimageCommitSha: string;
+                        mergeCommitSha: string;
+                    };
+                    filePath: string;
+                    matchedSpan: string;
+                    contentHash: string;
+                }[] | undefined;
+            }, {
+                kind: "authored";
+                author: string;
+                authoredAt: string;
+                targetDefect: string;
+                positiveFixtures: {
+                    pr: number;
+                    preimageSource: {
+                        kind: "lesson";
+                        lessonRef: string;
+                        badExample: string;
+                        goodExample: string;
+                    } | {
+                        kind: "commit";
+                        preimageCommitSha: string;
+                        mergeCommitSha: string;
+                    };
+                    filePath: string;
+                    matchedSpan: string;
+                    contentHash: string;
+                }[];
+                negativeFixtures?: {
+                    pr: number;
+                    preimageSource: {
+                        kind: "lesson";
+                        lessonRef: string;
+                        badExample: string;
+                        goodExample: string;
+                    } | {
+                        kind: "commit";
+                        preimageCommitSha: string;
+                        mergeCommitSha: string;
+                    };
+                    filePath: string;
+                    matchedSpan: string;
+                    contentHash: string;
+                }[] | undefined;
+            }>, z.ZodObject<{
+                /**
+                 * ADR-112 discriminator. OPTIONAL on the mined wire so legacy records (which
+                 * have no `kind`) round-trip byte-identical; absence is read as `'mined'` by
+                 * `provenanceKind()`. A new mined artifact MAY carry `kind: 'mined'` only
+                 * where the resulting hash churn is intentional.
+                 */
+                kind: z.ZodOptional<z.ZodLiteral<"mined">>;
                 /** Merged PR the rule was mined from (positive integer PR number). */
                 mergedPr: z.ZodNumber;
                 /**
@@ -812,11 +2926,13 @@ export declare const CompiledRulesFileSchema: z.ZodObject<{
                 mergedPr: number;
                 reviewThread: string;
                 commitSha: string;
+                kind?: "mined" | undefined;
             }, {
                 mergedPr: number;
                 reviewThread: string;
                 commitSha: string;
-            }>;
+                kind?: "mined" | undefined;
+            }>]>;
             positiveControl: z.ZodBoolean;
             negativeControl: z.ZodBoolean;
         }, "strip", z.ZodTypeAny, {
@@ -824,6 +2940,44 @@ export declare const CompiledRulesFileSchema: z.ZodObject<{
                 mergedPr: number;
                 reviewThread: string;
                 commitSha: string;
+                kind?: "mined" | undefined;
+            } | {
+                kind: "authored";
+                author: string;
+                authoredAt: string;
+                targetDefect: string;
+                positiveFixtures: {
+                    pr: number;
+                    preimageSource: {
+                        kind: "lesson";
+                        lessonRef: string;
+                        badExample: string;
+                        goodExample: string;
+                    } | {
+                        kind: "commit";
+                        preimageCommitSha: string;
+                        mergeCommitSha: string;
+                    };
+                    filePath: string;
+                    matchedSpan: string;
+                    contentHash: string;
+                }[];
+                negativeFixtures?: {
+                    pr: number;
+                    preimageSource: {
+                        kind: "lesson";
+                        lessonRef: string;
+                        badExample: string;
+                        goodExample: string;
+                    } | {
+                        kind: "commit";
+                        preimageCommitSha: string;
+                        mergeCommitSha: string;
+                    };
+                    filePath: string;
+                    matchedSpan: string;
+                    contentHash: string;
+                }[] | undefined;
             };
             positiveControl: boolean;
             negativeControl: boolean;
@@ -832,6 +2986,44 @@ export declare const CompiledRulesFileSchema: z.ZodObject<{
                 mergedPr: number;
                 reviewThread: string;
                 commitSha: string;
+                kind?: "mined" | undefined;
+            } | {
+                kind: "authored";
+                author: string;
+                authoredAt: string;
+                targetDefect: string;
+                positiveFixtures: {
+                    pr: number;
+                    preimageSource: {
+                        kind: "lesson";
+                        lessonRef: string;
+                        badExample: string;
+                        goodExample: string;
+                    } | {
+                        kind: "commit";
+                        preimageCommitSha: string;
+                        mergeCommitSha: string;
+                    };
+                    filePath: string;
+                    matchedSpan: string;
+                    contentHash: string;
+                }[];
+                negativeFixtures?: {
+                    pr: number;
+                    preimageSource: {
+                        kind: "lesson";
+                        lessonRef: string;
+                        badExample: string;
+                        goodExample: string;
+                    } | {
+                        kind: "commit";
+                        preimageCommitSha: string;
+                        mergeCommitSha: string;
+                    };
+                    filePath: string;
+                    matchedSpan: string;
+                    contentHash: string;
+                }[] | undefined;
             };
             positiveControl: boolean;
             negativeControl: boolean;
@@ -855,13 +3047,13 @@ export declare const CompiledRulesFileSchema: z.ZodObject<{
         engine: "regex" | "ast" | "ast-grep";
         compiledAt: string;
         status?: "active" | "archived" | "untested-against-codebase" | "pending-verification" | undefined;
+        badExample?: string | undefined;
+        goodExample?: string | undefined;
         astQuery?: string | undefined;
         astGrepPattern?: string | undefined;
         astGrepYamlRule?: z.objectOutputType<{
             rule: z.ZodRecord<z.ZodString, z.ZodUnknown>;
         }, z.ZodTypeAny, "passthrough"> | undefined;
-        badExample?: string | undefined;
-        goodExample?: string | undefined;
         createdAt?: string | undefined;
         fileGlobs?: string[] | undefined;
         category?: "security" | "architecture" | "style" | "performance" | undefined;
@@ -877,6 +3069,44 @@ export declare const CompiledRulesFileSchema: z.ZodObject<{
                 mergedPr: number;
                 reviewThread: string;
                 commitSha: string;
+                kind?: "mined" | undefined;
+            } | {
+                kind: "authored";
+                author: string;
+                authoredAt: string;
+                targetDefect: string;
+                positiveFixtures: {
+                    pr: number;
+                    preimageSource: {
+                        kind: "lesson";
+                        lessonRef: string;
+                        badExample: string;
+                        goodExample: string;
+                    } | {
+                        kind: "commit";
+                        preimageCommitSha: string;
+                        mergeCommitSha: string;
+                    };
+                    filePath: string;
+                    matchedSpan: string;
+                    contentHash: string;
+                }[];
+                negativeFixtures?: {
+                    pr: number;
+                    preimageSource: {
+                        kind: "lesson";
+                        lessonRef: string;
+                        badExample: string;
+                        goodExample: string;
+                    } | {
+                        kind: "commit";
+                        preimageCommitSha: string;
+                        mergeCommitSha: string;
+                    };
+                    filePath: string;
+                    matchedSpan: string;
+                    contentHash: string;
+                }[] | undefined;
             };
             positiveControl: boolean;
             negativeControl: boolean;
@@ -890,13 +3120,13 @@ export declare const CompiledRulesFileSchema: z.ZodObject<{
         engine: "regex" | "ast" | "ast-grep";
         compiledAt: string;
         status?: "active" | "archived" | "untested-against-codebase" | "pending-verification" | undefined;
+        badExample?: string | undefined;
+        goodExample?: string | undefined;
         astQuery?: string | undefined;
         astGrepPattern?: string | undefined;
         astGrepYamlRule?: z.objectInputType<{
             rule: z.ZodRecord<z.ZodString, z.ZodUnknown>;
         }, z.ZodTypeAny, "passthrough"> | undefined;
-        badExample?: string | undefined;
-        goodExample?: string | undefined;
         createdAt?: string | undefined;
         fileGlobs?: string[] | undefined;
         category?: "security" | "architecture" | "style" | "performance" | undefined;
@@ -912,6 +3142,44 @@ export declare const CompiledRulesFileSchema: z.ZodObject<{
                 mergedPr: number;
                 reviewThread: string;
                 commitSha: string;
+                kind?: "mined" | undefined;
+            } | {
+                kind: "authored";
+                author: string;
+                authoredAt: string;
+                targetDefect: string;
+                positiveFixtures: {
+                    pr: number;
+                    preimageSource: {
+                        kind: "lesson";
+                        lessonRef: string;
+                        badExample: string;
+                        goodExample: string;
+                    } | {
+                        kind: "commit";
+                        preimageCommitSha: string;
+                        mergeCommitSha: string;
+                    };
+                    filePath: string;
+                    matchedSpan: string;
+                    contentHash: string;
+                }[];
+                negativeFixtures?: {
+                    pr: number;
+                    preimageSource: {
+                        kind: "lesson";
+                        lessonRef: string;
+                        badExample: string;
+                        goodExample: string;
+                    } | {
+                        kind: "commit";
+                        preimageCommitSha: string;
+                        mergeCommitSha: string;
+                    };
+                    filePath: string;
+                    matchedSpan: string;
+                    contentHash: string;
+                }[] | undefined;
             };
             positiveControl: boolean;
             negativeControl: boolean;
@@ -925,13 +3193,13 @@ export declare const CompiledRulesFileSchema: z.ZodObject<{
         engine: "regex" | "ast" | "ast-grep";
         compiledAt: string;
         status?: "active" | "archived" | "untested-against-codebase" | "pending-verification" | undefined;
+        badExample?: string | undefined;
+        goodExample?: string | undefined;
         astQuery?: string | undefined;
         astGrepPattern?: string | undefined;
         astGrepYamlRule?: z.objectOutputType<{
             rule: z.ZodRecord<z.ZodString, z.ZodUnknown>;
         }, z.ZodTypeAny, "passthrough"> | undefined;
-        badExample?: string | undefined;
-        goodExample?: string | undefined;
         createdAt?: string | undefined;
         fileGlobs?: string[] | undefined;
         category?: "security" | "architecture" | "style" | "performance" | undefined;
@@ -947,6 +3215,44 @@ export declare const CompiledRulesFileSchema: z.ZodObject<{
                 mergedPr: number;
                 reviewThread: string;
                 commitSha: string;
+                kind?: "mined" | undefined;
+            } | {
+                kind: "authored";
+                author: string;
+                authoredAt: string;
+                targetDefect: string;
+                positiveFixtures: {
+                    pr: number;
+                    preimageSource: {
+                        kind: "lesson";
+                        lessonRef: string;
+                        badExample: string;
+                        goodExample: string;
+                    } | {
+                        kind: "commit";
+                        preimageCommitSha: string;
+                        mergeCommitSha: string;
+                    };
+                    filePath: string;
+                    matchedSpan: string;
+                    contentHash: string;
+                }[];
+                negativeFixtures?: {
+                    pr: number;
+                    preimageSource: {
+                        kind: "lesson";
+                        lessonRef: string;
+                        badExample: string;
+                        goodExample: string;
+                    } | {
+                        kind: "commit";
+                        preimageCommitSha: string;
+                        mergeCommitSha: string;
+                    };
+                    filePath: string;
+                    matchedSpan: string;
+                    contentHash: string;
+                }[] | undefined;
             };
             positiveControl: boolean;
             negativeControl: boolean;
@@ -960,13 +3266,13 @@ export declare const CompiledRulesFileSchema: z.ZodObject<{
         engine: "regex" | "ast" | "ast-grep";
         compiledAt: string;
         status?: "active" | "archived" | "untested-against-codebase" | "pending-verification" | undefined;
+        badExample?: string | undefined;
+        goodExample?: string | undefined;
         astQuery?: string | undefined;
         astGrepPattern?: string | undefined;
         astGrepYamlRule?: z.objectInputType<{
             rule: z.ZodRecord<z.ZodString, z.ZodUnknown>;
         }, z.ZodTypeAny, "passthrough"> | undefined;
-        badExample?: string | undefined;
-        goodExample?: string | undefined;
         createdAt?: string | undefined;
         fileGlobs?: string[] | undefined;
         category?: "security" | "architecture" | "style" | "performance" | undefined;
@@ -982,6 +3288,44 @@ export declare const CompiledRulesFileSchema: z.ZodObject<{
                 mergedPr: number;
                 reviewThread: string;
                 commitSha: string;
+                kind?: "mined" | undefined;
+            } | {
+                kind: "authored";
+                author: string;
+                authoredAt: string;
+                targetDefect: string;
+                positiveFixtures: {
+                    pr: number;
+                    preimageSource: {
+                        kind: "lesson";
+                        lessonRef: string;
+                        badExample: string;
+                        goodExample: string;
+                    } | {
+                        kind: "commit";
+                        preimageCommitSha: string;
+                        mergeCommitSha: string;
+                    };
+                    filePath: string;
+                    matchedSpan: string;
+                    contentHash: string;
+                }[];
+                negativeFixtures?: {
+                    pr: number;
+                    preimageSource: {
+                        kind: "lesson";
+                        lessonRef: string;
+                        badExample: string;
+                        goodExample: string;
+                    } | {
+                        kind: "commit";
+                        preimageCommitSha: string;
+                        mergeCommitSha: string;
+                    };
+                    filePath: string;
+                    matchedSpan: string;
+                    contentHash: string;
+                }[] | undefined;
             };
             positiveControl: boolean;
             negativeControl: boolean;
@@ -1045,13 +3389,13 @@ export declare const CompiledRulesFileSchema: z.ZodObject<{
         engine: "regex" | "ast" | "ast-grep";
         compiledAt: string;
         status?: "active" | "archived" | "untested-against-codebase" | "pending-verification" | undefined;
+        badExample?: string | undefined;
+        goodExample?: string | undefined;
         astQuery?: string | undefined;
         astGrepPattern?: string | undefined;
         astGrepYamlRule?: z.objectOutputType<{
             rule: z.ZodRecord<z.ZodString, z.ZodUnknown>;
         }, z.ZodTypeAny, "passthrough"> | undefined;
-        badExample?: string | undefined;
-        goodExample?: string | undefined;
         createdAt?: string | undefined;
         fileGlobs?: string[] | undefined;
         category?: "security" | "architecture" | "style" | "performance" | undefined;
@@ -1067,6 +3411,44 @@ export declare const CompiledRulesFileSchema: z.ZodObject<{
                 mergedPr: number;
                 reviewThread: string;
                 commitSha: string;
+                kind?: "mined" | undefined;
+            } | {
+                kind: "authored";
+                author: string;
+                authoredAt: string;
+                targetDefect: string;
+                positiveFixtures: {
+                    pr: number;
+                    preimageSource: {
+                        kind: "lesson";
+                        lessonRef: string;
+                        badExample: string;
+                        goodExample: string;
+                    } | {
+                        kind: "commit";
+                        preimageCommitSha: string;
+                        mergeCommitSha: string;
+                    };
+                    filePath: string;
+                    matchedSpan: string;
+                    contentHash: string;
+                }[];
+                negativeFixtures?: {
+                    pr: number;
+                    preimageSource: {
+                        kind: "lesson";
+                        lessonRef: string;
+                        badExample: string;
+                        goodExample: string;
+                    } | {
+                        kind: "commit";
+                        preimageCommitSha: string;
+                        mergeCommitSha: string;
+                    };
+                    filePath: string;
+                    matchedSpan: string;
+                    contentHash: string;
+                }[] | undefined;
             };
             positiveControl: boolean;
             negativeControl: boolean;
@@ -1089,13 +3471,13 @@ export declare const CompiledRulesFileSchema: z.ZodObject<{
         engine: "regex" | "ast" | "ast-grep";
         compiledAt: string;
         status?: "active" | "archived" | "untested-against-codebase" | "pending-verification" | undefined;
+        badExample?: string | undefined;
+        goodExample?: string | undefined;
         astQuery?: string | undefined;
         astGrepPattern?: string | undefined;
         astGrepYamlRule?: z.objectInputType<{
             rule: z.ZodRecord<z.ZodString, z.ZodUnknown>;
         }, z.ZodTypeAny, "passthrough"> | undefined;
-        badExample?: string | undefined;
-        goodExample?: string | undefined;
         createdAt?: string | undefined;
         fileGlobs?: string[] | undefined;
         category?: "security" | "architecture" | "style" | "performance" | undefined;
@@ -1111,6 +3493,44 @@ export declare const CompiledRulesFileSchema: z.ZodObject<{
                 mergedPr: number;
                 reviewThread: string;
                 commitSha: string;
+                kind?: "mined" | undefined;
+            } | {
+                kind: "authored";
+                author: string;
+                authoredAt: string;
+                targetDefect: string;
+                positiveFixtures: {
+                    pr: number;
+                    preimageSource: {
+                        kind: "lesson";
+                        lessonRef: string;
+                        badExample: string;
+                        goodExample: string;
+                    } | {
+                        kind: "commit";
+                        preimageCommitSha: string;
+                        mergeCommitSha: string;
+                    };
+                    filePath: string;
+                    matchedSpan: string;
+                    contentHash: string;
+                }[];
+                negativeFixtures?: {
+                    pr: number;
+                    preimageSource: {
+                        kind: "lesson";
+                        lessonRef: string;
+                        badExample: string;
+                        goodExample: string;
+                    } | {
+                        kind: "commit";
+                        preimageCommitSha: string;
+                        mergeCommitSha: string;
+                    };
+                    filePath: string;
+                    matchedSpan: string;
+                    contentHash: string;
+                }[] | undefined;
             };
             positiveControl: boolean;
             negativeControl: boolean;
@@ -1186,6 +3606,8 @@ export declare const CompilerOutputSchema: z.ZodEffects<z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     compilable: boolean;
     message?: string | undefined;
+    badExample?: string | undefined;
+    goodExample?: string | undefined;
     pattern?: string | undefined;
     engine?: "regex" | "ast" | "ast-grep" | undefined;
     astQuery?: string | undefined;
@@ -1193,8 +3615,6 @@ export declare const CompilerOutputSchema: z.ZodEffects<z.ZodObject<{
     astGrepYamlRule?: z.objectOutputType<{
         rule: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     }, z.ZodTypeAny, "passthrough"> | undefined;
-    badExample?: string | undefined;
-    goodExample?: string | undefined;
     fileGlobs?: string[] | undefined;
     severity?: "error" | "warning" | undefined;
     reasonCode?: "context-required" | "semantic-analysis-required" | undefined;
@@ -1202,6 +3622,8 @@ export declare const CompilerOutputSchema: z.ZodEffects<z.ZodObject<{
 }, {
     compilable: boolean;
     message?: string | undefined;
+    badExample?: string | undefined;
+    goodExample?: string | undefined;
     pattern?: string | undefined;
     engine?: "regex" | "ast" | "ast-grep" | undefined;
     astQuery?: string | undefined;
@@ -1209,8 +3631,6 @@ export declare const CompilerOutputSchema: z.ZodEffects<z.ZodObject<{
     astGrepYamlRule?: z.objectInputType<{
         rule: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     }, z.ZodTypeAny, "passthrough"> | undefined;
-    badExample?: string | undefined;
-    goodExample?: string | undefined;
     fileGlobs?: string[] | undefined;
     severity?: "error" | "warning" | undefined;
     reasonCode?: "context-required" | "semantic-analysis-required" | undefined;
@@ -1218,6 +3638,8 @@ export declare const CompilerOutputSchema: z.ZodEffects<z.ZodObject<{
 }>, {
     compilable: boolean;
     message?: string | undefined;
+    badExample?: string | undefined;
+    goodExample?: string | undefined;
     pattern?: string | undefined;
     engine?: "regex" | "ast" | "ast-grep" | undefined;
     astQuery?: string | undefined;
@@ -1225,8 +3647,6 @@ export declare const CompilerOutputSchema: z.ZodEffects<z.ZodObject<{
     astGrepYamlRule?: z.objectOutputType<{
         rule: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     }, z.ZodTypeAny, "passthrough"> | undefined;
-    badExample?: string | undefined;
-    goodExample?: string | undefined;
     fileGlobs?: string[] | undefined;
     severity?: "error" | "warning" | undefined;
     reasonCode?: "context-required" | "semantic-analysis-required" | undefined;
@@ -1234,6 +3654,8 @@ export declare const CompilerOutputSchema: z.ZodEffects<z.ZodObject<{
 }, {
     compilable: boolean;
     message?: string | undefined;
+    badExample?: string | undefined;
+    goodExample?: string | undefined;
     pattern?: string | undefined;
     engine?: "regex" | "ast" | "ast-grep" | undefined;
     astQuery?: string | undefined;
@@ -1241,8 +3663,6 @@ export declare const CompilerOutputSchema: z.ZodEffects<z.ZodObject<{
     astGrepYamlRule?: z.objectInputType<{
         rule: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     }, z.ZodTypeAny, "passthrough"> | undefined;
-    badExample?: string | undefined;
-    goodExample?: string | undefined;
     fileGlobs?: string[] | undefined;
     severity?: "error" | "warning" | undefined;
     reasonCode?: "context-required" | "semantic-analysis-required" | undefined;