@mmnto/cli 1.70.0 → 1.71.0

package/dist/commands/spine-cert-run-corpus.js

@@ -0,0 +1,133 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { z } from 'zod';
+import { buildCertifyingCorpus } from './spine-cert-corpus.js';
+import { buildReplayAdapters } from './spine-cert-record.js';
+import { ReplayArtifactSchema } from './spine-llm-replay.js';
+// ─── Fixture file names under the gate-1 dir ─────────
+const SPLIT_FILE = 'split.json';
+const REPLAY_FILE = 'llm-replay.v1.json';
+const CONTENT_FILE = 'review-content.json';
+const PR_DIFFS_FILE = 'pr-diffs.json';
+const GROUND_TRUTH_FILE = 'ground-truth-labels.json';
+const LEDGERS_FILE = 'miner-ledgers.json';
+// ─── Fixture schemas (the committed cert-run inputs) ──
+const ReviewThreadContentSchema = z.object({
+    pr: z.number().int().positive(),
+    mergeCommitSha: z.string().regex(/^[0-9a-f]{40}$/),
+    threads: z.array(z.object({
+        path: z.string(),
+        comments: z.array(z.object({ author: z.string(), body: z.string() })),
+        isResolved: z.boolean(),
+        isOutdated: z.boolean(),
+    })),
+});
+const ResolvedPrDiffSchema = z.object({
+    pr: z.number().int().positive(),
+    diff: z.string(),
+    controlKind: z.enum(['corpus', 'positive', 'negative']),
+    targetRuleId: z.string().optional(),
+});
+// firingLabelId → TP|FP
+const GroundTruthSchema = z.record(z.enum(['TP', 'FP']));
+/** A zero-network ReviewThreadSource backed by committed, frozen review content. */
+function frozenSourceFrom(contents) {
+    const byPr = new Map(contents.map((c) => [c.pr, c]));
+    return {
+        async fetch(pr) {
+            const content = byPr.get(pr);
+            return content
+                ? { kind: 'ok', content }
+                : { kind: 'unreachable', detail: `no frozen review content for pr ${pr}` };
+        },
+    };
+}
+/**
+ * Load + validate the committed cert-run fixture inputs from the gate-1 dir.
+ * Async so the `@mmnto/totem` runtime values (schema + error class) are
+ * dynamically imported per the CLI lazy-import convention, not pulled in at
+ * module load.
+ */
+export async function loadCertRunFixtures(gate1Dir) {
+    const { SplitArtifactSchema, TotemError } = await import('@mmnto/totem');
+    const loadJson = (file) => {
+        let raw;
+        try {
+            raw = fs.readFileSync(file, 'utf-8');
+        }
+        catch (err) {
+            throw new TotemError('CONFIG_INVALID', `Cert-run fixture missing: ${file}`, 'Ensure the gate-1 fixture set exists and is readable.', err);
+        }
+        try {
+            return JSON.parse(raw);
+        }
+        catch (err) {
+            throw new TotemError('CONFIG_INVALID', `Cert-run fixture is not valid JSON (${file})`, 'Re-freeze the gate-1 fixtures with `spine windtunnel record`.', err);
+        }
+    };
+    const split = SplitArtifactSchema.parse(loadJson(path.join(gate1Dir, SPLIT_FILE)));
+    const artifact = ReplayArtifactSchema.parse(loadJson(path.join(gate1Dir, REPLAY_FILE)));
+    const content = z
+        .array(ReviewThreadContentSchema)
+        .parse(loadJson(path.join(gate1Dir, CONTENT_FILE)));
+    const prDiffs = z.array(ResolvedPrDiffSchema).parse(loadJson(path.join(gate1Dir, PR_DIFFS_FILE)));
+    const gtRecord = GroundTruthSchema.parse(loadJson(path.join(gate1Dir, GROUND_TRUTH_FILE)));
+    const groundTruth = new Map(Object.entries(gtRecord));
+    return { split, artifact, content, prDiffs, groundTruth };
+}
+/** Derive the SplitLedger from the loaded split + the lock's resolved corpus. */
+function splitLedgerFrom(split, lock) {
+    return {
+        split,
+        corpus: lock.corpus.resolvedPrs.map((p) => p.pr),
+        corpusMergeCommits: lock.corpus.resolvedPrs.map((p) => ({
+            pr: p.pr,
+            mergeCommit: p.mergeCommit,
+        })),
+    };
+}
+/**
+ * Build the REPLAY-mode `CertifyingCorpusProvider` the certifying run injects.
+ *
+ * Loads the committed cert-run fixtures (split, frozen `llm-replay.v1` artifact,
+ * frozen review content, resolved-PR diffs, ground-truth labels) from the gate-1
+ * dir, constructs the zero-network replay adapters (gated on the lock's L2
+ * `llmReplaySha`) + a frozen review-thread source, then composes them through
+ * `buildCertifyingCorpus`. fold-I ledgers are emitted (default: written to
+ * `miner-ledgers.json`) for §7 observability. Throws loud if the lock lacks the
+ * L2 replay hash (no safe default for an integrity gate).
+ */
+export function buildReplayCorpusProvider(opts) {
+    return async (lock) => {
+        const { TotemError } = await import('@mmnto/totem');
+        const expectedHash = lock.controls.integrity.llmReplaySha;
+        if (!expectedHash) {
+            throw new TotemError('CONFIG_INVALID', 'Certifying run: lock is missing controls.integrity.llmReplaySha (L2) — the frozen ' +
+                'llm-replay fixture cannot be integrity-checked.', 'Re-freeze the lock after a `record` run.');
+        }
+        const { split, artifact, content, prDiffs, groundTruth } = await loadCertRunFixtures(opts.gate1Dir);
+        const { extractor, classifier } = buildReplayAdapters(artifact, expectedHash);
+        const { corpus, ledgers } = await buildCertifyingCorpus({
+            split,
+            splitLedger: splitLedgerFrom(split, lock),
+            source: frozenSourceFrom(content),
+            extractor,
+            classifier,
+            seedClassesProvided: opts.seedClassesProvided ?? false,
+            stage4: opts.stage4,
+            now: opts.now,
+            prDiffs,
+            groundTruth,
+        });
+        // fold-I (§7): emit the miner ledgers, observable beside the cert-run report.
+        if (opts.onLedgers) {
+            opts.onLedgers(ledgers);
+        }
+        else {
+            fs.mkdirSync(opts.gate1Dir, { recursive: true });
+            fs.writeFileSync(path.join(opts.gate1Dir, LEDGERS_FILE), JSON.stringify(ledgers, null, 2), 'utf-8');
+        }
+        return corpus;
+    };
+}
+//# sourceMappingURL=spine-cert-run-corpus.js.map

