@mmnto/cli 1.70.0 → 1.71.0

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

@@ -0,0 +1,57 @@
+import type { DraftClassifier, DraftExtractor, GroundTruthLabel, MinerLedgers, ResolvedPrDiff, ReviewThreadSource, SplitArtifact, SplitLedger, Stage4VerifierDeps } from '@mmnto/totem';
+import type { CertifyingCorpus } from './spine-windtunnel.js';
+export interface BuildCertifyingCorpusDeps {
+    /** The frozen train/held-out/control split. */
+    split: SplitArtifact;
+    /** SplitLedger (split + corpusMergeCommits) for the classify integrity re-check. */
+    splitLedger: SplitLedger;
+    /**
+     * Review-thread source. REPLAY (certifying run): a FROZEN source that reads
+     * committed fixture content (zero network, fold-K). LIVE (record): the gh-CLI
+     * adapter. The extract stage calls `source.fetch(pr)` to build the content the
+     * replay extractor keys on, so the content must be reproducible either way.
+     */
+    source: ReviewThreadSource;
+    /** Draft extractor. REPLAY: `ReplayDraftExtractor`; RECORD: `RecordingDraftExtractor`(Live). */
+    extractor: DraftExtractor;
+    /** Draft classifier. REPLAY: `ReplayDraftClassifier`; RECORD: `RecordingDraftClassifier`(Live). */
+    classifier: DraftClassifier;
+    /** Seed-blindness attestation (fold-I §7) — surfaced into the emission ledger. */
+    seedClassesProvided: boolean;
+    /** Stage-4 verifier deps (listFiles/readFile over the frozen post-image). */
+    stage4: Stage4VerifierDeps;
+    /** Injected timestamp (Tenet 15 determinism — no `new Date()` in the pipeline). */
+    now: string;
+    /** Resolved-PR diffs (corpus + positive/negative controls) for firing/scoring. */
+    prDiffs: ResolvedPrDiff[];
+    /** Frozen ground-truth labels keyed by firingLabelId (TP/FP). */
+    groundTruth: Map<string, GroundTruthLabel>;
+}
+export interface CertifyingCorpusBuildResult {
+    /** The corpus `runCertifyingEngine` scores (rules, prDiffs, groundTruth, provenanceByRule). */
+    corpus: CertifyingCorpus;
+    /** fold-I miner ledgers (emission/drop/classifier/split/apiUsage), emitted + CI-observable. */
+    ledgers: MinerLedgers;
+}
+/**
+ * Compose the shipped slice-2/3/4 stages into the certifying corpus (5c-ii).
+ *
+ * Runs Extract → Classify → Compile over the train slice via the injected ports
+ * (REPLAY for the certifying run — zero LLM, zero network; RECORD wraps the live
+ * adapters), then assembles the `CertifyingCorpus`:
+ *  - **rules + provenanceByRule** from the compiled candidates;
+ *  - **binding-2 (carried)**: archived (Stage-4 out-of-scope) rules are EXCLUDED
+ *    from the scored set (archived ≠ wind-tunnel FP — `buildFirings`/fold-F would
+ *    throw if one leaked); their provenance is dropped with them.
+ *  - **fold-I (FM-h)**: the API-usage ledger's held-out-fetch-count MUST be 0 —
+ *    a non-zero count means mining touched the held-out slice, which voids the
+ *    run, so we fail loud here.
+ *  - **prDiffs + groundTruth** are passed through from the (fixture or resolved)
+ *    inputs; firing/scoring is the deterministic 5c-i engine's job downstream.
+ *
+ * Returns the corpus + the fold-I ledgers (emitted for §7 observability). Pure of
+ * its own IO — all IO is behind the injected ports/deps, so it is fully testable
+ * with fakes (no LLM, no network, no real git).
+ */
+export declare function buildCertifyingCorpus(deps: BuildCertifyingCorpusDeps): Promise<CertifyingCorpusBuildResult>;
+//# sourceMappingURL=spine-cert-corpus.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"spine-cert-corpus.d.ts","sourceRoot":"","sources":["../../src/commands/spine-cert-corpus.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EACf,cAAc,EACd,gBAAgB,EAChB,YAAY,EAEZ,cAAc,EACd,kBAAkB,EAClB,aAAa,EACb,WAAW,EACX,kBAAkB,EACnB,MAAM,cAAc,CAAC;AAEtB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAI9D,MAAM,WAAW,yBAAyB;IACxC,+CAA+C;IAC/C,KAAK,EAAE,aAAa,CAAC;IACrB,oFAAoF;IACpF,WAAW,EAAE,WAAW,CAAC;IACzB;;;;;OAKG;IACH,MAAM,EAAE,kBAAkB,CAAC;IAC3B,gGAAgG;IAChG,SAAS,EAAE,cAAc,CAAC;IAC1B,mGAAmG;IACnG,UAAU,EAAE,eAAe,CAAC;IAC5B,kFAAkF;IAClF,mBAAmB,EAAE,OAAO,CAAC;IAC7B,6EAA6E;IAC7E,MAAM,EAAE,kBAAkB,CAAC;IAC3B,mFAAmF;IACnF,GAAG,EAAE,MAAM,CAAC;IACZ,kFAAkF;IAClF,OAAO,EAAE,cAAc,EAAE,CAAC;IAC1B,iEAAiE;IACjE,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;CAC5C;AAED,MAAM,WAAW,2BAA2B;IAC1C,+FAA+F;IAC/F,MAAM,EAAE,gBAAgB,CAAC;IACzB,+FAA+F;IAC/F,OAAO,EAAE,YAAY,CAAC;CACvB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,qBAAqB,CACzC,IAAI,EAAE,yBAAyB,GAC9B,OAAO,CAAC,2BAA2B,CAAC,CA0CtC"}

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

