@mmnto/totem 1.67.1 → 1.69.0

package/dist/spine/ledgers.d.ts.map

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

package/dist/spine/ledgers.js

@@ -0,0 +1,209 @@
+// ─── ADR-111 §8 Gate-1 miner execution ledgers ──────────────────────────────
+//
+// The five CI-observable ledgers a deterministic zero-LLM harness asserts the
+// Falsifying Metric against (run in `totem lint` / the test suite). The schemas
+// here are the on-disk contract; the harness (separate module) reads them +
+// the split's cover validator to pin each of the 9 FM clauses:
+//   emission   → FM(a) provenance / FM(b) unverified / FM(f) seed-blindness
+//   drop       → §6 sole disposition for content failure
+//   classifier → FM(c) behavioral never compiled
+//   split      → FM(d)/(g) cover + FM(e) split-disjointness
+//   apiUsage   → FM(h) held-out-fetch count MUST be 0
+import { z } from 'zod';
+import { ProvenanceRecordSchema } from '../compiler-schema.js';
+import { ClassifierDispositionSchema } from './candidate-rule.js';
+import { SplitArtifactSchema } from './split.js';
+function nonEmpty(label) {
+    return z.string().refine((s) => s.trim().length > 0, {
+        message: `${label} must be a non-empty reference`,
+    });
+}
+const PrNumber = z.number().int().positive();
+/** Routing off the classifier gate: structural → `compile`, behavioral → `rag-only` (never compiled). */
+export const RoutingSchema = z.enum(['compile', 'rag-only']);
+/**
+ * Provenance of a classifier-ledger disposition: a genuine classifier judgment
+ * (`classified`) vs a safe-default forced by classifier failure (`error-default`,
+ * always `behavioral`/RAG-only). Reported in the §8 done-criterion so a flaky
+ * classifier's error rate is a NAMED third cause of behavioral-heavy output —
+ * never conflated with "lc structural signal is sparse" (a valid HONEST-NEGATIVE)
+ * or "the classifier mis-routed everything" (Tenet 19). It is NOT a falsifying
+ * condition (no FM clause) — a done-criterion diagnostic, like `stage4Confirmed`.
+ */
+export const DispositionSourceSchema = z.enum(['classified', 'error-default']);
+/**
+ * Compile + Stage-4 disposition of a compile-routed (structural) candidate (slice 4).
+ * Recorded additively on the classifier ledger so the §8 done-criterion (which reads
+ * the LEDGER, not the compiled `rule.status`) can distinguish the verify-stage outcomes
+ * rather than collapse them onto the `stage4Confirmed` boolean:
+ *   - `confirmed`             — Stage-4 found positive in-scope evidence (active rule).
+ *   - `untested-no-matches`   — Stage-4 ran, zero hits (neutral/inconclusive).
+ *   - `archived-out-of-scope` — the §4 backstop ACTIVELY rejected a mis-structural
+ *                               candidate (fired on the baseline) — a classifier-over-eager
+ *                               signal, NOT the same as `no-matches` (Tenet 19, the
+ *                               compile-stage twin of `dispositionSource`).
+ *   - `compile-rejected`      — the pattern parsed but failed per-engine safety
+ *                               validation (e.g. ReDoS); never produced as a rule.
+ * Absent on entries the compile stage never touched (behavioral/rag-only, or a
+ * classify-only run). NOT a falsifying condition (no FM clause) — a done-criterion
+ * diagnostic; the harness only locks its consistency with `stage4Confirmed`.
+ */
+export const Stage4LedgerOutcomeSchema = z.enum([
+    'confirmed',
+    'untested-no-matches',
+    'archived-out-of-scope',
+    'compile-rejected',
+]);
+// ── 1. Emission ledger ──────────────────────────────────────────────────────
+export const EmissionLedgerEntrySchema = z.object({
+    candidateRef: nonEmpty('candidateRef'),
+    provenance: ProvenanceRecordSchema,
+    classifierDisposition: ClassifierDispositionSchema,
+    routing: RoutingSchema,
+    classifierLedgerRef: nonEmpty('classifierLedgerRef'),
+    unverified: z.literal(true),
+});
+export const EmissionLedgerSchema = z.object({
+    entries: z.array(EmissionLedgerEntrySchema),
+    /**
+     * Run-level seed-blindness attestation (§7). `false` = no seed class was
+     * supplied to any extraction/classification stage; `true` falsifies FM(f).
+     */
+    extractionInputsAttestation: z.object({ seedClassesProvided: z.boolean() }),
+});
+// ── 2. Drop ledger — the SOLE disposition for any content/provenance failure ──
+export const DropReasonCodeSchema = z.enum([
+    'unreachable',
+    'truncated',
+    'unparseable',
+    'incomplete-provenance',
+    // 'resolved-rejected' (slice 5a, mmnto-ai/totem#2201) — an ELIGIBILITY
+    // rejection, semantically distinct from the four above. The content WAS
+    // fetched (not `unreachable`), CAN be complete (not `truncated`), and PARSES
+    // (not `unparseable`); its provenance is intact (not `incomplete-provenance`).
+    // It is dropped because every human comment lived on review threads whose
+    // resolution status (`isResolved || isOutdated`) marks them contamination: a
+    // resolved/outdated thread reflects a discussion the author already closed, so
+    // mining it would launder superseded review noise into a candidate rule. The
+    // §6 resolution gate (in `runExtractStage`) emptied the eligible-human-comment
+    // set — every such rejection is ledgered here (never silently pre-filtered by
+    // the adapter), satisfying §8 "every rejection ledgered" + the FM.
+    'resolved-rejected',
+]);
+export const DropLedgerEntrySchema = z.object({
+    /**
+     * Source PR of the dropped candidate. REQUIRED — the funnel always knows which
+     * train PR it is processing (it iterates the train slice), even for an
+     * `incomplete-provenance` drop where the review-thread/SHA is missing. An
+     * unrecorded source would make the drop uncreditable and open an undetectable
+     * FM(i) train-skip gap.
+     */
+    sourcePr: PrNumber,
+    reasonCode: DropReasonCodeSchema,
+    detail: z.string().optional(),
+});
+export const DropLedgerSchema = z.object({ entries: z.array(DropLedgerEntrySchema) });
+// ── 3. Classifier ledger (reported in the done-criterion, §8) ────────────────
+export const ClassifierLedgerEntrySchema = z.object({
+    /**
+     * This classifier-ledger entry's own ref — the JOIN KEY that an emission entry's
+     * `classifierLedgerRef` points to (not necessarily the candidate's own
+     * `candidateRef`). Slice 1 joins on this ref + checks disposition consistency; a
+     * stricter same-candidate identity assertion is deferred to slice 2.
+     */
+    candidateRef: nonEmpty('candidateRef'),
+    disposition: ClassifierDispositionSchema,
+    /**
+     * Stage-4 Verify-Against-Codebase confirmation — the deterministic backstop.
+     * NON-CERTIFYING IN SLICE 1: Stage-4 is wired in slice 4, so the harness does NOT
+     * yet require `stage4Confirmed === true` for compile-routed candidates (it checks
+     * disposition consistency only). The field is carried now so slice 4 can enforce
+     * it without a schema change.
+     */
+    stage4Confirmed: z.boolean(),
+    /**
+     * Whether `disposition` is a genuine classifier judgment or a safe-default on
+     * classifier failure (always `behavioral`). Present-and-`'classified'` in normal
+     * runs; set `'error-default'` on the safe-default path (slice 3). Read by the §8
+     * terminal report (slice 5) to keep a flaky-classifier error rate from
+     * masquerading as structural-signal sparsity (Tenet 19, panel flag-5). Not an FM
+     * condition — a diagnostic, like `stage4Confirmed`.
+     */
+    dispositionSource: DispositionSourceSchema,
+    /**
+     * Compile + Stage-4 outcome (slice 4), set by `runCompileStage` on the matched
+     * compile-routed entry. OPTIONAL — absent until the compile stage runs (and
+     * never set on behavioral/rag-only entries, which are never compiled). When
+     * present it MUST be consistent with `stage4Confirmed`: `confirmed` ⟺
+     * `stage4Confirmed === true`; the other three outcomes ⟺ `false`. The §8 harness
+     * locks that consistency (no new FM clause) — see `Stage4LedgerOutcomeSchema`.
+     */
+    stage4Outcome: Stage4LedgerOutcomeSchema.optional(),
+});
+export const ClassifierLedgerSchema = z.object({ entries: z.array(ClassifierLedgerEntrySchema) });
+// ── 4. Split ledger — self-contained for the cover check ─────────────────────
+export const SplitLedgerSchema = z
+    .object({
+    split: SplitArtifactSchema,
+    /** The frozen corpus = `selectionRule(asOfCommit)` the cover is checked against. */
+    corpus: z.array(PrNumber),
+    /** PR → merge-commit, for the disjoint-by-merge-commit check (rebuilds the map). */
+    corpusMergeCommits: z.array(z.object({
+        pr: PrNumber,
+        // Lowercase 40-hex SHA (same canonical form as asOfCommit / provenance.commitSha)
+        // — a generic string would admit case/format bypasses of the collision check.
+        mergeCommit: z.string().regex(/^[0-9a-f]{40}$/, {
+            message: 'mergeCommit must be a lowercase 40-hex SHA',
+        }),
+    })),
+})
+    .refine((d) => {
+    const covered = new Set(d.corpusMergeCommits.map((e) => e.pr));
+    return d.corpus.every((pr) => covered.has(pr));
+}, {
+    // An incomplete map would silently skip merge-commit collision detection for
+    // the absent PRs — a straddling revert pair could escape the disjoint-by-
+    // merge-commit guard. Require full coverage of the corpus.
+    message: 'corpusMergeCommits must cover every corpus PR',
+    path: ['corpusMergeCommits'],
+})
+    .superRefine((d, ctx) => {
+    // Duplicate rows would inflate the cover-base bag while the Set-based checks
+    // dedupe them away — reject duplicates in corpus and corpusMergeCommits.pr.
+    if (new Set(d.corpus).size !== d.corpus.length) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: 'corpus contains duplicate PRs',
+            path: ['corpus'],
+        });
+    }
+    const prs = d.corpusMergeCommits.map((e) => e.pr);
+    if (new Set(prs).size !== prs.length) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: 'corpusMergeCommits contains duplicate PRs',
+            path: ['corpusMergeCommits'],
+        });
+    }
+});
+// ── 5. API-usage ledger ──────────────────────────────────────────────────────
+export const ApiFetchSliceSchema = z.enum(['train', 'heldOut']);
+export const ApiUsageLedgerEntrySchema = z.object({
+    targetPr: PrNumber,
+    slice: ApiFetchSliceSchema,
+    fetchKind: nonEmpty('fetchKind'),
+});
+export const ApiUsageLedgerSchema = z.object({
+    entries: z.array(ApiUsageLedgerEntrySchema),
+    /** MUST be 0 — any held-out/control content fetch during mining falsifies FM(h). */
+    heldOutFetchCount: z.number().int().nonnegative(),
+});
+// ── Aggregate ────────────────────────────────────────────────────────────────
+export const MinerLedgersSchema = z.object({
+    emission: EmissionLedgerSchema,
+    drop: DropLedgerSchema,
+    classifier: ClassifierLedgerSchema,
+    split: SplitLedgerSchema,
+    apiUsage: ApiUsageLedgerSchema,
+});
+//# sourceMappingURL=ledgers.js.map

