@mmnto/totem 1.78.0 → 1.79.0

package/dist/spine/authored-rule.js

@@ -0,0 +1,199 @@
+// ─── ADR-112 Gate-1 authored producer: the AuthoredRuleRecord envelope ───────
+//
+// The human-authored counterpart to ADR-111's mined `CandidateRuleRecord`. An
+// authored rule is anchored to a real historical DEFECT (its `provenance` is the
+// AUTHORED variant of the ADR-112 union — train-side preimage fixtures, §3/§4),
+// carries an INDEPENDENTLY-judged structural-eligibility result (NOT author-
+// asserted — §3), an accelerant-lineage marker (§7), and is minted
+// `unverified`/Yellow (ADR-089) with zero enforcement blast radius.
+//
+// SLICE A scope: the schema spine + the deterministic eligibility check + the
+// stable rule-id mint. The `totem rule author` CLI + the `.totem/spine/
+// authored-rules.yaml` reader are slice B; the compile-feed integration into
+// `runCompileStage` is gated on the `compileCandidate` param-widening flagged in
+// the slice-A report (a controller decision). The whitelist REGISTRY of
+// decidable classes lives in the CLI (slice B, mirroring `valueEqualityFieldsFor`);
+// this core check takes it injected (DI), staying network-free + LLM-free.
+import { createHash } from 'node:crypto';
+import { z } from 'zod';
+import { AuthoredProvenanceRecordSchema } from '../compiler-schema.js';
+/** The matcher engines an authored rule may declare (mirrors `CompiledRule.engine`). */
+export const DeclaredEngineSchema = z.enum(['regex', 'ast', 'ast-grep']);
+// The §3 eligibility-basis forms: `whitelist:<class>` (the cert-#1 deterministic basis,
+// a non-empty class after the colon), or the deferred `capability-check` /
+// `draft-classifier+stage4`. Pins `basis` to the contract so a free-form/typo'd value
+// can't validate (strategy item 2, #2259).
+const ELIGIBILITY_BASIS_RE = /^(?:whitelist:.+|capability-check|draft-classifier\+stage4)$/;
+/**
+ * ADR-112 §3 — the result of the INDEPENDENT structural-eligibility check.
+ * Produced by `evaluateStructuralEligibility` (NOT by the author): only
+ * `decidable: true` reaches the compiler, mapping to the compiler's
+ * `classifierDisposition: 'structural'`. `judgedBy` records who/what judged it
+ * (ledger-recorded, never the author), so a human cannot smuggle a behavioral
+ * policy past ADR-091's gate by hand-asserting "structural" (FM(d)).
+ */
+export const StructEligResultSchema = z.object({
+    decidable: z.boolean(),
+    /**
+     * `whitelist:<class>` for the cert-#1 static-whitelist basis; the
+     * `capability-check` / `draft-classifier+stage4` bases are contract-legal but
+     * deferred (slice-A uses the deterministic whitelist only). On a `decidable:
+     * false` verdict the basis still names the attempted whitelist class — the
+     * diagnostic is "no/ambiguous whitelist match", carried in `judgedBy`'s log.
+     * Constrained to the §3 forms (strategy item 2, #2259) so a typo'd/free-form
+     * basis can't validate — non-mutating (no `.trim()`), matching the hash-stability
+     * discipline on the other reference fields.
+     */
+    basis: z.string().refine((s) => ELIGIBILITY_BASIS_RE.test(s), {
+        message: 'basis must be a §3 eligibility basis: whitelist:<class> | capability-check | draft-classifier+stage4',
+    }),
+    judgedBy: z.string().refine((s) => s.trim().length > 0, {
+        message: 'judgedBy must name the check/agent that judged eligibility (never the author)',
+    }),
+});
+/** ADR-112 §3/§7 — accelerant-lineage marker. A mined hint that informed a human is recorded, never erased. */
+export const AuthoredOriginSchema = z.union([
+    z.object({ kind: z.literal('from-scratch') }),
+    z.object({
+        kind: z.literal('mined-accelerant'),
+        sourceRunId: z.string().refine((s) => s.trim().length > 0, { message: 'sourceRunId required' }),
+        suggestionHash: z.string().refine((s) => s.trim().length > 0, {
+            message: 'suggestionHash required',
+        }),
+    }),
+]);
+// The persisted minted-rule-id shape (ADR-112 §8): a 16-char lowercase-hex base from
+// `mintAuthoredRuleId`, with an optional collision suffix. The suffix is EXACTLY what the
+// mint emits — `-<n>` for n≥1, never `-0` and never zero-padded — so schema-valid ≡
+// mint-producible (#2259 CR: a looser `-\d+` admitted ids like `…-0`/`…-01` the mint can't
+// make). Pinned as a shared constant binding the SCHEMA boundary to the mint's codomain.
+const AUTHORED_RULE_ID_HEX_LEN = 16;
+const AUTHORED_RULE_ID_RE = new RegExp(`^[0-9a-f]{${AUTHORED_RULE_ID_HEX_LEN}}(?:-[1-9]\\d*)?$`);
+/**
+ * ADR-112 §3 — the authored producer's sole output envelope. Parallel to
+ * ADR-111's `CandidateRuleRecord` but carrying the AUTHORED provenance variant,
+ * the INDEPENDENTLY-judged eligibility result, and the accelerant lineage.
+ * Minted `unverified: true` (ADR-089) — zero enforcement blast radius.
+ */
+export const AuthoredRuleRecordSchema = z.object({
+    /**
+     * ADR-112 §3/§8 — the stable, minted rule identity (`mintAuthoredRuleId`),
+     * assigned ONCE at authoring time and PERSISTED on the record; NEVER re-derived
+     * from content at read time. `firingLabelId` + the §5.3
+     * `controls.positive[].targetRuleId` ground-truth labels embed it, so a
+     * content-re-derived id would orphan them (§8). Slice A reserves the field (this
+     * IS the schema spine); the authoring flow (slice B) mints it, and threading it
+     * into the compiled artifact's identity (`firingLabelId ← ruleId`, replacing the
+     * `dslSource`-derived `lessonHash`) is slice C/D. The RESOLVED id (with any `-N`
+     * collision suffix) is what is stored.
+     */
+    ruleId: z.string().regex(AUTHORED_RULE_ID_RE, {
+        message: 'ruleId must be a minted authored rule id — 16 hex chars + optional -<n> suffix (ADR-112 §3/§8)',
+    }),
+    provenance: AuthoredProvenanceRecordSchema,
+    /** INDEPENDENTLY established (§3) — the author never sets this; the check does. */
+    structuralEligibility: StructEligResultSchema,
+    origin: AuthoredOriginSchema,
+    declaredEngine: DeclaredEngineSchema,
+    /** Reference to the §8 authoring-ledger entry (author/date/engine/splitRef/attestations). */
+    authoringLedgerRef: z.string().refine((s) => s.trim().length > 0, {
+        message: 'authoringLedgerRef must be a non-empty ledger reference',
+    }),
+    /** The human-written matcher (same DSL the compiler accepts from the miner). */
+    dslSource: z.string().refine((s) => s.trim().length > 0, {
+        message: 'dslSource must be non-empty',
+    }),
+    /** Zero-trust mint (ADR-089 / ADR-112 §1) — always literally `true`. */
+    unverified: z.literal(true),
+});
+/**
+ * ADR-112 §3 — the INDEPENDENT structural-eligibility check. A CLOSED registry
+ * predicate, NOT prose: `decidable` is true iff EXACTLY ONE whitelist entry
+ * matches `(declaredEngine, structuralClass)`. Unknown class, unsupported
+ * engine, or multiple matches → `decidable: false` (NO default-to-structural).
+ * The author supplies `declaredEngine` + `structuralClass`; this check OWNS the
+ * verdict — any author-supplied disposition is irrelevant here (FM(d)).
+ * Deterministic + pure (no IO, no LLM) — the same input always yields the same
+ * verdict (Tenet-15).
+ */
+export function evaluateStructuralEligibility(input, whitelist, judgedBy) {
+    const matches = whitelist.filter((e) => e.engine === input.declaredEngine && e.structuralClass === input.structuralClass);
+    return {
+        decidable: matches.length === 1,
+        basis: `whitelist:${input.structuralClass}`,
+        judgedBy,
+    };
+}
+// ── Stable rule-id mint (ADR-112 §8) ──────────────────────────────────────────
+/**
+ * ADR-112 §8 — mint a stable, deterministic authored rule-id. The seed is
+ * `sha256(JSON.stringify([author, targetDefect]))[:16]` (an INJECTIVE encoding —
+ * see the inline note) — `dslSource` is DELIBERATELY EXCLUDED so an author can
+ * tighten/refactor the matcher without orphaning the rule's ledger history. On collision with an already-resolved id (two rules sharing the same
+ * `(author, targetDefect)`), a stable `-N` counter is appended. The RESOLVED id
+ * is what callers persist — never recompute the raw seed at read time, or a
+ * later sibling could shift the suffix (the gemini/agy break). The
+ * `never-remine` marker is keyed to `targetDefect`, handled by the accelerant
+ * miner, not here.
+ */
+export function mintAuthoredRuleId(author, targetDefect, existingIds) {
+    // Unambiguous seed encoding (GCA-high + CR-major, #2259): a bare `author·targetDefect`
+    // ALIASES distinct tuples — ('a·b','c') and ('a','b·c') collapse onto one seed. A JSON
+    // array of the two inputs is injective: distinct (author, targetDefect) pairs can never
+    // serialize to the same string, so a persisted id can't collide by encoding.
+    const seed = createHash('sha256')
+        .update(JSON.stringify([author, targetDefect]))
+        .digest('hex')
+        .slice(0, AUTHORED_RULE_ID_HEX_LEN);
+    if (!existingIds.has(seed))
+        return seed;
+    for (let n = 1;; n += 1) {
+        const candidate = `${seed}-${n}`;
+        if (!existingIds.has(candidate))
+            return candidate;
+    }
+}
+/**
+ * ADR-112 §2/§8 — turn structurally-DECIDABLE authored rules into the input
+ * `runCompileStage` consumes, reusing the ONE G-series compiler (never a second).
+ * The disposition is set HERE to `'structural'` from the INDEPENDENT eligibility
+ * verdict (§3) — the author never sets it. A NON-decidable record is a contract
+ * violation → FAIL LOUD (the FM(d) backstop in code), never a silent skip.
+ * `classifierLedgerRef = authored:<authoringLedgerRef>` is unique per rule (the
+ * authoring ledger is 1:1 with the rule); a duplicate fails loud so the downstream
+ * 1:1 classifier-ledger join can't silently collapse.
+ */
+export function toCompileFeed(records) {
+    const candidates = [];
+    const entries = [];
+    const seen = new Set();
+    for (const record of records) {
+        if (!record.structuralEligibility.decidable) {
+            throw new Error(`[Totem Error] toCompileFeed: authored rule '${record.authoringLedgerRef}' is not structurally decidable — a non-decidable rule must never reach the compiler (ADR-112 §3 / FM(d))`);
+        }
+        const classifierLedgerRef = `authored:${record.authoringLedgerRef}`;
+        if (seen.has(classifierLedgerRef)) {
+            throw new Error(`[Totem Error] toCompileFeed: duplicate authoringLedgerRef '${record.authoringLedgerRef}' — each authored rule needs a unique ledger ref for the 1:1 compile join`);
+        }
+        seen.add(classifierLedgerRef);
+        candidates.push({
+            provenance: record.provenance,
+            classifierDisposition: 'structural',
+            classifierLedgerRef,
+            dslSource: record.dslSource,
+            // §3 (#7): carry the whitelist-judged engine so the compiler can assert it
+            // compiled under THAT engine — a regex-whitelisted rule whose dslSource parses
+            // as ast-grep must fail loud, not silently re-route to a different engine.
+            declaredEngine: record.declaredEngine,
+            unverified: true,
+        });
+        entries.push({
+            candidateRef: classifierLedgerRef,
+            disposition: 'structural',
+            stage4Confirmed: false,
+            dispositionSource: 'authored-whitelist',
+        });
+    }
+    return { candidates, classifierLedger: { entries } };
+}
+//# sourceMappingURL=authored-rule.js.map