@@ -0,0 +1,51 @@
+/**
+ * Compose the shipped slice-2/3/4 stages into the certifying corpus (5c-ii).
+ *
+ * Runs Extract → Classify → Compile over the train slice via the injected ports
+ * (REPLAY for the certifying run — zero LLM, zero network; RECORD wraps the live
+ * adapters), then assembles the `CertifyingCorpus`:
+ *  - **rules + provenanceByRule** from the compiled candidates;
+ *  - **binding-2 (carried)**: archived (Stage-4 out-of-scope) rules are EXCLUDED
+ *    from the scored set (archived ≠ wind-tunnel FP — `buildFirings`/fold-F would
+ *    throw if one leaked); their provenance is dropped with them.
+ *  - **fold-I (FM-h)**: the API-usage ledger's held-out-fetch-count MUST be 0 —
+ *    a non-zero count means mining touched the held-out slice, which voids the
+ *    run, so we fail loud here.
+ *  - **prDiffs + groundTruth** are passed through from the (fixture or resolved)
+ *    inputs; firing/scoring is the deterministic 5c-i engine's job downstream.
+ *
+ * Returns the corpus + the fold-I ledgers (emitted for §7 observability). Pure of
+ * its own IO — all IO is behind the injected ports/deps, so it is fully testable
+ * with fakes (no LLM, no network, no real git).
+ */
+export async function buildCertifyingCorpus(deps) {
+    const { runExtractStage, runClassifyStage, runCompileStage, assembleMinerLedgers, TotemError } = await import('@mmnto/totem');
+    // Stage 1 — Extract (REPLAY or LIVE via the injected ports).
+    const extract = await runExtractStage(deps.split, {
+        source: deps.source,
+        extractor: deps.extractor,
+        seedClassesProvided: deps.seedClassesProvided,
+    });
+    // fold-I (FM-h): the held-out slice must NEVER be fetched during mining.
+    if (extract.apiUsageLedger.heldOutFetchCount !== 0) {
+        throw new TotemError('CONFIG_INVALID', `Held-out fetch count is ${extract.apiUsageLedger.heldOutFetchCount}, must be 0 ` +
+            `(fold-I / FM-h): mining touched the held-out slice, which voids the certifying run.`, 'The extract stage fetched a held-out PR. Verify the split + fetch loop honor the train-only boundary.');
+    }
+    // Stage 2 — Classify; Stage 3/4 — Compile + Stage-4 verify.
+    const classify = await runClassifyStage(extract, deps.splitLedger, {
+        classifier: deps.classifier,
+    });
+    const compileResult = await runCompileStage(classify, { stage4: deps.stage4, now: deps.now });
+    // binding-2 (carried): exclude Stage-4 out-of-scope (archived) rules from the
+    // scored set — archived ≠ wind-tunnel FP; fold-F throws if one reaches firing.
+    const scored = compileResult.compiled.filter((c) => c.rule.status !== 'archived');
+    const rules = scored.map((c) => c.rule);
+    const provenanceByRule = new Map(scored.map((c) => [c.rule.lessonHash, c.provenance]));
+    // fold-I ledgers — emitted + CI-observable (§7), never asserted-on beyond FM-h.
+    const ledgers = assembleMinerLedgers(deps.splitLedger, extract, classify);
+    return {
+        corpus: { rules, prDiffs: deps.prDiffs, groundTruth: deps.groundTruth, provenanceByRule },
+        ledgers,
+    };
+}
+//# sourceMappingURL=spine-cert-corpus.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"spine-cert-corpus.js","sourceRoot":"","sources":["../../src/commands/spine-cert-corpus.ts"],"names":[],"mappings":"AAoDA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,CAAC,KAAK,UAAU,qBAAqB,CACzC,IAA+B;IAE/B,MAAM,EAAE,eAAe,EAAE,gBAAgB,EAAE,eAAe,EAAE,oBAAoB,EAAE,UAAU,EAAE,GAC5F,MAAM,MAAM,CAAC,cAAc,CAAC,CAAC;IAE/B,6DAA6D;IAC7D,MAAM,OAAO,GAAG,MAAM,eAAe,CAAC,IAAI,CAAC,KAAK,EAAE;QAChD,MAAM,EAAE,IAAI,CAAC,MAAM;QACnB,SAAS,EAAE,IAAI,CAAC,SAAS;QACzB,mBAAmB,EAAE,IAAI,CAAC,mBAAmB;KAC9C,CAAC,CAAC;IAEH,yEAAyE;IACzE,IAAI,OAAO,CAAC,cAAc,CAAC,iBAAiB,KAAK,CAAC,EAAE,CAAC;QACnD,MAAM,IAAI,UAAU,CAClB,gBAAgB,EAChB,2BAA2B,OAAO,CAAC,cAAc,CAAC,iBAAiB,cAAc;YAC/E,qFAAqF,EACvF,uGAAuG,CACxG,CAAC;IACJ,CAAC;IAED,4DAA4D;IAC5D,MAAM,QAAQ,GAAG,MAAM,gBAAgB,CAAC,OAAO,EAAE,IAAI,CAAC,WAAW,EAAE;QACjE,UAAU,EAAE,IAAI,CAAC,UAAU;KAC5B,CAAC,CAAC;IACH,MAAM,aAAa,GAAG,MAAM,eAAe,CAAC,QAAQ,EAAE,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,GAAG,EAAE,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC;IAE9F,8EAA8E;IAC9E,+EAA+E;IAC/E,MAAM,MAAM,GAAG,aAAa,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,KAAK,UAAU,CAAC,CAAC;IAClF,MAAM,KAAK,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;IACxC,MAAM,gBAAgB,GAAG,IAAI,GAAG,CAC9B,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC,CAAC,UAAU,CAAC,CAAC,CACrD,CAAC;IAEF,gFAAgF;IAChF,MAAM,OAAO,GAAG,oBAAoB,CAAC,IAAI,CAAC,WAAW,EAAE,OAAO,EAAE,QAAQ,CAAC,CAAC;IAE1E,OAAO;QACL,MAAM,EAAE,EAAE,KAAK,EAAE,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,WAAW,EAAE,IAAI,CAAC,WAAW,EAAE,gBAAgB,EAAE;QACzF,OAAO;KACR,CAAC;AACJ,CAAC"}

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

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

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

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

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