package/dist/commands/spine-cert-run-corpus.js.map

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

package/dist/commands/spine-cert-run-corpus.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=spine-cert-run-corpus.test.d.ts.map

package/dist/commands/spine-cert-run-corpus.test.d.ts.map

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

package/dist/commands/spine-cert-run-corpus.test.js

@@ -0,0 +1,171 @@
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { recordReplayFixture } from './spine-cert-record.js';
+import { buildReplayCorpusProvider } from './spine-cert-run-corpus.js';
+import { serializeReplayArtifact } from './spine-llm-replay.js';
+// ─── Fixtures ────────────────────────────────────────
+const sha = (n) => String(n).padStart(40, '0');
+const NOW = '2026-06-19T12:00:00.000Z';
+const REGEX_DSL = [
+    '**Pattern:** `forbiddenCall\\(`',
+    '**Engine:** regex',
+    '**Severity:** warning',
+    '',
+    '### Bad Example',
+    '```ts',
+    'forbiddenCall()',
+    '```',
+].join('\n');
+const PROVENANCE = {
+    promptTemplateHash: sha(11),
+    systemPromptHash: sha(12),
+    provider: 'anthropic',
+    model: 'claude-test',
+    temperature: 0,
+    orchestratorVersion: '0.0.0-test',
+    adapterKind: 'extractor+classifier',
+    keyVersion: 'v1',
+    totemVersion: '0.0.0-test',
+};
+const SPLIT = {
+    asOfCommit: sha(100),
+    trainPrs: [1],
+    heldOutPrs: [],
+    excludedPrs: [],
+    positiveControlPrs: [],
+    negativeControlPrs: [],
+    splitRule: { predicate: 'code-touching non-bot', cutIndex: 1 },
+};
+const SPLIT_LEDGER = {
+    split: SPLIT,
+    corpus: [1],
+    corpusMergeCommits: [{ pr: 1, mergeCommit: sha(1) }],
+};
+function content(pr) {
+    return {
+        pr,
+        mergeCommitSha: sha(pr),
+        threads: [
+            {
+                path: 'src/a.ts',
+                comments: [{ author: 'Jane', body: 'note' }],
+                isResolved: false,
+                isOutdated: false,
+            },
+        ],
+    };
+}
+function fakeSource() {
+    return {
+        async fetch(pr) {
+            return { kind: 'ok', content: content(pr) };
+        },
+    };
+}
+function fakeExtractor() {
+    return {
+        async draft() {
+            return [REGEX_DSL];
+        },
+    };
+}
+function fakeClassifier() {
+    return {
+        async classify() {
+            return { disposition: 'structural', dispositionSource: 'classified' };
+        },
+    };
+}
+function stage4(files) {
+    return {
+        listFiles: () => Promise.resolve(Object.keys(files)),
+        readFile: (f) => f in files ? Promise.resolve(files[f]) : Promise.reject(new Error(`absent ${f}`)),
+    };
+}
+/** A minimal lock partial — the provider reads only the L2 hash + resolved corpus. */
+function lockWith(llmReplaySha) {
+    return {
+        controls: { integrity: { llmReplaySha } },
+        corpus: { resolvedPrs: [{ pr: 1, mergeCommit: sha(1) }] },
+    };
+}
+let tmpDir;
+let gate1Dir;
+beforeEach(async () => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'totem-cert-run-'));
+    gate1Dir = path.join(tmpDir, 'gate-1');
+    fs.mkdirSync(gate1Dir, { recursive: true });
+    // Freeze a replay fixture from the live fakes, then lay down the committed
+    // cert-run inputs the run path loads.
+    const { artifact } = await recordReplayFixture({
+        split: SPLIT,
+        splitLedger: SPLIT_LEDGER,
+        source: fakeSource(),
+        liveExtractor: fakeExtractor(),
+        liveClassifier: fakeClassifier(),
+        seedClassesProvided: false,
+        provenance: PROVENANCE,
+    });
+    fs.writeFileSync(path.join(gate1Dir, 'split.json'), JSON.stringify(SPLIT), 'utf-8');
+    fs.writeFileSync(path.join(gate1Dir, 'llm-replay.v1.json'), serializeReplayArtifact(artifact), 'utf-8');
+    fs.writeFileSync(path.join(gate1Dir, 'review-content.json'), JSON.stringify([content(1)]), 'utf-8');
+    fs.writeFileSync(path.join(gate1Dir, 'pr-diffs.json'), JSON.stringify([]), 'utf-8');
+    fs.writeFileSync(path.join(gate1Dir, 'ground-truth-labels.json'), JSON.stringify({}), 'utf-8');
+});
+afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+});
+/** Recompute the artifact hash the lock must carry (L2), from the written fixture. */
+async function fixtureHash() {
+    const { hash } = await recordReplayFixture({
+        split: SPLIT,
+        splitLedger: SPLIT_LEDGER,
+        source: fakeSource(),
+        liveExtractor: fakeExtractor(),
+        liveClassifier: fakeClassifier(),
+        seedClassesProvided: false,
+        provenance: PROVENANCE,
+    });
+    return hash;
+}
+// ─── Tests ───────────────────────────────────────────
+describe('buildReplayCorpusProvider (run-path)', () => {
+    it('loads the committed fixtures + replays them into a corpus (zero LLM/network)', async () => {
+        const hash = await fixtureHash();
+        let captured;
+        const provider = buildReplayCorpusProvider({
+            gate1Dir,
+            stage4: stage4({ 'src/a.ts': 'forbiddenCall()' }),
+            now: NOW,
+            onLedgers: (l) => {
+                captured = l;
+            },
+        });
+        const corpus = await provider(lockWith(hash));
+        expect(corpus.rules).toHaveLength(1);
+        expect(corpus.provenanceByRule.get(corpus.rules[0].lessonHash)?.mergedPr).toBe(1);
+        // fold-I ledgers emitted via the sink.
+        expect(captured?.apiUsage.heldOutFetchCount).toBe(0);
+    });
+    it('throws loud when the lock lacks the L2 llmReplaySha (no integrity gate)', async () => {
+        const provider = buildReplayCorpusProvider({
+            gate1Dir,
+            stage4: stage4({ 'src/a.ts': 'forbiddenCall()' }),
+            now: NOW,
+        });
+        await expect(provider(lockWith(undefined))).rejects.toThrow(/llmReplaySha/);
+    });
+    it('writes the fold-I miner ledgers to the gate-1 dir by default', async () => {
+        const hash = await fixtureHash();
+        const provider = buildReplayCorpusProvider({
+            gate1Dir,
+            stage4: stage4({ 'src/a.ts': 'forbiddenCall()' }),
+            now: NOW,
+        });
+        await provider(lockWith(hash));
+        expect(fs.existsSync(path.join(gate1Dir, 'miner-ledgers.json'))).toBe(true);
+    });
+});
+//# sourceMappingURL=spine-cert-run-corpus.test.js.map