package/dist/spine/authored-rule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"authored-rule.js","sourceRoot":"","sources":["../../src/spine/authored-rule.ts"],"names":[],"mappings":"AAAA,gFAAgF;AAChF,EAAE;AACF,8EAA8E;AAC9E,iFAAiF;AACjF,gFAAgF;AAChF,6EAA6E;AAC7E,mEAAmE;AACnE,oEAAoE;AACpE,EAAE;AACF,8EAA8E;AAC9E,wEAAwE;AACxE,6EAA6E;AAC7E,iFAAiF;AACjF,wEAAwE;AACxE,oFAAoF;AACpF,2EAA2E;AAE3E,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAEzC,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,8BAA8B,EAAE,MAAM,uBAAuB,CAAC;AAIvE,wFAAwF;AACxF,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,KAAK,EAAE,UAAU,CAAC,CAAC,CAAC;AAGzE,wFAAwF;AACxF,2EAA2E;AAC3E,sFAAsF;AACtF,2CAA2C;AAC3C,MAAM,oBAAoB,GAAG,8DAA8D,CAAC;AAE5F;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC7C,SAAS,EAAE,CAAC,CAAC,OAAO,EAAE;IACtB;;;;;;;;;OASG;IACH,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,oBAAoB,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE;QAC5D,OAAO,EACL,sGAAsG;KACzG,CAAC;IACF,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,MAAM,GAAG,CAAC,EAAE;QACtD,OAAO,EAAE,+EAA+E;KACzF,CAAC;CACH,CAAC,CAAC;AAGH,+GAA+G;AAC/G,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC;IAC1C,CAAC,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,cAAc,CAAC,EAAE,CAAC;IAC7C,CAAC,CAAC,MAAM,CAAC;QACP,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,kBAAkB,CAAC;QACnC,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,MAAM,GAAG,CAAC,EAAE,EAAE,OAAO,EAAE,sBAAsB,EAAE,CAAC;QAC/F,cAAc,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,MAAM,GAAG,CAAC,EAAE;YAC5D,OAAO,EAAE,yBAAyB;SACnC,CAAC;KACH,CAAC;CACH,CAAC,CAAC;AAGH,qFAAqF;AACrF,0FAA0F;AAC1F,oFAAoF;AACpF,2FAA2F;AAC3F,yFAAyF;AACzF,MAAM,wBAAwB,GAAG,EAAE,CAAC;AACpC,MAAM,mBAAmB,GAAG,IAAI,MAAM,CAAC,aAAa,wBAAwB,mBAAmB,CAAC,CAAC;AAEjG;;;;;GAKG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC/C;;;;;;;;;;OAUG;IACH,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,mBAAmB,EAAE;QAC5C,OAAO,EACL,gGAAgG;KACnG,CAAC;IACF,UAAU,EAAE,8BAA8B;IAC1C,mFAAmF;IACnF,qBAAqB,EAAE,sBAAsB;IAC7C,MAAM,EAAE,oBAAoB;IAC5B,cAAc,EAAE,oBAAoB;IACpC,6FAA6F;IAC7F,kBAAkB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,MAAM,GAAG,CAAC,EAAE;QAChE,OAAO,EAAE,yDAAyD;KACnE,CAAC;IACF,gFAAgF;IAChF,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,MAAM,GAAG,CAAC,EAAE;QACvD,OAAO,EAAE,6BAA6B;KACvC,CAAC;IACF,wEAAwE;IACxE,UAAU,EAAE,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC;CAC5B,CAAC,CAAC;AAgBH;;;;;;;;;GASG;AACH,MAAM,UAAU,6BAA6B,CAC3C,KAAkE,EAClE,SAAoC,EACpC,QAAgB;IAEhB,MAAM,OAAO,GAAG,SAAS,CAAC,MAAM,CAC9B,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,KAAK,KAAK,CAAC,cAAc,IAAI,CAAC,CAAC,eAAe,KAAK,KAAK,CAAC,eAAe,CACxF,CAAC;IACF,OAAO;QACL,SAAS,EAAE,OAAO,CAAC,MAAM,KAAK,CAAC;QAC/B,KAAK,EAAE,aAAa,KAAK,CAAC,eAAe,EAAE;QAC3C,QAAQ;KACT,CAAC;AACJ,CAAC;AAED,iFAAiF;AAEjF;;;;;;;;;;GAUG;AACH,MAAM,UAAU,kBAAkB,CAChC,MAAc,EACd,YAAoB,EACpB,WAAgC;IAEhC,uFAAuF;IACvF,uFAAuF;IACvF,wFAAwF;IACxF,6EAA6E;IAC7E,MAAM,IAAI,GAAG,UAAU,CAAC,QAAQ,CAAC;SAC9B,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC,CAAC;SAC9C,MAAM,CAAC,KAAK,CAAC;SACb,KAAK,CAAC,CAAC,EAAE,wBAAwB,CAAC,CAAC;IACtC,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,IAAI,CAAC;QAAE,OAAO,IAAI,CAAC;IACxC,KAAK,IAAI,CAAC,GAAG,CAAC,GAAI,CAAC,IAAI,CAAC,EAAE,CAAC;QACzB,MAAM,SAAS,GAAG,GAAG,IAAI,IAAI,CAAC,EAAE,CAAC;QACjC,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,SAAS,CAAC;YAAE,OAAO,SAAS,CAAC;IACpD,CAAC;AACH,CAAC;AAeD;;;;;;;;;GASG;AACH,MAAM,UAAU,aAAa,CAAC,OAAsC;IAClE,MAAM,UAAU,GAA4B,EAAE,CAAC;IAC/C,MAAM,OAAO,GAAgC,EAAE,CAAC;IAChD,MAAM,IAAI,GAAG,IAAI,GAAG,EAAU,CAAC;IAC/B,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE,CAAC;QAC7B,IAAI,CAAC,MAAM,CAAC,qBAAqB,CAAC,SAAS,EAAE,CAAC;YAC5C,MAAM,IAAI,KAAK,CACb,+CAA+C,MAAM,CAAC,kBAAkB,2GAA2G,CACpL,CAAC;QACJ,CAAC;QACD,MAAM,mBAAmB,GAAG,YAAY,MAAM,CAAC,kBAAkB,EAAE,CAAC;QACpE,IAAI,IAAI,CAAC,GAAG,CAAC,mBAAmB,CAAC,EAAE,CAAC;YAClC,MAAM,IAAI,KAAK,CACb,8DAA8D,MAAM,CAAC,kBAAkB,2EAA2E,CACnK,CAAC;QACJ,CAAC;QACD,IAAI,CAAC,GAAG,CAAC,mBAAmB,CAAC,CAAC;QAC9B,UAAU,CAAC,IAAI,CAAC;YACd,UAAU,EAAE,MAAM,CAAC,UAAU;YAC7B,qBAAqB,EAAE,YAAY;YACnC,mBAAmB;YACnB,SAAS,EAAE,MAAM,CAAC,SAAS;YAC3B,2EAA2E;YAC3E,+EAA+E;YAC/E,2EAA2E;YAC3E,cAAc,EAAE,MAAM,CAAC,cAAc;YACrC,UAAU,EAAE,IAAI;SACjB,CAAC,CAAC;QACH,OAAO,CAAC,IAAI,CAAC;YACX,YAAY,EAAE,mBAAmB;YACjC,WAAW,EAAE,YAAY;YACzB,eAAe,EAAE,KAAK;YACtB,iBAAiB,EAAE,oBAAoB;SACxC,CAAC,CAAC;IACL,CAAC;IACD,OAAO,EAAE,UAAU,EAAE,gBAAgB,EAAE,EAAE,OAAO,EAAE,EAAE,CAAC;AACvD,CAAC"}

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=authored-rule.test.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"authored-rule.test.d.ts","sourceRoot":"","sources":["../../src/spine/authored-rule.test.ts"],"names":[],"mappings":""}

