@mmnto/totem 1.118.0 → 1.119.0

package/dist/compiler-schema.d.ts

@@ -36,6 +36,16 @@ export declare const AstGrepYamlRuleSchema: z.ZodObject<{
     rule: z.ZodRecord<z.ZodString, z.ZodUnknown>;
 }, z.ZodTypeAny, "passthrough">>;
 export type AstGrepYamlRule = NapiConfig;
+/**
+ * A full sha256 digest in lowercase hex — the codomain of every content hash on
+ * this seam (Prop 310 § Design 10's CR-blind example-pair hash, the record file's
+ * own content hash). Canonical form only, for the same reason `COMMIT_SHA_RE`
+ * refuses uppercase: admitting a non-canonical digest is a silent data-quality
+ * hole, and normalising it on parse would move the hash basis.
+ */
+export declare const SHA256_HEX_RE: RegExp;
+export declare const AUTHORED_RULE_ID_HEX_LEN = 16;
+export declare const AUTHORED_RULE_ID_RE: RegExp;
 /**
  * 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,
@@ -110,6 +120,15 @@ export type MinedProvenanceRecord = z.infer<typeof MinedProvenanceWireSchema>;
  *     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).
+ *   - `record` (Prop 310 § Design 10 + Amendment 1): DERIVED at intake from a
+ *     `.totem/rules/<slug>.rule.yaml` record's `examples[ordinal]` pair, joined by
+ *     the `(ruleId, ordinal)` key with the CR-blind `pairHash` as drift sensor.
+ *     The bad/good text is carried inline exactly as the `lesson` branch carries
+ *     it, so the differential evaluates identically; the key is what differs.
+ *     Amendment 1 makes the record's `examples` block the EDITABLE home — this
+ *     branch is the derived side and is never hand-authored (an inline
+ *     `preimageSource` in the authored envelope is a migration error, rejected by
+ *     name at intake).
  *
  * `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
@@ -158,6 +177,42 @@ export declare const PreimageSourceSchema: z.ZodDiscriminatedUnion<"kind", [z.Zo
     kind: "commit";
     preimageCommitSha: string;
     mergeCommitSha: string;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"record">;
+    /**
+     * Prop 310 § Design 10 — half of the join key. The ADR-112 §8 producer-minted
+     * rule id the record was ingested under; pinned to the mint's codomain so a
+     * derivation that lost the id fails LOUD instead of anchoring the pair to a
+     * free-text label.
+     */
+    ruleId: z.ZodString;
+    /** The `examples[i]` ordinal within the record — the other half of the join key (§ Design 10). */
+    ordinal: z.ZodNumber;
+    /**
+     * Amendment 1 item 3 — the CR-blind per-pair content hash (`ruleExamplePairHash`),
+     * computed over the LF-image of the pair's material. The § Design 10 DRIFT SENSOR:
+     * an `examples` edit flips it, which flips the ledger `contentHash`, which reads
+     * `revised`. There is no second mechanism.
+     */
+    pairHash: z.ZodString;
+    /** The record's `examples[ordinal].bad` — the defect preimage the matcher must FIRE on (§4). */
+    badExample: z.ZodEffects<z.ZodString, string, string>;
+    /** The record's `examples[ordinal].good` — the fixed postimage the matcher must stay SILENT on (§4). */
+    goodExample: z.ZodEffects<z.ZodString, string, string>;
+}, "strict", z.ZodTypeAny, {
+    kind: "record";
+    badExample: string;
+    goodExample: string;
+    ruleId: string;
+    ordinal: number;
+    pairHash: string;
+}, {
+    kind: "record";
+    badExample: string;
+    goodExample: string;
+    ruleId: string;
+    ordinal: number;
+    pairHash: string;
 }>]>;
 export type PreimageSource = z.infer<typeof PreimageSourceSchema>;
 /**
@@ -209,6 +264,42 @@ export declare const AuthoredFixtureSchema: z.ZodEffects<z.ZodObject<{
         kind: "commit";
         preimageCommitSha: string;
         mergeCommitSha: string;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"record">;
+        /**
+         * Prop 310 § Design 10 — half of the join key. The ADR-112 §8 producer-minted
+         * rule id the record was ingested under; pinned to the mint's codomain so a
+         * derivation that lost the id fails LOUD instead of anchoring the pair to a
+         * free-text label.
+         */
+        ruleId: z.ZodString;
+        /** The `examples[i]` ordinal within the record — the other half of the join key (§ Design 10). */
+        ordinal: z.ZodNumber;
+        /**
+         * Amendment 1 item 3 — the CR-blind per-pair content hash (`ruleExamplePairHash`),
+         * computed over the LF-image of the pair's material. The § Design 10 DRIFT SENSOR:
+         * an `examples` edit flips it, which flips the ledger `contentHash`, which reads
+         * `revised`. There is no second mechanism.
+         */
+        pairHash: z.ZodString;
+        /** The record's `examples[ordinal].bad` — the defect preimage the matcher must FIRE on (§4). */
+        badExample: z.ZodEffects<z.ZodString, string, string>;
+        /** The record's `examples[ordinal].good` — the fixed postimage the matcher must stay SILENT on (§4). */
+        goodExample: z.ZodEffects<z.ZodString, string, string>;
+    }, "strict", z.ZodTypeAny, {
+        kind: "record";
+        badExample: string;
+        goodExample: string;
+        ruleId: string;
+        ordinal: number;
+        pairHash: string;
+    }, {
+        kind: "record";
+        badExample: string;
+        goodExample: string;
+        ruleId: string;
+        ordinal: number;
+        pairHash: string;
     }>]>;
     /** File the defect locus lives in. */
     filePath: z.ZodEffects<z.ZodString, string, string>;
@@ -227,6 +318,13 @@ export declare const AuthoredFixtureSchema: z.ZodEffects<z.ZodObject<{
         kind: "commit";
         preimageCommitSha: string;
         mergeCommitSha: string;
+    } | {
+        kind: "record";
+        badExample: string;
+        goodExample: string;
+        ruleId: string;
+        ordinal: number;
+        pairHash: string;
     };
     filePath: string;
     matchedSpan: string;
@@ -242,6 +340,13 @@ export declare const AuthoredFixtureSchema: z.ZodEffects<z.ZodObject<{
         kind: "commit";
         preimageCommitSha: string;
         mergeCommitSha: string;
+    } | {
+        kind: "record";
+        badExample: string;
+        goodExample: string;
+        ruleId: string;
+        ordinal: number;
+        pairHash: string;
     };
     filePath: string;
     matchedSpan: string;
@@ -257,6 +362,13 @@ export declare const AuthoredFixtureSchema: z.ZodEffects<z.ZodObject<{
         kind: "commit";
         preimageCommitSha: string;
         mergeCommitSha: string;
+    } | {
+        kind: "record";
+        badExample: string;
+        goodExample: string;
+        ruleId: string;
+        ordinal: number;
+        pairHash: string;
     };
     filePath: string;
     matchedSpan: string;
@@ -272,6 +384,13 @@ export declare const AuthoredFixtureSchema: z.ZodEffects<z.ZodObject<{
         kind: "commit";
         preimageCommitSha: string;
         mergeCommitSha: string;
+    } | {
+        kind: "record";
+        badExample: string;
+        goodExample: string;
+        ruleId: string;
+        ordinal: number;
+        pairHash: string;
     };
     filePath: string;
     matchedSpan: string;