@@ -0,0 +1,112 @@
+import { describe, expect, it } from 'vitest';
+import { buildCertifyingCorpus } from './spine-cert-corpus.js';
+// ─── Fixtures (mirrors the slice-2/3/4 stage tests) ───
+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');
+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(dsls) {
+    return {
+        async draft() {
+            return dsls;
+        },
+    };
+}
+function fakeClassifier(disposition = 'structural') {
+    return {
+        async classify() {
+            return { disposition, dispositionSource: 'classified' };
+        },
+    };
+}
+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 stage4(files) {
+    return {
+        listFiles: () => Promise.resolve(Object.keys(files)),
+        readFile: (f) => f in files ? Promise.resolve(files[f]) : Promise.reject(new Error(`absent ${f}`)),
+    };
+}
+function baseDeps(overrides = {}) {
+    return {
+        split: SPLIT,
+        splitLedger: SPLIT_LEDGER,
+        source: fakeSource(),
+        extractor: fakeExtractor([REGEX_DSL]),
+        classifier: fakeClassifier(),
+        seedClassesProvided: false,
+        stage4: stage4({ 'src/a.ts': 'forbiddenCall()' }),
+        now: NOW,
+        prDiffs: [],
+        groundTruth: new Map(),
+        ...overrides,
+    };
+}
+// ─── Tests ───────────────────────────────────────────
+describe('buildCertifyingCorpus', () => {
+    it('composes extract→classify→compile into a corpus (rules + provenanceByRule + fold-I ledgers)', async () => {
+        const { corpus, ledgers } = await buildCertifyingCorpus(baseDeps());
+        expect(corpus.rules).toHaveLength(1);
+        const rule = corpus.rules[0];
+        // provenanceByRule maps the survivor to its mining provenance (train PR 1).
+        const prov = corpus.provenanceByRule.get(rule.lessonHash);
+        expect(prov).toBeDefined();
+        expect(prov.mergedPr).toBe(1);
+        // fold-I: held-out fetch count is 0 (FM-h) + seed-blindness surfaced.
+        expect(ledgers.apiUsage.heldOutFetchCount).toBe(0);
+        expect(ledgers.emission.extractionInputsAttestation.seedClassesProvided).toBe(false);
+    });
+    it('binding-2: a Stage-4 out-of-scope (archived) rule is EXCLUDED from the scored set', async () => {
+        // The rule fires only on a TEST file → Stage-4 out-of-scope → status archived →
+        // must not reach the scored set (archived ≠ wind-tunnel FP; fold-F would throw).
+        const { corpus } = await buildCertifyingCorpus(baseDeps({ stage4: stage4({ 'src/a.test.ts': 'forbiddenCall()' }) }));
+        expect(corpus.rules).toHaveLength(0);
+        expect(corpus.provenanceByRule.size).toBe(0);
+    });
+    it('a behavioral candidate is routed rag-only (never compiled into the scored set)', async () => {
+        const { corpus } = await buildCertifyingCorpus(baseDeps({ classifier: fakeClassifier('behavioral') }));
+        expect(corpus.rules).toHaveLength(0);
+    });
+});
+//# sourceMappingURL=spine-cert-corpus.test.js.map

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

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