package/dist/spine/authored-rule.test.js

@@ -0,0 +1,220 @@
+import { describe, expect, it } from 'vitest';
+import { AuthoredRuleRecordSchema, evaluateStructuralEligibility, mintAuthoredRuleId, toCompileFeed, } from './authored-rule.js';
+const WHITELIST = [
+    { engine: 'regex', structuralClass: 'float-finite-assert' },
+    { engine: 'ast-grep', structuralClass: 'divisor-le-zero' },
+];
+describe('evaluateStructuralEligibility (ADR-112 §3 — closed predicate)', () => {
+    it('decidable:true on EXACTLY ONE (engine,class) match', () => {
+        const r = evaluateStructuralEligibility({ declaredEngine: 'regex', structuralClass: 'float-finite-assert' }, WHITELIST, 'static-whitelist@cert-1');
+        expect(r.decidable).toBe(true);
+        expect(r.basis).toBe('whitelist:float-finite-assert');
+        expect(r.judgedBy).toBe('static-whitelist@cert-1');
+    });
+    it('decidable:false on an UNKNOWN class (no default-to-structural)', () => {
+        const r = evaluateStructuralEligibility({ declaredEngine: 'regex', structuralClass: 'unbounded-recursion-behavioral' }, WHITELIST, 'static-whitelist@cert-1');
+        expect(r.decidable).toBe(false);
+    });
+    it('decidable:false when the engine cannot represent the class (no matching pair)', () => {
+        // class is whitelisted for ast-grep, not regex → no (regex, divisor-le-zero) entry.
+        const r = evaluateStructuralEligibility({ declaredEngine: 'regex', structuralClass: 'divisor-le-zero' }, WHITELIST, 'static-whitelist@cert-1');
+        expect(r.decidable).toBe(false);
+    });
+    it('decidable:false on MULTIPLE matches (ambiguous)', () => {
+        const dupes = [
+            { engine: 'regex', structuralClass: 'float-finite-assert' },
+            { engine: 'regex', structuralClass: 'float-finite-assert' },
+        ];
+        const r = evaluateStructuralEligibility({ declaredEngine: 'regex', structuralClass: 'float-finite-assert' }, dupes, 'static-whitelist@cert-1');
+        expect(r.decidable).toBe(false);
+    });
+    it('is deterministic — 100 sequential iterations yield an identical verdict (LLM-free)', () => {
+        const first = JSON.stringify(evaluateStructuralEligibility({ declaredEngine: 'ast-grep', structuralClass: 'divisor-le-zero' }, WHITELIST, 'static-whitelist@cert-1'));
+        for (let i = 0; i < 100; i += 1) {
+            const again = JSON.stringify(evaluateStructuralEligibility({ declaredEngine: 'ast-grep', structuralClass: 'divisor-le-zero' }, WHITELIST, 'static-whitelist@cert-1'));
+            expect(again).toBe(first);
+        }
+    });
+});
+describe('AuthoredRuleRecord schema (ADR-112 §3)', () => {
+    const base = {
+        ruleId: '0f1e2d3c4b5a6978',
+        provenance: {
+            kind: 'authored',
+            author: 'totem-claude',
+            authoredAt: '2026-06-27',
+            targetDefect: 'float equality compared with == instead of a finite-tolerance check',
+            positiveFixtures: [
+                {
+                    pr: 100,
+                    mergeCommitSha: 'b'.repeat(40),
+                    preimageCommitSha: 'c'.repeat(40),
+                    filePath: 'src/physics/step.ts',
+                    matchedSpan: 'L10-L12',
+                    contentHash: 'deadbeefcafe',
+                },
+            ],
+        },
+        structuralEligibility: {
+            decidable: true,
+            basis: 'whitelist:float-finite-assert',
+            judgedBy: 's',
+        },
+        origin: { kind: 'from-scratch' },
+        declaredEngine: 'regex',
+        authoringLedgerRef: 'alr-0001',
+        dslSource: '**Pattern:** `== *\\d+\\.\\d+f?`',
+        unverified: true,
+    };
+    it('accepts a complete authored record', () => {
+        expect(() => AuthoredRuleRecordSchema.parse(base)).not.toThrow();
+    });
+    it('has NO author-settable disposition/routing field (the check owns eligibility — FM(d))', () => {
+        const parsed = AuthoredRuleRecordSchema.parse(base);
+        expect('classifierDisposition' in parsed).toBe(false);
+        expect('routing' in parsed).toBe(false);
+    });
+    it('requires the independent structuralEligibility result', () => {
+        const { structuralEligibility: _omit, ...without } = base;
+        expect(() => AuthoredRuleRecordSchema.parse(without)).toThrow();
+    });
+    it('reserves the minted ruleId on the record (ADR-112 §3/§8 — persisted, never re-derived)', () => {
+        const { ruleId: _omit, ...without } = base;
+        expect(() => AuthoredRuleRecordSchema.parse(without)).toThrow();
+        expect(() => AuthoredRuleRecordSchema.parse({ ...base, ruleId: '  ' })).toThrow();
+        expect(AuthoredRuleRecordSchema.parse(base).ruleId).toBe('0f1e2d3c4b5a6978');
+    });
+    it('enforces the minted ruleId SHAPE at the boundary — 16 hex + optional -<n> (#2259 CR-major)', () => {
+        for (const bad of [
+            'NOTHEXNOTHEXNOTH',
+            '0f1e2d3c',
+            '0f1e2d3c4b5a6978abcd',
+            '0F1E2D3C4B5A6978',
+            'rid-alr-1',
+            // non-canonical suffixes the mint never emits (n≥1, no zero-pad) — #2259 CR
+            '0f1e2d3c4b5a6978-0',
+            '0f1e2d3c4b5a6978-01',
+        ]) {
+            expect(() => AuthoredRuleRecordSchema.parse({ ...base, ruleId: bad })).toThrow();
+        }
+        for (const ok of ['0f1e2d3c4b5a6978', '0f1e2d3c4b5a6978-1', 'abcdef0123456789-42']) {
+            expect(() => AuthoredRuleRecordSchema.parse({ ...base, ruleId: ok })).not.toThrow();
+        }
+        // the mint always produces a schema-valid id (the shared shape constant binds both).
+        expect(() => AuthoredRuleRecordSchema.parse({
+            ...base,
+            ruleId: mintAuthoredRuleId('totem-claude', 'float-finite-assert', new Set()),
+        })).not.toThrow();
+    });
+    it('forces unverified:true (zero blast radius — ADR-089/§1)', () => {
+        expect(() => AuthoredRuleRecordSchema.parse({ ...base, unverified: false })).toThrow();
+    });
+    it('constrains structuralEligibility.basis to the §3 forms — not free-form (strategy item 2, #2259)', () => {
+        const withBasis = (basis) => ({
+            ...base,
+            structuralEligibility: { ...base.structuralEligibility, basis },
+        });
+        for (const bad of [
+            '',
+            'freeform',
+            'whitelist:',
+            'whitelisted',
+            'stage4',
+            ' capability-check',
+        ]) {
+            expect(() => AuthoredRuleRecordSchema.parse(withBasis(bad))).toThrow();
+        }
+        for (const ok of [
+            'whitelist:float-finite-assert',
+            'capability-check',
+            'draft-classifier+stage4',
+        ]) {
+            expect(() => AuthoredRuleRecordSchema.parse(withBasis(ok))).not.toThrow();
+        }
+    });
+});
+describe('mintAuthoredRuleId (ADR-112 §8)', () => {
+    it('is deterministic for the same (author,targetDefect) and excludes dslSource', () => {
+        const a = mintAuthoredRuleId('totem-claude', 'float-finite-assert', new Set());
+        const b = mintAuthoredRuleId('totem-claude', 'float-finite-assert', new Set());
+        expect(a).toBe(b);
+        expect(a).toMatch(/^[0-9a-f]{16}$/);
+    });
+    it('encodes (author,targetDefect) injectively — delimiter-aliased tuples do NOT collide (#2259)', () => {
+        // A bare `author·targetDefect` seed would alias these two distinct tuples onto one id.
+        const a = mintAuthoredRuleId('a·b', 'c', new Set());
+        const b = mintAuthoredRuleId('a', 'b·c', new Set());
+        expect(a).not.toBe(b);
+    });
+    it('appends a stable counter on collision and yields distinct persisted ids', () => {
+        const first = mintAuthoredRuleId('totem-claude', 'divisor-le-zero', new Set());
+        const second = mintAuthoredRuleId('totem-claude', 'divisor-le-zero', new Set([first]));
+        const third = mintAuthoredRuleId('totem-claude', 'divisor-le-zero', new Set([first, second]));
+        expect(second).toBe(`${first}-1`);
+        expect(third).toBe(`${first}-2`);
+        expect(new Set([first, second, third]).size).toBe(3);
+    });
+    it('is stable across re-runs given the already-resolved id set', () => {
+        const resolved = mintAuthoredRuleId('a', 'd', new Set());
+        expect(mintAuthoredRuleId('a', 'd', new Set([resolved]))).toBe(`${resolved}-1`);
+        expect(mintAuthoredRuleId('a', 'd', new Set([resolved]))).toBe(`${resolved}-1`);
+    });
+});
+describe('toCompileFeed (ADR-112 §2/§8 — authored → compile-stage input)', () => {
+    const decidable = (ref) => ({
+        ruleId: mintAuthoredRuleId('totem-claude', ref, new Set()),
+        provenance: {
+            kind: 'authored',
+            author: 'totem-claude',
+            authoredAt: '2026-06-27',
+            targetDefect: 'float equality compared with == instead of a finite check',
+            positiveFixtures: [
+                {
+                    pr: 1,
+                    mergeCommitSha: 'a'.repeat(40),
+                    preimageCommitSha: 'b'.repeat(40),
+                    filePath: 'src/a.ts',
+                    matchedSpan: 'L1',
+                    contentHash: 'h1',
+                },
+            ],
+        },
+        structuralEligibility: {
+            decidable: true,
+            basis: 'whitelist:float-finite-assert',
+            judgedBy: 's',
+        },
+        origin: { kind: 'from-scratch' },
+        declaredEngine: 'regex',
+        authoringLedgerRef: ref,
+        dslSource: '**Pattern:** `== *\\d`',
+        unverified: true,
+    });
+    it('emits one structural candidate + a 1:1 authored-whitelist ledger entry per decidable rule', () => {
+        const feed = toCompileFeed([decidable('alr-1'), decidable('alr-2')]);
+        expect(feed.candidates).toHaveLength(2);
+        // the adapter — not the author — sets the disposition to structural.
+        expect(feed.candidates.every((c) => c.classifierDisposition === 'structural')).toBe(true);
+        // authored provenance is carried through, not flattened to a mined shape.
+        expect(feed.candidates[0].provenance.kind).toBe('authored');
+        expect(feed.candidates.map((c) => c.classifierLedgerRef)).toEqual([
+            'authored:alr-1',
+            'authored:alr-2',
+        ]);
+        // the classifier ledger NEVER claims an LLM judged a human rule (Tenet-20).
+        expect(feed.classifierLedger.entries.every((e) => e.dispositionSource === 'authored-whitelist')).toBe(true);
+        // the join key is 1:1 between candidate and ledger entry (runCompileStage requires it).
+        expect(feed.classifierLedger.entries.map((e) => e.candidateRef)).toEqual(feed.candidates.map((c) => c.classifierLedgerRef));
+    });
+    it('FAILS LOUD on a non-decidable record (FM(d) — never reaches the compiler)', () => {
+        const nd = {
+            ...decidable('alr-x'),
+            structuralEligibility: { decidable: false, basis: 'whitelist:foo', judgedBy: 's' },
+        };
+        expect(() => toCompileFeed([nd])).toThrow(/not structurally decidable/);
+    });
+    it('FAILS LOUD on a duplicate authoringLedgerRef (protects the 1:1 compile join)', () => {
+        expect(() => toCompileFeed([decidable('dup'), decidable('dup')])).toThrow(/duplicate authoringLedgerRef/);
+    });
+});
+//# sourceMappingURL=authored-rule.test.js.map