package/dist/commands/spine-cert-run-corpus.test.js.map

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

package/dist/commands/spine-windtunnel.d.ts

@@ -20,6 +20,51 @@ export interface RunOptions {
     lcDir?: string;
     lockPath?: string;
     phase?: string;
+    /**
+     * 5c-ii injection seam (out of 5c-i scope to populate): the certifying corpus
+     * — resolved-PR diffs (corpus + controls), the active compiled rules, and the
+     * frozen ground-truth labels. When omitted on a certifying run, the real
+     * engine path throws a structured "corpus provider not wired" error rather
+     * than silently scoring an empty set. 5c-ii (the orchestrator) supplies the
+     * live-recorded corpus here; 5c-i unit tests supply a deterministic fixture.
+     */
+    certifyingCorpus?: CertifyingCorpusProvider;
+}
+/**
+ * The certifying corpus the real engine scores (5c-ii supplies this; 5c-i
+ * defines the seam + the deterministic engine that consumes it). Returns the
+ * active compiled rules (archived MUST be excluded — fold-F throws otherwise),
+ * the resolved-PR diffs (corpus + positive/negative controls), and the frozen
+ * ground-truth labels keyed by firingLabelId.
+ */
+export type CertifyingCorpusProvider = (lock: WindtunnelLock) => Promise<CertifyingCorpus> | CertifyingCorpus;
+export interface CertifyingCorpus {
+    rules: import('@mmnto/totem').CompiledRule[];
+    prDiffs: import('@mmnto/totem').ResolvedPrDiff[];
+    groundTruth: Map<string, import('@mmnto/totem').GroundTruthLabel>;
+    /**
+     * Mining provenance per rule (lessonHash → provenance) — supplied by the
+     * orchestrator from the candidate/emission records. fold-B needs it to stamp
+     * legitimacy; a survivor without provenance is surfaced as a skip, never
+     * fabricated.
+     */
+    provenanceByRule: Map<string, import('@mmnto/totem').ProvenanceRecord>;
+}
+/** Internal shape the run command's scorer + persist step consume (engine-agnostic). */
+interface EngineResult {
+    mintedRuleIds: string[];
+    firings: import('@mmnto/totem').RuleFiring[];
+    groundTruth: Map<string, import('@mmnto/totem').GroundTruthLabel>;
+    positiveControlTargets: Array<{
+        pr: number;
+        targetRuleId: string;
+    }>;
+    /** C2 — real touched-file exposure (0 for the harness mock). */
+    filesTouchedInWindow: number;
+    /** Candidate rules eligible for fold-B stamping (empty for the harness mock). */
+    candidates: import('@mmnto/totem').CompiledRule[];
+    /** Mining provenance per rule for fold-B (empty for the harness mock). */
+    provenanceByRule: Map<string, import('@mmnto/totem').ProvenanceRecord>;
 }
 /**
  * `totem spine windtunnel run`
@@ -92,5 +137,25 @@ export declare function enumeratePrMetas(asOfCommit: string, lcDir: string, safe
     parseRevertSha: (body: string) => string | undefined;
     isBotIdentity: (author: string) => boolean;
 }): PrMeta[];
+/**
+ * Run the REAL engine for the certifying phase (5c-i — #2189 item 1).
+ *
+ * Replaces the mock for `--phase certifying`: drives each resolved-PR diff
+ * through `buildFirings` (core), which runs `enrichWithAstContext` +
+ * `applyAstRulesToAdditions` with the shared post-image `readStrategy` (S1/C1)
+ * and maps every violation to a `RuleFiring` (content-based labelId). Then:
+ *  - **fold-F**: `buildFirings` throws if any archived rule is in the scored set
+ *    (the engine never runs on an archived rule).
+ *  - **A1 (fold-D)**: `assertUniqueFiringLabels` hard-gates labelId uniqueness
+ *    BEFORE scoring (throws on collision, surfacing the offending refs).
+ *  - **C2**: `filesTouchedInWindow` is the real distinct-file exposure.
+ *  - **fold-H**: neg-control firings flow through as `controlKind:'negative'`;
+ *    unlabeled firings route to needsAdjudication via the scorer.
+ *
+ * The corpus itself (resolved-PR diffs + active rules + frozen ground truth) is
+ * supplied by the 5c-ii orchestrator via the `certifyingCorpus` seam. 5c-i owns
+ * the deterministic engine; it does NOT fetch/compile live data (out of scope).
+ */
+export declare function runCertifyingEngine(lock: WindtunnelLock, readStrategy: (file: string) => Promise<string | null>, corpusProvider?: CertifyingCorpusProvider): Promise<EngineResult>;
 export {};
 //# sourceMappingURL=spine-windtunnel.d.ts.map