@@ -448,6 +567,42 @@ export declare const AuthoredProvenanceRecordSchema: z.ZodObject<{
             kind: "commit";
             preimageCommitSha: string;
             mergeCommitSha: string;
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"record">;
+            /**
+             * Prop 310 § Design 10 — half of the join key. The ADR-112 §8 producer-minted
+             * rule id the record was ingested under; pinned to the mint's codomain so a
+             * derivation that lost the id fails LOUD instead of anchoring the pair to a
+             * free-text label.
+             */
+            ruleId: z.ZodString;
+            /** The `examples[i]` ordinal within the record — the other half of the join key (§ Design 10). */
+            ordinal: z.ZodNumber;
+            /**
+             * Amendment 1 item 3 — the CR-blind per-pair content hash (`ruleExamplePairHash`),
+             * computed over the LF-image of the pair's material. The § Design 10 DRIFT SENSOR:
+             * an `examples` edit flips it, which flips the ledger `contentHash`, which reads
+             * `revised`. There is no second mechanism.
+             */
+            pairHash: z.ZodString;
+            /** The record's `examples[ordinal].bad` — the defect preimage the matcher must FIRE on (§4). */
+            badExample: z.ZodEffects<z.ZodString, string, string>;
+            /** The record's `examples[ordinal].good` — the fixed postimage the matcher must stay SILENT on (§4). */
+            goodExample: z.ZodEffects<z.ZodString, string, string>;
+        }, "strict", z.ZodTypeAny, {
+            kind: "record";
+            badExample: string;
+            goodExample: string;
+            ruleId: string;
+            ordinal: number;
+            pairHash: string;
+        }, {
+            kind: "record";
+            badExample: string;
+            goodExample: string;
+            ruleId: string;
+            ordinal: number;
+            pairHash: string;
         }>]>;
         /** File the defect locus lives in. */
         filePath: z.ZodEffects<z.ZodString, string, string>;
@@ -466,6 +621,13 @@ export declare const AuthoredProvenanceRecordSchema: z.ZodObject<{
             kind: "commit";
             preimageCommitSha: string;
             mergeCommitSha: string;
+        } | {
+            kind: "record";
+            badExample: string;
+            goodExample: string;
+            ruleId: string;
+            ordinal: number;
+            pairHash: string;
         };
         filePath: string;
         matchedSpan: string;
@@ -481,6 +643,13 @@ export declare const AuthoredProvenanceRecordSchema: z.ZodObject<{
             kind: "commit";
             preimageCommitSha: string;
             mergeCommitSha: string;
+        } | {
+            kind: "record";
+            badExample: string;
+            goodExample: string;
+            ruleId: string;
+            ordinal: number;
+            pairHash: string;
         };
         filePath: string;
         matchedSpan: string;
@@ -496,6 +665,13 @@ export declare const AuthoredProvenanceRecordSchema: z.ZodObject<{
             kind: "commit";
             preimageCommitSha: string;
             mergeCommitSha: string;
+        } | {
+            kind: "record";
+            badExample: string;
+            goodExample: string;
+            ruleId: string;
+            ordinal: number;
+            pairHash: string;
         };
         filePath: string;
         matchedSpan: string;
@@ -511,6 +687,13 @@ export declare const AuthoredProvenanceRecordSchema: z.ZodObject<{
             kind: "commit";
             preimageCommitSha: string;
             mergeCommitSha: string;
+        } | {
+            kind: "record";
+            badExample: string;
+            goodExample: string;
+            ruleId: string;
+            ordinal: number;
+            pairHash: string;
         };
         filePath: string;
         matchedSpan: string;
@@ -596,6 +779,13 @@ export declare const AuthoredProvenanceRecordSchema: z.ZodObject<{
             kind: "commit";
             preimageCommitSha: string;
             mergeCommitSha: string;
+        } | {
+            kind: "record";
+            badExample: string;
+            goodExample: string;
+            ruleId: string;
+            ordinal: number;
+            pairHash: string;
         };
         filePath: string;
         matchedSpan: string;
@@ -629,6 +819,13 @@ export declare const AuthoredProvenanceRecordSchema: z.ZodObject<{
             kind: "commit";
             preimageCommitSha: string;
             mergeCommitSha: string;
+        } | {
+            kind: "record";
+            badExample: string;
+            goodExample: string;
+            ruleId: string;
+            ordinal: number;
+            pairHash: string;
         };
         filePath: string;
         matchedSpan: string;
@@ -710,6 +907,42 @@ export declare const ProvenanceRecordSchema: z.ZodUnion<[z.ZodObject<{
             kind: "commit";
             preimageCommitSha: string;
             mergeCommitSha: string;
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"record">;
+            /**
+             * Prop 310 § Design 10 — half of the join key. The ADR-112 §8 producer-minted
+             * rule id the record was ingested under; pinned to the mint's codomain so a
+             * derivation that lost the id fails LOUD instead of anchoring the pair to a
+             * free-text label.
+             */
+            ruleId: z.ZodString;
+            /** The `examples[i]` ordinal within the record — the other half of the join key (§ Design 10). */
+            ordinal: z.ZodNumber;
+            /**
+             * Amendment 1 item 3 — the CR-blind per-pair content hash (`ruleExamplePairHash`),
+             * computed over the LF-image of the pair's material. The § Design 10 DRIFT SENSOR:
+             * an `examples` edit flips it, which flips the ledger `contentHash`, which reads
+             * `revised`. There is no second mechanism.
+             */
+            pairHash: z.ZodString;
+            /** The record's `examples[ordinal].bad` — the defect preimage the matcher must FIRE on (§4). */
+            badExample: z.ZodEffects<z.ZodString, string, string>;
+            /** The record's `examples[ordinal].good` — the fixed postimage the matcher must stay SILENT on (§4). */
+            goodExample: z.ZodEffects<z.ZodString, string, string>;
+        }, "strict", z.ZodTypeAny, {
+            kind: "record";
+            badExample: string;
+            goodExample: string;
+            ruleId: string;
+            ordinal: number;
+            pairHash: string;
+        }, {
+            kind: "record";
+            badExample: string;
+            goodExample: string;
+            ruleId: string;
+            ordinal: number;
+            pairHash: string;
         }>]>;
         /** File the defect locus lives in. */
         filePath: z.ZodEffects<z.ZodString, string, string>;