package/dist/spine/ledgers.js.map

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

package/dist/spine/miner-harness.d.ts

@@ -0,0 +1,30 @@
+import { type MinerLedgers } from './ledgers.js';
+export type FmClause = 'a' | 'b' | 'c' | 'd' | 'e-split' | 'e-emission' | 'f' | 'g' | 'h' | 'i' | 'stage4-consistency' | 'schema';
+export interface FmViolation {
+    clause: FmClause;
+    detail: string;
+}
+export interface FalsificationResult {
+    /** true iff NO Falsifying-Metric clause holds (the miner run is contract-clean). */
+    ok: boolean;
+    violations: FmViolation[];
+}
+/**
+ * Run the §8 falsification harness over raw (untrusted) ledger JSON. The schema
+ * parse is the first gate — an incomplete provenance tuple (FM(a)) or a
+ * non-`unverified` mint (FM(b)) cannot construct a valid `MinerLedgers`, so a
+ * parse failure is mapped to its clause. Surviving ledgers then run the
+ * cross-cutting checks (c, d, e-split, e-emission, f, g, h, i).
+ */
+export declare function runFalsificationHarness(rawLedgers: unknown): FalsificationResult;
+/**
+ * Cross-cutting checks over an ALREADY-VALIDATED `MinerLedgers`.
+ *
+ * ⚠ FM(a) (incomplete provenance) and FM(b) (non-`unverified` mint) are
+ * SCHEMA-ENFORCED and are NOT re-asserted here — a caller that hands in an
+ * in-process `MinerLedgers` gets no FM(a)/(b) coverage from this function. For
+ * untrusted/raw ledger JSON use {@link runFalsificationHarness}, which parses
+ * (catching FM(a)/(b)) before delegating here.
+ */
+export declare function checkParsedLedgers(ledgers: MinerLedgers): FmViolation[];
+//# sourceMappingURL=miner-harness.d.ts.map