package/dist/commands/spine-windtunnel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spine-windtunnel.d.ts","sourceRoot":"","sources":["../../src/commands/spine-windtunnel.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,MAAM,EAAuB,cAAc,EAAE,MAAM,cAAc,CAAC;AAShF,MAAM,WAAW,aAAa;IAC5B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,aAAa,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAoFtE;AAID,MAAM,WAAW,UAAU;IACzB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;GASG;AACH,wBAAsB,UAAU,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAmKhE;AAID,KAAK,UAAU,GAAG,cAAc,cAAc,EAAE,QAAQ,CAAC;AAEzD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,EAClB,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,UAAU,GACnB,OAAO,CAWT;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,MAAM,GAAG,SAAS,EACzB,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,UAAU,GACnB,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAkB1C;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,UAAU,GAAG,IAAI,CA0DhG;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,WAAW,EAAE,MAAM,EAAE,EACrB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,UAAU,GACnB,MAAM,GAAG,IAAI,CA+Cf;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACpC,WAAW,EAAE,MAAM,EAAE,EACrB,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,UAAU,GACnB,IAAI,CAmBN;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,wBAAwB,CAC5C,IAAI,EAAE,cAAc,EACpB,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,UAAU,GACnB,OAAO,CAAC,IAAI,CAAC,CAqGf;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,UAAU,EACpB,OAAO,EAAE;IACP,aAAa,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,CAAC;IAClD,cAAc,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAC;IACrD,aAAa,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC;CAC5C,GACA,MAAM,EAAE,CA+DV"}
+{"version":3,"file":"spine-windtunnel.d.ts","sourceRoot":"","sources":["../../src/commands/spine-windtunnel.ts"],"names":[],"mappings":"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"}