@@ -728,6 +961,13 @@ export declare const ProvenanceRecordSchema: z.ZodUnion<[z.ZodObject<{
             kind: "commit";
             preimageCommitSha: string;
             mergeCommitSha: string;
+        } | {
+            kind: "record";
+            badExample: string;
+            goodExample: string;
+            ruleId: string;
+            ordinal: number;
+            pairHash: string;
         };
         filePath: string;
         matchedSpan: string;
@@ -743,6 +983,13 @@ export declare const ProvenanceRecordSchema: z.ZodUnion<[z.ZodObject<{
             kind: "commit";
             preimageCommitSha: string;
             mergeCommitSha: string;
+        } | {
+            kind: "record";
+            badExample: string;
+            goodExample: string;
+            ruleId: string;
+            ordinal: number;
+            pairHash: string;
         };
         filePath: string;
         matchedSpan: string;
@@ -758,6 +1005,13 @@ export declare const ProvenanceRecordSchema: z.ZodUnion<[z.ZodObject<{
             kind: "commit";
             preimageCommitSha: string;
             mergeCommitSha: string;
+        } | {
+            kind: "record";
+            badExample: string;
+            goodExample: string;
+            ruleId: string;
+            ordinal: number;
+            pairHash: string;
         };
         filePath: string;
         matchedSpan: string;
@@ -773,6 +1027,13 @@ export declare const ProvenanceRecordSchema: z.ZodUnion<[z.ZodObject<{
             kind: "commit";
             preimageCommitSha: string;
             mergeCommitSha: string;
+        } | {
+            kind: "record";
+            badExample: string;
+            goodExample: string;
+            ruleId: string;
+            ordinal: number;
+            pairHash: string;
         };
         filePath: string;
         matchedSpan: string;
@@ -858,6 +1119,13 @@ export declare const ProvenanceRecordSchema: z.ZodUnion<[z.ZodObject<{
             kind: "commit";
             preimageCommitSha: string;
             mergeCommitSha: string;
+        } | {
+            kind: "record";
+            badExample: string;
+            goodExample: string;
+            ruleId: string;
+            ordinal: number;
+            pairHash: string;
         };
         filePath: string;
         matchedSpan: string;
@@ -891,6 +1159,13 @@ export declare const ProvenanceRecordSchema: z.ZodUnion<[z.ZodObject<{
             kind: "commit";
             preimageCommitSha: string;
             mergeCommitSha: string;
+        } | {
+            kind: "record";
+            badExample: string;
+            goodExample: string;
+            ruleId: string;
+            ordinal: number;
+            pairHash: string;
         };
         filePath: string;
         matchedSpan: string;
@@ -1012,6 +1287,42 @@ export declare const LegitimacySchema: z.ZodObject<{
                 kind: "commit";
                 preimageCommitSha: string;
                 mergeCommitSha: string;
+            }>, z.ZodObject<{
+                kind: z.ZodLiteral<"record">;
+                /**
+                 * Prop 310 § Design 10 — half of the join key. The ADR-112 §8 producer-minted
+                 * rule id the record was ingested under; pinned to the mint's codomain so a
+                 * derivation that lost the id fails LOUD instead of anchoring the pair to a
+                 * free-text label.
+                 */
+                ruleId: z.ZodString;
+                /** The `examples[i]` ordinal within the record — the other half of the join key (§ Design 10). */
+                ordinal: z.ZodNumber;
+                /**
+                 * Amendment 1 item 3 — the CR-blind per-pair content hash (`ruleExamplePairHash`),
+                 * computed over the LF-image of the pair's material. The § Design 10 DRIFT SENSOR:
+                 * an `examples` edit flips it, which flips the ledger `contentHash`, which reads
+                 * `revised`. There is no second mechanism.
+                 */
+                pairHash: z.ZodString;
+                /** The record's `examples[ordinal].bad` — the defect preimage the matcher must FIRE on (§4). */
+                badExample: z.ZodEffects<z.ZodString, string, string>;
+                /** The record's `examples[ordinal].good` — the fixed postimage the matcher must stay SILENT on (§4). */
+                goodExample: z.ZodEffects<z.ZodString, string, string>;
+            }, "strict", z.ZodTypeAny, {
+                kind: "record";
+                badExample: string;
+                goodExample: string;
+                ruleId: string;
+                ordinal: number;
+                pairHash: string;
+            }, {
+                kind: "record";
+                badExample: string;
+                goodExample: string;
+                ruleId: string;
+                ordinal: number;
+                pairHash: string;
             }>]>;
             /** File the defect locus lives in. */
             filePath: z.ZodEffects<z.ZodString, string, string>;
@@ -1030,6 +1341,13 @@ export declare const LegitimacySchema: z.ZodObject<{
                 kind: "commit";
                 preimageCommitSha: string;
                 mergeCommitSha: string;
+            } | {
+                kind: "record";
+                badExample: string;
+                goodExample: string;
+                ruleId: string;
+                ordinal: number;
+                pairHash: string;
             };
             filePath: string;
             matchedSpan: string;
@@ -1045,6 +1363,13 @@ export declare const LegitimacySchema: z.ZodObject<{
                 kind: "commit";
                 preimageCommitSha: string;
                 mergeCommitSha: string;
+            } | {
+                kind: "record";
+                badExample: string;
+                goodExample: string;
+                ruleId: string;
+                ordinal: number;
+                pairHash: string;
             };
             filePath: string;
             matchedSpan: string;
@@ -1060,6 +1385,13 @@ export declare const LegitimacySchema: z.ZodObject<{
                 kind: "commit";
                 preimageCommitSha: string;
                 mergeCommitSha: string;
+            } | {
+                kind: "record";
+                badExample: string;
+                goodExample: string;
+                ruleId: string;
+                ordinal: number;
+                pairHash: string;
             };
             filePath: string;
             matchedSpan: string;
@@ -1075,6 +1407,13 @@ export declare const LegitimacySchema: z.ZodObject<{
                 kind: "commit";
                 preimageCommitSha: string;
                 mergeCommitSha: string;
+            } | {
+                kind: "record";
+                badExample: string;
+                goodExample: string;
+                ruleId: string;
+                ordinal: number;
+                pairHash: string;
             };
             filePath: string;
             matchedSpan: string;
@@ -1160,6 +1499,13 @@ export declare const LegitimacySchema: z.ZodObject<{
                 kind: "commit";
                 preimageCommitSha: string;
                 mergeCommitSha: string;
+            } | {
+                kind: "record";
+                badExample: string;
+                goodExample: string;
+                ruleId: string;
+                ordinal: number;
+                pairHash: string;
             };
             filePath: string;
             matchedSpan: string;
@@ -1193,6 +1539,13 @@ export declare const LegitimacySchema: z.ZodObject<{
                 kind: "commit";
                 preimageCommitSha: string;
                 mergeCommitSha: string;
+            } | {
+                kind: "record";
+                badExample: string;
+                goodExample: string;
+                ruleId: string;
+                ordinal: number;
+                pairHash: string;
             };
             filePath: string;
             matchedSpan: string;
@@ -1266,6 +1619,13 @@ export declare const LegitimacySchema: z.ZodObject<{
                 kind: "commit";
                 preimageCommitSha: string;
                 mergeCommitSha: string;
+            } | {
+                kind: "record";
+                badExample: string;
+                goodExample: string;
+                ruleId: string;
+                ordinal: number;
+                pairHash: string;
             };
             filePath: string;
             matchedSpan: string;
@@ -1308,6 +1668,13 @@ export declare const LegitimacySchema: z.ZodObject<{
                 kind: "commit";
                 preimageCommitSha: string;
                 mergeCommitSha: string;
+            } | {
+                kind: "record";
+                badExample: string;
+                goodExample: string;
+                ruleId: string;
+                ordinal: number;
+                pairHash: string;
             };
             filePath: string;
             matchedSpan: string;
@@ -1577,6 +1944,42 @@ export declare const CompiledRuleSchema: z.ZodEffects<z.ZodObject<{
                     kind: "commit";
                     preimageCommitSha: string;
                     mergeCommitSha: string;
+                }>, z.ZodObject<{
+                    kind: z.ZodLiteral<"record">;
+                    /**
+                     * Prop 310 § Design 10 — half of the join key. The ADR-112 §8 producer-minted
+                     * rule id the record was ingested under; pinned to the mint's codomain so a
+                     * derivation that lost the id fails LOUD instead of anchoring the pair to a
+                     * free-text label.
+                     */
+                    ruleId: z.ZodString;
+                    /** The `examples[i]` ordinal within the record — the other half of the join key (§ Design 10). */
+                    ordinal: z.ZodNumber;
+                    /**
+                     * Amendment 1 item 3 — the CR-blind per-pair content hash (`ruleExamplePairHash`),
+                     * computed over the LF-image of the pair's material. The § Design 10 DRIFT SENSOR:
+                     * an `examples` edit flips it, which flips the ledger `contentHash`, which reads
+                     * `revised`. There is no second mechanism.
+                     */
+                    pairHash: z.ZodString;
+                    /** The record's `examples[ordinal].bad` — the defect preimage the matcher must FIRE on (§4). */
+                    badExample: z.ZodEffects<z.ZodString, string, string>;
+                    /** The record's `examples[ordinal].good` — the fixed postimage the matcher must stay SILENT on (§4). */
+                    goodExample: z.ZodEffects<z.ZodString, string, string>;
+                }, "strict", z.ZodTypeAny, {
+                    kind: "record";
+                    badExample: string;
+                    goodExample: string;
+                    ruleId: string;
+                    ordinal: number;
+                    pairHash: string;
+                }, {
+                    kind: "record";
+                    badExample: string;
+                    goodExample: string;
+                    ruleId: string;
+                    ordinal: number;
+                    pairHash: string;
                 }>]>;
                 /** File the defect locus lives in. */
                 filePath: z.ZodEffects<z.ZodString, string, string>;
@@ -1595,6 +1998,13 @@ export declare const CompiledRuleSchema: z.ZodEffects<z.ZodObject<{
                     kind: "commit";
                     preimageCommitSha: string;
                     mergeCommitSha: string;
+                } | {
+                    kind: "record";
+                    badExample: string;
+                    goodExample: string;
+                    ruleId: string;
+                    ordinal: number;
+                    pairHash: string;
                 };
                 filePath: string;
                 matchedSpan: string;
@@ -1610,6 +2020,13 @@ export declare const CompiledRuleSchema: z.ZodEffects<z.ZodObject<{
                     kind: "commit";
                     preimageCommitSha: string;
                     mergeCommitSha: string;
+                } | {
+                    kind: "record";
+                    badExample: string;
+                    goodExample: string;
+                    ruleId: string;
+                    ordinal: number;
+                    pairHash: string;
                 };
                 filePath: string;
                 matchedSpan: string;
@@ -1625,6 +2042,13 @@ export declare const CompiledRuleSchema: z.ZodEffects<z.ZodObject<{
                     kind: "commit";
                     preimageCommitSha: string;
                     mergeCommitSha: string;
+                } | {
+                    kind: "record";
+                    badExample: string;
+                    goodExample: string;
+                    ruleId: string;
+                    ordinal: number;
+                    pairHash: string;
                 };
                 filePath: string;
                 matchedSpan: string;
@@ -1640,6 +2064,13 @@ export declare const CompiledRuleSchema: z.ZodEffects<z.ZodObject<{
                     kind: "commit";
                     preimageCommitSha: string;
                     mergeCommitSha: string;
+                } | {
+                    kind: "record";
+                    badExample: string;
+                    goodExample: string;
+                    ruleId: string;
+                    ordinal: number;
+                    pairHash: string;
                 };
                 filePath: string;
                 matchedSpan: string;
@@ -1725,6 +2156,13 @@ export declare const CompiledRuleSchema: z.ZodEffects<z.ZodObject<{
                     kind: "commit";
                     preimageCommitSha: string;
                     mergeCommitSha: string;
+                } | {
+                    kind: "record";
+                    badExample: string;
+                    goodExample: string;
+                    ruleId: string;
+                    ordinal: number;
+                    pairHash: string;
                 };
                 filePath: string;
                 matchedSpan: string;
@@ -1758,6 +2196,13 @@ export declare const CompiledRuleSchema: z.ZodEffects<z.ZodObject<{
                     kind: "commit";
                     preimageCommitSha: string;
                     mergeCommitSha: string;
+                } | {
+                    kind: "record";
+                    badExample: string;
+                    goodExample: string;
+                    ruleId: string;
+                    ordinal: number;
+                    pairHash: string;
                 };
                 filePath: string;
                 matchedSpan: string;
@@ -1831,6 +2276,13 @@ export declare const CompiledRuleSchema: z.ZodEffects<z.ZodObject<{
                     kind: "commit";
                     preimageCommitSha: string;
                     mergeCommitSha: string;
+                } | {
+                    kind: "record";
+                    badExample: string;
+                    goodExample: string;
+                    ruleId: string;
+                    ordinal: number;
+                    pairHash: string;
                 };
                 filePath: string;
                 matchedSpan: string;
@@ -1873,6 +2325,13 @@ export declare const CompiledRuleSchema: z.ZodEffects<z.ZodObject<{
                     kind: "commit";
                     preimageCommitSha: string;
                     mergeCommitSha: string;
+                } | {
+                    kind: "record";
+                    badExample: string;
+                    goodExample: string;
+                    ruleId: string;
+                    ordinal: number;
+                    pairHash: string;
                 };
                 filePath: string;
                 matchedSpan: string;
@@ -1905,6 +2364,124 @@ export declare const CompiledRuleSchema: z.ZodEffects<z.ZodObject<{
      * reader falls back to the legacy engine-type proxy.
      */
     ruleClass: z.ZodOptional<z.ZodEnum<["hard", "advisory"]>>;
+    /**
+     * Prop 310 § Design 7 / mmnto-ai/totem#1574 — first-class structural
+     * exclusions. Entries are POSITIVE-form globs applied as exclusions: a file is
+     * in scope iff it matches some `fileGlobs` entry AND no `excludeGlobs` entry
+     * (`positiveMatch && !excludeMatch`). `!`-negation is a parse error in the
+     * record grammar, so an entry here never carries one.
+     */
+    excludeGlobs: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /**
+     * Prop 310 § Design 8 — the absence / must-contain block. The rule fires on a
+     * target match at locus L iff `pattern` does NOT match within the declared
+     * scope containing L. `pattern` is a safe-regex2-gated regex evaluated
+     * TEXTUALLY, independent of `engine`; V1 carries exactly one block.
+     *
+     * The scope enum MIRRORS `RequiresScopeSchema` (`spine/rule-record.ts`) rather
+     * than importing it — `compiler-schema.ts` is an import-graph LEAF (zod only)
+     * and `spine/rule-record.ts` transitively imports it, so an import here would
+     * close a cycle. The two are COUPLED by an equality test in
+     * `record-lower.test.ts`, never left to drift on inspection. `block` is
+     * reserved-unimplemented at the grammar (§ Design 8) and therefore can never
+     * reach a compiled rule.
+     */
+    requires: z.ZodOptional<z.ZodObject<{
+        pattern: z.ZodString;
+        scope: z.ZodEnum<["line", "file"]>;
+    }, "strip", z.ZodTypeAny, {
+        pattern: string;
+        scope: "line" | "file";
+    }, {
+        pattern: string;
+        scope: "line" | "file";
+    }>>;
+    /**
+     * Prop 310 § Design 5 / § Design 10 — certification's PRIMARY PREIMAGE SOURCE
+     * (ADR-112 §4), and per Amendment 1 the record's block is the hand-editable
+     * home (the fixture envelope derives). Carried verbatim, in ordinal order: the
+     * `(ruleId, ordinal)` join key is positional, so a reorder is a re-pair.
+     *
+     * Deliberately NOT projected onto the legacy `badExample`/`goodExample` pair —
+     * that would be Tenet 20's prohibited mirror (two hand-editable homes for one
+     * object). Consumers that need a single exemplar read `examples[0]`.
+     */
+    examples: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        bad: z.ZodString;
+        good: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        bad: string;
+        good: string;
+    }, {
+        bad: string;
+        good: string;
+    }>, "many">>;
+    /**
+     * Prop 310 § Design 6 — the rule's grammar binding: the single declared
+     * language the ast-grep payload was validated under, resolved against the
+     * Map-backed `extensionToLanguage` registry at compile (built-ins + pack
+     * contributions), never a spec-frozen enum. Present only for record-path
+     * ast-grep rules; the record grammar FORBIDS `language` for regex.
+     */
+    language: z.ZodOptional<z.ZodString>;
+    /**
+     * Prop 310 § Design 9 (Amendment R4) — the classification block, carried
+     * VERBATIM and **NEVER EVALUATED at V1**. Evaluation is gated by the ADR-103
+     * Amendment's proof-required-for-enforcement ruling (and any OPA wiring by
+     * Amendment R1's Q2 perf probe); when SMT lands, the verification result binds
+     * to the emitted artifact via the Amendment's R2 certificate chain. Any reader
+     * that starts EXECUTING this field has crossed the R4 gate — a doctrine change,
+     * not a code change.
+     *
+     * The record key keeps its shipped snake_case name (`verification_shadow`, a
+     * named § Design 4 exception); the COMPILED home is camelCase like every other
+     * field here — the rename happens exactly once, at lowering.
+     */
+    verificationShadow: z.ZodOptional<z.ZodObject<{
+        type: z.ZodString;
+        source: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: string;
+        source: string;
+    }, {
+        type: string;
+        source: string;
+    }>>;
+    /**
+     * Prop 310 § Design 4 — the optional author-supplied recovery hint. Compiled
+     * home added under § Design 12's total-lowering obligation: the parser admits
+     * the construct, so it either lands here or fails compile loud, and failing
+     * loud on a legal § Design 4 field is not an option. See `record-lower.ts`
+     * § "Total lowering, mechanically".
+     */
+    recoveryHint: z.ZodOptional<z.ZodString>;
+    /**
+     * Prop 310 § Design 4 (R8) — Prop 270 §8's curation-provenance block, carried
+     * under the § Design 4 collision rename (`curation`, not `provenance` — that
+     * name is the ADR-112 producer's own output field). Compiled home added under
+     * § Design 12's total-lowering obligation, same grounds as `recoveryHint`.
+     *
+     * Shape mirrors `RuleCurationSchema` (`spine/rule-record.ts`) for the same
+     * import-graph-leaf reason as `requires.scope` above, and is coupled by test.
+     * The grammar's all-or-none process-trio refinement is a PARSE-stage rule; a
+     * compiled rule only ever carries a record that already satisfied it.
+     */
+    curation: z.ZodOptional<z.ZodObject<{
+        sourceLesson: z.ZodString;
+        curatedBy: z.ZodOptional<z.ZodString>;
+        curatedAt: z.ZodOptional<z.ZodString>;
+        baseline5Phase: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        sourceLesson: string;
+        curatedBy?: string | undefined;
+        curatedAt?: string | undefined;
+        baseline5Phase?: number | undefined;
+    }, {
+        sourceLesson: string;
+        curatedBy?: string | undefined;
+        curatedAt?: string | undefined;
+        baseline5Phase?: number | undefined;
+    }>>;
 }, "strip", z.ZodTypeAny, {
     message: string;
     lessonHash: string;
@@ -1952,6 +2529,13 @@ export declare const CompiledRuleSchema: z.ZodEffects<z.ZodObject<{
                     kind: "commit";
                     preimageCommitSha: string;
                     mergeCommitSha: string;
+                } | {
+                    kind: "record";
+                    badExample: string;
+                    goodExample: string;
+                    ruleId: string;
+                    ordinal: number;
+                    pairHash: string;
                 };
                 filePath: string;
                 matchedSpan: string;
@@ -1974,6 +2558,27 @@ export declare const CompiledRuleSchema: z.ZodEffects<z.ZodObject<{
         negativeControl: boolean;
     } | undefined;
     ruleClass?: "hard" | "advisory" | undefined;
+    excludeGlobs?: string[] | undefined;
+    requires?: {
+        pattern: string;
+        scope: "line" | "file";
+    } | undefined;
+    examples?: {
+        bad: string;
+        good: string;
+    }[] | undefined;
+    language?: string | undefined;
+    verificationShadow?: {
+        type: string;
+        source: string;
+    } | undefined;
+    recoveryHint?: string | undefined;
+    curation?: {
+        sourceLesson: string;
+        curatedBy?: string | undefined;
+        curatedAt?: string | undefined;
+        baseline5Phase?: number | undefined;
+    } | undefined;
 }, {
     message: string;
     lessonHash: string;
@@ -2021,6 +2626,13 @@ export declare const CompiledRuleSchema: z.ZodEffects<z.ZodObject<{
                     kind: "commit";
                     preimageCommitSha: string;
                     mergeCommitSha: string;
+                } | {
+                    kind: "record";
+                    badExample: string;
+                    goodExample: string;
+                    ruleId: string;
+                    ordinal: number;
+                    pairHash: string;
                 };
                 filePath: string;
                 matchedSpan: string;
@@ -2043,6 +2655,27 @@ export declare const CompiledRuleSchema: z.ZodEffects<z.ZodObject<{
         negativeControl: boolean;
     } | undefined;
     ruleClass?: "hard" | "advisory" | undefined;
+    excludeGlobs?: string[] | undefined;
+    requires?: {
+        pattern: string;
+        scope: "line" | "file";
+    } | undefined;
+    examples?: {
+        bad: string;
+        good: string;
+    }[] | undefined;
+    language?: string | undefined;
+    verificationShadow?: {
+        type: string;
+        source: string;
+    } | undefined;
+    recoveryHint?: string | undefined;
+    curation?: {
+        sourceLesson: string;
+        curatedBy?: string | undefined;
+        curatedAt?: string | undefined;
+        baseline5Phase?: number | undefined;
+    } | undefined;
 }>, {
     message: string;
     lessonHash: string;
@@ -2090,6 +2723,13 @@ export declare const CompiledRuleSchema: z.ZodEffects<z.ZodObject<{
                     kind: "commit";
                     preimageCommitSha: string;
                     mergeCommitSha: string;
+                } | {
+                    kind: "record";
+                    badExample: string;
+                    goodExample: string;
+                    ruleId: string;
+                    ordinal: number;
+                    pairHash: string;
                 };
                 filePath: string;
                 matchedSpan: string;
@@ -2112,6 +2752,27 @@ export declare const CompiledRuleSchema: z.ZodEffects<z.ZodObject<{
         negativeControl: boolean;
     } | undefined;
     ruleClass?: "hard" | "advisory" | undefined;
+    excludeGlobs?: string[] | undefined;
+    requires?: {
+        pattern: string;
+        scope: "line" | "file";
+    } | undefined;
+    examples?: {
+        bad: string;
+        good: string;
+    }[] | undefined;
+    language?: string | undefined;
+    verificationShadow?: {
+        type: string;
+        source: string;
+    } | undefined;
+    recoveryHint?: string | undefined;
+    curation?: {
+        sourceLesson: string;
+        curatedBy?: string | undefined;
+        curatedAt?: string | undefined;
+        baseline5Phase?: number | undefined;
+    } | undefined;
 }, {
     message: string;
     lessonHash: string;
@@ -2159,6 +2820,13 @@ export declare const CompiledRuleSchema: z.ZodEffects<z.ZodObject<{
                     kind: "commit";
                     preimageCommitSha: string;
                     mergeCommitSha: string;
+                } | {
+                    kind: "record";
+                    badExample: string;
+                    goodExample: string;
+                    ruleId: string;
+                    ordinal: number;
+                    pairHash: string;
                 };
                 filePath: string;
                 matchedSpan: string;
@@ -2181,6 +2849,27 @@ export declare const CompiledRuleSchema: z.ZodEffects<z.ZodObject<{
         negativeControl: boolean;
     } | undefined;
     ruleClass?: "hard" | "advisory" | undefined;
+    excludeGlobs?: string[] | undefined;
+    requires?: {
+        pattern: string;
+        scope: "line" | "file";
+    } | undefined;
+    examples?: {
+        bad: string;
+        good: string;
+    }[] | undefined;
+    language?: string | undefined;
+    verificationShadow?: {
+        type: string;
+        source: string;
+    } | undefined;
+    recoveryHint?: string | undefined;
+    curation?: {
+        sourceLesson: string;
+        curatedBy?: string | undefined;
+        curatedAt?: string | undefined;
+        baseline5Phase?: number | undefined;
+    } | undefined;
 }>;
 export type CompiledRule = z.infer<typeof CompiledRuleSchema>;
 /**
@@ -2534,6 +3223,42 @@ export declare const CompiledRulesFileSchema: z.ZodObject<{
                         kind: "commit";
                         preimageCommitSha: string;
                         mergeCommitSha: string;
+                    }>, z.ZodObject<{
+                        kind: z.ZodLiteral<"record">;
+                        /**
+                         * Prop 310 § Design 10 — half of the join key. The ADR-112 §8 producer-minted
+                         * rule id the record was ingested under; pinned to the mint's codomain so a
+                         * derivation that lost the id fails LOUD instead of anchoring the pair to a
+                         * free-text label.
+                         */
+                        ruleId: z.ZodString;
+                        /** The `examples[i]` ordinal within the record — the other half of the join key (§ Design 10). */
+                        ordinal: z.ZodNumber;
+                        /**
+                         * Amendment 1 item 3 — the CR-blind per-pair content hash (`ruleExamplePairHash`),
+                         * computed over the LF-image of the pair's material. The § Design 10 DRIFT SENSOR:
+                         * an `examples` edit flips it, which flips the ledger `contentHash`, which reads
+                         * `revised`. There is no second mechanism.
+                         */
+                        pairHash: z.ZodString;
+                        /** The record's `examples[ordinal].bad` — the defect preimage the matcher must FIRE on (§4). */
+                        badExample: z.ZodEffects<z.ZodString, string, string>;
+                        /** The record's `examples[ordinal].good` — the fixed postimage the matcher must stay SILENT on (§4). */
+                        goodExample: z.ZodEffects<z.ZodString, string, string>;
+                    }, "strict", z.ZodTypeAny, {
+                        kind: "record";
+                        badExample: string;
+                        goodExample: string;
+                        ruleId: string;
+                        ordinal: number;
+                        pairHash: string;
+                    }, {
+                        kind: "record";
+                        badExample: string;
+                        goodExample: string;
+                        ruleId: string;
+                        ordinal: number;
+                        pairHash: string;
                     }>]>;
                     /** File the defect locus lives in. */
                     filePath: z.ZodEffects<z.ZodString, string, string>;
@@ -2552,6 +3277,13 @@ export declare const CompiledRulesFileSchema: z.ZodObject<{
                         kind: "commit";
                         preimageCommitSha: string;
                         mergeCommitSha: string;
+                    } | {
+                        kind: "record";
+                        badExample: string;
+                        goodExample: string;
+                        ruleId: string;
+                        ordinal: number;
+                        pairHash: string;
                     };
                     filePath: string;
                     matchedSpan: string;
@@ -2567,6 +3299,13 @@ export declare const CompiledRulesFileSchema: z.ZodObject<{
                         kind: "commit";
                         preimageCommitSha: string;
                         mergeCommitSha: string;
+                    } | {
+                        kind: "record";
+                        badExample: string;
+                        goodExample: string;
+                        ruleId: string;
+                        ordinal: number;
+                        pairHash: string;
                     };
                     filePath: string;
                     matchedSpan: string;
@@ -2582,6 +3321,13 @@ export declare const CompiledRulesFileSchema: z.ZodObject<{
                         kind: "commit";
                         preimageCommitSha: string;
                         mergeCommitSha: string;
+                    } | {
+                        kind: "record";
+                        badExample: string;
+                        goodExample: string;
+                        ruleId: string;
+                        ordinal: number;
+                        pairHash: string;
                     };
                     filePath: string;
                     matchedSpan: string;
@@ -2597,6 +3343,13 @@ export declare const CompiledRulesFileSchema: z.ZodObject<{
                         kind: "commit";
                         preimageCommitSha: string;
                         mergeCommitSha: string;
+                    } | {
+                        kind: "record";
+                        badExample: string;
+                        goodExample: string;
+                        ruleId: string;
+                        ordinal: number;
+                        pairHash: string;
                     };
                     filePath: string;
                     matchedSpan: string;
@@ -2682,6 +3435,13 @@ export declare const CompiledRulesFileSchema: z.ZodObject<{
                         kind: "commit";
                         preimageCommitSha: string;
                         mergeCommitSha: string;
+                    } | {
+                        kind: "record";
+                        badExample: string;
+                        goodExample: string;
+                        ruleId: string;
+                        ordinal: number;
+                        pairHash: string;
                     };
                     filePath: string;
                     matchedSpan: string;
@@ -2715,6 +3475,13 @@ export declare const CompiledRulesFileSchema: z.ZodObject<{
                         kind: "commit";
                         preimageCommitSha: string;
                         mergeCommitSha: string;
+                    } | {
+                        kind: "record";
+                        badExample: string;
+                        goodExample: string;
+                        ruleId: string;
+                        ordinal: number;
+                        pairHash: string;
                     };
                     filePath: string;
                     matchedSpan: string;
@@ -2788,6 +3555,13 @@ export declare const CompiledRulesFileSchema: z.ZodObject<{
                         kind: "commit";
                         preimageCommitSha: string;
                         mergeCommitSha: string;
+                    } | {
+                        kind: "record";
+                        badExample: string;
+                        goodExample: string;
+                        ruleId: string;
+                        ordinal: number;
+                        pairHash: string;
                     };
                     filePath: string;
                     matchedSpan: string;
@@ -2830,6 +3604,13 @@ export declare const CompiledRulesFileSchema: z.ZodObject<{
                         kind: "commit";
                         preimageCommitSha: string;
                         mergeCommitSha: string;
+                    } | {
+                        kind: "record";
+                        badExample: string;
+                        goodExample: string;
+                        ruleId: string;
+                        ordinal: number;
+                        pairHash: string;
                     };
                     filePath: string;
                     matchedSpan: string;
@@ -2862,6 +3643,124 @@ export declare const CompiledRulesFileSchema: z.ZodObject<{
          * reader falls back to the legacy engine-type proxy.
          */
         ruleClass: z.ZodOptional<z.ZodEnum<["hard", "advisory"]>>;
+        /**
+         * Prop 310 § Design 7 / mmnto-ai/totem#1574 — first-class structural
+         * exclusions. Entries are POSITIVE-form globs applied as exclusions: a file is
+         * in scope iff it matches some `fileGlobs` entry AND no `excludeGlobs` entry
+         * (`positiveMatch && !excludeMatch`). `!`-negation is a parse error in the
+         * record grammar, so an entry here never carries one.
+         */
+        excludeGlobs: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        /**
+         * Prop 310 § Design 8 — the absence / must-contain block. The rule fires on a
+         * target match at locus L iff `pattern` does NOT match within the declared
+         * scope containing L. `pattern` is a safe-regex2-gated regex evaluated
+         * TEXTUALLY, independent of `engine`; V1 carries exactly one block.
+         *
+         * The scope enum MIRRORS `RequiresScopeSchema` (`spine/rule-record.ts`) rather
+         * than importing it — `compiler-schema.ts` is an import-graph LEAF (zod only)
+         * and `spine/rule-record.ts` transitively imports it, so an import here would
+         * close a cycle. The two are COUPLED by an equality test in
+         * `record-lower.test.ts`, never left to drift on inspection. `block` is
+         * reserved-unimplemented at the grammar (§ Design 8) and therefore can never
+         * reach a compiled rule.
+         */
+        requires: z.ZodOptional<z.ZodObject<{
+            pattern: z.ZodString;
+            scope: z.ZodEnum<["line", "file"]>;
+        }, "strip", z.ZodTypeAny, {
+            pattern: string;
+            scope: "line" | "file";
+        }, {
+            pattern: string;
+            scope: "line" | "file";
+        }>>;
+        /**
+         * Prop 310 § Design 5 / § Design 10 — certification's PRIMARY PREIMAGE SOURCE
+         * (ADR-112 §4), and per Amendment 1 the record's block is the hand-editable
+         * home (the fixture envelope derives). Carried verbatim, in ordinal order: the
+         * `(ruleId, ordinal)` join key is positional, so a reorder is a re-pair.
+         *
+         * Deliberately NOT projected onto the legacy `badExample`/`goodExample` pair —
+         * that would be Tenet 20's prohibited mirror (two hand-editable homes for one
+         * object). Consumers that need a single exemplar read `examples[0]`.
+         */
+        examples: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            bad: z.ZodString;
+            good: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            bad: string;
+            good: string;
+        }, {
+            bad: string;
+            good: string;
+        }>, "many">>;
+        /**
+         * Prop 310 § Design 6 — the rule's grammar binding: the single declared
+         * language the ast-grep payload was validated under, resolved against the
+         * Map-backed `extensionToLanguage` registry at compile (built-ins + pack
+         * contributions), never a spec-frozen enum. Present only for record-path
+         * ast-grep rules; the record grammar FORBIDS `language` for regex.
+         */
+        language: z.ZodOptional<z.ZodString>;
+        /**
+         * Prop 310 § Design 9 (Amendment R4) — the classification block, carried
+         * VERBATIM and **NEVER EVALUATED at V1**. Evaluation is gated by the ADR-103
+         * Amendment's proof-required-for-enforcement ruling (and any OPA wiring by
+         * Amendment R1's Q2 perf probe); when SMT lands, the verification result binds
+         * to the emitted artifact via the Amendment's R2 certificate chain. Any reader
+         * that starts EXECUTING this field has crossed the R4 gate — a doctrine change,
+         * not a code change.
+         *
+         * The record key keeps its shipped snake_case name (`verification_shadow`, a
+         * named § Design 4 exception); the COMPILED home is camelCase like every other
+         * field here — the rename happens exactly once, at lowering.
+         */
+        verificationShadow: z.ZodOptional<z.ZodObject<{
+            type: z.ZodString;
+            source: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            type: string;
+            source: string;
+        }, {
+            type: string;
+            source: string;
+        }>>;
+        /**
+         * Prop 310 § Design 4 — the optional author-supplied recovery hint. Compiled
+         * home added under § Design 12's total-lowering obligation: the parser admits
+         * the construct, so it either lands here or fails compile loud, and failing
+         * loud on a legal § Design 4 field is not an option. See `record-lower.ts`
+         * § "Total lowering, mechanically".
+         */
+        recoveryHint: z.ZodOptional<z.ZodString>;
+        /**
+         * Prop 310 § Design 4 (R8) — Prop 270 §8's curation-provenance block, carried
+         * under the § Design 4 collision rename (`curation`, not `provenance` — that
+         * name is the ADR-112 producer's own output field). Compiled home added under
+         * § Design 12's total-lowering obligation, same grounds as `recoveryHint`.
+         *
+         * Shape mirrors `RuleCurationSchema` (`spine/rule-record.ts`) for the same
+         * import-graph-leaf reason as `requires.scope` above, and is coupled by test.
+         * The grammar's all-or-none process-trio refinement is a PARSE-stage rule; a
+         * compiled rule only ever carries a record that already satisfied it.
+         */
+        curation: z.ZodOptional<z.ZodObject<{
+            sourceLesson: z.ZodString;
+            curatedBy: z.ZodOptional<z.ZodString>;
+            curatedAt: z.ZodOptional<z.ZodString>;
+            baseline5Phase: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            sourceLesson: string;
+            curatedBy?: string | undefined;
+            curatedAt?: string | undefined;
+            baseline5Phase?: number | undefined;
+        }, {
+            sourceLesson: string;
+            curatedBy?: string | undefined;
+            curatedAt?: string | undefined;
+            baseline5Phase?: number | undefined;
+        }>>;
     }, "strip", z.ZodTypeAny, {
         message: string;
         lessonHash: string;
@@ -2909,6 +3808,13 @@ export declare const CompiledRulesFileSchema: z.ZodObject<{
                         kind: "commit";
                         preimageCommitSha: string;
                         mergeCommitSha: string;
+                    } | {
+                        kind: "record";
+                        badExample: string;
+                        goodExample: string;
+                        ruleId: string;
+                        ordinal: number;
+                        pairHash: string;
                     };
                     filePath: string;
                     matchedSpan: string;
@@ -2931,6 +3837,27 @@ export declare const CompiledRulesFileSchema: z.ZodObject<{
             negativeControl: boolean;
         } | undefined;
         ruleClass?: "hard" | "advisory" | undefined;
+        excludeGlobs?: string[] | undefined;
+        requires?: {
+            pattern: string;
+            scope: "line" | "file";
+        } | undefined;
+        examples?: {
+            bad: string;
+            good: string;
+        }[] | undefined;
+        language?: string | undefined;
+        verificationShadow?: {
+            type: string;
+            source: string;
+        } | undefined;
+        recoveryHint?: string | undefined;
+        curation?: {
+            sourceLesson: string;
+            curatedBy?: string | undefined;
+            curatedAt?: string | undefined;
+            baseline5Phase?: number | undefined;
+        } | undefined;
     }, {
         message: string;
         lessonHash: string;
@@ -2978,6 +3905,13 @@ export declare const CompiledRulesFileSchema: z.ZodObject<{
                         kind: "commit";
                         preimageCommitSha: string;
                         mergeCommitSha: string;
+                    } | {
+                        kind: "record";
+                        badExample: string;
+                        goodExample: string;
+                        ruleId: string;
+                        ordinal: number;
+                        pairHash: string;
                     };
                     filePath: string;
                     matchedSpan: string;
@@ -3000,6 +3934,27 @@ export declare const CompiledRulesFileSchema: z.ZodObject<{
             negativeControl: boolean;
         } | undefined;
         ruleClass?: "hard" | "advisory" | undefined;
+        excludeGlobs?: string[] | undefined;
+        requires?: {
+            pattern: string;
+            scope: "line" | "file";
+        } | undefined;
+        examples?: {
+            bad: string;
+            good: string;
+        }[] | undefined;
+        language?: string | undefined;
+        verificationShadow?: {
+            type: string;
+            source: string;
+        } | undefined;
+        recoveryHint?: string | undefined;
+        curation?: {
+            sourceLesson: string;
+            curatedBy?: string | undefined;
+            curatedAt?: string | undefined;
+            baseline5Phase?: number | undefined;
+        } | undefined;
     }>, {
         message: string;
         lessonHash: string;
@@ -3047,6 +4002,13 @@ export declare const CompiledRulesFileSchema: z.ZodObject<{
                         kind: "commit";
                         preimageCommitSha: string;
                         mergeCommitSha: string;
+                    } | {
+                        kind: "record";
+                        badExample: string;
+                        goodExample: string;
+                        ruleId: string;
+                        ordinal: number;
+                        pairHash: string;
                     };
                     filePath: string;
                     matchedSpan: string;
@@ -3069,6 +4031,27 @@ export declare const CompiledRulesFileSchema: z.ZodObject<{
             negativeControl: boolean;
         } | undefined;
         ruleClass?: "hard" | "advisory" | undefined;
+        excludeGlobs?: string[] | undefined;
+        requires?: {
+            pattern: string;
+            scope: "line" | "file";
+        } | undefined;
+        examples?: {
+            bad: string;
+            good: string;
+        }[] | undefined;
+        language?: string | undefined;
+        verificationShadow?: {
+            type: string;
+            source: string;
+        } | undefined;
+        recoveryHint?: string | undefined;
+        curation?: {
+            sourceLesson: string;
+            curatedBy?: string | undefined;
+            curatedAt?: string | undefined;
+            baseline5Phase?: number | undefined;
+        } | undefined;
     }, {
         message: string;
         lessonHash: string;
@@ -3116,6 +4099,13 @@ export declare const CompiledRulesFileSchema: z.ZodObject<{
                         kind: "commit";
                         preimageCommitSha: string;
                         mergeCommitSha: string;
+                    } | {
+                        kind: "record";
+                        badExample: string;
+                        goodExample: string;
+                        ruleId: string;
+                        ordinal: number;
+                        pairHash: string;
                     };
                     filePath: string;
                     matchedSpan: string;
@@ -3138,6 +4128,27 @@ export declare const CompiledRulesFileSchema: z.ZodObject<{
             negativeControl: boolean;
         } | undefined;
         ruleClass?: "hard" | "advisory" | undefined;
+        excludeGlobs?: string[] | undefined;
+        requires?: {
+            pattern: string;
+            scope: "line" | "file";
+        } | undefined;
+        examples?: {
+            bad: string;
+            good: string;
+        }[] | undefined;
+        language?: string | undefined;
+        verificationShadow?: {
+            type: string;
+            source: string;
+        } | undefined;
+        recoveryHint?: string | undefined;
+        curation?: {
+            sourceLesson: string;
+            curatedBy?: string | undefined;
+            curatedAt?: string | undefined;
+            baseline5Phase?: number | undefined;
+        } | undefined;
     }>, "many">;
     /**
      * Lessons that could not be compiled into a rule. 4-tuple shape since
@@ -3235,6 +4246,13 @@ export declare const CompiledRulesFileSchema: z.ZodObject<{
                         kind: "commit";
                         preimageCommitSha: string;
                         mergeCommitSha: string;
+                    } | {
+                        kind: "record";
+                        badExample: string;
+                        goodExample: string;
+                        ruleId: string;
+                        ordinal: number;
+                        pairHash: string;
                     };
                     filePath: string;
                     matchedSpan: string;
@@ -3257,6 +4275,27 @@ export declare const CompiledRulesFileSchema: z.ZodObject<{
             negativeControl: boolean;
         } | undefined;
         ruleClass?: "hard" | "advisory" | undefined;
+        excludeGlobs?: string[] | undefined;
+        requires?: {
+            pattern: string;
+            scope: "line" | "file";
+        } | undefined;
+        examples?: {
+            bad: string;
+            good: string;
+        }[] | undefined;
+        language?: string | undefined;
+        verificationShadow?: {
+            type: string;
+            source: string;
+        } | undefined;
+        recoveryHint?: string | undefined;
+        curation?: {
+            sourceLesson: string;
+            curatedBy?: string | undefined;
+            curatedAt?: string | undefined;
+            baseline5Phase?: number | undefined;
+        } | undefined;
     }[];
     nonCompilable?: {
         hash: string;
@@ -3313,6 +4352,13 @@ export declare const CompiledRulesFileSchema: z.ZodObject<{
                         kind: "commit";
                         preimageCommitSha: string;
                         mergeCommitSha: string;
+                    } | {
+                        kind: "record";
+                        badExample: string;
+                        goodExample: string;
+                        ruleId: string;
+                        ordinal: number;
+                        pairHash: string;
                     };
                     filePath: string;
                     matchedSpan: string;
@@ -3335,6 +4381,27 @@ export declare const CompiledRulesFileSchema: z.ZodObject<{
             negativeControl: boolean;
         } | undefined;
         ruleClass?: "hard" | "advisory" | undefined;
+        excludeGlobs?: string[] | undefined;
+        requires?: {
+            pattern: string;
+            scope: "line" | "file";
+        } | undefined;
+        examples?: {
+            bad: string;
+            good: string;
+        }[] | undefined;
+        language?: string | undefined;
+        verificationShadow?: {
+            type: string;
+            source: string;
+        } | undefined;
+        recoveryHint?: string | undefined;
+        curation?: {
+            sourceLesson: string;
+            curatedBy?: string | undefined;
+            curatedAt?: string | undefined;
+            baseline5Phase?: number | undefined;
+        } | undefined;
     }[];
     nonCompilable?: (string | {
         hash: string;