@mmnto/totem 1.79.0 → 1.81.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
@@ -89,37 +98,181 @@ export declare const MinedProvenanceWireSchema: z.ZodObject<{
     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 must CARRY both commits + the
- * defect locus here so derivation is possible. `matchedSpan` + `contentHash`
- * are the line-drift-stable locus (cf. `firingLabelId`), not just the file.
+ * (§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.ZodObject<{
-    /** The PR whose merge introduced the fix (the in-corpus anchor). */
+export declare const AuthoredFixtureSchema: z.ZodEffects<z.ZodObject<{
+    /** The PR where the defect was caught/introduced (the in-corpus anchor). */
     pr: z.ZodNumber;
-    /** The PR's merge/squash commit — the post-fix (defect-absent) anchor. */
-    mergeCommitSha: z.ZodString;
-    /** The PARENT (pre-fix) commit where the DEFECT is present (ADR-112 §4). */
-    preimageCommitSha: z.ZodString;
+    /** 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>;
-}, "strip", z.ZodTypeAny, {
+}, "strict", z.ZodTypeAny, {
     pr: number;
-    mergeCommitSha: string;
-    preimageCommitSha: string;
+    preimageSource: {
+        kind: "lesson";
+        lessonRef: string;
+        badExample: string;
+        goodExample: string;
+    } | {
+        kind: "commit";
+        preimageCommitSha: string;
+        mergeCommitSha: string;
+    };
     filePath: string;
     matchedSpan: string;
     contentHash: string;
 }, {
     pr: number;
-    mergeCommitSha: string;
-    preimageCommitSha: string;
+    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;
@@ -143,59 +296,221 @@ export declare const AuthoredProvenanceRecordSchema: z.ZodObject<{
     /** 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.ZodObject<{
-        /** The PR whose merge introduced the fix (the in-corpus anchor). */
+    positiveFixtures: z.ZodArray<z.ZodEffects<z.ZodObject<{
+        /** The PR where the defect was caught/introduced (the in-corpus anchor). */
         pr: z.ZodNumber;
-        /** The PR's merge/squash commit — the post-fix (defect-absent) anchor. */
-        mergeCommitSha: z.ZodString;
-        /** The PARENT (pre-fix) commit where the DEFECT is present (ADR-112 §4). */
-        preimageCommitSha: z.ZodString;
+        /** 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>;
-    }, "strip", z.ZodTypeAny, {
+    }, "strict", z.ZodTypeAny, {
         pr: number;
-        mergeCommitSha: string;
-        preimageCommitSha: string;
+        preimageSource: {
+            kind: "lesson";
+            lessonRef: string;
+            badExample: string;
+            goodExample: string;
+        } | {
+            kind: "commit";
+            preimageCommitSha: string;
+            mergeCommitSha: string;
+        };
         filePath: string;
         matchedSpan: string;
         contentHash: string;
     }, {
         pr: number;
-        mergeCommitSha: string;
-        preimageCommitSha: string;
+        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.ZodObject<{
-        /** The PR whose merge introduced the fix (the in-corpus anchor). */
+    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 PR's merge/squash commit — the post-fix (defect-absent) anchor. */
-        mergeCommitSha: z.ZodString;
-        /** The PARENT (pre-fix) commit where the DEFECT is present (ADR-112 §4). */
-        preimageCommitSha: z.ZodString;
+        /** 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>;
-    }, "strip", z.ZodTypeAny, {
+    }, "strict", z.ZodTypeAny, {
         pr: number;
-        mergeCommitSha: string;
-        preimageCommitSha: string;
+        preimageSource: {
+            kind: "lesson";
+            lessonRef: string;
+            badExample: string;
+            goodExample: string;
+        } | {
+            kind: "commit";
+            preimageCommitSha: string;
+            mergeCommitSha: string;
+        };
         filePath: string;
         matchedSpan: string;
         contentHash: string;
     }, {
         pr: number;
-        mergeCommitSha: string;
-        preimageCommitSha: string;
+        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;
@@ -207,16 +522,32 @@ export declare const AuthoredProvenanceRecordSchema: z.ZodObject<{
     targetDefect: string;
     positiveFixtures: {
         pr: number;
-        mergeCommitSha: string;
-        preimageCommitSha: string;
+        preimageSource: {
+            kind: "lesson";
+            lessonRef: string;
+            badExample: string;
+            goodExample: string;
+        } | {
+            kind: "commit";
+            preimageCommitSha: string;
+            mergeCommitSha: string;
+        };
         filePath: string;
         matchedSpan: string;
         contentHash: string;
     }[];
     negativeFixtures?: {
         pr: number;
-        mergeCommitSha: string;
-        preimageCommitSha: string;
+        preimageSource: {
+            kind: "lesson";
+            lessonRef: string;
+            badExample: string;
+            goodExample: string;
+        } | {
+            kind: "commit";
+            preimageCommitSha: string;
+            mergeCommitSha: string;
+        };
         filePath: string;
         matchedSpan: string;
         contentHash: string;
@@ -228,16 +559,32 @@ export declare const AuthoredProvenanceRecordSchema: z.ZodObject<{
     targetDefect: string;
     positiveFixtures: {
         pr: number;
-        mergeCommitSha: string;
-        preimageCommitSha: string;
+        preimageSource: {
+            kind: "lesson";
+            lessonRef: string;
+            badExample: string;
+            goodExample: string;
+        } | {
+            kind: "commit";
+            preimageCommitSha: string;
+            mergeCommitSha: string;
+        };
         filePath: string;
         matchedSpan: string;
         contentHash: string;
     }[];
     negativeFixtures?: {
         pr: number;
-        mergeCommitSha: string;
-        preimageCommitSha: string;
+        preimageSource: {
+            kind: "lesson";
+            lessonRef: string;
+            badExample: string;
+            goodExample: string;
+        } | {
+            kind: "commit";
+            preimageCommitSha: string;
+            mergeCommitSha: string;
+        };
         filePath: string;
         matchedSpan: string;
         contentHash: string;
@@ -265,59 +612,221 @@ export declare const ProvenanceRecordSchema: z.ZodUnion<[z.ZodObject<{
     /** 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.ZodObject<{
-        /** The PR whose merge introduced the fix (the in-corpus anchor). */
+    positiveFixtures: z.ZodArray<z.ZodEffects<z.ZodObject<{
+        /** The PR where the defect was caught/introduced (the in-corpus anchor). */
         pr: z.ZodNumber;
-        /** The PR's merge/squash commit — the post-fix (defect-absent) anchor. */
-        mergeCommitSha: z.ZodString;
-        /** The PARENT (pre-fix) commit where the DEFECT is present (ADR-112 §4). */
-        preimageCommitSha: z.ZodString;
+        /** 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>;
-    }, "strip", z.ZodTypeAny, {
+    }, "strict", z.ZodTypeAny, {
         pr: number;
-        mergeCommitSha: string;
-        preimageCommitSha: string;
+        preimageSource: {
+            kind: "lesson";
+            lessonRef: string;
+            badExample: string;
+            goodExample: string;
+        } | {
+            kind: "commit";
+            preimageCommitSha: string;
+            mergeCommitSha: string;
+        };
         filePath: string;
         matchedSpan: string;
         contentHash: string;
     }, {
         pr: number;
-        mergeCommitSha: string;
-        preimageCommitSha: string;
+        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.ZodObject<{
-        /** The PR whose merge introduced the fix (the in-corpus anchor). */
+    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 PR's merge/squash commit — the post-fix (defect-absent) anchor. */
-        mergeCommitSha: z.ZodString;
-        /** The PARENT (pre-fix) commit where the DEFECT is present (ADR-112 §4). */
-        preimageCommitSha: z.ZodString;
+        /** 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>;
-    }, "strip", z.ZodTypeAny, {
+    }, "strict", z.ZodTypeAny, {
         pr: number;
-        mergeCommitSha: string;
-        preimageCommitSha: string;
+        preimageSource: {
+            kind: "lesson";
+            lessonRef: string;
+            badExample: string;
+            goodExample: string;
+        } | {
+            kind: "commit";
+            preimageCommitSha: string;
+            mergeCommitSha: string;
+        };
         filePath: string;
         matchedSpan: string;
         contentHash: string;
     }, {
         pr: number;
-        mergeCommitSha: string;
-        preimageCommitSha: string;
+        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;
@@ -329,16 +838,32 @@ export declare const ProvenanceRecordSchema: z.ZodUnion<[z.ZodObject<{
     targetDefect: string;
     positiveFixtures: {
         pr: number;
-        mergeCommitSha: string;
-        preimageCommitSha: string;
+        preimageSource: {
+            kind: "lesson";
+            lessonRef: string;
+            badExample: string;
+            goodExample: string;
+        } | {
+            kind: "commit";
+            preimageCommitSha: string;
+            mergeCommitSha: string;
+        };
         filePath: string;
         matchedSpan: string;
         contentHash: string;
     }[];
     negativeFixtures?: {
         pr: number;
-        mergeCommitSha: string;
-        preimageCommitSha: string;
+        preimageSource: {
+            kind: "lesson";
+            lessonRef: string;
+            badExample: string;
+            goodExample: string;
+        } | {
+            kind: "commit";
+            preimageCommitSha: string;
+            mergeCommitSha: string;
+        };
         filePath: string;
         matchedSpan: string;
         contentHash: string;
@@ -350,16 +875,32 @@ export declare const ProvenanceRecordSchema: z.ZodUnion<[z.ZodObject<{
     targetDefect: string;
     positiveFixtures: {
         pr: number;
-        mergeCommitSha: string;
-        preimageCommitSha: string;
+        preimageSource: {
+            kind: "lesson";
+            lessonRef: string;
+            badExample: string;
+            goodExample: string;
+        } | {
+            kind: "commit";
+            preimageCommitSha: string;
+            mergeCommitSha: string;
+        };
         filePath: string;
         matchedSpan: string;
         contentHash: string;
     }[];
     negativeFixtures?: {
         pr: number;
-        mergeCommitSha: string;
-        preimageCommitSha: string;
+        preimageSource: {
+            kind: "lesson";
+            lessonRef: string;
+            badExample: string;
+            goodExample: string;
+        } | {
+            kind: "commit";
+            preimageCommitSha: string;
+            mergeCommitSha: string;
+        };
         filePath: string;
         matchedSpan: string;
         contentHash: string;
@@ -427,59 +968,221 @@ export declare const LegitimacySchema: z.ZodObject<{
         /** 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.ZodObject<{
-            /** The PR whose merge introduced the fix (the in-corpus anchor). */
+        positiveFixtures: z.ZodArray<z.ZodEffects<z.ZodObject<{
+            /** The PR where the defect was caught/introduced (the in-corpus anchor). */
             pr: z.ZodNumber;
-            /** The PR's merge/squash commit — the post-fix (defect-absent) anchor. */
-            mergeCommitSha: z.ZodString;
-            /** The PARENT (pre-fix) commit where the DEFECT is present (ADR-112 §4). */
-            preimageCommitSha: z.ZodString;
+            /** 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>;
-        }, "strip", z.ZodTypeAny, {
+        }, "strict", z.ZodTypeAny, {
             pr: number;
-            mergeCommitSha: string;
-            preimageCommitSha: string;
+            preimageSource: {
+                kind: "lesson";
+                lessonRef: string;
+                badExample: string;
+                goodExample: string;
+            } | {
+                kind: "commit";
+                preimageCommitSha: string;
+                mergeCommitSha: string;
+            };
             filePath: string;
             matchedSpan: string;
             contentHash: string;
         }, {
             pr: number;
-            mergeCommitSha: string;
-            preimageCommitSha: string;
+            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.ZodObject<{
-            /** The PR whose merge introduced the fix (the in-corpus anchor). */
+        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 PR's merge/squash commit — the post-fix (defect-absent) anchor. */
-            mergeCommitSha: z.ZodString;
-            /** The PARENT (pre-fix) commit where the DEFECT is present (ADR-112 §4). */
-            preimageCommitSha: z.ZodString;
+            /** 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>;
-        }, "strip", z.ZodTypeAny, {
+        }, "strict", z.ZodTypeAny, {
             pr: number;
-            mergeCommitSha: string;
-            preimageCommitSha: string;
+            preimageSource: {
+                kind: "lesson";
+                lessonRef: string;
+                badExample: string;
+                goodExample: string;
+            } | {
+                kind: "commit";
+                preimageCommitSha: string;
+                mergeCommitSha: string;
+            };
             filePath: string;
             matchedSpan: string;
             contentHash: string;
         }, {
             pr: number;
-            mergeCommitSha: string;
-            preimageCommitSha: string;
+            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;
@@ -491,16 +1194,32 @@ export declare const LegitimacySchema: z.ZodObject<{
         targetDefect: string;
         positiveFixtures: {
             pr: number;
-            mergeCommitSha: string;
-            preimageCommitSha: string;
+            preimageSource: {
+                kind: "lesson";
+                lessonRef: string;
+                badExample: string;
+                goodExample: string;
+            } | {
+                kind: "commit";
+                preimageCommitSha: string;
+                mergeCommitSha: string;
+            };
             filePath: string;
             matchedSpan: string;
             contentHash: string;
         }[];
         negativeFixtures?: {
             pr: number;
-            mergeCommitSha: string;
-            preimageCommitSha: string;
+            preimageSource: {
+                kind: "lesson";
+                lessonRef: string;
+                badExample: string;
+                goodExample: string;
+            } | {
+                kind: "commit";
+                preimageCommitSha: string;
+                mergeCommitSha: string;
+            };
             filePath: string;
             matchedSpan: string;
             contentHash: string;
@@ -512,16 +1231,32 @@ export declare const LegitimacySchema: z.ZodObject<{
         targetDefect: string;
         positiveFixtures: {
             pr: number;
-            mergeCommitSha: string;
-            preimageCommitSha: string;
+            preimageSource: {
+                kind: "lesson";
+                lessonRef: string;
+                badExample: string;
+                goodExample: string;
+            } | {
+                kind: "commit";
+                preimageCommitSha: string;
+                mergeCommitSha: string;
+            };
             filePath: string;
             matchedSpan: string;
             contentHash: string;
         }[];
         negativeFixtures?: {
             pr: number;
-            mergeCommitSha: string;
-            preimageCommitSha: string;
+            preimageSource: {
+                kind: "lesson";
+                lessonRef: string;
+                badExample: string;
+                goodExample: string;
+            } | {
+                kind: "commit";
+                preimageCommitSha: string;
+                mergeCommitSha: string;
+            };
             filePath: string;
             matchedSpan: string;
             contentHash: string;
@@ -573,16 +1308,32 @@ export declare const LegitimacySchema: z.ZodObject<{
         targetDefect: string;
         positiveFixtures: {
             pr: number;
-            mergeCommitSha: string;
-            preimageCommitSha: string;
+            preimageSource: {
+                kind: "lesson";
+                lessonRef: string;
+                badExample: string;
+                goodExample: string;
+            } | {
+                kind: "commit";
+                preimageCommitSha: string;
+                mergeCommitSha: string;
+            };
             filePath: string;
             matchedSpan: string;
             contentHash: string;
         }[];
         negativeFixtures?: {
             pr: number;
-            mergeCommitSha: string;
-            preimageCommitSha: string;
+            preimageSource: {
+                kind: "lesson";
+                lessonRef: string;
+                badExample: string;
+                goodExample: string;
+            } | {
+                kind: "commit";
+                preimageCommitSha: string;
+                mergeCommitSha: string;
+            };
             filePath: string;
             matchedSpan: string;
             contentHash: string;
@@ -603,16 +1354,32 @@ export declare const LegitimacySchema: z.ZodObject<{
         targetDefect: string;
         positiveFixtures: {
             pr: number;
-            mergeCommitSha: string;
-            preimageCommitSha: string;
+            preimageSource: {
+                kind: "lesson";
+                lessonRef: string;
+                badExample: string;
+                goodExample: string;
+            } | {
+                kind: "commit";
+                preimageCommitSha: string;
+                mergeCommitSha: string;
+            };
             filePath: string;
             matchedSpan: string;
             contentHash: string;
         }[];
         negativeFixtures?: {
             pr: number;
-            mergeCommitSha: string;
-            preimageCommitSha: string;
+            preimageSource: {
+                kind: "lesson";
+                lessonRef: string;
+                badExample: string;
+                goodExample: string;
+            } | {
+                kind: "commit";
+                preimageCommitSha: string;
+                mergeCommitSha: string;
+            };
             filePath: string;
             matchedSpan: string;
             contentHash: string;
@@ -817,59 +1584,221 @@ export declare const CompiledRuleSchema: z.ZodEffects<z.ZodObject<{
             /** 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.ZodObject<{
-                /** The PR whose merge introduced the fix (the in-corpus anchor). */
+            positiveFixtures: z.ZodArray<z.ZodEffects<z.ZodObject<{
+                /** The PR where the defect was caught/introduced (the in-corpus anchor). */
                 pr: z.ZodNumber;
-                /** The PR's merge/squash commit — the post-fix (defect-absent) anchor. */
-                mergeCommitSha: z.ZodString;
-                /** The PARENT (pre-fix) commit where the DEFECT is present (ADR-112 §4). */
-                preimageCommitSha: z.ZodString;
+                /** 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>;
-            }, "strip", z.ZodTypeAny, {
+            }, "strict", z.ZodTypeAny, {
                 pr: number;
-                mergeCommitSha: string;
-                preimageCommitSha: string;
+                preimageSource: {
+                    kind: "lesson";
+                    lessonRef: string;
+                    badExample: string;
+                    goodExample: string;
+                } | {
+                    kind: "commit";
+                    preimageCommitSha: string;
+                    mergeCommitSha: string;
+                };
                 filePath: string;
                 matchedSpan: string;
                 contentHash: string;
             }, {
                 pr: number;
-                mergeCommitSha: string;
-                preimageCommitSha: string;
+                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.ZodObject<{
-                /** The PR whose merge introduced the fix (the in-corpus anchor). */
+            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 PR's merge/squash commit — the post-fix (defect-absent) anchor. */
-                mergeCommitSha: z.ZodString;
-                /** The PARENT (pre-fix) commit where the DEFECT is present (ADR-112 §4). */
-                preimageCommitSha: z.ZodString;
+                /** 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>;
-            }, "strip", z.ZodTypeAny, {
+            }, "strict", z.ZodTypeAny, {
                 pr: number;
-                mergeCommitSha: string;
-                preimageCommitSha: string;
+                preimageSource: {
+                    kind: "lesson";
+                    lessonRef: string;
+                    badExample: string;
+                    goodExample: string;
+                } | {
+                    kind: "commit";
+                    preimageCommitSha: string;
+                    mergeCommitSha: string;
+                };
                 filePath: string;
                 matchedSpan: string;
                 contentHash: string;
             }, {
                 pr: number;
-                mergeCommitSha: string;
-                preimageCommitSha: string;
+                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;
@@ -881,16 +1810,32 @@ export declare const CompiledRuleSchema: z.ZodEffects<z.ZodObject<{
             targetDefect: string;
             positiveFixtures: {
                 pr: number;
-                mergeCommitSha: string;
-                preimageCommitSha: string;
+                preimageSource: {
+                    kind: "lesson";
+                    lessonRef: string;
+                    badExample: string;
+                    goodExample: string;
+                } | {
+                    kind: "commit";
+                    preimageCommitSha: string;
+                    mergeCommitSha: string;
+                };
                 filePath: string;
                 matchedSpan: string;
                 contentHash: string;
             }[];
             negativeFixtures?: {
                 pr: number;
-                mergeCommitSha: string;
-                preimageCommitSha: string;
+                preimageSource: {
+                    kind: "lesson";
+                    lessonRef: string;
+                    badExample: string;
+                    goodExample: string;
+                } | {
+                    kind: "commit";
+                    preimageCommitSha: string;
+                    mergeCommitSha: string;
+                };
                 filePath: string;
                 matchedSpan: string;
                 contentHash: string;
@@ -902,16 +1847,32 @@ export declare const CompiledRuleSchema: z.ZodEffects<z.ZodObject<{
             targetDefect: string;
             positiveFixtures: {
                 pr: number;
-                mergeCommitSha: string;
-                preimageCommitSha: string;
+                preimageSource: {
+                    kind: "lesson";
+                    lessonRef: string;
+                    badExample: string;
+                    goodExample: string;
+                } | {
+                    kind: "commit";
+                    preimageCommitSha: string;
+                    mergeCommitSha: string;
+                };
                 filePath: string;
                 matchedSpan: string;
                 contentHash: string;
             }[];
             negativeFixtures?: {
                 pr: number;
-                mergeCommitSha: string;
-                preimageCommitSha: string;
+                preimageSource: {
+                    kind: "lesson";
+                    lessonRef: string;
+                    badExample: string;
+                    goodExample: string;
+                } | {
+                    kind: "commit";
+                    preimageCommitSha: string;
+                    mergeCommitSha: string;
+                };
                 filePath: string;
                 matchedSpan: string;
                 contentHash: string;
@@ -963,16 +1924,32 @@ export declare const CompiledRuleSchema: z.ZodEffects<z.ZodObject<{
             targetDefect: string;
             positiveFixtures: {
                 pr: number;
-                mergeCommitSha: string;
-                preimageCommitSha: string;
+                preimageSource: {
+                    kind: "lesson";
+                    lessonRef: string;
+                    badExample: string;
+                    goodExample: string;
+                } | {
+                    kind: "commit";
+                    preimageCommitSha: string;
+                    mergeCommitSha: string;
+                };
                 filePath: string;
                 matchedSpan: string;
                 contentHash: string;
             }[];
             negativeFixtures?: {
                 pr: number;
-                mergeCommitSha: string;
-                preimageCommitSha: string;
+                preimageSource: {
+                    kind: "lesson";
+                    lessonRef: string;
+                    badExample: string;
+                    goodExample: string;
+                } | {
+                    kind: "commit";
+                    preimageCommitSha: string;
+                    mergeCommitSha: string;
+                };
                 filePath: string;
                 matchedSpan: string;
                 contentHash: string;
@@ -993,16 +1970,32 @@ export declare const CompiledRuleSchema: z.ZodEffects<z.ZodObject<{
             targetDefect: string;
             positiveFixtures: {
                 pr: number;
-                mergeCommitSha: string;
-                preimageCommitSha: string;
+                preimageSource: {
+                    kind: "lesson";
+                    lessonRef: string;
+                    badExample: string;
+                    goodExample: string;
+                } | {
+                    kind: "commit";
+                    preimageCommitSha: string;
+                    mergeCommitSha: string;
+                };
                 filePath: string;
                 matchedSpan: string;
                 contentHash: string;
             }[];
             negativeFixtures?: {
                 pr: number;
-                mergeCommitSha: string;
-                preimageCommitSha: string;
+                preimageSource: {
+                    kind: "lesson";
+                    lessonRef: string;
+                    badExample: string;
+                    goodExample: string;
+                } | {
+                    kind: "commit";
+                    preimageCommitSha: string;
+                    mergeCommitSha: string;
+                };
                 filePath: string;
                 matchedSpan: string;
                 contentHash: string;
@@ -1030,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;
@@ -1060,16 +2053,32 @@ export declare const CompiledRuleSchema: z.ZodEffects<z.ZodObject<{
             targetDefect: string;
             positiveFixtures: {
                 pr: number;
-                mergeCommitSha: string;
-                preimageCommitSha: string;
+                preimageSource: {
+                    kind: "lesson";
+                    lessonRef: string;
+                    badExample: string;
+                    goodExample: string;
+                } | {
+                    kind: "commit";
+                    preimageCommitSha: string;
+                    mergeCommitSha: string;
+                };
                 filePath: string;
                 matchedSpan: string;
                 contentHash: string;
             }[];
             negativeFixtures?: {
                 pr: number;
-                mergeCommitSha: string;
-                preimageCommitSha: string;
+                preimageSource: {
+                    kind: "lesson";
+                    lessonRef: string;
+                    badExample: string;
+                    goodExample: string;
+                } | {
+                    kind: "commit";
+                    preimageCommitSha: string;
+                    mergeCommitSha: string;
+                };
                 filePath: string;
                 matchedSpan: string;
                 contentHash: string;
@@ -1087,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;
@@ -1117,16 +2126,32 @@ export declare const CompiledRuleSchema: z.ZodEffects<z.ZodObject<{
             targetDefect: string;
             positiveFixtures: {
                 pr: number;
-                mergeCommitSha: string;
-                preimageCommitSha: string;
+                preimageSource: {
+                    kind: "lesson";
+                    lessonRef: string;
+                    badExample: string;
+                    goodExample: string;
+                } | {
+                    kind: "commit";
+                    preimageCommitSha: string;
+                    mergeCommitSha: string;
+                };
                 filePath: string;
                 matchedSpan: string;
                 contentHash: string;
             }[];
             negativeFixtures?: {
                 pr: number;
-                mergeCommitSha: string;
-                preimageCommitSha: string;
+                preimageSource: {
+                    kind: "lesson";
+                    lessonRef: string;
+                    badExample: string;
+                    goodExample: string;
+                } | {
+                    kind: "commit";
+                    preimageCommitSha: string;
+                    mergeCommitSha: string;
+                };
                 filePath: string;
                 matchedSpan: string;
                 contentHash: string;
@@ -1144,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;
@@ -1174,16 +2199,32 @@ export declare const CompiledRuleSchema: z.ZodEffects<z.ZodObject<{
             targetDefect: string;
             positiveFixtures: {
                 pr: number;
-                mergeCommitSha: string;
-                preimageCommitSha: string;
+                preimageSource: {
+                    kind: "lesson";
+                    lessonRef: string;
+                    badExample: string;
+                    goodExample: string;
+                } | {
+                    kind: "commit";
+                    preimageCommitSha: string;
+                    mergeCommitSha: string;
+                };
                 filePath: string;
                 matchedSpan: string;
                 contentHash: string;
             }[];
             negativeFixtures?: {
                 pr: number;
-                mergeCommitSha: string;
-                preimageCommitSha: string;
+                preimageSource: {
+                    kind: "lesson";
+                    lessonRef: string;
+                    badExample: string;
+                    goodExample: string;
+                } | {
+                    kind: "commit";
+                    preimageCommitSha: string;
+                    mergeCommitSha: string;
+                };
                 filePath: string;
                 matchedSpan: string;
                 contentHash: string;
@@ -1201,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;
@@ -1231,16 +2272,32 @@ export declare const CompiledRuleSchema: z.ZodEffects<z.ZodObject<{
             targetDefect: string;
             positiveFixtures: {
                 pr: number;
-                mergeCommitSha: string;
-                preimageCommitSha: string;
+                preimageSource: {
+                    kind: "lesson";
+                    lessonRef: string;
+                    badExample: string;
+                    goodExample: string;
+                } | {
+                    kind: "commit";
+                    preimageCommitSha: string;
+                    mergeCommitSha: string;
+                };
                 filePath: string;
                 matchedSpan: string;
                 contentHash: string;
             }[];
             negativeFixtures?: {
                 pr: number;
-                mergeCommitSha: string;
-                preimageCommitSha: string;
+                preimageSource: {
+                    kind: "lesson";
+                    lessonRef: string;
+                    badExample: string;
+                    goodExample: string;
+                } | {
+                    kind: "commit";
+                    preimageCommitSha: string;
+                    mergeCommitSha: string;
+                };
                 filePath: string;
                 matchedSpan: string;
                 contentHash: string;
@@ -1551,59 +2608,221 @@ export declare const CompiledRulesFileSchema: z.ZodObject<{
                 /** 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.ZodObject<{
-                    /** The PR whose merge introduced the fix (the in-corpus anchor). */
+                positiveFixtures: z.ZodArray<z.ZodEffects<z.ZodObject<{
+                    /** The PR where the defect was caught/introduced (the in-corpus anchor). */
                     pr: z.ZodNumber;
-                    /** The PR's merge/squash commit — the post-fix (defect-absent) anchor. */
-                    mergeCommitSha: z.ZodString;
-                    /** The PARENT (pre-fix) commit where the DEFECT is present (ADR-112 §4). */
-                    preimageCommitSha: z.ZodString;
+                    /** 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>;
-                }, "strip", z.ZodTypeAny, {
+                }, "strict", z.ZodTypeAny, {
                     pr: number;
-                    mergeCommitSha: string;
-                    preimageCommitSha: string;
+                    preimageSource: {
+                        kind: "lesson";
+                        lessonRef: string;
+                        badExample: string;
+                        goodExample: string;
+                    } | {
+                        kind: "commit";
+                        preimageCommitSha: string;
+                        mergeCommitSha: string;
+                    };
                     filePath: string;
                     matchedSpan: string;
                     contentHash: string;
                 }, {
                     pr: number;
-                    mergeCommitSha: string;
-                    preimageCommitSha: string;
+                    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.ZodObject<{
-                    /** The PR whose merge introduced the fix (the in-corpus anchor). */
+                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 PR's merge/squash commit — the post-fix (defect-absent) anchor. */
-                    mergeCommitSha: z.ZodString;
-                    /** The PARENT (pre-fix) commit where the DEFECT is present (ADR-112 §4). */
-                    preimageCommitSha: z.ZodString;
+                    /** 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>;
-                }, "strip", z.ZodTypeAny, {
+                }, "strict", z.ZodTypeAny, {
                     pr: number;
-                    mergeCommitSha: string;
-                    preimageCommitSha: string;
+                    preimageSource: {
+                        kind: "lesson";
+                        lessonRef: string;
+                        badExample: string;
+                        goodExample: string;
+                    } | {
+                        kind: "commit";
+                        preimageCommitSha: string;
+                        mergeCommitSha: string;
+                    };
                     filePath: string;
                     matchedSpan: string;
                     contentHash: string;
                 }, {
                     pr: number;
-                    mergeCommitSha: string;
-                    preimageCommitSha: string;
+                    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;
@@ -1615,16 +2834,32 @@ export declare const CompiledRulesFileSchema: z.ZodObject<{
                 targetDefect: string;
                 positiveFixtures: {
                     pr: number;
-                    mergeCommitSha: string;
-                    preimageCommitSha: string;
+                    preimageSource: {
+                        kind: "lesson";
+                        lessonRef: string;
+                        badExample: string;
+                        goodExample: string;
+                    } | {
+                        kind: "commit";
+                        preimageCommitSha: string;
+                        mergeCommitSha: string;
+                    };
                     filePath: string;
                     matchedSpan: string;
                     contentHash: string;
                 }[];
                 negativeFixtures?: {
                     pr: number;
-                    mergeCommitSha: string;
-                    preimageCommitSha: string;
+                    preimageSource: {
+                        kind: "lesson";
+                        lessonRef: string;
+                        badExample: string;
+                        goodExample: string;
+                    } | {
+                        kind: "commit";
+                        preimageCommitSha: string;
+                        mergeCommitSha: string;
+                    };
                     filePath: string;
                     matchedSpan: string;
                     contentHash: string;
@@ -1636,16 +2871,32 @@ export declare const CompiledRulesFileSchema: z.ZodObject<{
                 targetDefect: string;
                 positiveFixtures: {
                     pr: number;
-                    mergeCommitSha: string;
-                    preimageCommitSha: string;
+                    preimageSource: {
+                        kind: "lesson";
+                        lessonRef: string;
+                        badExample: string;
+                        goodExample: string;
+                    } | {
+                        kind: "commit";
+                        preimageCommitSha: string;
+                        mergeCommitSha: string;
+                    };
                     filePath: string;
                     matchedSpan: string;
                     contentHash: string;
                 }[];
                 negativeFixtures?: {
                     pr: number;
-                    mergeCommitSha: string;
-                    preimageCommitSha: string;
+                    preimageSource: {
+                        kind: "lesson";
+                        lessonRef: string;
+                        badExample: string;
+                        goodExample: string;
+                    } | {
+                        kind: "commit";
+                        preimageCommitSha: string;
+                        mergeCommitSha: string;
+                    };
                     filePath: string;
                     matchedSpan: string;
                     contentHash: string;
@@ -1697,16 +2948,32 @@ export declare const CompiledRulesFileSchema: z.ZodObject<{
                 targetDefect: string;
                 positiveFixtures: {
                     pr: number;
-                    mergeCommitSha: string;
-                    preimageCommitSha: string;
+                    preimageSource: {
+                        kind: "lesson";
+                        lessonRef: string;
+                        badExample: string;
+                        goodExample: string;
+                    } | {
+                        kind: "commit";
+                        preimageCommitSha: string;
+                        mergeCommitSha: string;
+                    };
                     filePath: string;
                     matchedSpan: string;
                     contentHash: string;
                 }[];
                 negativeFixtures?: {
                     pr: number;
-                    mergeCommitSha: string;
-                    preimageCommitSha: string;
+                    preimageSource: {
+                        kind: "lesson";
+                        lessonRef: string;
+                        badExample: string;
+                        goodExample: string;
+                    } | {
+                        kind: "commit";
+                        preimageCommitSha: string;
+                        mergeCommitSha: string;
+                    };
                     filePath: string;
                     matchedSpan: string;
                     contentHash: string;
@@ -1727,16 +2994,32 @@ export declare const CompiledRulesFileSchema: z.ZodObject<{
                 targetDefect: string;
                 positiveFixtures: {
                     pr: number;
-                    mergeCommitSha: string;
-                    preimageCommitSha: string;
+                    preimageSource: {
+                        kind: "lesson";
+                        lessonRef: string;
+                        badExample: string;
+                        goodExample: string;
+                    } | {
+                        kind: "commit";
+                        preimageCommitSha: string;
+                        mergeCommitSha: string;
+                    };
                     filePath: string;
                     matchedSpan: string;
                     contentHash: string;
                 }[];
                 negativeFixtures?: {
                     pr: number;
-                    mergeCommitSha: string;
-                    preimageCommitSha: string;
+                    preimageSource: {
+                        kind: "lesson";
+                        lessonRef: string;
+                        badExample: string;
+                        goodExample: string;
+                    } | {
+                        kind: "commit";
+                        preimageCommitSha: string;
+                        mergeCommitSha: string;
+                    };
                     filePath: string;
                     matchedSpan: string;
                     contentHash: string;
@@ -1764,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;
@@ -1794,16 +3077,32 @@ export declare const CompiledRulesFileSchema: z.ZodObject<{
                 targetDefect: string;
                 positiveFixtures: {
                     pr: number;
-                    mergeCommitSha: string;
-                    preimageCommitSha: string;
+                    preimageSource: {
+                        kind: "lesson";
+                        lessonRef: string;
+                        badExample: string;
+                        goodExample: string;
+                    } | {
+                        kind: "commit";
+                        preimageCommitSha: string;
+                        mergeCommitSha: string;
+                    };
                     filePath: string;
                     matchedSpan: string;
                     contentHash: string;
                 }[];
                 negativeFixtures?: {
                     pr: number;
-                    mergeCommitSha: string;
-                    preimageCommitSha: string;
+                    preimageSource: {
+                        kind: "lesson";
+                        lessonRef: string;
+                        badExample: string;
+                        goodExample: string;
+                    } | {
+                        kind: "commit";
+                        preimageCommitSha: string;
+                        mergeCommitSha: string;
+                    };
                     filePath: string;
                     matchedSpan: string;
                     contentHash: string;
@@ -1821,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;
@@ -1851,16 +3150,32 @@ export declare const CompiledRulesFileSchema: z.ZodObject<{
                 targetDefect: string;
                 positiveFixtures: {
                     pr: number;
-                    mergeCommitSha: string;
-                    preimageCommitSha: string;
+                    preimageSource: {
+                        kind: "lesson";
+                        lessonRef: string;
+                        badExample: string;
+                        goodExample: string;
+                    } | {
+                        kind: "commit";
+                        preimageCommitSha: string;
+                        mergeCommitSha: string;
+                    };
                     filePath: string;
                     matchedSpan: string;
                     contentHash: string;
                 }[];
                 negativeFixtures?: {
                     pr: number;
-                    mergeCommitSha: string;
-                    preimageCommitSha: string;
+                    preimageSource: {
+                        kind: "lesson";
+                        lessonRef: string;
+                        badExample: string;
+                        goodExample: string;
+                    } | {
+                        kind: "commit";
+                        preimageCommitSha: string;
+                        mergeCommitSha: string;
+                    };
                     filePath: string;
                     matchedSpan: string;
                     contentHash: string;
@@ -1878,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;
@@ -1908,16 +3223,32 @@ export declare const CompiledRulesFileSchema: z.ZodObject<{
                 targetDefect: string;
                 positiveFixtures: {
                     pr: number;
-                    mergeCommitSha: string;
-                    preimageCommitSha: string;
+                    preimageSource: {
+                        kind: "lesson";
+                        lessonRef: string;
+                        badExample: string;
+                        goodExample: string;
+                    } | {
+                        kind: "commit";
+                        preimageCommitSha: string;
+                        mergeCommitSha: string;
+                    };
                     filePath: string;
                     matchedSpan: string;
                     contentHash: string;
                 }[];
                 negativeFixtures?: {
                     pr: number;
-                    mergeCommitSha: string;
-                    preimageCommitSha: string;
+                    preimageSource: {
+                        kind: "lesson";
+                        lessonRef: string;
+                        badExample: string;
+                        goodExample: string;
+                    } | {
+                        kind: "commit";
+                        preimageCommitSha: string;
+                        mergeCommitSha: string;
+                    };
                     filePath: string;
                     matchedSpan: string;
                     contentHash: string;
@@ -1935,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;
@@ -1965,16 +3296,32 @@ export declare const CompiledRulesFileSchema: z.ZodObject<{
                 targetDefect: string;
                 positiveFixtures: {
                     pr: number;
-                    mergeCommitSha: string;
-                    preimageCommitSha: string;
+                    preimageSource: {
+                        kind: "lesson";
+                        lessonRef: string;
+                        badExample: string;
+                        goodExample: string;
+                    } | {
+                        kind: "commit";
+                        preimageCommitSha: string;
+                        mergeCommitSha: string;
+                    };
                     filePath: string;
                     matchedSpan: string;
                     contentHash: string;
                 }[];
                 negativeFixtures?: {
                     pr: number;
-                    mergeCommitSha: string;
-                    preimageCommitSha: string;
+                    preimageSource: {
+                        kind: "lesson";
+                        lessonRef: string;
+                        badExample: string;
+                        goodExample: string;
+                    } | {
+                        kind: "commit";
+                        preimageCommitSha: string;
+                        mergeCommitSha: string;
+                    };
                     filePath: string;
                     matchedSpan: string;
                     contentHash: string;
@@ -2042,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;
@@ -2072,16 +3419,32 @@ export declare const CompiledRulesFileSchema: z.ZodObject<{
                 targetDefect: string;
                 positiveFixtures: {
                     pr: number;
-                    mergeCommitSha: string;
-                    preimageCommitSha: string;
+                    preimageSource: {
+                        kind: "lesson";
+                        lessonRef: string;
+                        badExample: string;
+                        goodExample: string;
+                    } | {
+                        kind: "commit";
+                        preimageCommitSha: string;
+                        mergeCommitSha: string;
+                    };
                     filePath: string;
                     matchedSpan: string;
                     contentHash: string;
                 }[];
                 negativeFixtures?: {
                     pr: number;
-                    mergeCommitSha: string;
-                    preimageCommitSha: string;
+                    preimageSource: {
+                        kind: "lesson";
+                        lessonRef: string;
+                        badExample: string;
+                        goodExample: string;
+                    } | {
+                        kind: "commit";
+                        preimageCommitSha: string;
+                        mergeCommitSha: string;
+                    };
                     filePath: string;
                     matchedSpan: string;
                     contentHash: string;
@@ -2108,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;
@@ -2138,16 +3501,32 @@ export declare const CompiledRulesFileSchema: z.ZodObject<{
                 targetDefect: string;
                 positiveFixtures: {
                     pr: number;
-                    mergeCommitSha: string;
-                    preimageCommitSha: string;
+                    preimageSource: {
+                        kind: "lesson";
+                        lessonRef: string;
+                        badExample: string;
+                        goodExample: string;
+                    } | {
+                        kind: "commit";
+                        preimageCommitSha: string;
+                        mergeCommitSha: string;
+                    };
                     filePath: string;
                     matchedSpan: string;
                     contentHash: string;
                 }[];
                 negativeFixtures?: {
                     pr: number;
-                    mergeCommitSha: string;
-                    preimageCommitSha: string;
+                    preimageSource: {
+                        kind: "lesson";
+                        lessonRef: string;
+                        badExample: string;
+                        goodExample: string;
+                    } | {
+                        kind: "commit";
+                        preimageCommitSha: string;
+                        mergeCommitSha: string;
+                    };
                     filePath: string;
                     matchedSpan: string;
                     contentHash: string;
@@ -2227,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;
@@ -2234,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;
@@ -2243,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;
@@ -2250,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;
@@ -2259,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;
@@ -2266,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;
@@ -2275,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;
@@ -2282,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;