package/dist/commands/spine-cert-e2e.test.d.ts

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

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

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

package/dist/commands/spine-cert-e2e.test.js

@@ -0,0 +1,145 @@
+import * as net from 'node:net';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { buildCertifyingCorpus } from './spine-cert-corpus.js';
+import { buildReplayAdapters, recordReplayFixture } from './spine-cert-record.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',
+};
+function content(pr) {
+    return {
+        pr,
+        mergeCommitSha: sha(pr),
+        threads: [
+            {
+                path: 'src/a.ts',
+                comments: [{ author: 'Jane', body: 'note' }],
+                isResolved: false,
+                isOutdated: false,
+            },
+        ],
+    };
+}
+function frozenSource() {
+    return {
+        async fetch(pr) {
+            return { kind: 'ok', content: content(pr) };
+        },
+    };
+}
+function liveExtractor() {
+    return {
+        async draft() {
+            return [REGEX_DSL];
+        },
+    };
+}
+function liveClassifier() {
+    return {
+        async classify() {
+            return { disposition: 'structural', dispositionSource: 'classified' };
+        },
+    };
+}
+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 stage4() {
+    const files = { 'src/a.ts': 'forbiddenCall()' };
+    return {
+        listFiles: () => Promise.resolve(Object.keys(files)),
+        readFile: (f) => f in files ? Promise.resolve(files[f]) : Promise.reject(new Error(`absent ${f}`)),
+    };
+}
+/** Record a replay fixture from the live fakes (the artifact the cert run replays). */
+async function freezeFixture() {
+    return recordReplayFixture({
+        split: SPLIT,
+        splitLedger: SPLIT_LEDGER,
+        source: frozenSource(),
+        liveExtractor: liveExtractor(),
+        liveClassifier: liveClassifier(),
+        seedClassesProvided: false,
+        provenance: PROVENANCE,
+    });
+}
+function replayCorpus(artifact, hash) {
+    const { extractor, classifier } = buildReplayAdapters(artifact, hash);
+    return buildCertifyingCorpus({
+        split: SPLIT,
+        splitLedger: SPLIT_LEDGER,
+        source: frozenSource(),
+        extractor,
+        classifier,
+        seedClassesProvided: false,
+        stage4: stage4(),
+        now: NOW,
+        prDiffs: [],
+        groundTruth: new Map(),
+    });
+}
+// ─── fold-K: E2E replay round-trip under network isolation ───
+describe('5c-ii cert run — replay round-trip + TCP isolation (fold-K)', () => {
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('replays the recorded fixture into a faithful corpus (record→freeze→replay round-trip)', async () => {
+        const { artifact, hash } = await freezeFixture();
+        const { corpus } = await replayCorpus(artifact, hash);
+        expect(corpus.rules).toHaveLength(1);
+        const rule = corpus.rules[0];
+        expect(corpus.provenanceByRule.get(rule.lessonHash)?.mergedPr).toBe(1);
+    });
+    it('the replay path makes ZERO outgoing network calls (fold-K TCP block)', async () => {
+        const { artifact, hash } = await freezeFixture();
+        // Block every outgoing TCP/fetch — the replay corpus build must complete
+        // without tripping either guard (zero-LLM, zero-network by construction).
+        const netConnect = vi.spyOn(net.Socket.prototype, 'connect').mockImplementation((() => {
+            throw new Error('fold-K violation: outgoing TCP connect attempted during replay');
+        }));
+        const fetchSpy = vi.spyOn(globalThis, 'fetch').mockImplementation((() => {
+            throw new Error('fold-K violation: fetch attempted during replay');
+        }));
+        const { corpus } = await replayCorpus(artifact, hash);
+        expect(corpus.rules).toHaveLength(1);
+        expect(netConnect).not.toHaveBeenCalled();
+        expect(fetchSpy).not.toHaveBeenCalled();
+    });
+    it('a wrong expected-hash trips the integrity gate before any replay (loud fixture failure)', async () => {
+        const { artifact } = await freezeFixture();
+        // L2: the lock-wired hash must match the artifact; a stale/tampered one fails loud.
+        expect(() => buildReplayAdapters(artifact, sha(99))).toThrow();
+    });
+});
+//# sourceMappingURL=spine-cert-e2e.test.js.map

