@mmnto/totem 1.118.0 → 1.119.0

package/dist/spine/authored-rule.d.ts

@@ -57,7 +57,7 @@ export declare const AuthoredOriginSchema: z.ZodUnion<[z.ZodObject<{
     suggestionHash: string;
 }>]>;
 export type AuthoredOrigin = z.infer<typeof AuthoredOriginSchema>;
-export declare const AUTHORED_RULE_ID_RE: RegExp;
+export { AUTHORED_RULE_ID_RE } from '../compiler-schema.js';
 /**
  * ADR-112 §3 — the authored producer's sole output envelope. Parallel to
  * ADR-111's `CandidateRuleRecord` but carrying the AUTHORED provenance variant,
@@ -111,6 +111,27 @@ export declare const AuthoredRuleRecordSchema: z.ZodObject<{
                 kind: "commit";
                 preimageCommitSha: string;
                 mergeCommitSha: string;
+            }>, z.ZodObject<{
+                kind: z.ZodLiteral<"record">;
+                ruleId: z.ZodString;
+                ordinal: z.ZodNumber;
+                pairHash: z.ZodString;
+                badExample: z.ZodEffects<z.ZodString, string, string>;
+                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;
             }>]>;
             filePath: z.ZodEffects<z.ZodString, string, string>;
             matchedSpan: z.ZodEffects<z.ZodString, string, string>;
@@ -126,6 +147,13 @@ export declare const AuthoredRuleRecordSchema: z.ZodObject<{
                 kind: "commit";
                 preimageCommitSha: string;
                 mergeCommitSha: string;
+            } | {
+                kind: "record";
+                badExample: string;
+                goodExample: string;
+                ruleId: string;
+                ordinal: number;
+                pairHash: string;
             };
             filePath: string;
             matchedSpan: string;
@@ -141,6 +169,13 @@ export declare const AuthoredRuleRecordSchema: z.ZodObject<{
                 kind: "commit";
                 preimageCommitSha: string;
                 mergeCommitSha: string;
+            } | {
+                kind: "record";
+                badExample: string;
+                goodExample: string;
+                ruleId: string;
+                ordinal: number;
+                pairHash: string;
             };
             filePath: string;
             matchedSpan: string;
@@ -156,6 +191,13 @@ export declare const AuthoredRuleRecordSchema: z.ZodObject<{
                 kind: "commit";
                 preimageCommitSha: string;
                 mergeCommitSha: string;
+            } | {
+                kind: "record";
+                badExample: string;
+                goodExample: string;
+                ruleId: string;
+                ordinal: number;
+                pairHash: string;
             };
             filePath: string;
             matchedSpan: string;
@@ -171,6 +213,13 @@ export declare const AuthoredRuleRecordSchema: z.ZodObject<{
                 kind: "commit";
                 preimageCommitSha: string;
                 mergeCommitSha: string;
+            } | {
+                kind: "record";
+                badExample: string;
+                goodExample: string;
+                ruleId: string;
+                ordinal: number;
+                pairHash: string;
             };
             filePath: string;
             matchedSpan: string;
@@ -240,6 +289,13 @@ export declare const AuthoredRuleRecordSchema: z.ZodObject<{
                 kind: "commit";
                 preimageCommitSha: string;
                 mergeCommitSha: string;
+            } | {
+                kind: "record";
+                badExample: string;
+                goodExample: string;
+                ruleId: string;
+                ordinal: number;
+                pairHash: string;
             };
             filePath: string;
             matchedSpan: string;
@@ -273,6 +329,13 @@ export declare const AuthoredRuleRecordSchema: z.ZodObject<{
                 kind: "commit";
                 preimageCommitSha: string;
                 mergeCommitSha: string;
+            } | {
+                kind: "record";
+                badExample: string;
+                goodExample: string;
+                ruleId: string;
+                ordinal: number;
+                pairHash: string;
             };
             filePath: string;
             matchedSpan: string;
@@ -334,14 +397,445 @@ export declare const AuthoredRuleRecordSchema: z.ZodObject<{
         sourceRunId: string;
         suggestionHash: string;
     }>]>;
+    /**
+     * The engine the structural-eligibility whitelist was judged for. Since Prop 310
+     * slice 3 it is DERIVED at intake from the record's `target.type`
+     * (`parsed.derivedEngine`, § Design 3/R17) and is never author-mirrored — a
+     * mirrored engine field is Tenet 20's prohibited copy at record scale.
+     */
     declaredEngine: z.ZodEnum<["regex", "ast", "ast-grep"]>;
     /** Reference to the §8 authoring-ledger entry (author/date/engine/splitRef/attestations). */
     authoringLedgerRef: z.ZodEffects<z.ZodString, string, string>;