package/dist/spine/authored-rule.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"authored-rule.test.js","sourceRoot":"","sources":["../../src/spine/authored-rule.test.ts"],"names":[],"mappings":"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"}

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

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { type ProvenanceRecord } from '../compiler-schema.js';
 /**
  * Stage-2 classifier disposition (ADR-091 funnel, the gate). A `structural`
  * (syntactic-invariant) candidate is compile-eligible; a `behavioral` candidate
@@ -8,6 +9,32 @@ import { z } from 'zod';
  */
 export declare const ClassifierDispositionSchema: z.ZodEnum<["structural", "behavioral"]>;
 export type ClassifierDisposition = z.infer<typeof ClassifierDispositionSchema>;
+/**
+ * ADR-112 — the minimal candidate shape the compile actuator (`compileCandidate`
+ * / `runCompileStage`) actually reads. BOTH the mined `CandidateRuleRecord` and an
+ * authored-derived candidate (via `toCompileFeed`) satisfy it: `provenance` is the
+ * `mined | authored` union, so ONE compiler accepts either producer without an
+ * authored rule masquerading as a classify result (ADR-112 §2 — a parallel
+ * front-end to one compiler, never a second compiler). The mined
+ * `CandidateRuleRecord` (whose `provenance` is the narrower `MinedProvenanceRecord`)
+ * is assignable to this shape; so is the authored compile-feed candidate.
+ */
+export interface CompileInputCandidate {
+    provenance: ProvenanceRecord;
+    classifierDisposition: ClassifierDisposition;
+    classifierLedgerRef: string;
+    dslSource: string;
+    /**
+     * ADR-112 §3 (#2259/#7) — the engine the structural-eligibility whitelist judged
+     * this rule for (AUTHORED producer only). When present, `compileCandidate` asserts
+     * the compiled engine MATCHES it: a regex-whitelisted rule whose `dslSource` parses
+     * as ast-grep is a contract violation (the eligibility verdict was engine-specific),
+     * not a silent re-route. The MINED producer omits it — its engine + identity are
+     * `dslSource`-derived, so it carries no independent declaration to bind against.
+     */
+    declaredEngine?: 'regex' | 'ast' | 'ast-grep';
+    unverified: true;
+}
 /**
  * ADR-111 §3 — the miner's sole output envelope, minted `unverified`/Yellow
  * with no hand-curation. A candidate that cannot produce a complete provenance
@@ -23,6 +50,7 @@ export declare const CandidateRuleRecordSchema: z.ZodObject<{
      * schema-unconstructible (FM(a)).
      */
     provenance: z.ZodObject<{
+        kind: z.ZodOptional<z.ZodLiteral<"mined">>;
         mergedPr: z.ZodNumber;
         reviewThread: z.ZodEffects<z.ZodString, string, string>;
         commitSha: z.ZodString;
@@ -30,10 +58,12 @@ export declare const CandidateRuleRecordSchema: z.ZodObject<{
         mergedPr: number;
         reviewThread: string;
         commitSha: string;
+        kind?: "mined" | undefined;
     }, {
         mergedPr: number;
         reviewThread: string;
         commitSha: string;
+        kind?: "mined" | undefined;
     }>;
     /** Stage-2 disposition. `behavioral` ⇒ RAG-only, never compiled (FM(c)). */
     classifierDisposition: z.ZodEnum<["structural", "behavioral"]>;
@@ -64,6 +94,7 @@ export declare const CandidateRuleRecordSchema: z.ZodObject<{
         mergedPr: number;
         reviewThread: string;
         commitSha: string;
+        kind?: "mined" | undefined;
     };
     unverified: true;
     classifierDisposition: "structural" | "behavioral";
@@ -74,6 +105,7 @@ export declare const CandidateRuleRecordSchema: z.ZodObject<{
         mergedPr: number;
         reviewThread: string;
         commitSha: string;
+        kind?: "mined" | undefined;
     };
     unverified: true;
     classifierDisposition: "structural" | "behavioral";

package/dist/spine/candidate-rule.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"candidate-rule.d.ts","sourceRoot":"","sources":["../../src/spine/candidate-rule.ts"],"names":[],"mappings":"AAcA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB;;;;;;GAMG;AACH,eAAO,MAAM,2BAA2B,yCAAuC,CAAC;AAChF,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEhF;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB;IACpC;;;;;;OAMG;;;;;;;;;;;;;;IAEH,4EAA4E;;IAE5E;;;;;;OAMG;;IAIH;;;;;OAKG;;IAIH;;;;;OAKG;;;;;;;;;;;;;;;;;;;;;;EAEH,CAAC;AAEH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC"}
+{"version":3,"file":"candidate-rule.d.ts","sourceRoot":"","sources":["../../src/spine/candidate-rule.ts"],"names":[],"mappings":"AAcA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAA6B,KAAK,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAEzF;;;;;;GAMG;AACH,eAAO,MAAM,2BAA2B,yCAAuC,CAAC;AAChF,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEhF;;;;;;;;;GASG;AACH,MAAM,WAAW,qBAAqB;IACpC,UAAU,EAAE,gBAAgB,CAAC;IAC7B,qBAAqB,EAAE,qBAAqB,CAAC;IAC7C,mBAAmB,EAAE,MAAM,CAAC;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB;;;;;;;OAOG;IACH,cAAc,CAAC,EAAE,OAAO,GAAG,KAAK,GAAG,UAAU,CAAC;IAC9C,UAAU,EAAE,IAAI,CAAC;CAClB;AAED;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB;IACpC;;;;;;OAMG;;;;;;;;;;;;;;;;;IAEH,4EAA4E;;IAE5E;;;;;;OAMG;;IAIH;;;;;OAKG;;IAIH;;;;;OAKG;;;;;;;;;;;;;;;;;;;;;;;;EAEH,CAAC;AAEH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC"}