package/dist/commands/spine-cert-e2e.test.js.map

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

package/dist/commands/spine-cert-persist.d.ts

@@ -0,0 +1,63 @@
+import type { CompiledRule, LegitimacyProjectionSkip, ProvenanceRecord, RuleFiring, WindtunnelVerdict } from '@mmnto/totem';
+export interface CertPersistInput {
+    /** The scorer verdict for this run. */
+    verdict: WindtunnelVerdict;
+    /** Firings the verdict was computed over (for the C1 control map + report). */
+    firings: RuleFiring[];
+    /** Minted (active) rule ids the scorer evaluated. */
+    mintedRuleIds: string[];
+    /** Positive-control targets (for the per-rule control map). */
+    positiveControlTargets: Array<{
+        pr: number;
+        targetRuleId: string;
+    }>;
+    /** Candidate compiled rules eligible for stamping (the corpus rules). */
+    candidates: CompiledRule[];
+    /** Mining provenance per rule (lessonHash → provenance). */
+    provenanceByRule: Map<string, ProvenanceRecord>;
+    /**
+     * Where PASS-survivors are written (the cert OUTPUT compiled-rules file under
+     * the gate-1 dir — NOT the repo's live `.totem/compiled-rules.json`, which the
+     * strategy#516 populator owns). Required: no default to the live corpus, so a
+     * cert run can never clobber it.
+     */
+    certifiedRulesOutPath: string;
+    /** Directory for the transient cert-run report (§6 L3). */
+    reportDir: string;
+    /** Injected ISO timestamp (report filename + body) — keeps the call testable. */
+    nowIso: string;
+    /** Corpus identity for the report (the lock's asOfCommit). */
+    asOfCommit: string;
+}
+export interface CertPersistResult {
+    /** True iff PASS-survivors were written to the cert output (PASS only). */
+    persisted: boolean;
+    /** Number of survivor rules stamped + written. */
+    stampedCount: number;
+    /** Absolute path of the transient cert-run report. */
+    reportPath: string;
+    /** Path of the written cert rules file (only when persisted). */
+    certifiedRulesPath?: string;
+    /** Projection skips (non-survivors / missing-provenance / verdict-not-pass). */
+    skips: LegitimacyProjectionSkip[];
+}
+/**
+ * The certifying-run persistence boundary (§6 L3 + bindings 1+4).
+ *
+ * 1. Computes the C1 per-rule control map from the firings (survivor-only).
+ * 2. fold-B `projectLegitimacy`: stamps survivors PASS-only, from their OWN
+ *    control results (never the global nonVacuity); non-PASS stamps nothing.
+ * 3. fold-C `buildCertifiedRulesFile`: parses the payload BEFORE any write, so a
+ *    half-stamp fails loud pre-disk. On PASS with ≥1 survivor, the validated
+ *    file is written to `certifiedRulesOutPath` (the cert OUTPUT, never the live
+ *    corpus — strategy#516 promotes from here).
+ * 4. Always writes a transient cert-run report (verdict + skips + cull ledger +
+ *    needs-adjudication + exposure) under `reportDir` — including for non-PASS
+ *    runs, which write a report but NO rules (L3: non-terminals never reach the
+ *    corpus).
+ *
+ * The clock + paths are injected so the whole step is deterministically testable
+ * with a tmpdir, no real lock required.
+ */
+export declare function persistCertifyingOutcome(input: CertPersistInput): Promise<CertPersistResult>;
+//# sourceMappingURL=spine-cert-persist.d.ts.map

