@mmnto/totem 1.78.0 → 1.79.0

package/dist/compiler-schema.d.ts

@@ -45,8 +45,25 @@ export type AstGrepYamlRule = NapiConfig;
  * zero-trust), the single source of truth `deriveRuleClass` reads. Control
  * *evidence* (which PRs/fixtures proved each control) rides the wind-tunnel
  * manifest (ADR-110 §6), not the per-rule marker.
+ *
+ * **ADR-112 — this is the MINED variant of the `ProvenanceRecord` union.** The
+ * wire shape is otherwise UNCHANGED: `kind` is OPTIONAL and absent on every
+ * pre-ADR-112 record, so a legacy mined provenance parses + reserializes
+ * BYTE-IDENTICAL (no added key — `canonicalStringify` omits the undefined
+ * discriminator exactly as it omits an absent `unverified`), preserving the
+ * non-mutating-refine manifest-hash discipline. Absence ⇒ `'mined'` via
+ * `provenanceKind()`; the miner path types its provenance as
+ * `MinedProvenanceRecord` (the documented mining-only boundary), so its readers
+ * of `mergedPr` / `commitSha` stay type-safe without narrowing.
  */
-export declare const ProvenanceRecordSchema: z.ZodObject<{
+export declare const MinedProvenanceWireSchema: z.ZodObject<{
+    /**
+     * ADR-112 discriminator. OPTIONAL on the mined wire so legacy records (which
+     * have no `kind`) round-trip byte-identical; absence is read as `'mined'` by
+     * `provenanceKind()`. A new mined artifact MAY carry `kind: 'mined'` only
+     * where the resulting hash churn is intentional.
+     */
+    kind: z.ZodOptional<z.ZodLiteral<"mined">>;
     /** Merged PR the rule was mined from (positive integer PR number). */
     mergedPr: z.ZodNumber;
     /**
@@ -64,12 +81,333 @@ export declare const ProvenanceRecordSchema: z.ZodObject<{
     mergedPr: number;
     reviewThread: string;
     commitSha: string;
+    kind?: "mined" | undefined;
 }, {
     mergedPr: number;
     reviewThread: string;
     commitSha: string;
+    kind?: "mined" | undefined;
 }>;
+export type MinedProvenanceRecord = z.infer<typeof MinedProvenanceWireSchema>;
+/**
+ * ADR-112 §3 — one real lc instance an authored rule claims to catch. ALL such
+ * fixtures are TRAIN-side (the §5 leakage guard); the preimage-differential
+ * (§4) is evaluated in slice C/D, but the record must CARRY both commits + the
+ * defect locus here so derivation is possible. `matchedSpan` + `contentHash`
+ * are the line-drift-stable locus (cf. `firingLabelId`), not just the file.
+ */
+export declare const AuthoredFixtureSchema: z.ZodObject<{
+    /** The PR whose merge introduced the fix (the in-corpus anchor). */
+    pr: z.ZodNumber;
+    /** The PR's merge/squash commit — the post-fix (defect-absent) anchor. */
+    mergeCommitSha: z.ZodString;
+    /** The PARENT (pre-fix) commit where the DEFECT is present (ADR-112 §4). */
+    preimageCommitSha: z.ZodString;
+    /** File the defect locus lives in. */
+    filePath: z.ZodEffects<z.ZodString, string, string>;
+    /** Line-range or AST-node path — the defect locus, not just the file. */
+    matchedSpan: z.ZodEffects<z.ZodString, string, string>;
+    /** Span content hash, line-drift-stable (cf. `firingLabelId`). */
+    contentHash: z.ZodEffects<z.ZodString, string, string>;
+}, "strip", z.ZodTypeAny, {
+    pr: number;
+    mergeCommitSha: string;
+    preimageCommitSha: string;
+    filePath: string;
+    matchedSpan: string;
+    contentHash: string;
+}, {
+    pr: number;
+    mergeCommitSha: string;
+    preimageCommitSha: string;
+    filePath: string;
+    matchedSpan: string;
+    contentHash: string;
+}>;
+export type AuthoredFixture = z.infer<typeof AuthoredFixtureSchema>;
+/**
+ * ADR-112 §3 — the AUTHORED variant of the `ProvenanceRecord` union. A
+ * hand-authored rule is anchored to a real historical DEFECT (the pre-image,
+ * NOT its fix — ADR-110 §4 TP-def) via ≥1 train-side `positiveFixtures` entry.
+ * `kind: 'authored'` is REQUIRED (the discriminator), so this can never be
+ * mistaken for a mined record and an authored record can never round-trip as
+ * mined. Attributable (`author` never anonymous); the embargo/ledger
+ * attestations ride the §8 authoring-ledger, not this marker.
+ */
+export declare const AuthoredProvenanceRecordSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"authored">;
+    /** Agent-id or operator handle — attributable, never anonymous. */
+    author: z.ZodEffects<z.ZodString, string, string>;
+    /** ISO-8601 authoring date — a real calendar date (`YYYY-MM-DD`) or a full timestamp. */
+    authoredAt: z.ZodEffects<z.ZodString, string, string>;
+    /** The declared DEFECT the rule targets — the pre-image, not its fix. */
+    targetDefect: z.ZodEffects<z.ZodString, string, string>;
+    /** ≥1 real lc instance the rule claims to catch — ALL train-side (§5). */
+    positiveFixtures: z.ZodArray<z.ZodObject<{
+        /** The PR whose merge introduced the fix (the in-corpus anchor). */
+        pr: z.ZodNumber;
+        /** The PR's merge/squash commit — the post-fix (defect-absent) anchor. */
+        mergeCommitSha: z.ZodString;
+        /** The PARENT (pre-fix) commit where the DEFECT is present (ADR-112 §4). */
+        preimageCommitSha: z.ZodString;
+        /** File the defect locus lives in. */
+        filePath: z.ZodEffects<z.ZodString, string, string>;
+        /** Line-range or AST-node path — the defect locus, not just the file. */
+        matchedSpan: z.ZodEffects<z.ZodString, string, string>;
+        /** Span content hash, line-drift-stable (cf. `firingLabelId`). */
+        contentHash: z.ZodEffects<z.ZodString, string, string>;
+    }, "strip", z.ZodTypeAny, {
+        pr: number;
+        mergeCommitSha: string;
+        preimageCommitSha: string;
+        filePath: string;
+        matchedSpan: string;
+        contentHash: string;
+    }, {
+        pr: number;
+        mergeCommitSha: string;
+        preimageCommitSha: string;
+        filePath: string;
+        matchedSpan: string;
+        contentHash: string;
+    }>, "many">;
+    /** Declared near-misses the rule must stay silent on (feeds §6 negative controls). */
+    negativeFixtures: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        /** The PR whose merge introduced the fix (the in-corpus anchor). */
+        pr: z.ZodNumber;
+        /** The PR's merge/squash commit — the post-fix (defect-absent) anchor. */
+        mergeCommitSha: z.ZodString;
+        /** The PARENT (pre-fix) commit where the DEFECT is present (ADR-112 §4). */
+        preimageCommitSha: z.ZodString;
+        /** File the defect locus lives in. */
+        filePath: z.ZodEffects<z.ZodString, string, string>;
+        /** Line-range or AST-node path — the defect locus, not just the file. */
+        matchedSpan: z.ZodEffects<z.ZodString, string, string>;
+        /** Span content hash, line-drift-stable (cf. `firingLabelId`). */
+        contentHash: z.ZodEffects<z.ZodString, string, string>;
+    }, "strip", z.ZodTypeAny, {
+        pr: number;
+        mergeCommitSha: string;
+        preimageCommitSha: string;
+        filePath: string;
+        matchedSpan: string;
+        contentHash: string;
+    }, {
+        pr: number;
+        mergeCommitSha: string;
+        preimageCommitSha: string;
+        filePath: string;
+        matchedSpan: string;
+        contentHash: string;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    kind: "authored";
+    author: string;
+    authoredAt: string;
+    targetDefect: string;
+    positiveFixtures: {
+        pr: number;
+        mergeCommitSha: string;
+        preimageCommitSha: string;
+        filePath: string;
+        matchedSpan: string;
+        contentHash: string;
+    }[];
+    negativeFixtures?: {
+        pr: number;
+        mergeCommitSha: string;
+        preimageCommitSha: string;
+        filePath: string;
+        matchedSpan: string;
+        contentHash: string;
+    }[] | undefined;
+}, {
+    kind: "authored";
+    author: string;
+    authoredAt: string;
+    targetDefect: string;
+    positiveFixtures: {
+        pr: number;
+        mergeCommitSha: string;
+        preimageCommitSha: string;
+        filePath: string;
+        matchedSpan: string;
+        contentHash: string;
+    }[];
+    negativeFixtures?: {
+        pr: number;
+        mergeCommitSha: string;
+        preimageCommitSha: string;
+        filePath: string;
+        matchedSpan: string;
+        contentHash: string;
+    }[] | undefined;
+}>;
+export type AuthoredProvenanceRecord = z.infer<typeof AuthoredProvenanceRecordSchema>;
+/**
+ * ADR-112 §3 — `provenance` is a discriminated UNION on `kind`
+ * (`mined | authored`), the first multi-producer attribute on a rule
+ * (Consequence 3). Built as a `z.union` (NOT `z.discriminatedUnion`) on
+ * purpose: the mined wire keeps `kind` OPTIONAL for byte-identical legacy
+ * round-trip, which a required-discriminator schema cannot express. The two
+ * branches are disjoint on their required fields (`authored` requires
+ * `kind:'authored'` + author/targetDefect/fixtures; the mined branch is the
+ * only one a legacy `{mergedPr, reviewThread, commitSha}` record satisfies), so
+ * the union is unambiguous. `Authored` is listed FIRST so a record carrying
+ * `kind:'authored'` never matches the mined branch.
+ */
+export declare const ProvenanceRecordSchema: z.ZodUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"authored">;
+    /** Agent-id or operator handle — attributable, never anonymous. */
+    author: z.ZodEffects<z.ZodString, string, string>;
+    /** ISO-8601 authoring date — a real calendar date (`YYYY-MM-DD`) or a full timestamp. */
+    authoredAt: z.ZodEffects<z.ZodString, string, string>;
+    /** The declared DEFECT the rule targets — the pre-image, not its fix. */
+    targetDefect: z.ZodEffects<z.ZodString, string, string>;
+    /** ≥1 real lc instance the rule claims to catch — ALL train-side (§5). */
+    positiveFixtures: z.ZodArray<z.ZodObject<{
+        /** The PR whose merge introduced the fix (the in-corpus anchor). */
+        pr: z.ZodNumber;
+        /** The PR's merge/squash commit — the post-fix (defect-absent) anchor. */
+        mergeCommitSha: z.ZodString;
+        /** The PARENT (pre-fix) commit where the DEFECT is present (ADR-112 §4). */
+        preimageCommitSha: z.ZodString;
+        /** File the defect locus lives in. */
+        filePath: z.ZodEffects<z.ZodString, string, string>;
+        /** Line-range or AST-node path — the defect locus, not just the file. */
+        matchedSpan: z.ZodEffects<z.ZodString, string, string>;
+        /** Span content hash, line-drift-stable (cf. `firingLabelId`). */
+        contentHash: z.ZodEffects<z.ZodString, string, string>;
+    }, "strip", z.ZodTypeAny, {
+        pr: number;
+        mergeCommitSha: string;
+        preimageCommitSha: string;
+        filePath: string;
+        matchedSpan: string;
+        contentHash: string;
+    }, {
+        pr: number;
+        mergeCommitSha: string;
+        preimageCommitSha: string;
+        filePath: string;
+        matchedSpan: string;
+        contentHash: string;
+    }>, "many">;
+    /** Declared near-misses the rule must stay silent on (feeds §6 negative controls). */
+    negativeFixtures: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        /** The PR whose merge introduced the fix (the in-corpus anchor). */
+        pr: z.ZodNumber;
+        /** The PR's merge/squash commit — the post-fix (defect-absent) anchor. */
+        mergeCommitSha: z.ZodString;
+        /** The PARENT (pre-fix) commit where the DEFECT is present (ADR-112 §4). */
+        preimageCommitSha: z.ZodString;
+        /** File the defect locus lives in. */
+        filePath: z.ZodEffects<z.ZodString, string, string>;
+        /** Line-range or AST-node path — the defect locus, not just the file. */
+        matchedSpan: z.ZodEffects<z.ZodString, string, string>;
+        /** Span content hash, line-drift-stable (cf. `firingLabelId`). */
+        contentHash: z.ZodEffects<z.ZodString, string, string>;
+    }, "strip", z.ZodTypeAny, {
+        pr: number;
+        mergeCommitSha: string;
+        preimageCommitSha: string;
+        filePath: string;
+        matchedSpan: string;
+        contentHash: string;
+    }, {
+        pr: number;
+        mergeCommitSha: string;
+        preimageCommitSha: string;
+        filePath: string;
+        matchedSpan: string;
+        contentHash: string;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    kind: "authored";
+    author: string;
+    authoredAt: string;
+    targetDefect: string;
+    positiveFixtures: {
+        pr: number;
+        mergeCommitSha: string;
+        preimageCommitSha: string;
+        filePath: string;
+        matchedSpan: string;
+        contentHash: string;
+    }[];
+    negativeFixtures?: {
+        pr: number;
+        mergeCommitSha: string;
+        preimageCommitSha: string;
+        filePath: string;
+        matchedSpan: string;
+        contentHash: string;
+    }[] | undefined;
+}, {
+    kind: "authored";
+    author: string;
+    authoredAt: string;
+    targetDefect: string;
+    positiveFixtures: {
+        pr: number;
+        mergeCommitSha: string;
+        preimageCommitSha: string;
+        filePath: string;
+        matchedSpan: string;
+        contentHash: string;
+    }[];
+    negativeFixtures?: {
+        pr: number;
+        mergeCommitSha: string;
+        preimageCommitSha: string;
+        filePath: string;
+        matchedSpan: string;
+        contentHash: string;
+    }[] | undefined;
+}>, z.ZodObject<{
+    /**
+     * ADR-112 discriminator. OPTIONAL on the mined wire so legacy records (which
+     * have no `kind`) round-trip byte-identical; absence is read as `'mined'` by
+     * `provenanceKind()`. A new mined artifact MAY carry `kind: 'mined'` only
+     * where the resulting hash churn is intentional.
+     */
+    kind: z.ZodOptional<z.ZodLiteral<"mined">>;
+    /** Merged PR the rule was mined from (positive integer PR number). */
+    mergedPr: z.ZodNumber;
+    /**
+     * Reference to the review thread that adjudicated the rule. Rejects empty and
+     * whitespace-only via a NON-MUTATING refinement (greptile/CR #2186): a
+     * `.trim()` transform would silently normalize a padded value on parse, so a
+     * stamped rule's on-disk JSON could differ from its parsed form and churn the
+     * manifest hash on the next `verify-manifest`. `.refine` validates without
+     * mutating, so the stored value round-trips byte-identically.
+     */
+    reviewThread: z.ZodEffects<z.ZodString, string, string>;
+    /** Full 40-hex git commit SHA the rule was frozen at. */
+    commitSha: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    mergedPr: number;
+    reviewThread: string;
+    commitSha: string;
+    kind?: "mined" | undefined;
+}, {
+    mergedPr: number;
+    reviewThread: string;
+    commitSha: string;
+    kind?: "mined" | undefined;
+}>]>;
 export type ProvenanceRecord = z.infer<typeof ProvenanceRecordSchema>;