-    /** The human-written matcher (same DSL the compiler accepts from the miner). */
-    dslSource: z.ZodEffects<z.ZodString, string, string>;
+    /**
+     * Prop 310 § Design 1 — the INGESTED rule record. Replaces the inline
+     * `dslSource`: since slice 3 the record file is the only authoring surface, so
+     * the matcher reaches the compiler already parsed, never re-serialised into
+     * lesson markdown.
+     *
+     * `contentHash` is the sha256 of the LF-admitted bytes actually ingested, and it
+     * is what the §8 attestations bind to (§ Design 1's relocation constraint): the
+     * `path` is INFORMATIONAL only, because renaming a record changes no identity
+     * (§ Design 1) and must not force re-attestation. `parsed` is the in-memory
+     * value the lowering consumes and is never hash material — `contentHash` stands
+     * in for it, so the bytes and the attestation can never disagree.
+     */
+    record: z.ZodObject<{
+        /** Repo-relative POSIX path the record was read from — informational, never identity. */
+        path: z.ZodEffects<z.ZodString, string, string>;
+        /** sha256 of the LF-admitted record bytes — what every attestation binds to. */
+        contentHash: z.ZodString;
+        /** Slice 1's parsed value (§ Design 3's derived engine + Amendment 1's pair hashes). */
+        parsed: z.ZodObject<{
+            record: z.ZodObject<{
+                schemaVersion: z.ZodLiteral<1>;
+                severity: z.ZodEnum<["error", "warning"]>;
+                message: z.ZodEffects<z.ZodString, string, string>;
+                recoveryHint: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+                target: z.ZodEffects<z.ZodObject<{
+                    type: z.ZodEnum<["ast-grep", "regex"]>;
+                    language: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+                    pattern: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+                    rule: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Record<string, unknown>, Record<string, unknown>>>;
+                    scope: z.ZodObject<{
+                        fileGlobs: z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">;
+                        excludeGlobs: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">>;
+                    }, "strict", z.ZodTypeAny, {
+                        fileGlobs: string[];
+                        excludeGlobs?: string[] | undefined;
+                    }, {
+                        fileGlobs: string[];
+                        excludeGlobs?: string[] | undefined;
+                    }>;
+                }, "strict", z.ZodTypeAny, {
+                    type: "regex" | "ast-grep";
+                    scope: {
+                        fileGlobs: string[];
+                        excludeGlobs?: string[] | undefined;
+                    };
+                    rule?: Record<string, unknown> | undefined;
+                    pattern?: string | undefined;
+                    language?: string | undefined;
+                }, {
+                    type: "regex" | "ast-grep";
+                    scope: {
+                        fileGlobs: string[];
+                        excludeGlobs?: string[] | undefined;
+                    };
+                    rule?: Record<string, unknown> | undefined;
+                    pattern?: string | undefined;
+                    language?: string | undefined;
+                }>, {
+                    type: "regex" | "ast-grep";
+                    scope: {
+                        fileGlobs: string[];
+                        excludeGlobs?: string[] | undefined;
+                    };
+                    rule?: Record<string, unknown> | undefined;
+                    pattern?: string | undefined;
+                    language?: string | undefined;
+                }, {
+                    type: "regex" | "ast-grep";
+                    scope: {
+                        fileGlobs: string[];
+                        excludeGlobs?: string[] | undefined;
+                    };
+                    rule?: Record<string, unknown> | undefined;
+                    pattern?: string | undefined;
+                    language?: string | undefined;
+                }>;
+                examples: z.ZodArray<z.ZodObject<{
+                    bad: z.ZodEffects<z.ZodString, string, string>;
+                    good: z.ZodEffects<z.ZodString, string, string>;
+                }, "strict", z.ZodTypeAny, {
+                    bad: string;
+                    good: string;
+                }, {
+                    bad: string;
+                    good: string;
+                }>, "many">;
+                requires: z.ZodOptional<z.ZodObject<{
+                    pattern: z.ZodEffects<z.ZodString, string, string>;
+                    scope: z.ZodEnum<["line", "file"]>;
+                }, "strict", z.ZodTypeAny, {
+                    pattern: string;
+                    scope: "line" | "file";
+                }, {
+                    pattern: string;
+                    scope: "line" | "file";
+                }>>;
+                curation: z.ZodOptional<z.ZodEffects<z.ZodObject<{
+                    sourceLesson: z.ZodEffects<z.ZodString, string, string>;
+                    curatedBy: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+                    curatedAt: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+                    baseline5Phase: z.ZodOptional<z.ZodNumber>;
+                }, "strict", z.ZodTypeAny, {
+                    sourceLesson: string;
+                    curatedBy?: string | undefined;
+                    curatedAt?: string | undefined;
+                    baseline5Phase?: number | undefined;
+                }, {
+                    sourceLesson: string;
+                    curatedBy?: string | undefined;
+                    curatedAt?: string | undefined;
+                    baseline5Phase?: number | undefined;
+                }>, {
+                    sourceLesson: string;
+                    curatedBy?: string | undefined;
+                    curatedAt?: string | undefined;
+                    baseline5Phase?: number | undefined;
+                }, {
+                    sourceLesson: string;
+                    curatedBy?: string | undefined;
+                    curatedAt?: string | undefined;
+                    baseline5Phase?: number | undefined;
+                }>>;
+                verification_shadow: z.ZodOptional<z.ZodObject<{
+                    type: z.ZodEffects<z.ZodString, string, string>;
+                    source: z.ZodEffects<z.ZodString, string, string>;
+                }, "strict", z.ZodTypeAny, {
+                    type: string;
+                    source: string;
+                }, {
+                    type: string;
+                    source: string;
+                }>>;
+            }, "strict", z.ZodTypeAny, {
+                message: string;
+                severity: "error" | "warning";
+                examples: {
+                    bad: string;
+                    good: string;
+                }[];
+                schemaVersion: 1;
+                target: {
+                    type: "regex" | "ast-grep";
+                    scope: {
+                        fileGlobs: string[];
+                        excludeGlobs?: string[] | undefined;
+                    };
+                    rule?: Record<string, unknown> | undefined;
+                    pattern?: string | undefined;
+                    language?: string | undefined;
+                };
+                requires?: {
+                    pattern: string;
+                    scope: "line" | "file";
+                } | undefined;
+                recoveryHint?: string | undefined;
+                curation?: {
+                    sourceLesson: string;
+                    curatedBy?: string | undefined;
+                    curatedAt?: string | undefined;
+                    baseline5Phase?: number | undefined;
+                } | undefined;
+                verification_shadow?: {
+                    type: string;
+                    source: string;
+                } | undefined;
+            }, {
+                message: string;
+                severity: "error" | "warning";
+                examples: {
+                    bad: string;
+                    good: string;
+                }[];
+                schemaVersion: 1;
+                target: {
+                    type: "regex" | "ast-grep";
+                    scope: {
+                        fileGlobs: string[];
+                        excludeGlobs?: string[] | undefined;
+                    };
+                    rule?: Record<string, unknown> | undefined;
+                    pattern?: string | undefined;
+                    language?: string | undefined;
+                };
+                requires?: {
+                    pattern: string;
+                    scope: "line" | "file";
+                } | undefined;
+                recoveryHint?: string | undefined;
+                curation?: {
+                    sourceLesson: string;
+                    curatedBy?: string | undefined;
+                    curatedAt?: string | undefined;
+                    baseline5Phase?: number | undefined;
+                } | undefined;
+                verification_shadow?: {
+                    type: string;
+                    source: string;
+                } | undefined;
+            }>;
+            derivedEngine: z.ZodEnum<["ast-grep", "regex"]>;
+            examplePairHashes: z.ZodArray<z.ZodObject<{
+                ordinal: z.ZodNumber;
+                hash: z.ZodString;
+            }, "strict", z.ZodTypeAny, {
+                ordinal: number;
+                hash: string;
+            }, {
+                ordinal: number;
+                hash: string;
+            }>, "many">;
+        }, "strict", z.ZodTypeAny, {
+            record: {
+                message: string;
+                severity: "error" | "warning";
+                examples: {
+                    bad: string;
+                    good: string;
+                }[];
+                schemaVersion: 1;
+                target: {
+                    type: "regex" | "ast-grep";
+                    scope: {
+                        fileGlobs: string[];
+                        excludeGlobs?: string[] | undefined;
+                    };
+                    rule?: Record<string, unknown> | undefined;
+                    pattern?: string | undefined;
+                    language?: string | undefined;
+                };
+                requires?: {
+                    pattern: string;
+                    scope: "line" | "file";
+                } | undefined;
+                recoveryHint?: string | undefined;
+                curation?: {
+                    sourceLesson: string;
+                    curatedBy?: string | undefined;
+                    curatedAt?: string | undefined;
+                    baseline5Phase?: number | undefined;
+                } | undefined;
+                verification_shadow?: {
+                    type: string;
+                    source: string;
+                } | undefined;
+            };
+            derivedEngine: "regex" | "ast-grep";
+            examplePairHashes: {
+                ordinal: number;
+                hash: string;
+            }[];
+        }, {
+            record: {
+                message: string;
+                severity: "error" | "warning";
+                examples: {
+                    bad: string;
+                    good: string;
+                }[];
+                schemaVersion: 1;
+                target: {
+                    type: "regex" | "ast-grep";
+                    scope: {
+                        fileGlobs: string[];
+                        excludeGlobs?: string[] | undefined;
+                    };
+                    rule?: Record<string, unknown> | undefined;
+                    pattern?: string | undefined;
+                    language?: string | undefined;
+                };
+                requires?: {
+                    pattern: string;
+                    scope: "line" | "file";
+                } | undefined;
+                recoveryHint?: string | undefined;
+                curation?: {
+                    sourceLesson: string;
+                    curatedBy?: string | undefined;
+                    curatedAt?: string | undefined;
+                    baseline5Phase?: number | undefined;
+                } | undefined;
+                verification_shadow?: {
+                    type: string;
+                    source: string;
+                } | undefined;
+            };
+            derivedEngine: "regex" | "ast-grep";
+            examplePairHashes: {
+                ordinal: number;
+                hash: string;
+            }[];
+        }>;
+    }, "strict", z.ZodTypeAny, {
+        path: string;
+        contentHash: string;
+        parsed: {
+            record: {
+                message: string;
+                severity: "error" | "warning";
+                examples: {
+                    bad: string;
+                    good: string;
+                }[];
+                schemaVersion: 1;
+                target: {
+                    type: "regex" | "ast-grep";
+                    scope: {
+                        fileGlobs: string[];
+                        excludeGlobs?: string[] | undefined;
+                    };
+                    rule?: Record<string, unknown> | undefined;
+                    pattern?: string | undefined;
+                    language?: string | undefined;
+                };
+                requires?: {
+                    pattern: string;
+                    scope: "line" | "file";
+                } | undefined;
+                recoveryHint?: string | undefined;
+                curation?: {
+                    sourceLesson: string;
+                    curatedBy?: string | undefined;
+                    curatedAt?: string | undefined;
+                    baseline5Phase?: number | undefined;
+                } | undefined;
+                verification_shadow?: {
+                    type: string;
+                    source: string;
+                } | undefined;
+            };
+            derivedEngine: "regex" | "ast-grep";
+            examplePairHashes: {
+                ordinal: number;
+                hash: string;
+            }[];
+        };
+    }, {
+        path: string;
+        contentHash: string;
+        parsed: {
+            record: {
+                message: string;
+                severity: "error" | "warning";
+                examples: {
+                    bad: string;
+                    good: string;
+                }[];
+                schemaVersion: 1;
+                target: {
+                    type: "regex" | "ast-grep";
+                    scope: {
+                        fileGlobs: string[];
+                        excludeGlobs?: string[] | undefined;
+                    };
+                    rule?: Record<string, unknown> | undefined;
+                    pattern?: string | undefined;
+                    language?: string | undefined;
+                };
+                requires?: {
+                    pattern: string;
+                    scope: "line" | "file";
+                } | undefined;
+                recoveryHint?: string | undefined;
+                curation?: {
+                    sourceLesson: string;
+                    curatedBy?: string | undefined;
+                    curatedAt?: string | undefined;
+                    baseline5Phase?: number | undefined;
+                } | undefined;
+                verification_shadow?: {
+                    type: string;
+                    source: string;
+                } | undefined;
+            };
+            derivedEngine: "regex" | "ast-grep";
+            examplePairHashes: {
+                ordinal: number;
+                hash: string;
+            }[];
+        };
+    }>;
     /** Zero-trust mint (ADR-089 / ADR-112 §1) — always literally `true`. */
     unverified: z.ZodLiteral<true>;
 }, "strip", z.ZodTypeAny, {
+    record: {
+        path: string;
+        contentHash: string;
+        parsed: {
+            record: {
+                message: string;
+                severity: "error" | "warning";
+                examples: {
+                    bad: string;
+                    good: string;
+                }[];
+                schemaVersion: 1;
+                target: {
+                    type: "regex" | "ast-grep";
+                    scope: {
+                        fileGlobs: string[];
+                        excludeGlobs?: string[] | undefined;
+                    };
+                    rule?: Record<string, unknown> | undefined;
+                    pattern?: string | undefined;
+                    language?: string | undefined;
+                };
+                requires?: {
+                    pattern: string;
+                    scope: "line" | "file";
+                } | undefined;
+                recoveryHint?: string | undefined;
+                curation?: {
+                    sourceLesson: string;
+                    curatedBy?: string | undefined;
+                    curatedAt?: string | undefined;
+                    baseline5Phase?: number | undefined;
+                } | undefined;
+                verification_shadow?: {
+                    type: string;
+                    source: string;
+                } | undefined;
+            };
+            derivedEngine: "regex" | "ast-grep";
+            examplePairHashes: {
+                ordinal: number;
+                hash: string;
+            }[];
+        };
+    };
+    ruleId: string;
     provenance: {
         kind: "authored";
         author: string;
@@ -358,6 +852,13 @@ export declare const AuthoredRuleRecordSchema: z.ZodObject<{
                 kind: "commit";
                 preimageCommitSha: string;
                 mergeCommitSha: string;
+            } | {
+                kind: "record";
+                badExample: string;
+                goodExample: string;
+                ruleId: string;
+                ordinal: number;
+                pairHash: string;
             };
             filePath: string;
             matchedSpan: string;
@@ -377,7 +878,6 @@ export declare const AuthoredRuleRecordSchema: z.ZodObject<{
         }[] | undefined;
     };
     unverified: true;
-    ruleId: string;
     origin: {
         kind: "from-scratch";
     } | {
@@ -385,7 +885,6 @@ export declare const AuthoredRuleRecordSchema: z.ZodObject<{
         sourceRunId: string;
         suggestionHash: string;
     };
-    dslSource: string;
     structuralEligibility: {
         decidable: boolean;
         basis: string;
@@ -394,6 +893,52 @@ export declare const AuthoredRuleRecordSchema: z.ZodObject<{
     declaredEngine: "regex" | "ast" | "ast-grep";
     authoringLedgerRef: string;
 }, {
+    record: {
+        path: string;
+        contentHash: string;
+        parsed: {
+            record: {
+                message: string;
+                severity: "error" | "warning";
+                examples: {
+                    bad: string;
+                    good: string;
+                }[];
+                schemaVersion: 1;
+                target: {
+                    type: "regex" | "ast-grep";
+                    scope: {
+                        fileGlobs: string[];
+                        excludeGlobs?: string[] | undefined;
+                    };
+                    rule?: Record<string, unknown> | undefined;
+                    pattern?: string | undefined;
+                    language?: string | undefined;
+                };
+                requires?: {
+                    pattern: string;
+                    scope: "line" | "file";
+                } | undefined;
+                recoveryHint?: string | undefined;
+                curation?: {
+                    sourceLesson: string;
+                    curatedBy?: string | undefined;
+                    curatedAt?: string | undefined;
+                    baseline5Phase?: number | undefined;
+                } | undefined;
+                verification_shadow?: {
+                    type: string;
+                    source: string;
+                } | undefined;
+            };
+            derivedEngine: "regex" | "ast-grep";
+            examplePairHashes: {
+                ordinal: number;
+                hash: string;
+            }[];
+        };
+    };
+    ruleId: string;
     provenance: {
         kind: "authored";
         author: string;
@@ -410,6 +955,13 @@ export declare const AuthoredRuleRecordSchema: z.ZodObject<{
                 kind: "commit";
                 preimageCommitSha: string;
                 mergeCommitSha: string;
+            } | {
+                kind: "record";
+                badExample: string;
+                goodExample: string;
+                ruleId: string;
+                ordinal: number;
+                pairHash: string;
             };
             filePath: string;
             matchedSpan: string;
@@ -429,7 +981,6 @@ export declare const AuthoredRuleRecordSchema: z.ZodObject<{
         }[] | undefined;
     };
     unverified: true;
-    ruleId: string;
     origin: {
         kind: "from-scratch";
     } | {
@@ -437,7 +988,6 @@ export declare const AuthoredRuleRecordSchema: z.ZodObject<{
         sourceRunId: string;
         suggestionHash: string;
     };
-    dslSource: string;
     structuralEligibility: {
         decidable: boolean;
         basis: string;
@@ -447,6 +997,52 @@ export declare const AuthoredRuleRecordSchema: z.ZodObject<{
     authoringLedgerRef: string;
 }>;
 export type AuthoredRuleRecord = z.infer<typeof AuthoredRuleRecordSchema>;
+/**
+ * Prop 310 § Design 10 — the AUTHOR-SIDE positive fixture: the ADR-112 §6 corpus
+ * anchor (`pr` + `filePath` + `matchedSpan` + `contentHash`, the line-drift-stable
+ * locus) plus an ORDINAL REFERENCE into the record's `examples`.
+ *
+ * The author writes the reference; INTAKE derives the fixture's `preimageSource`
+ * from `examples[example]` and the minted `ruleId` (Amendment 1: the record's
+ * `examples` block is the editable home, the envelope derives). So an inline
+ * `preimageSource` here is unknown-key under `.strict()` AND named explicitly by
+ * the intake's migration scan — the author never hand-writes the derived side, and
+ * the derived `AuthoredFixture` never carries the reference back (two homes for
+ * one ordinal is the Tenet-20 mirror).
+ *
+ * Refines are NON-mutating, matching `AuthoredFixtureSchema`'s own hash-stability
+ * discipline: these values land inside the ledger's material hash.
+ */
+export declare const RecordFixtureInputSchema: z.ZodObject<{
+    /** The PR where the defect was caught/introduced (the in-corpus anchor). */
+    pr: z.ZodNumber;
+    /** 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>;
+    /**
+     * The `examples[i]` ordinal this fixture's preimage differential draws from
+     * (§ Design 10's `(ruleId, ordinal)` join key). A dangling ordinal, or two
+     * fixtures of one entry naming the same one, fails LOUD at intake — never a
+     * silent re-pair.
+     */
+    example: z.ZodNumber;
+}, "strict", z.ZodTypeAny, {
+    pr: number;
+    filePath: string;
+    matchedSpan: string;
+    contentHash: string;
+    example: number;
+}, {
+    pr: number;
+    filePath: string;
+    matchedSpan: string;
+    contentHash: string;
+    example: number;
+}>;
+export type RecordFixtureInput = z.infer<typeof RecordFixtureInputSchema>;
 export declare const AuthoredRuleInputSchema: z.ZodObject<{
     /** Agent-id or operator handle — attributable (mirrors the provenance field). Trimmed. */
     author: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
@@ -459,8 +1055,6 @@ export declare const AuthoredRuleInputSchema: z.ZodObject<{
     authoredAt: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
     /** The declared DEFECT the rule targets — the pre-image, not its fix (ADR-110 §4 TP-def). Trimmed. */
     targetDefect: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
-    /** The matcher engine the author declares; the eligibility check confirms it can represent the class. */
-    declaredEngine: z.ZodEnum<["regex", "ast", "ast-grep"]>;
     /**
      * The structural rule-CLASS the author CLAIMS. Fed to the INDEPENDENT
      * `evaluateStructuralEligibility` against the DI whitelist; it is NOT stored
@@ -470,102 +1064,48 @@ export declare const AuthoredRuleInputSchema: z.ZodObject<{
      * cause an exact-match miss against the registry.
      */
     structuralClass: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
-    /** The human-written matcher (same DSL the compiler accepts from the miner). */
-    dslSource: z.ZodEffects<z.ZodString, string, string>;
+    /**
+     * Prop 310 § Design 1 — a repo-relative POSIX reference to the rule record,
+     * `.totem/rules/<slug>.rule.yaml`. THE ONLY rule carrier the envelope accepts
+     * (OQ-1 ruling, records-only): an inline `dslSource` / `declaredEngine` /
+     * `preimageSource` is a migration error the intake rejects BY NAME.
+     *
+     * The path's shape (inside `<totemDir>/rules/`, `*.rule.yaml`, no `..`) is
+     * checked at the intake seam, which has the filesystem; this schema only pins
+     * it to a non-empty string. Trimmed: the path is NOT hash material (§ Design 1
+     * — a rename must not force re-attestation), so normalising it costs nothing
+     * and stops a stray space from becoming an unresolvable reference.
+     */
+    record: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
     /** ≥1 real lc instance the rule claims to catch — ALL train-side (§5). */
-    positiveFixtures: z.ZodArray<z.ZodEffects<z.ZodObject<{
+    positiveFixtures: z.ZodArray<z.ZodObject<{
+        /** The PR where the defect was caught/introduced (the in-corpus anchor). */
         pr: z.ZodNumber;
-        preimageSource: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
-            kind: z.ZodLiteral<"lesson">;
-            lessonRef: z.ZodString;
-            badExample: z.ZodEffects<z.ZodString, string, string>;
-            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">;
-            preimageCommitSha: z.ZodString;
-            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>;
+        /**
+         * The `examples[i]` ordinal this fixture's preimage differential draws from
+         * (§ Design 10's `(ruleId, ordinal)` join key). A dangling ordinal, or two
+         * fixtures of one entry naming the same one, fails LOUD at intake — never a
+         * silent re-pair.
+         */
+        example: z.ZodNumber;
     }, "strict", z.ZodTypeAny, {
         pr: number;
-        preimageSource: {
-            kind: "lesson";
-            lessonRef: string;
-            badExample: string;
-            goodExample: string;
-        } | {
-            kind: "commit";
-            preimageCommitSha: string;
-            mergeCommitSha: string;
-        };
-        filePath: string;
-        matchedSpan: string;
-        contentHash: string;
-    }, {
-        pr: number;
-        preimageSource: {
-            kind: "lesson";
-            lessonRef: string;
-            badExample: string;
-            goodExample: string;
-        } | {
-            kind: "commit";
-            preimageCommitSha: string;
-            mergeCommitSha: string;
-        };
-        filePath: string;
-        matchedSpan: string;
-        contentHash: string;
-    }>, {
-        pr: number;
-        preimageSource: {
-            kind: "lesson";
-            lessonRef: string;
-            badExample: string;
-            goodExample: string;
-        } | {
-            kind: "commit";
-            preimageCommitSha: string;
-            mergeCommitSha: string;
-        };
         filePath: string;
         matchedSpan: string;
         contentHash: string;
+        example: number;
     }, {
         pr: number;
-        preimageSource: {
-            kind: "lesson";
-            lessonRef: string;
-            badExample: string;
-            goodExample: string;
-        } | {
-            kind: "commit";
-            preimageCommitSha: string;
-            mergeCommitSha: string;
-        };
         filePath: string;
         matchedSpan: string;
         contentHash: string;
+        example: number;
     }>, "many">;
     /**
      * Declared SILENCE-ONLY near-misses the rule must stay silent on (feeds §6
@@ -645,27 +1185,17 @@ export declare const AuthoredRuleInputSchema: z.ZodObject<{
         suggestionHash: string;
     }>]>>;
 }, "strict", z.ZodTypeAny, {
+    record: string;
     author: string;
     authoredAt: string;
     targetDefect: string;
     positiveFixtures: {
         pr: number;
-        preimageSource: {
-            kind: "lesson";
-            lessonRef: string;
-            badExample: string;
-            goodExample: string;
-        } | {
-            kind: "commit";
-            preimageCommitSha: string;
-            mergeCommitSha: string;
-        };
         filePath: string;
         matchedSpan: string;
         contentHash: string;
+        example: number;
     }[];
-    dslSource: string;
-    declaredEngine: "regex" | "ast" | "ast-grep";
     structuralClass: string;
     negativeFixtures?: {
         filePath: string;
@@ -687,27 +1217,17 @@ export declare const AuthoredRuleInputSchema: z.ZodObject<{
         suggestionHash: string;
     } | undefined;
 }, {
+    record: string;
     author: string;
     authoredAt: string;
     targetDefect: string;
     positiveFixtures: {
         pr: number;
-        preimageSource: {
-            kind: "lesson";
-            lessonRef: string;
-            badExample: string;
-            goodExample: string;
-        } | {
-            kind: "commit";
-            preimageCommitSha: string;
-            mergeCommitSha: string;
-        };
         filePath: string;
         matchedSpan: string;
         contentHash: string;
+        example: number;
     }[];
-    dslSource: string;
-    declaredEngine: "regex" | "ast" | "ast-grep";
     structuralClass: string;
     negativeFixtures?: {
         filePath: string;
@@ -771,8 +1291,6 @@ export declare const AuthoredRulesFileSchema: z.ZodObject<{
         authoredAt: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
         /** The declared DEFECT the rule targets — the pre-image, not its fix (ADR-110 §4 TP-def). Trimmed. */
         targetDefect: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
-        /** The matcher engine the author declares; the eligibility check confirms it can represent the class. */
-        declaredEngine: z.ZodEnum<["regex", "ast", "ast-grep"]>;
         /**
          * The structural rule-CLASS the author CLAIMS. Fed to the INDEPENDENT
          * `evaluateStructuralEligibility` against the DI whitelist; it is NOT stored
@@ -782,102 +1300,48 @@ export declare const AuthoredRulesFileSchema: z.ZodObject<{
          * cause an exact-match miss against the registry.
          */
         structuralClass: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
-        /** The human-written matcher (same DSL the compiler accepts from the miner). */
-        dslSource: z.ZodEffects<z.ZodString, string, string>;
+        /**
+         * Prop 310 § Design 1 — a repo-relative POSIX reference to the rule record,
+         * `.totem/rules/<slug>.rule.yaml`. THE ONLY rule carrier the envelope accepts
+         * (OQ-1 ruling, records-only): an inline `dslSource` / `declaredEngine` /
+         * `preimageSource` is a migration error the intake rejects BY NAME.
+         *
+         * The path's shape (inside `<totemDir>/rules/`, `*.rule.yaml`, no `..`) is
+         * checked at the intake seam, which has the filesystem; this schema only pins
+         * it to a non-empty string. Trimmed: the path is NOT hash material (§ Design 1
+         * — a rename must not force re-attestation), so normalising it costs nothing
+         * and stops a stray space from becoming an unresolvable reference.
+         */
+        record: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
         /** ≥1 real lc instance the rule claims to catch — ALL train-side (§5). */
-        positiveFixtures: z.ZodArray<z.ZodEffects<z.ZodObject<{
+        positiveFixtures: z.ZodArray<z.ZodObject<{
+            /** The PR where the defect was caught/introduced (the in-corpus anchor). */
             pr: z.ZodNumber;
-            preimageSource: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
-                kind: z.ZodLiteral<"lesson">;
-                lessonRef: z.ZodString;
-                badExample: z.ZodEffects<z.ZodString, string, string>;
-                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">;
-                preimageCommitSha: z.ZodString;
-                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>;
+            /**
+             * The `examples[i]` ordinal this fixture's preimage differential draws from
+             * (§ Design 10's `(ruleId, ordinal)` join key). A dangling ordinal, or two
+             * fixtures of one entry naming the same one, fails LOUD at intake — never a
+             * silent re-pair.
+             */
+            example: z.ZodNumber;
         }, "strict", z.ZodTypeAny, {
             pr: number;
-            preimageSource: {
-                kind: "lesson";
-                lessonRef: string;
-                badExample: string;
-                goodExample: string;
-            } | {
-                kind: "commit";
-                preimageCommitSha: string;
-                mergeCommitSha: string;
-            };
             filePath: string;
             matchedSpan: string;
             contentHash: string;
+            example: number;
         }, {
             pr: number;
-            preimageSource: {
-                kind: "lesson";
-                lessonRef: string;
-                badExample: string;
-                goodExample: string;
-            } | {
-                kind: "commit";
-                preimageCommitSha: string;
-                mergeCommitSha: string;
-            };
-            filePath: string;
-            matchedSpan: string;
-            contentHash: string;
-        }>, {
-            pr: number;
-            preimageSource: {
-                kind: "lesson";
-                lessonRef: string;
-                badExample: string;
-                goodExample: string;
-            } | {
-                kind: "commit";
-                preimageCommitSha: string;
-                mergeCommitSha: string;
-            };
-            filePath: string;
-            matchedSpan: string;
-            contentHash: string;
-        }, {
-            pr: number;
-            preimageSource: {
-                kind: "lesson";
-                lessonRef: string;
-                badExample: string;
-                goodExample: string;
-            } | {
-                kind: "commit";
-                preimageCommitSha: string;
-                mergeCommitSha: string;
-            };
             filePath: string;
             matchedSpan: string;
             contentHash: string;
+            example: number;
         }>, "many">;
         /**
          * Declared SILENCE-ONLY near-misses the rule must stay silent on (feeds §6
@@ -957,27 +1421,17 @@ export declare const AuthoredRulesFileSchema: z.ZodObject<{
             suggestionHash: string;
         }>]>>;
     }, "strict", z.ZodTypeAny, {
+        record: string;
         author: string;
         authoredAt: string;
         targetDefect: string;
         positiveFixtures: {
             pr: number;
-            preimageSource: {
-                kind: "lesson";
-                lessonRef: string;
-                badExample: string;
-                goodExample: string;
-            } | {
-                kind: "commit";
-                preimageCommitSha: string;
-                mergeCommitSha: string;
-            };
             filePath: string;
             matchedSpan: string;
             contentHash: string;
+            example: number;
         }[];
-        dslSource: string;
-        declaredEngine: "regex" | "ast" | "ast-grep";
         structuralClass: string;
         negativeFixtures?: {
             filePath: string;
@@ -999,27 +1453,17 @@ export declare const AuthoredRulesFileSchema: z.ZodObject<{
             suggestionHash: string;
         } | undefined;
     }, {
+        record: string;
         author: string;
         authoredAt: string;
         targetDefect: string;
         positiveFixtures: {
             pr: number;
-            preimageSource: {
-                kind: "lesson";
-                lessonRef: string;
-                badExample: string;
-                goodExample: string;
-            } | {
-                kind: "commit";
-                preimageCommitSha: string;
-                mergeCommitSha: string;
-            };
             filePath: string;
             matchedSpan: string;
             contentHash: string;
+            example: number;
         }[];
-        dslSource: string;
-        declaredEngine: "regex" | "ast" | "ast-grep";
         structuralClass: string;
         negativeFixtures?: {
             filePath: string;
@@ -1043,27 +1487,17 @@ export declare const AuthoredRulesFileSchema: z.ZodObject<{
     }>, "many">;
 }, "strict", z.ZodTypeAny, {
     rules: {
+        record: string;
         author: string;
         authoredAt: string;
         targetDefect: string;
         positiveFixtures: {
             pr: number;
-            preimageSource: {
-                kind: "lesson";
-                lessonRef: string;
-                badExample: string;
-                goodExample: string;
-            } | {
-                kind: "commit";
-                preimageCommitSha: string;
-                mergeCommitSha: string;
-            };
             filePath: string;
             matchedSpan: string;
             contentHash: string;
+            example: number;
         }[];
-        dslSource: string;
-        declaredEngine: "regex" | "ast" | "ast-grep";
         structuralClass: string;
         negativeFixtures?: {
             filePath: string;
@@ -1091,27 +1525,17 @@ export declare const AuthoredRulesFileSchema: z.ZodObject<{
     freezeCommitment?: string | undefined;
 }, {
     rules: {
+        record: string;
         author: string;
         authoredAt: string;
         targetDefect: string;
         positiveFixtures: {
             pr: number;
-            preimageSource: {
-                kind: "lesson";
-                lessonRef: string;
-                badExample: string;
-                goodExample: string;
-            } | {
-                kind: "commit";
-                preimageCommitSha: string;
-                mergeCommitSha: string;
-            };
             filePath: string;
             matchedSpan: string;
             contentHash: string;
+            example: number;
         }[];
-        dslSource: string;
-        declaredEngine: "regex" | "ast" | "ast-grep";
         structuralClass: string;
         negativeFixtures?: {
             filePath: string;