package/dist/commands/spine-cert-persist.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spine-cert-persist.d.ts","sourceRoot":"","sources":["../../src/commands/spine-cert-persist.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,YAAY,EACZ,wBAAwB,EACxB,gBAAgB,EAChB,UAAU,EACV,iBAAiB,EAClB,MAAM,cAAc,CAAC;AAItB,MAAM,WAAW,gBAAgB;IAC/B,uCAAuC;IACvC,OAAO,EAAE,iBAAiB,CAAC;IAC3B,+EAA+E;IAC/E,OAAO,EAAE,UAAU,EAAE,CAAC;IACtB,qDAAqD;IACrD,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,+DAA+D;IAC/D,sBAAsB,EAAE,KAAK,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACpE,yEAAyE;IACzE,UAAU,EAAE,YAAY,EAAE,CAAC;IAC3B,4DAA4D;IAC5D,gBAAgB,EAAE,GAAG,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;IAChD;;;;;OAKG;IACH,qBAAqB,EAAE,MAAM,CAAC;IAC9B,2DAA2D;IAC3D,SAAS,EAAE,MAAM,CAAC;IAClB,iFAAiF;IACjF,MAAM,EAAE,MAAM,CAAC;IACf,8DAA8D;IAC9D,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,iBAAiB;IAChC,2EAA2E;IAC3E,SAAS,EAAE,OAAO,CAAC;IACnB,kDAAkD;IAClD,YAAY,EAAE,MAAM,CAAC;IACrB,sDAAsD;IACtD,UAAU,EAAE,MAAM,CAAC;IACnB,iEAAiE;IACjE,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,gFAAgF;IAChF,KAAK,EAAE,wBAAwB,EAAE,CAAC;CACnC;AAUD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,wBAAwB,CAC5C,KAAK,EAAE,gBAAgB,GACtB,OAAO,CAAC,iBAAiB,CAAC,CAsE5B"}

package/dist/commands/spine-cert-persist.js