+/**
+ * ADR-112 — the canonical reader of a provenance record's producer kind. An
+ * absent discriminator (every legacy mined record) reads as `'mined'`. Use this
+ * + the guards below instead of touching `.kind` directly, so the
+ * absent-⇒-mined default lives in exactly one place (Tenet 20).
+ */
+export declare function provenanceKind(p: ProvenanceRecord): 'mined' | 'authored';
+/** ADR-112 — type-narrowing guard for the mined branch (mined-only field reads). */
+export declare function isMinedProvenance(p: ProvenanceRecord): p is MinedProvenanceRecord;
+/** ADR-112 — type-narrowing guard for the authored branch. */
+export declare function isAuthoredProvenance(p: ProvenanceRecord): p is AuthoredProvenanceRecord;
 /**
  * mmnto-ai/totem#2183 — the three **peer** legs of the ADR-110 §3 legitimacy
  * bar, mapping 1:1 onto the strategy#666 Tenet-9 three-check so the Gate-1
@@ -80,7 +418,122 @@ export type ProvenanceRecord = z.infer<typeof ProvenanceRecordSchema>;
  * failed one); the evidence behind each pass lives in the wind-tunnel manifest.
  */
 export declare const LegitimacySchema: z.ZodObject<{
-    provenance: z.ZodObject<{
+    provenance: z.ZodUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"authored">;
+        /** Agent-id or operator handle — attributable, never anonymous. */
+        author: z.ZodEffects<z.ZodString, string, string>;
+        /** ISO-8601 authoring date — a real calendar date (`YYYY-MM-DD`) or a full timestamp. */
+        authoredAt: z.ZodEffects<z.ZodString, string, string>;
+        /** The declared DEFECT the rule targets — the pre-image, not its fix. */
+        targetDefect: z.ZodEffects<z.ZodString, string, string>;
+        /** ≥1 real lc instance the rule claims to catch — ALL train-side (§5). */
+        positiveFixtures: z.ZodArray<z.ZodObject<{
+            /** The PR whose merge introduced the fix (the in-corpus anchor). */
+            pr: z.ZodNumber;
+            /** The PR's merge/squash commit — the post-fix (defect-absent) anchor. */
+            mergeCommitSha: z.ZodString;
+            /** The PARENT (pre-fix) commit where the DEFECT is present (ADR-112 §4). */
+            preimageCommitSha: z.ZodString;
+            /** File the defect locus lives in. */
+            filePath: z.ZodEffects<z.ZodString, string, string>;
+            /** Line-range or AST-node path — the defect locus, not just the file. */
+            matchedSpan: z.ZodEffects<z.ZodString, string, string>;
+            /** Span content hash, line-drift-stable (cf. `firingLabelId`). */
+            contentHash: z.ZodEffects<z.ZodString, string, string>;
+        }, "strip", z.ZodTypeAny, {
+            pr: number;
+            mergeCommitSha: string;
+            preimageCommitSha: string;
+            filePath: string;
+            matchedSpan: string;
+            contentHash: string;
+        }, {
+            pr: number;
+            mergeCommitSha: string;
+            preimageCommitSha: string;
+            filePath: string;
+            matchedSpan: string;
+            contentHash: string;
+        }>, "many">;
+        /** Declared near-misses the rule must stay silent on (feeds §6 negative controls). */
+        negativeFixtures: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            /** The PR whose merge introduced the fix (the in-corpus anchor). */
+            pr: z.ZodNumber;
+            /** The PR's merge/squash commit — the post-fix (defect-absent) anchor. */
+            mergeCommitSha: z.ZodString;
+            /** The PARENT (pre-fix) commit where the DEFECT is present (ADR-112 §4). */
+            preimageCommitSha: z.ZodString;
+            /** File the defect locus lives in. */
+            filePath: z.ZodEffects<z.ZodString, string, string>;
+            /** Line-range or AST-node path — the defect locus, not just the file. */
+            matchedSpan: z.ZodEffects<z.ZodString, string, string>;
+            /** Span content hash, line-drift-stable (cf. `firingLabelId`). */
+            contentHash: z.ZodEffects<z.ZodString, string, string>;
+        }, "strip", z.ZodTypeAny, {
+            pr: number;
+            mergeCommitSha: string;
+            preimageCommitSha: string;
+            filePath: string;
+            matchedSpan: string;
+            contentHash: string;
+        }, {
+            pr: number;
+            mergeCommitSha: string;
+            preimageCommitSha: string;
+            filePath: string;
+            matchedSpan: string;
+            contentHash: string;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        kind: "authored";
+        author: string;
+        authoredAt: string;
+        targetDefect: string;
+        positiveFixtures: {
+            pr: number;
+            mergeCommitSha: string;
+            preimageCommitSha: string;
+            filePath: string;
+            matchedSpan: string;
+            contentHash: string;
+        }[];
+        negativeFixtures?: {
+            pr: number;
+            mergeCommitSha: string;
+            preimageCommitSha: string;
+            filePath: string;
+            matchedSpan: string;
+            contentHash: string;
+        }[] | undefined;
+    }, {
+        kind: "authored";
+        author: string;
+        authoredAt: string;
+        targetDefect: string;
+        positiveFixtures: {
+            pr: number;
+            mergeCommitSha: string;
+            preimageCommitSha: string;
+            filePath: string;
+            matchedSpan: string;
+            contentHash: string;
+        }[];
+        negativeFixtures?: {
+            pr: number;
+            mergeCommitSha: string;
+            preimageCommitSha: string;
+            filePath: string;
+            matchedSpan: string;
+            contentHash: string;
+        }[] | undefined;
+    }>, z.ZodObject<{
+        /**
+         * ADR-112 discriminator. OPTIONAL on the mined wire so legacy records (which
+         * have no `kind`) round-trip byte-identical; absence is read as `'mined'` by
+         * `provenanceKind()`. A new mined artifact MAY carry `kind: 'mined'` only
+         * where the resulting hash churn is intentional.
+         */
+        kind: z.ZodOptional<z.ZodLiteral<"mined">>;
         /** Merged PR the rule was mined from (positive integer PR number). */
         mergedPr: z.ZodNumber;
         /**
@@ -98,11 +551,13 @@ export declare const LegitimacySchema: z.ZodObject<{
         mergedPr: number;
         reviewThread: string;
         commitSha: string;
+        kind?: "mined" | undefined;
     }, {
         mergedPr: number;
         reviewThread: string;
         commitSha: string;
-    }>;
+        kind?: "mined" | undefined;
+    }>]>;
     positiveControl: z.ZodBoolean;
     negativeControl: z.ZodBoolean;
 }, "strip", z.ZodTypeAny, {
@@ -110,6 +565,28 @@ export declare const LegitimacySchema: z.ZodObject<{
         mergedPr: number;
         reviewThread: string;
         commitSha: string;
+        kind?: "mined" | undefined;
+    } | {
+        kind: "authored";
+        author: string;
+        authoredAt: string;
+        targetDefect: string;
+        positiveFixtures: {
+            pr: number;
+            mergeCommitSha: string;
+            preimageCommitSha: string;
+            filePath: string;
+            matchedSpan: string;
+            contentHash: string;
+        }[];
+        negativeFixtures?: {
+            pr: number;
+            mergeCommitSha: string;
+            preimageCommitSha: string;
+            filePath: string;
+            matchedSpan: string;
+            contentHash: string;
+        }[] | undefined;
     };
     positiveControl: boolean;
     negativeControl: boolean;
@@ -118,6 +595,28 @@ export declare const LegitimacySchema: z.ZodObject<{
         mergedPr: number;
         reviewThread: string;
         commitSha: string;
+        kind?: "mined" | undefined;
+    } | {
+        kind: "authored";
+        author: string;
+        authoredAt: string;
+        targetDefect: string;
+        positiveFixtures: {
+            pr: number;
+            mergeCommitSha: string;
+            preimageCommitSha: string;
+            filePath: string;
+            matchedSpan: string;
+            contentHash: string;
+        }[];
+        negativeFixtures?: {
+            pr: number;
+            mergeCommitSha: string;
+            preimageCommitSha: string;
+            filePath: string;
+            matchedSpan: string;
+            contentHash: string;
+        }[] | undefined;
     };
     positiveControl: boolean;
     negativeControl: boolean;
@@ -309,7 +808,122 @@ export declare const CompiledRuleSchema: z.ZodEffects<z.ZodObject<{
      * signal and preserves pre-#2183 manifest hashes via canonicalStringify.
      */
     legitimacy: z.ZodOptional<z.ZodObject<{
-        provenance: z.ZodObject<{
+        provenance: z.ZodUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"authored">;
+            /** Agent-id or operator handle — attributable, never anonymous. */
+            author: z.ZodEffects<z.ZodString, string, string>;
+            /** ISO-8601 authoring date — a real calendar date (`YYYY-MM-DD`) or a full timestamp. */
+            authoredAt: z.ZodEffects<z.ZodString, string, string>;
+            /** The declared DEFECT the rule targets — the pre-image, not its fix. */
+            targetDefect: z.ZodEffects<z.ZodString, string, string>;
+            /** ≥1 real lc instance the rule claims to catch — ALL train-side (§5). */
+            positiveFixtures: z.ZodArray<z.ZodObject<{
+                /** The PR whose merge introduced the fix (the in-corpus anchor). */
+                pr: z.ZodNumber;
+                /** The PR's merge/squash commit — the post-fix (defect-absent) anchor. */
+                mergeCommitSha: z.ZodString;
+                /** The PARENT (pre-fix) commit where the DEFECT is present (ADR-112 §4). */
+                preimageCommitSha: z.ZodString;
+                /** File the defect locus lives in. */
+                filePath: z.ZodEffects<z.ZodString, string, string>;
+                /** Line-range or AST-node path — the defect locus, not just the file. */
+                matchedSpan: z.ZodEffects<z.ZodString, string, string>;
+                /** Span content hash, line-drift-stable (cf. `firingLabelId`). */
+                contentHash: z.ZodEffects<z.ZodString, string, string>;
+            }, "strip", z.ZodTypeAny, {
+                pr: number;
+                mergeCommitSha: string;
+                preimageCommitSha: string;
+                filePath: string;
+                matchedSpan: string;
+                contentHash: string;
+            }, {
+                pr: number;
+                mergeCommitSha: string;
+                preimageCommitSha: string;
+                filePath: string;
+                matchedSpan: string;
+                contentHash: string;
+            }>, "many">;
+            /** Declared near-misses the rule must stay silent on (feeds §6 negative controls). */
+            negativeFixtures: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                /** The PR whose merge introduced the fix (the in-corpus anchor). */
+                pr: z.ZodNumber;
+                /** The PR's merge/squash commit — the post-fix (defect-absent) anchor. */
+                mergeCommitSha: z.ZodString;
+                /** The PARENT (pre-fix) commit where the DEFECT is present (ADR-112 §4). */
+                preimageCommitSha: z.ZodString;
+                /** File the defect locus lives in. */
+                filePath: z.ZodEffects<z.ZodString, string, string>;
+                /** Line-range or AST-node path — the defect locus, not just the file. */
+                matchedSpan: z.ZodEffects<z.ZodString, string, string>;
+                /** Span content hash, line-drift-stable (cf. `firingLabelId`). */
+                contentHash: z.ZodEffects<z.ZodString, string, string>;
+            }, "strip", z.ZodTypeAny, {
+                pr: number;
+                mergeCommitSha: string;
+                preimageCommitSha: string;
+                filePath: string;
+                matchedSpan: string;
+                contentHash: string;
+            }, {
+                pr: number;
+                mergeCommitSha: string;
+                preimageCommitSha: string;
+                filePath: string;
+                matchedSpan: string;
+                contentHash: string;
+            }>, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            kind: "authored";
+            author: string;
+            authoredAt: string;
+            targetDefect: string;
+            positiveFixtures: {
+                pr: number;
+                mergeCommitSha: string;
+                preimageCommitSha: string;
+                filePath: string;
+                matchedSpan: string;
+                contentHash: string;
+            }[];
+            negativeFixtures?: {
+                pr: number;
+                mergeCommitSha: string;
+                preimageCommitSha: string;
+                filePath: string;
+                matchedSpan: string;
+                contentHash: string;
+            }[] | undefined;
+        }, {
+            kind: "authored";
+            author: string;
+            authoredAt: string;
+            targetDefect: string;
+            positiveFixtures: {
+                pr: number;
+                mergeCommitSha: string;
+                preimageCommitSha: string;
+                filePath: string;
+                matchedSpan: string;
+                contentHash: string;
+            }[];
+            negativeFixtures?: {
+                pr: number;
+                mergeCommitSha: string;
+                preimageCommitSha: string;
+                filePath: string;
+                matchedSpan: string;
+                contentHash: string;
+            }[] | undefined;
+        }>, z.ZodObject<{
+            /**
+             * ADR-112 discriminator. OPTIONAL on the mined wire so legacy records (which
+             * have no `kind`) round-trip byte-identical; absence is read as `'mined'` by
+             * `provenanceKind()`. A new mined artifact MAY carry `kind: 'mined'` only
+             * where the resulting hash churn is intentional.
+             */
+            kind: z.ZodOptional<z.ZodLiteral<"mined">>;
             /** Merged PR the rule was mined from (positive integer PR number). */
             mergedPr: z.ZodNumber;
             /**
@@ -327,11 +941,13 @@ export declare const CompiledRuleSchema: z.ZodEffects<z.ZodObject<{
             mergedPr: number;
             reviewThread: string;
             commitSha: string;
+            kind?: "mined" | undefined;
         }, {
             mergedPr: number;
             reviewThread: string;
             commitSha: string;
-        }>;
+            kind?: "mined" | undefined;
+        }>]>;
         positiveControl: z.ZodBoolean;
         negativeControl: z.ZodBoolean;
     }, "strip", z.ZodTypeAny, {
@@ -339,6 +955,28 @@ export declare const CompiledRuleSchema: z.ZodEffects<z.ZodObject<{
             mergedPr: number;
             reviewThread: string;
             commitSha: string;
+            kind?: "mined" | undefined;
+        } | {
+            kind: "authored";
+            author: string;
+            authoredAt: string;
+            targetDefect: string;
+            positiveFixtures: {
+                pr: number;
+                mergeCommitSha: string;
+                preimageCommitSha: string;
+                filePath: string;
+                matchedSpan: string;
+                contentHash: string;
+            }[];
+            negativeFixtures?: {
+                pr: number;
+                mergeCommitSha: string;
+                preimageCommitSha: string;
+                filePath: string;
+                matchedSpan: string;
+                contentHash: string;
+            }[] | undefined;
         };
         positiveControl: boolean;
         negativeControl: boolean;
@@ -347,6 +985,28 @@ export declare const CompiledRuleSchema: z.ZodEffects<z.ZodObject<{
             mergedPr: number;
             reviewThread: string;
             commitSha: string;
+            kind?: "mined" | undefined;
+        } | {
+            kind: "authored";
+            author: string;
+            authoredAt: string;
+            targetDefect: string;
+            positiveFixtures: {
+                pr: number;
+                mergeCommitSha: string;
+                preimageCommitSha: string;
+                filePath: string;
+                matchedSpan: string;
+                contentHash: string;
+            }[];
+            negativeFixtures?: {
+                pr: number;
+                mergeCommitSha: string;
+                preimageCommitSha: string;
+                filePath: string;
+                matchedSpan: string;
+                contentHash: string;
+            }[] | undefined;
         };
         positiveControl: boolean;
         negativeControl: boolean;
@@ -392,6 +1052,28 @@ export declare const CompiledRuleSchema: z.ZodEffects<z.ZodObject<{
             mergedPr: number;
             reviewThread: string;
             commitSha: string;
+            kind?: "mined" | undefined;
+        } | {
+            kind: "authored";
+            author: string;
+            authoredAt: string;
+            targetDefect: string;
+            positiveFixtures: {
+                pr: number;
+                mergeCommitSha: string;
+                preimageCommitSha: string;
+                filePath: string;
+                matchedSpan: string;
+                contentHash: string;
+            }[];
+            negativeFixtures?: {
+                pr: number;
+                mergeCommitSha: string;
+                preimageCommitSha: string;
+                filePath: string;
+                matchedSpan: string;
+                contentHash: string;
+            }[] | undefined;
         };
         positiveControl: boolean;
         negativeControl: boolean;
@@ -427,6 +1109,28 @@ export declare const CompiledRuleSchema: z.ZodEffects<z.ZodObject<{
             mergedPr: number;
             reviewThread: string;
             commitSha: string;
+            kind?: "mined" | undefined;
+        } | {
+            kind: "authored";
+            author: string;
+            authoredAt: string;
+            targetDefect: string;
+            positiveFixtures: {
+                pr: number;
+                mergeCommitSha: string;
+                preimageCommitSha: string;
+                filePath: string;
+                matchedSpan: string;
+                contentHash: string;
+            }[];
+            negativeFixtures?: {
+                pr: number;
+                mergeCommitSha: string;
+                preimageCommitSha: string;
+                filePath: string;
+                matchedSpan: string;
+                contentHash: string;
+            }[] | undefined;
         };
         positiveControl: boolean;
         negativeControl: boolean;
@@ -462,6 +1166,28 @@ export declare const CompiledRuleSchema: z.ZodEffects<z.ZodObject<{
             mergedPr: number;
             reviewThread: string;
             commitSha: string;
+            kind?: "mined" | undefined;
+        } | {
+            kind: "authored";
+            author: string;
+            authoredAt: string;
+            targetDefect: string;
+            positiveFixtures: {
+                pr: number;
+                mergeCommitSha: string;
+                preimageCommitSha: string;
+                filePath: string;
+                matchedSpan: string;
+                contentHash: string;
+            }[];
+            negativeFixtures?: {
+                pr: number;
+                mergeCommitSha: string;
+                preimageCommitSha: string;
+                filePath: string;
+                matchedSpan: string;
+                contentHash: string;
+            }[] | undefined;
         };
         positiveControl: boolean;
         negativeControl: boolean;
@@ -497,6 +1223,28 @@ export declare const CompiledRuleSchema: z.ZodEffects<z.ZodObject<{
             mergedPr: number;
             reviewThread: string;
             commitSha: string;
+            kind?: "mined" | undefined;
+        } | {
+            kind: "authored";
+            author: string;
+            authoredAt: string;
+            targetDefect: string;
+            positiveFixtures: {
+                pr: number;
+                mergeCommitSha: string;
+                preimageCommitSha: string;
+                filePath: string;
+                matchedSpan: string;
+                contentHash: string;
+            }[];
+            negativeFixtures?: {
+                pr: number;
+                mergeCommitSha: string;
+                preimageCommitSha: string;
+                filePath: string;
+                matchedSpan: string;
+                contentHash: string;
+            }[] | undefined;
         };
         positiveControl: boolean;
         negativeControl: boolean;
@@ -794,7 +1542,122 @@ export declare const CompiledRulesFileSchema: z.ZodObject<{
          * signal and preserves pre-#2183 manifest hashes via canonicalStringify.
          */
         legitimacy: z.ZodOptional<z.ZodObject<{
-            provenance: z.ZodObject<{
+            provenance: z.ZodUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"authored">;
+                /** Agent-id or operator handle — attributable, never anonymous. */
+                author: z.ZodEffects<z.ZodString, string, string>;
+                /** ISO-8601 authoring date — a real calendar date (`YYYY-MM-DD`) or a full timestamp. */
+                authoredAt: z.ZodEffects<z.ZodString, string, string>;
+                /** The declared DEFECT the rule targets — the pre-image, not its fix. */
+                targetDefect: z.ZodEffects<z.ZodString, string, string>;
+                /** ≥1 real lc instance the rule claims to catch — ALL train-side (§5). */
+                positiveFixtures: z.ZodArray<z.ZodObject<{
+                    /** The PR whose merge introduced the fix (the in-corpus anchor). */
+                    pr: z.ZodNumber;
+                    /** The PR's merge/squash commit — the post-fix (defect-absent) anchor. */
+                    mergeCommitSha: z.ZodString;
+                    /** The PARENT (pre-fix) commit where the DEFECT is present (ADR-112 §4). */
+                    preimageCommitSha: z.ZodString;
+                    /** File the defect locus lives in. */
+                    filePath: z.ZodEffects<z.ZodString, string, string>;
+                    /** Line-range or AST-node path — the defect locus, not just the file. */
+                    matchedSpan: z.ZodEffects<z.ZodString, string, string>;
+                    /** Span content hash, line-drift-stable (cf. `firingLabelId`). */
+                    contentHash: z.ZodEffects<z.ZodString, string, string>;
+                }, "strip", z.ZodTypeAny, {
+                    pr: number;
+                    mergeCommitSha: string;
+                    preimageCommitSha: string;
+                    filePath: string;
+                    matchedSpan: string;
+                    contentHash: string;
+                }, {
+                    pr: number;
+                    mergeCommitSha: string;
+                    preimageCommitSha: string;
+                    filePath: string;
+                    matchedSpan: string;
+                    contentHash: string;
+                }>, "many">;
+                /** Declared near-misses the rule must stay silent on (feeds §6 negative controls). */
+                negativeFixtures: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    /** The PR whose merge introduced the fix (the in-corpus anchor). */
+                    pr: z.ZodNumber;
+                    /** The PR's merge/squash commit — the post-fix (defect-absent) anchor. */
+                    mergeCommitSha: z.ZodString;
+                    /** The PARENT (pre-fix) commit where the DEFECT is present (ADR-112 §4). */
+                    preimageCommitSha: z.ZodString;
+                    /** File the defect locus lives in. */
+                    filePath: z.ZodEffects<z.ZodString, string, string>;
+                    /** Line-range or AST-node path — the defect locus, not just the file. */
+                    matchedSpan: z.ZodEffects<z.ZodString, string, string>;
+                    /** Span content hash, line-drift-stable (cf. `firingLabelId`). */
+                    contentHash: z.ZodEffects<z.ZodString, string, string>;
+                }, "strip", z.ZodTypeAny, {
+                    pr: number;
+                    mergeCommitSha: string;
+                    preimageCommitSha: string;
+                    filePath: string;
+                    matchedSpan: string;
+                    contentHash: string;
+                }, {
+                    pr: number;
+                    mergeCommitSha: string;
+                    preimageCommitSha: string;
+                    filePath: string;
+                    matchedSpan: string;
+                    contentHash: string;
+                }>, "many">>;
+            }, "strip", z.ZodTypeAny, {
+                kind: "authored";
+                author: string;
+                authoredAt: string;
+                targetDefect: string;
+                positiveFixtures: {
+                    pr: number;
+                    mergeCommitSha: string;
+                    preimageCommitSha: string;
+                    filePath: string;
+                    matchedSpan: string;
+                    contentHash: string;
+                }[];
+                negativeFixtures?: {
+                    pr: number;
+                    mergeCommitSha: string;
+                    preimageCommitSha: string;
+                    filePath: string;
+                    matchedSpan: string;
+                    contentHash: string;
+                }[] | undefined;
+            }, {
+                kind: "authored";
+                author: string;
+                authoredAt: string;
+                targetDefect: string;
+                positiveFixtures: {
+                    pr: number;
+                    mergeCommitSha: string;
+                    preimageCommitSha: string;
+                    filePath: string;
+                    matchedSpan: string;
+                    contentHash: string;
+                }[];
+                negativeFixtures?: {
+                    pr: number;
+                    mergeCommitSha: string;
+                    preimageCommitSha: string;
+                    filePath: string;
+                    matchedSpan: string;
+                    contentHash: string;
+                }[] | undefined;
+            }>, z.ZodObject<{
+                /**
+                 * ADR-112 discriminator. OPTIONAL on the mined wire so legacy records (which
+                 * have no `kind`) round-trip byte-identical; absence is read as `'mined'` by
+                 * `provenanceKind()`. A new mined artifact MAY carry `kind: 'mined'` only
+                 * where the resulting hash churn is intentional.
+                 */
+                kind: z.ZodOptional<z.ZodLiteral<"mined">>;
                 /** Merged PR the rule was mined from (positive integer PR number). */
                 mergedPr: z.ZodNumber;
                 /**
@@ -812,11 +1675,13 @@ export declare const CompiledRulesFileSchema: z.ZodObject<{
                 mergedPr: number;
                 reviewThread: string;
                 commitSha: string;
+                kind?: "mined" | undefined;
             }, {
                 mergedPr: number;
                 reviewThread: string;
                 commitSha: string;
-            }>;
+                kind?: "mined" | undefined;
+            }>]>;
             positiveControl: z.ZodBoolean;
             negativeControl: z.ZodBoolean;
         }, "strip", z.ZodTypeAny, {
@@ -824,6 +1689,28 @@ export declare const CompiledRulesFileSchema: z.ZodObject<{
                 mergedPr: number;
                 reviewThread: string;
                 commitSha: string;
+                kind?: "mined" | undefined;
+            } | {
+                kind: "authored";
+                author: string;
+                authoredAt: string;
+                targetDefect: string;
+                positiveFixtures: {
+                    pr: number;
+                    mergeCommitSha: string;
+                    preimageCommitSha: string;
+                    filePath: string;
+                    matchedSpan: string;
+                    contentHash: string;
+                }[];
+                negativeFixtures?: {
+                    pr: number;
+                    mergeCommitSha: string;
+                    preimageCommitSha: string;
+                    filePath: string;
+                    matchedSpan: string;
+                    contentHash: string;
+                }[] | undefined;
             };
             positiveControl: boolean;
             negativeControl: boolean;
@@ -832,6 +1719,28 @@ export declare const CompiledRulesFileSchema: z.ZodObject<{
                 mergedPr: number;
                 reviewThread: string;
                 commitSha: string;
+                kind?: "mined" | undefined;
+            } | {
+                kind: "authored";
+                author: string;
+                authoredAt: string;
+                targetDefect: string;
+                positiveFixtures: {
+                    pr: number;
+                    mergeCommitSha: string;
+                    preimageCommitSha: string;
+                    filePath: string;
+                    matchedSpan: string;
+                    contentHash: string;
+                }[];
+                negativeFixtures?: {
+                    pr: number;
+                    mergeCommitSha: string;
+                    preimageCommitSha: string;
+                    filePath: string;
+                    matchedSpan: string;
+                    contentHash: string;
+                }[] | undefined;
             };
             positiveControl: boolean;
             negativeControl: boolean;
@@ -877,6 +1786,28 @@ export declare const CompiledRulesFileSchema: z.ZodObject<{
                 mergedPr: number;
                 reviewThread: string;
                 commitSha: string;
+                kind?: "mined" | undefined;
+            } | {
+                kind: "authored";
+                author: string;
+                authoredAt: string;
+                targetDefect: string;
+                positiveFixtures: {
+                    pr: number;
+                    mergeCommitSha: string;
+                    preimageCommitSha: string;
+                    filePath: string;
+                    matchedSpan: string;
+                    contentHash: string;
+                }[];
+                negativeFixtures?: {
+                    pr: number;
+                    mergeCommitSha: string;
+                    preimageCommitSha: string;
+                    filePath: string;
+                    matchedSpan: string;
+                    contentHash: string;
+                }[] | undefined;
             };
             positiveControl: boolean;
             negativeControl: boolean;
@@ -912,6 +1843,28 @@ export declare const CompiledRulesFileSchema: z.ZodObject<{
                 mergedPr: number;
                 reviewThread: string;
                 commitSha: string;
+                kind?: "mined" | undefined;
+            } | {
+                kind: "authored";
+                author: string;
+                authoredAt: string;
+                targetDefect: string;
+                positiveFixtures: {
+                    pr: number;
+                    mergeCommitSha: string;
+                    preimageCommitSha: string;
+                    filePath: string;
+                    matchedSpan: string;
+                    contentHash: string;
+                }[];
+                negativeFixtures?: {
+                    pr: number;
+                    mergeCommitSha: string;
+                    preimageCommitSha: string;
+                    filePath: string;
+                    matchedSpan: string;
+                    contentHash: string;
+                }[] | undefined;
             };
             positiveControl: boolean;
             negativeControl: boolean;
@@ -947,6 +1900,28 @@ export declare const CompiledRulesFileSchema: z.ZodObject<{
                 mergedPr: number;
                 reviewThread: string;
                 commitSha: string;
+                kind?: "mined" | undefined;
+            } | {
+                kind: "authored";
+                author: string;
+                authoredAt: string;
+                targetDefect: string;
+                positiveFixtures: {
+                    pr: number;
+                    mergeCommitSha: string;
+                    preimageCommitSha: string;
+                    filePath: string;
+                    matchedSpan: string;
+                    contentHash: string;
+                }[];
+                negativeFixtures?: {
+                    pr: number;
+                    mergeCommitSha: string;
+                    preimageCommitSha: string;
+                    filePath: string;
+                    matchedSpan: string;
+                    contentHash: string;
+                }[] | undefined;
             };
             positiveControl: boolean;
             negativeControl: boolean;
@@ -982,6 +1957,28 @@ export declare const CompiledRulesFileSchema: z.ZodObject<{
                 mergedPr: number;
                 reviewThread: string;
                 commitSha: string;
+                kind?: "mined" | undefined;
+            } | {
+                kind: "authored";
+                author: string;
+                authoredAt: string;
+                targetDefect: string;
+                positiveFixtures: {
+                    pr: number;
+                    mergeCommitSha: string;
+                    preimageCommitSha: string;
+                    filePath: string;
+                    matchedSpan: string;
+                    contentHash: string;
+                }[];
+                negativeFixtures?: {
+                    pr: number;
+                    mergeCommitSha: string;
+                    preimageCommitSha: string;
+                    filePath: string;
+                    matchedSpan: string;
+                    contentHash: string;
+                }[] | undefined;
             };
             positiveControl: boolean;
             negativeControl: boolean;
@@ -1067,6 +2064,28 @@ export declare const CompiledRulesFileSchema: z.ZodObject<{
                 mergedPr: number;
                 reviewThread: string;
                 commitSha: string;
+                kind?: "mined" | undefined;
+            } | {
+                kind: "authored";
+                author: string;
+                authoredAt: string;
+                targetDefect: string;
+                positiveFixtures: {
+                    pr: number;
+                    mergeCommitSha: string;
+                    preimageCommitSha: string;
+                    filePath: string;
+                    matchedSpan: string;
+                    contentHash: string;
+                }[];
+                negativeFixtures?: {
+                    pr: number;
+                    mergeCommitSha: string;
+                    preimageCommitSha: string;
+                    filePath: string;
+                    matchedSpan: string;
+                    contentHash: string;
+                }[] | undefined;
             };
             positiveControl: boolean;
             negativeControl: boolean;
@@ -1111,6 +2130,28 @@ export declare const CompiledRulesFileSchema: z.ZodObject<{
                 mergedPr: number;
                 reviewThread: string;
                 commitSha: string;
+                kind?: "mined" | undefined;
+            } | {
+                kind: "authored";
+                author: string;
+                authoredAt: string;
+                targetDefect: string;
+                positiveFixtures: {
+                    pr: number;
+                    mergeCommitSha: string;
+                    preimageCommitSha: string;
+                    filePath: string;
+                    matchedSpan: string;
+                    contentHash: string;
+                }[];
+                negativeFixtures?: {
+                    pr: number;
+                    mergeCommitSha: string;
+                    preimageCommitSha: string;
+                    filePath: string;
+                    matchedSpan: string;
+                    contentHash: string;
+                }[] | undefined;
             };
             positiveControl: boolean;
             negativeControl: boolean;