package/dist/spine/miner-harness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"miner-harness.d.ts","sourceRoot":"","sources":["../../src/spine/miner-harness.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,KAAK,YAAY,EAAsB,MAAM,cAAc,CAAC;AAGrE,MAAM,MAAM,QAAQ,GAChB,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,SAAS,GACT,YAAY,GACZ,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GAIH,oBAAoB,GACpB,QAAQ,CAAC;AAEb,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,QAAQ,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,mBAAmB;IAClC,oFAAoF;IACpF,EAAE,EAAE,OAAO,CAAC;IACZ,UAAU,EAAE,WAAW,EAAE,CAAC;CAC3B;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,UAAU,EAAE,OAAO,GAAG,mBAAmB,CAOhF;AAED;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,YAAY,GAAG,WAAW,EAAE,CAUvE"}

package/dist/spine/miner-harness.js

@@ -0,0 +1,214 @@
+// ─── ADR-111 §8 Gate-1 falsification harness — zero-LLM, CI-observable ───────
+//
+// Asserts the nine Falsifying-Metric clauses (a)–(i) against the five execution
+// ledgers (§8) + the split cover validator. Pure + deterministic; runs in
+// `totem lint` / the test suite. The miner run is contract-clean iff `ok` (no
+// clause holds). Clause (e) has two halves: `e-split` (slice disjointness, from
+// the cover validator) and `e-emission` (∀ emitted: `provenance.mergedPr ∈
+// trainPrs`) — split-disjointness is necessary-not-sufficient (a candidate can
+// be sourced from a held-out PR even with perfectly disjoint slices).
+import { MinerLedgersSchema } from './ledgers.js';
+import { validateSplitCover } from './split.js';
+/**
+ * Run the §8 falsification harness over raw (untrusted) ledger JSON. The schema
+ * parse is the first gate — an incomplete provenance tuple (FM(a)) or a
+ * non-`unverified` mint (FM(b)) cannot construct a valid `MinerLedgers`, so a
+ * parse failure is mapped to its clause. Surviving ledgers then run the
+ * cross-cutting checks (c, d, e-split, e-emission, f, g, h, i).
+ */
+export function runFalsificationHarness(rawLedgers) {
+    const parsed = MinerLedgersSchema.safeParse(rawLedgers);
+    if (!parsed.success) {
+        return { ok: false, violations: parsed.error.issues.map(mapZodIssueToClause) };
+    }
+    const violations = checkParsedLedgers(parsed.data);
+    return { ok: violations.length === 0, violations };
+}
+/**
+ * Cross-cutting checks over an ALREADY-VALIDATED `MinerLedgers`.
+ *
+ * ⚠ FM(a) (incomplete provenance) and FM(b) (non-`unverified` mint) are
+ * SCHEMA-ENFORCED and are NOT re-asserted here — a caller that hands in an
+ * in-process `MinerLedgers` gets no FM(a)/(b) coverage from this function. For
+ * untrusted/raw ledger JSON use {@link runFalsificationHarness}, which parses
+ * (catching FM(a)/(b)) before delegating here.
+ */
+export function checkParsedLedgers(ledgers) {
+    const violations = [];
+    checkClassifierRouting(ledgers, violations); // (c)
+    checkStage4Consistency(ledgers, violations); // (consistency, not an FM letter)
+    checkSplitCover(ledgers, violations); // (d) / (g) / (e-split)
+    checkEmissionMembership(ledgers, violations); // (e-emission)
+    checkSeedBlindness(ledgers, violations); // (f)
+    checkApiUsage(ledgers, violations); // (h)
+    checkTrainCoverage(ledgers, violations); // (i)
+    return violations;
+}
+// Map a Zod parse failure to its FM clause by a SEGMENT match on the issue path:
+// a `provenance` segment ⇒ FM(a) (incomplete tuple), an `unverified` segment ⇒
+// FM(b) (non-Yellow mint). Segment-level (not a substring on the joined path) so
+// a future field like `classifierProvenanceRef` can't masquerade as `provenance`.
+function mapZodIssueToClause(issue) {
+    const segments = issue.path.map(String);
+    const clause = segments.includes('unverified')
+        ? 'b'
+        : segments.includes('provenance')
+            ? 'a'
+            : 'schema';
+    return { clause, detail: `${segments.join('.') || '<root>'}: ${issue.message}` };
+}
+// (c) — a behavioral candidate must never reach compile, and every emitted
+// candidate must carry an attesting classifier-ledger entry.
+function checkClassifierRouting(ledgers, out) {
+    const classifierByRef = new Map(ledgers.classifier.entries.map((c) => [c.candidateRef, c]));
+    for (const e of ledgers.emission.entries) {
+        if (e.classifierDisposition === 'behavioral' && e.routing === 'compile') {
+            out.push({
+                clause: 'c',
+                detail: `candidate ${e.candidateRef}: behavioral candidate routed to compile`,
+            });
+        }
+        const attesting = classifierByRef.get(e.classifierLedgerRef);
+        if (attesting === undefined) {
+            out.push({
+                clause: 'c',
+                detail: `candidate ${e.candidateRef}: no classifier-ledger entry for ref '${e.classifierLedgerRef}'`,
+            });
+        }
+        else if (e.classifierDisposition !== attesting.disposition) {
+            // The two ledgers disagree on this candidate's class — a producer integrity bug.
+            out.push({
+                clause: 'c',
+                detail: `candidate ${e.candidateRef}: emission disposition '${e.classifierDisposition}' does not match classifier-ledger disposition '${attesting.disposition}'`,
+            });
+        }
+        else if (e.routing === 'compile' && attesting.disposition === 'behavioral') {
+            out.push({
+                clause: 'c',
+                detail: `candidate ${e.candidateRef}: compile-routed but classifier ledger attests behavioral`,
+            });
+        }
+    }
+}
+// (consistency, NOT an FM letter) — the compile/Stage-4 outcome recorded on a
+// classifier entry must agree with its `stage4Confirmed` boolean. By construction
+// `runCompileStage`'s atomic outcome→{status, stage4Confirmed, stage4Outcome} map
+// makes desync unreachable; this locks it anyway (symmetric to FM(c)'s by-
+// construction check). `confirmed` ⟺ `stage4Confirmed:true`; the three inert
+// outcomes ⟺ `false`; an entry with NO recorded outcome can never be confirmed
+// (nothing produced the evidence — e.g. a behavioral/rag-only or pre-compile entry).
+// Per the panel (strategy/codex/gemini flag-5 shape) this is a done-criterion guard,
+// NOT a new lettered Falsifying-Metric clause — a–i are unchanged.
+function checkStage4Consistency(ledgers, out) {
+    for (const c of ledgers.classifier.entries) {
+        if (c.stage4Outcome === undefined) {
+            if (c.stage4Confirmed) {
+                out.push({
+                    clause: 'stage4-consistency',
+                    detail: `classifier entry ${c.candidateRef}: stage4Confirmed is true but no stage4Outcome was recorded`,
+                });
+            }
+            continue;
+        }
+        const confirmedByOutcome = c.stage4Outcome === 'confirmed';
+        if (c.stage4Confirmed !== confirmedByOutcome) {
+            out.push({
+                clause: 'stage4-consistency',
+                detail: `classifier entry ${c.candidateRef}: stage4Confirmed=${c.stage4Confirmed} is inconsistent with stage4Outcome='${c.stage4Outcome}'`,
+            });
+        }
+    }
+}
+// (d) extra / (g) missing / (e-split) disjointness — via the cover validator.
+function checkSplitCover(ledgers, out) {
+    const { split, corpus, corpusMergeCommits } = ledgers.split;
+    const mergeCommitByPr = new Map(corpusMergeCommits.map(({ pr, mergeCommit }) => [pr, mergeCommit]));
+    const r = validateSplitCover(split, corpus, mergeCommitByPr);
+    if (r.cover.extra.length > 0) {
+        out.push({ clause: 'd', detail: `out-of-corpus split members: [${r.cover.extra}]` });
+    }
+    if (r.cover.missing.length > 0) {
+        out.push({ clause: 'g', detail: `corpus PRs in no slice (silent drop): [${r.cover.missing}]` });
+    }
+    const splitDisjointness = r.overlaps.trainHeldOut.length +
+        r.overlaps.trainExcluded.length +
+        r.overlaps.heldOutExcluded.length +
+        r.controlsOutsideHeldOut.length +
+        r.controlOverlap.length +
+        r.mergeCommitCollisions.length;
+    if (splitDisjointness > 0) {
+        out.push({
+            clause: 'e-split',
+            detail: `slice disjointness violated — train∩heldOut=[${r.overlaps.trainHeldOut}] ` +
+                `train∩excluded=[${r.overlaps.trainExcluded}] heldOut∩excluded=[${r.overlaps.heldOutExcluded}] ` +
+                `controls⊄heldOut=[${r.controlsOutsideHeldOut}] pos∩neg=[${r.controlOverlap}] ` +
+                `mergeCommitCollisions=[${r.mergeCommitCollisions}]`,
+        });
+    }
+}
+// (e-emission) — every emitted candidate's provenance PR must be in the train slice.
+function checkEmissionMembership(ledgers, out) {
+    const trainSet = new Set(ledgers.split.split.trainPrs);
+    const mergeCommitByPr = new Map(ledgers.split.corpusMergeCommits.map(({ pr, mergeCommit }) => [pr, mergeCommit]));
+    for (const e of ledgers.emission.entries) {
+        if (!trainSet.has(e.provenance.mergedPr)) {
+            out.push({
+                clause: 'e-emission',
+                detail: `candidate ${e.candidateRef}: provenance PR ${e.provenance.mergedPr} is not in the train slice`,
+            });
+            continue;
+        }
+        // The provenance commit SHA must be the PR's frozen merge commit — a tuple
+        // carrying an arbitrary (or another PR's) SHA is provenance in name only.
+        const expectedSha = mergeCommitByPr.get(e.provenance.mergedPr);
+        if (expectedSha !== undefined && e.provenance.commitSha !== expectedSha) {
+            out.push({
+                clause: 'e-emission',
+                detail: `candidate ${e.candidateRef}: provenance commitSha does not match PR ${e.provenance.mergedPr}'s frozen merge commit`,
+            });
+        }
+    }
+}
+// (f) — seed-blindness attestation.
+function checkSeedBlindness(ledgers, out) {
+    if (ledgers.emission.extractionInputsAttestation.seedClassesProvided) {
+        out.push({
+            clause: 'f',
+            detail: 'a seed class was supplied to an extraction/classification stage',
+        });
+    }
+}
+// (h) — no content fetch against a held-out/control PR. The actual partition is
+// DERIVED from the frozen split (heldOut membership), NOT trusted from the
+// ledger's self-declared `slice` label — a buggy/adversarial producer could read
+// held-out material and label it `slice: "train"`. The declared heldOutFetchCount
+// is likewise recomputed from the entries, never trusted as an independent claim.
+function checkApiUsage(ledgers, out) {
+    const heldOutSet = new Set(ledgers.split.split.heldOutPrs);
+    const heldOutFetches = ledgers.apiUsage.entries.filter((f) => heldOutSet.has(f.targetPr) || f.slice === 'heldOut');
+    if (heldOutFetches.length > 0 || ledgers.apiUsage.heldOutFetchCount !== heldOutFetches.length) {
+        out.push({
+            clause: 'h',
+            detail: `held-out fetch(es) present or miscounted (derived=${heldOutFetches.length}, declared=${ledgers.apiUsage.heldOutFetchCount}, targets=[${heldOutFetches.map((f) => f.targetPr)}])`,
+        });
+    }
+}
+// (i) — every train PR must be processed by the emission OR the drop ledger.
+// This is AT-LEAST-ONE (the ADR-111 FM(i) violation is "processed by NEITHER the
+// emission ledger NOR the drop ledger"), NOT exactly-one: a single PR's review
+// thread can yield multiple candidates, so the same train PR legitimately appears
+// in BOTH ledgers (one candidate emitted, another dropped). `sourcePr` is
+// required on every drop, so each drop is creditable here (no uncreditable gap).
+function checkTrainCoverage(ledgers, out) {
+    const emitted = new Set(ledgers.emission.entries.map((e) => e.provenance.mergedPr));
+    const dropped = new Set(ledgers.drop.entries.map((d) => d.sourcePr));
+    for (const pr of ledgers.split.split.trainPrs) {
+        if (!emitted.has(pr) && !dropped.has(pr)) {
+            out.push({
+                clause: 'i',
+                detail: `train PR ${pr} processed by neither the emission nor the drop ledger`,
+            });
+        }
+    }
+}
+//# sourceMappingURL=miner-harness.js.map

package/dist/spine/miner-harness.js.map

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

package/dist/spine/miner-harness.test.d.ts

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

package/dist/spine/miner-harness.test.d.ts.map

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