package/dist/spine/candidate-rule.js

@@ -12,7 +12,7 @@
 // (ADR-089): `unverified: true` forces `deriveRuleClass` to 'advisory' on any
 // later projection, so a candidate can never mint as `hard`.
 import { z } from 'zod';
-import { ProvenanceRecordSchema } from '../compiler-schema.js';
+import { MinedProvenanceWireSchema } from '../compiler-schema.js';
 /**
  * Stage-2 classifier disposition (ADR-091 funnel, the gate). A `structural`
  * (syntactic-invariant) candidate is compile-eligible; a `behavioral` candidate
@@ -35,7 +35,7 @@ export const CandidateRuleRecordSchema = z.object({
      * downstream projection — no rename seam. An incomplete tuple is
      * schema-unconstructible (FM(a)).
      */
-    provenance: ProvenanceRecordSchema,
+    provenance: MinedProvenanceWireSchema,
     /** Stage-2 disposition. `behavioral` ⇒ RAG-only, never compiled (FM(c)). */
     classifierDisposition: ClassifierDispositionSchema,
     /**

package/dist/spine/candidate-rule.js.map

@@ -1 +1 @@
-{"version":3,"file":"candidate-rule.js","sourceRoot":"","sources":["../../src/spine/candidate-rule.ts"],"names":[],"mappings":"AAAA,+EAA+E;AAC/E,EAAE;AACF,8EAA8E;AAC9E,+EAA+E;AAC/E,yEAAyE;AACzE,2EAA2E;AAC3E,4EAA4E;AAC5E,wEAAwE;AACxE,gFAAgF;AAChF,yEAAyE;AACzE,yEAAyE;AACzE,8EAA8E;AAC9E,6DAA6D;AAE7D,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AAE/D;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,2BAA2B,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,YAAY,EAAE,YAAY,CAAC,CAAC,CAAC;AAGhF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,CAAC,CAAC,MAAM,CAAC;IAChD;;;;;;OAMG;IACH,UAAU,EAAE,sBAAsB;IAClC,4EAA4E;IAC5E,qBAAqB,EAAE,2BAA2B;IAClD;;;;;;OAMG;IACH,mBAAmB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,MAAM,GAAG,CAAC,EAAE;QACjE,OAAO,EAAE,0DAA0D;KACpE,CAAC;IACF;;;;;OAKG;IACH,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,MAAM,GAAG,CAAC,EAAE;QACvD,OAAO,EAAE,6BAA6B;KACvC,CAAC;IACF;;;;;OAKG;IACH,UAAU,EAAE,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC;CAC5B,CAAC,CAAC"}
+{"version":3,"file":"candidate-rule.js","sourceRoot":"","sources":["../../src/spine/candidate-rule.ts"],"names":[],"mappings":"AAAA,+EAA+E;AAC/E,EAAE;AACF,8EAA8E;AAC9E,+EAA+E;AAC/E,yEAAyE;AACzE,2EAA2E;AAC3E,4EAA4E;AAC5E,wEAAwE;AACxE,gFAAgF;AAChF,yEAAyE;AACzE,yEAAyE;AACzE,8EAA8E;AAC9E,6DAA6D;AAE7D,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,yBAAyB,EAAyB,MAAM,uBAAuB,CAAC;AAEzF;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,2BAA2B,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,YAAY,EAAE,YAAY,CAAC,CAAC,CAAC;AA8BhF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,CAAC,CAAC,MAAM,CAAC;IAChD;;;;;;OAMG;IACH,UAAU,EAAE,yBAAyB;IACrC,4EAA4E;IAC5E,qBAAqB,EAAE,2BAA2B;IAClD;;;;;;OAMG;IACH,mBAAmB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,MAAM,GAAG,CAAC,EAAE;QACjE,OAAO,EAAE,0DAA0D;KACpE,CAAC;IACF;;;;;OAKG;IACH,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,MAAM,GAAG,CAAC,EAAE;QACvD,OAAO,EAAE,6BAA6B;KACvC,CAAC;IACF;;;;;OAKG;IACH,UAAU,EAAE,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC;CAC5B,CAAC,CAAC"}

package/dist/spine/classify.d.ts

@@ -10,19 +10,19 @@ import { type ClassifierLedger, type EmissionLedger, type MinerLedgers, type Rou
  */
 export declare const ClassifierResultSchema: z.ZodEffects<z.ZodObject<{
     disposition: z.ZodEnum<["structural", "behavioral"]>;
-    dispositionSource: z.ZodEnum<["classified", "error-default"]>;
+    dispositionSource: z.ZodEnum<["classified", "error-default", "authored-whitelist"]>;
 }, "strip", z.ZodTypeAny, {
     disposition: "structural" | "behavioral";
-    dispositionSource: "classified" | "error-default";
+    dispositionSource: "classified" | "error-default" | "authored-whitelist";
 }, {
     disposition: "structural" | "behavioral";
-    dispositionSource: "classified" | "error-default";
+    dispositionSource: "classified" | "error-default" | "authored-whitelist";
 }>, {
     disposition: "structural" | "behavioral";
-    dispositionSource: "classified" | "error-default";
+    dispositionSource: "classified" | "error-default" | "authored-whitelist";
 }, {
     disposition: "structural" | "behavioral";
-    dispositionSource: "classified" | "error-default";
+    dispositionSource: "classified" | "error-default" | "authored-whitelist";
 }>;
 export type ClassifierResult = z.infer<typeof ClassifierResultSchema>;
 /**

package/dist/spine/compile.d.ts

@@ -1,7 +1,6 @@
 import { type CompiledRule, type ProvenanceRecord } from '../compiler-schema.js';
 import { type Stage4Baseline, type Stage4VerificationResult, type Stage4VerifierDeps } from '../stage4-verifier.js';
-import type { CandidateRuleRecord } from './candidate-rule.js';
-import type { ClassifyStageResult } from './classify.js';
+import type { CompileInputCandidate } from './candidate-rule.js';
 import type { ClassifierLedger } from './ledgers.js';
 /**
  * The slice-4 output: a compiled, Stage-4-verified candidate. Carries `provenance`
@@ -16,6 +15,19 @@ export interface CompiledCandidate {
     rule: CompiledRule;
     stage4: Stage4VerificationResult;
 }
+/**
+ * ADR-112 §2 — the minimal input `runCompileStage` consumes: the candidates + the
+ * classifier ledger. A miner `ClassifyStageResult` satisfies it structurally (its
+ * extra `emissionLedger` is never read here); the authored producer's
+ * `toCompileFeed` builds it WITHOUT a mining emission ledger (an authored rule has
+ * no review-thread emission to attest, and the classifier ledger carries
+ * `dispositionSource: 'authored-whitelist'`, not a fabricated `'classified'`). One
+ * compiler, two producers — neither masquerading as the other.
+ */
+export interface CompileStageInput {
+    candidates: readonly CompileInputCandidate[];
+    classifierLedger: ClassifierLedger;
+}
 /** Pure compile outcome (no IO): a compiled rule, or a loud per-engine validation rejection. */
 export type CompileOutcome = {
     kind: 'compiled';
@@ -45,7 +57,7 @@ export interface CompileStageResult {
  * `rejected` outcome (NOT a throw) when the pattern parses but fails per-engine
  * safety validation (e.g. ReDoS) — a counted, reported `compile-rejected` state.
  */
-export declare function compileCandidate(candidate: CandidateRuleRecord, opts: {
+export declare function compileCandidate(candidate: CompileInputCandidate, opts: {
     now: string;
 }): CompileOutcome;
 /**
@@ -58,5 +70,5 @@ export declare function compileCandidate(candidate: CandidateRuleRecord, opts: {
  * new entries array — updated entries are spread copies, unmodified entries share
  * the original reference (a structural copy, not a deep copy).
  */
-export declare function runCompileStage(classify: ClassifyStageResult, deps: CompileStageDeps): Promise<CompileStageResult>;
+export declare function runCompileStage(classify: CompileStageInput, deps: CompileStageDeps): Promise<CompileStageResult>;
 //# sourceMappingURL=compile.d.ts.map