package/dist/commands/spine-windtunnel.js

@@ -1,5 +1,7 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
+import { persistCertifyingOutcome } from './spine-cert-persist.js';
+import { buildReplayCorpusProvider } from './spine-cert-run-corpus.js';
 // ─── Named constants ─────────────────────────────────
 const LOCK_REL_PATH = '.totem/spine/gate-1/windtunnel.lock.json';
 const COMMIT_SHA_REGEX = /^[0-9a-f]{40}$/;
@@ -149,12 +151,48 @@ export async function runCommand(opts) {
     // simple null-returning strategy (all files → skip classification = fail-open).
     // When lcDir is provided, resolve post-image blobs from the lc clone.
     const readStrategy = buildReadStrategy(lcDir, lock.corpus.selectionRule.asOfCommit, safeExec);
-    // Enrich with AST context for any additions (harness: no diff, so no additions).
-    // In the real certifying run, the caller would build additions from PR diffs
-    // and pass them through enrichWithAstContext + applyAstRulesToAdditions with
-    // the shared readStrategy (S1/C1 — same content for regex astContext + AST).
-    // Run the engine — harness phase uses mock engines.
-    const { mintedRuleIds, firings, groundTruth, positiveControlTargets } = await runMockEngine(lock, readStrategy);
+    // Run the engine. Harness phase → mock engine (no real rules yet). Certifying
+    // phase → the REAL engine path (5c-i): build additions from each resolved-PR
+    // diff → enrichWithAstContext + applyAstRulesToAdditions with the shared
+    // post-image readStrategy → RuleFiring[] → A1 unique-label hard-gate → score.
+    // C2: filesTouchedInWindow is the real exposure computed from the diffs (no
+    // longer the hard-coded 0).
+    // A single wall-clock stamp for the whole certifying run — threaded into both
+    // the replay-corpus provider (compile-stage timestamp) and the persist step
+    // (report generatedAt / filename slug) so the two artifacts share one moment.
+    const runNowIso = new Date().toISOString();
+    // Certifying phase: use the injected corpus (tests) or build the REPLAY-mode
+    // provider from the committed cert-run fixtures under the gate-1 dir (5c-ii).
+    let corpusProvider = opts.certifyingCorpus;
+    if (lock.phase === 'certifying' && !corpusProvider) {
+        const gate1Dir = path.dirname(lockPath);
+        const asOf = lock.corpus.selectionRule.asOfCommit;
+        const stage4 = lcDir
+            ? {
+                listFiles: async () => safeExec('git', ['ls-tree', '-r', '--name-only', asOf], { cwd: lcDir })
+                    .split('\n')
+                    .filter(Boolean),
+                readFile: async (f) => safeExec('git', ['show', `${asOf}:${f.replace(/\\/g, '/')}`], { cwd: lcDir }),
+                workingDirectory: lcDir,
+            }
+            : {
+                // No lc clone → Stage-4 sees no files (rules read as 'no-matches' /
+                // untested, NOT archived) — the wind-tunnel firing/scoring still runs.
+                listFiles: async () => [],
+                readFile: async (f) => {
+                    throw new TotemError('CONFIG_INVALID', `Cert run: no lc clone (--lc-dir) — cannot read ${f} for Stage-4.`, 'Provide the lc clone via --lc-dir or the TOTEM_LC_DIR environment variable.');
+                },
+            };
+        corpusProvider = buildReplayCorpusProvider({
+            gate1Dir,
+            stage4,
+            now: runNowIso,
+        });
+    }
+    const engineResult = lock.phase === 'certifying'
+        ? await runCertifyingEngine(lock, readStrategy, corpusProvider)
+        : await runMockEngineAdapter(lock, readStrategy);
+    const { mintedRuleIds, firings, groundTruth, positiveControlTargets, filesTouchedInWindow } = engineResult;
     // Score
     const verdict = scoreWindtunnel({
         firings,
@@ -169,7 +207,7 @@ export async function runCommand(opts) {
         },
         actualExposure: {
             activeRulesEvaluated: mintedRuleIds.length,
-            filesTouchedInWindow: 0,
+            filesTouchedInWindow,
             positiveControlsExercised: positiveControlTargets.length,
         },
     });
@@ -201,6 +239,31 @@ export async function runCommand(opts) {
             console.log(`    • ${id}`);
         }
     }