@@ -0,0 +1,85 @@
+import { createHash } from 'node:crypto';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+/** Filesystem-safe slug for an ISO timestamp (`2026-06-20T23:59:59.000Z` → `20260620T235959`). */
+function timestampSlug(nowIso) {
+    return nowIso
+        .replace(/[-:]/g, '')
+        .replace(/\.\d+Z$/, '')
+        .replace('Z', '');
+}
+/**
+ * The certifying-run persistence boundary (§6 L3 + bindings 1+4).
+ *
+ * 1. Computes the C1 per-rule control map from the firings (survivor-only).
+ * 2. fold-B `projectLegitimacy`: stamps survivors PASS-only, from their OWN
+ *    control results (never the global nonVacuity); non-PASS stamps nothing.
+ * 3. fold-C `buildCertifiedRulesFile`: parses the payload BEFORE any write, so a
+ *    half-stamp fails loud pre-disk. On PASS with ≥1 survivor, the validated
+ *    file is written to `certifiedRulesOutPath` (the cert OUTPUT, never the live
+ *    corpus — strategy#516 promotes from here).
+ * 4. Always writes a transient cert-run report (verdict + skips + cull ledger +
+ *    needs-adjudication + exposure) under `reportDir` — including for non-PASS
+ *    runs, which write a report but NO rules (L3: non-terminals never reach the
+ *    corpus).
+ *
+ * The clock + paths are injected so the whole step is deterministically testable
+ * with a tmpdir, no real lock required.
+ */
+export async function persistCertifyingOutcome(input) {
+    const { computePerRuleControlResults, projectLegitimacy, buildCertifiedRulesFile, saveCompiledRulesFile, } = await import('@mmnto/totem');
+    const perRuleControls = computePerRuleControlResults({
+        firings: input.firings,
+        mintedRuleIds: input.mintedRuleIds,
+        positiveControlTargets: input.positiveControlTargets,
+    });
+    // fold-B — survivor-only, PASS-only legitimacy projection.
+    const projection = projectLegitimacy({
+        verdict: input.verdict,
+        perRuleControls,
+        candidates: input.candidates,
+        provenanceByRule: input.provenanceByRule,
+    });
+    let persisted = false;
+    let certifiedRulesPath;
+    if (input.verdict.verdict === 'PASS' && projection.stamped.length > 0) {
+        // fold-C — parse-before-write net (throws loud on any half-stamp pre-disk).
+        const file = buildCertifiedRulesFile(projection.stamped);
+        fs.mkdirSync(path.dirname(input.certifiedRulesOutPath), { recursive: true });
+        saveCompiledRulesFile(input.certifiedRulesOutPath, file);
+        persisted = true;
+        certifiedRulesPath = input.certifiedRulesOutPath;
+    }
+    // Transient cert-run report (§6 L3) — never the live corpus.
+    const report = {
+        kind: 'windtunnel-cert-run.v1',
+        generatedAt: input.nowIso,
+        asOfCommit: input.asOfCommit,
+        verdict: input.verdict,
+        persisted,
+        stampedRuleIds: projection.stamped.map((r) => r.lessonHash),
+        skips: projection.skips,
+        firingCount: input.firings.length,
+    };
+    // Content hash over the run identity (NOT the timestamp) so the same run is
+    // recognizable across re-runs; the timestamp disambiguates the filename.
+    const reportHash = createHash('sha256')
+        .update(JSON.stringify({
+        asOfCommit: input.asOfCommit,
+        verdict: input.verdict.verdict,
+        labelIds: input.firings.map((f) => f.labelId).sort(),
+    }))
+        .digest('hex')
+        .slice(0, 12);
+    const reportPath = path.join(input.reportDir, `run-${timestampSlug(input.nowIso)}-${reportHash}.json`);
+    fs.mkdirSync(input.reportDir, { recursive: true });
+    fs.writeFileSync(reportPath, JSON.stringify(report, null, 2), 'utf-8');
+    return {
+        persisted,
+        stampedCount: projection.stamped.length,
+        reportPath,
+        certifiedRulesPath,
+        skips: projection.skips,
+    };
+}
+//# sourceMappingURL=spine-cert-persist.js.map

package/dist/commands/spine-cert-persist.js.map

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

package/dist/commands/spine-cert-persist.test.d.ts

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

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

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