+    // 5c-ii: certifying-phase persistence — fold-B project → fold-C parse-before-write
+    // persist (PASS-survivors-only) + the transient cert-run report (§6 L3). The
+    // repo's live `.totem/compiled-rules.json` is NEVER touched here; survivors land
+    // in the gate-1 cert output, which strategy#516 promotes to the live corpus.
+    if (lock.phase === 'certifying') {
+        // Persist beside the same gate-1 dir the fixtures were loaded from (line ~288),
+        // not a hardcoded path — keeps cert output co-located under a non-default --lock-path.
+        const gate1Dir = path.dirname(lockPath);
+        const persistResult = await persistCertifyingOutcome({
+            verdict,
+            firings,
+            mintedRuleIds,
+            positiveControlTargets,
+            candidates: engineResult.candidates,
+            provenanceByRule: engineResult.provenanceByRule,
+            certifiedRulesOutPath: path.join(gate1Dir, 'compiled-rules.json'),
+            reportDir: path.join(gate1Dir, 'run-reports'),
+            nowIso: runNowIso,
+            asOfCommit: lock.corpus.selectionRule.asOfCommit,
+        });
+        console.error(`[WindtunnelRun] Cert-run report: ${persistResult.reportPath}` +
+            (persistResult.persisted
+                ? ` — ${persistResult.stampedCount} survivor(s) stamped → ${persistResult.certifiedRulesPath}`
+                : ` — no rules persisted (verdict ${verdict.verdict}); live corpus untouched`));
+    }
     // Exit non-zero on FAIL / HONEST-NEGATIVE / needs-adjudication
     if (verdict.verdict !== 'PASS' || verdict.needsAdjudication.length > 0) {
         process.exitCode = 1;
@@ -531,4 +594,94 @@ async function runMockEngine(lock, _readStrategy) {
     }
     return { mintedRuleIds, firings, groundTruth, positiveControlTargets };
 }
+/** Adapt the harness mock engine to the EngineResult shape (filesTouched = 0). */
+async function runMockEngineAdapter(lock, readStrategy) {
+    const mock = await runMockEngine(lock, readStrategy);
+    return {
+        ...mock,
+        filesTouchedInWindow: 0,
+        candidates: [],
+        provenanceByRule: new Map(),
+    };
+}
+// ─── Real engine (certifying phase, 5c-i) ────────────
+/**
+ * Run the REAL engine for the certifying phase (5c-i — #2189 item 1).
+ *
+ * Replaces the mock for `--phase certifying`: drives each resolved-PR diff
+ * through `buildFirings` (core), which runs `enrichWithAstContext` +
+ * `applyAstRulesToAdditions` with the shared post-image `readStrategy` (S1/C1)
+ * and maps every violation to a `RuleFiring` (content-based labelId). Then:
+ *  - **fold-F**: `buildFirings` throws if any archived rule is in the scored set
+ *    (the engine never runs on an archived rule).
+ *  - **A1 (fold-D)**: `assertUniqueFiringLabels` hard-gates labelId uniqueness
+ *    BEFORE scoring (throws on collision, surfacing the offending refs).
+ *  - **C2**: `filesTouchedInWindow` is the real distinct-file exposure.
+ *  - **fold-H**: neg-control firings flow through as `controlKind:'negative'`;
+ *    unlabeled firings route to needsAdjudication via the scorer.
+ *
+ * The corpus itself (resolved-PR diffs + active rules + frozen ground truth) is
+ * supplied by the 5c-ii orchestrator via the `certifyingCorpus` seam. 5c-i owns
+ * the deterministic engine; it does NOT fetch/compile live data (out of scope).
+ */
+export async function runCertifyingEngine(lock, readStrategy, corpusProvider) {
+    const { buildFirings, assertUniqueFiringLabels, resolveGitRoot, TotemError, FiringLabelCollisionError, } = await import('@mmnto/totem');
+    if (!corpusProvider) {
+        // No silent empty-set scoring: a certifying run with no corpus provider is a
+        // wiring error (5c-ii supplies it). Fail loud + actionable (Tenet 4).
+        throw new TotemError('CONFIG_INVALID', 'Wind-tunnel certifying run: no certifying-corpus provider wired (5c-ii orchestration).', 'The deterministic real-engine firing path (5c-i) is in place, but the corpus ' +
+            '(resolved-PR diffs + compiled rules + ground truth) is supplied by the 5c-ii ' +
+            'orchestrator. Run via the certifying orchestrator once it lands.');
+    }
+    const corpus = await corpusProvider(lock);
+    const cwd = resolveGitRoot(process.cwd()) ?? process.cwd();
+    const ruleEngineCtx = {
+        logger: { warn: (msg) => console.error(`[WindtunnelRun] ${msg}`) },
+        state: { hasWarnedShieldContext: false },
+    };
+    // buildFirings runs fold-F (archived assert) internally before the engine; its
+    // only throw is ArchivedRuleInScopeError, which propagates. A1 (labelId
+    // collision) is deliberately NOT raised here — it is the caller's pre-score gate
+    // below (assertUniqueFiringLabels), so the structured per-collision report is
+    // threaded there rather than swallowed at construction. (greptile #2215 P2.)
+    const built = await buildFirings({
+        rules: corpus.rules,
+        prDiffs: corpus.prDiffs,
+        cwd,
+        readStrategy,
+        ruleEngineCtx,
+        onWarn: (msg) => console.error(`[WindtunnelRun] ${msg}`),
+    });
+    // A1 (fold-D): post-dedup uniqueness INVARIANT before scoring (Tenet 4).
+    // `buildFirings` now collapses same-labelId matches (fold-D dedup), so this can
+    // no longer fire on an honest multi-match line — a collision here signals a
+    // dedup BUG, not corpus data, so it fails loud as an internal invariant.
+    try {
+        assertUniqueFiringLabels(built.firings);
+    }
+    catch (err) {
+        if (err instanceof FiringLabelCollisionError) {
+            console.error(`[WindtunnelRun] A1 post-dedup invariant violated (fold-D):`);
+            for (const c of err.collisions) {
+                console.error(`  • ${c.labelId.slice(0, 12)}… ×${c.evidenceRefs.length}`);
+            }
+            throw new TotemError('CONFIG_INVALID', err.message, 'A post-dedup firing-label collision is an internal invariant violation: buildFirings ' +
+                'should have collapsed same-labelId matches. This indicates a dedup defect, not a corpus issue.', err);
+        }
+        throw err;
+    }
+    const mintedRuleIds = corpus.rules.map((r) => r.lessonHash);
+    console.error(`[WindtunnelRun] Certifying engine: ${mintedRuleIds.length} rule(s), ` +
+        `${corpus.prDiffs.length} PR diff(s), ${built.firings.length} firing(s), ` +
+        `${built.filesTouchedInWindow} file(s) touched.`);
+    return {
+        mintedRuleIds,
+        firings: built.firings,
+        groundTruth: corpus.groundTruth,
+        positiveControlTargets: built.positiveControlTargets,
+        filesTouchedInWindow: built.filesTouchedInWindow,
+        candidates: corpus.rules,
+        provenanceByRule: corpus.provenanceByRule,
+    };
+}
 //# sourceMappingURL=spine-windtunnel.js.map