@mmnto/totem 1.79.0 → 1.81.0

package/dist/spine/preimage-differential.d.ts

@@ -0,0 +1,112 @@
+/**
+ * ADR-112 §4/§6 — the preimage-differential materializer (slice C1: the inert primitive).
+ *
+ * An authored rule is only a legitimate positive control if its matcher **fires
+ * on the defect preimage** and is **silent on the fixed postimage** (§4). A
+ * matcher that fires on the *fixed* form is "fix-shaped" — the exact failure
+ * mode the miner's honest-negative is made of — and must never be admitted as a
+ * legitimate control (Falsifying Metric §1(i)).
+ *
+ * This module evaluates that differential against a fixture's declared
+ * `preimageSource` (lesson-anchored PRIMARY / commit-pair FALLBACK) and reports
+ * the raw evidence + a differential-level classification. It is deliberately
+ * INERT: it wires nothing into the cert path, mints no §5 run verdict, and emits
+ * no controls. Slice C2 consumes this to gate control emission; slice D maps the
+ * differential to the ADR-110 §5 terminal vocabulary (PASS / FAIL /
+ * HONEST-NEGATIVE). The boundary is load-bearing — `over-match` / `vacuous` here
+ * are DIFFERENTIAL outcomes, NOT run verdicts (the scorer owns that).
+ *
+ * Seam (Tenet-21 reuse): firing goes through `runSmokeGate`, the same
+ * role-agnostic engine entry point the compiler's #1408 under-match / #1580
+ * over-match checks use — regex and ast-grep, in-memory, no temp file, no diff
+ * fabrication, no `firingLabelId` minted here. The lesson source evaluates
+ * against the in-record `badExample`/`goodExample` exemplars (contract §5.4), so
+ * the lesson path is pure and hermetic — no clock, no network, no filesystem.
+ */
+import type { AuthoredFixture, CompiledRule, PreimageSource } from '../compiler-schema.js';
+/**
+ * Differential-level classification of a single fixture's preimage/postimage
+ * evaluation. NOT an ADR-110 §5 run verdict (PASS/FAIL/HONEST-NEGATIVE) — the
+ * scorer (slice D) maps these to that vocabulary. Keep the boundary explicit.
+ */
+export type PreimageDifferentialOutcome = 
+/** Fires on the preimage, silent on the postimage — the legitimate positive control (§4). */
+'differential-holds'
+/**
+ * Fires on the postimage (the fixed form) and NOT on the preimage — fix-shaped,
+ * the literal Falsifying Metric §1(i). Never a charitable pass.
+ */
+ | 'fix-shaped'
+/**
+ * Fires on BOTH the preimage and the postimage. The matcher establishes no
+ * differential. This is the cert-critical escape the scorer cannot catch on a
+ * synthetic exemplar (its positive-control check is fire-on-preimage only, and
+ * a single-occurrence defect's fixed form never appears in the real window) —
+ * so the silent-on-postimage leg here is the ONLY signal that surfaces it
+ * (contract review, ADR-112 §4/§5.3). C2 must gate on it.
+ */
+ | 'over-match'
+/** Fires on NEITHER side — the matcher catches nothing (a vacuous control). */
+ | 'vacuous-silent'
+/**
+ * The engine refused to execute on at least one side (invalid regex, ast-grep
+ * runtime throw, an unparseable exemplar, or an engine the smoke gate does not
+ * cover) — the differential could not be established. Fail-loud, distinct from
+ * a clean no-match; routes to operator adjudication, never a silent pass.
+ */
+ | 'needs-adjudication'
+/**
+ * The fixture declares a `commit`-pair preimage source — deferred to slice C2
+ * (the land-then-fix fallback; lc cert-#1 is lesson-anchored). A typed
+ * non-pass that keeps the union total; never treated as a passing control.
+ */
+ | 'unsupported-source';
+export interface PreimageDifferentialResult {
+    /** The differential-level classification (see `PreimageDifferentialOutcome`). */
+    outcome: PreimageDifferentialOutcome;
+    /** The fixture's declared preimage-source kind. */
+    sourceKind: PreimageSource['kind'];
+    /**
+     * The matcher fired on the defect preimage. `null` when the preimage could not
+     * be evaluated (engine refusal, or an unsupported `commit` source).
+     */
+    firesOnPreimage: boolean | null;
+    /**
+     * The matcher stayed silent on the fixed postimage. `null` when the postimage
+     * could not be evaluated (engine refusal, or an unsupported `commit` source).
+     */
+    silentOnPostimage: boolean | null;
+    /** Engine match count on the preimage exemplar (evidence). `null` when not evaluated. */
+    preimageMatchCount: number | null;
+    /** Engine match count on the postimage exemplar (evidence). `null` when not evaluated. */
+    postimageMatchCount: number | null;
+    /** First-line engine/defer reason — present for `needs-adjudication` / `unsupported-source`. */
+    reason?: string;
+}
+/**
+ * Injection port for the COMMIT-pair preimage source (slice C2). The lesson
+ * source (C1) needs none of this — it evaluates against in-record exemplars and
+ * stays I/O-free. Declared here so C2's git-tree reads inject through an explicit
+ * port (mirroring the cert corpus builder's `Stage4VerifierDeps`) and core never
+ * does filesystem/git directly. `evaluatePreimageDifferential` is already async
+ * so wiring this in C2 is a non-breaking, additive change.
+ */
+export interface PreimageDifferentialDeps {
+    /** Read a file's content as of a given commit SHA (the pre-fix / post-fix tree). */
+    readFileAtCommit(commitSha: string, filePath: string): Promise<string>;
+}
+/**
+ * Evaluate the ADR-112 §4 preimage-differential for one authored fixture against
+ * a compiled rule, switching on the fixture's declared `preimageSource.kind`.
+ *
+ * Returns the raw evidence (`firesOnPreimage`, `silentOnPostimage`, match counts)
+ * plus a differential-level `outcome`. It does NOT mint a §5 run verdict and does
+ * NOT emit controls — those are slice C2/D. The `commit` source is a typed
+ * non-pass (`unsupported-source`) deferred to C2; the union stays total.
+ *
+ * Async-from-the-start so C2 can inject `PreimageDifferentialDeps` for git-tree
+ * reads without a breaking signature change; the C1 lesson path resolves
+ * synchronously under the hood (pure, hermetic).
+ */
+export declare function evaluatePreimageDifferential(rule: CompiledRule, fixture: AuthoredFixture): Promise<PreimageDifferentialResult>;
+//# sourceMappingURL=preimage-differential.d.ts.map

package/dist/spine/preimage-differential.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preimage-differential.d.ts","sourceRoot":"","sources":["../../src/spine/preimage-differential.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAGH,OAAO,KAAK,EAAE,eAAe,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAI3F;;;;GAIG;AACH,MAAM,MAAM,2BAA2B;AACrC,6FAA6F;AAC3F,oBAAoB;AACtB;;;GAGG;GACD,YAAY;AACd;;;;;;;GAOG;GACD,YAAY;AACd,+EAA+E;GAC7E,gBAAgB;AAClB;;;;;GAKG;GACD,oBAAoB;AACtB;;;;GAIG;GACD,oBAAoB,CAAC;AAEzB,MAAM,WAAW,0BAA0B;IACzC,iFAAiF;IACjF,OAAO,EAAE,2BAA2B,CAAC;IACrC,mDAAmD;IACnD,UAAU,EAAE,cAAc,CAAC,MAAM,CAAC,CAAC;IACnC;;;OAGG;IACH,eAAe,EAAE,OAAO,GAAG,IAAI,CAAC;IAChC;;;OAGG;IACH,iBAAiB,EAAE,OAAO,GAAG,IAAI,CAAC;IAClC,yFAAyF;IACzF,kBAAkB,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,0FAA0F;IAC1F,mBAAmB,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,gGAAgG;IAChG,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,wBAAwB;IACvC,oFAAoF;IACpF,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;CACxE;AAkFD;;;;;;;;;;;;GAYG;AACH,wBAAsB,4BAA4B,CAChD,IAAI,EAAE,YAAY,EAClB,OAAO,EAAE,eAAe,GACvB,OAAO,CAAC,0BAA0B,CAAC,CAgBrC"}

package/dist/spine/preimage-differential.js

@@ -0,0 +1,122 @@
+/**
+ * ADR-112 §4/§6 — the preimage-differential materializer (slice C1: the inert primitive).
+ *
+ * An authored rule is only a legitimate positive control if its matcher **fires
+ * on the defect preimage** and is **silent on the fixed postimage** (§4). A
+ * matcher that fires on the *fixed* form is "fix-shaped" — the exact failure
+ * mode the miner's honest-negative is made of — and must never be admitted as a
+ * legitimate control (Falsifying Metric §1(i)).
+ *
+ * This module evaluates that differential against a fixture's declared
+ * `preimageSource` (lesson-anchored PRIMARY / commit-pair FALLBACK) and reports
+ * the raw evidence + a differential-level classification. It is deliberately
+ * INERT: it wires nothing into the cert path, mints no §5 run verdict, and emits
+ * no controls. Slice C2 consumes this to gate control emission; slice D maps the
+ * differential to the ADR-110 §5 terminal vocabulary (PASS / FAIL /
+ * HONEST-NEGATIVE). The boundary is load-bearing — `over-match` / `vacuous` here
+ * are DIFFERENTIAL outcomes, NOT run verdicts (the scorer owns that).
+ *
+ * Seam (Tenet-21 reuse): firing goes through `runSmokeGate`, the same
+ * role-agnostic engine entry point the compiler's #1408 under-match / #1580
+ * over-match checks use — regex and ast-grep, in-memory, no temp file, no diff
+ * fabrication, no `firingLabelId` minted here. The lesson source evaluates
+ * against the in-record `badExample`/`goodExample` exemplars (contract §5.4), so
+ * the lesson path is pure and hermetic — no clock, no network, no filesystem.
+ */
+import { runSmokeGate } from '../compile-smoke-gate.js';
+// ─── Classification ─────────────────────────────────
+function classifyDifferential(firesOnPreimage, silentOnPostimage) {
+    if (firesOnPreimage && silentOnPostimage)
+        return 'differential-holds';
+    if (firesOnPreimage && !silentOnPostimage)
+        return 'over-match';
+    if (!firesOnPreimage && silentOnPostimage)
+        return 'vacuous-silent';
+    return 'fix-shaped';
+}
+// ─── Lesson-anchored differential (C1) ──────────────
+function evaluateLessonDifferential(rule, source) {
+    const pre = runSmokeGate(rule, source.badExample);
+    const post = runSmokeGate(rule, source.goodExample);
+    // An exemplar with no evaluable code cannot establish a differential. Two
+    // ways that happens: (1) the engine REFUSES to run — invalid regex, ast-grep
+    // throw, uncovered engine — which `runSmokeGate` reports via `reason`; (2) the
+    // exemplar is empty/whitespace-only, which `runSmokeGate` instead reports as a
+    // CLEAN no-match (no `reason`) — and that would vacuously read as
+    // silent-on-postimage / fires-on-neither, masking that one side had nothing to
+    // evaluate (an empty postimage falsely reading as `differential-holds` is the
+    // dishonest control this primitive exists to catch). The schema enforces
+    // non-empty exemplars, but this is a public primitive reachable by direct
+    // (unparsed) construction, so it defends its own contract: either condition on
+    // either side → `needs-adjudication`, fail-loud, never a silent clean result.
+    const preUnevaluable = source.badExample.trim().length === 0 || pre.reason !== undefined;
+    const postUnevaluable = source.goodExample.trim().length === 0 || post.reason !== undefined;
+    if (preUnevaluable || postUnevaluable) {
+        const reason = (source.badExample.trim().length === 0
+            ? 'badExample (the defect preimage) is empty or whitespace-only — no evaluable code to establish the differential'
+            : pre.reason) ??
+            (source.goodExample.trim().length === 0
+                ? 'goodExample (the fixed postimage) is empty or whitespace-only — no evaluable code to establish the differential'
+                : post.reason);
+        return {
+            outcome: 'needs-adjudication',
+            sourceKind: 'lesson',
+            firesOnPreimage: preUnevaluable ? null : pre.matched,
+            silentOnPostimage: postUnevaluable ? null : !post.matched,
+            preimageMatchCount: preUnevaluable ? null : pre.matchCount,
+            postimageMatchCount: postUnevaluable ? null : post.matchCount,
+            reason,
+        };
+    }
+    const firesOnPreimage = pre.matched;
+    const silentOnPostimage = !post.matched;
+    return {
+        outcome: classifyDifferential(firesOnPreimage, silentOnPostimage),
+        sourceKind: 'lesson',
+        firesOnPreimage,
+        silentOnPostimage,
+        preimageMatchCount: pre.matchCount,
+        postimageMatchCount: post.matchCount,
+    };
+}
+function deferredCommitResult() {
+    return {
+        outcome: 'unsupported-source',
+        sourceKind: 'commit',
+        firesOnPreimage: null,
+        silentOnPostimage: null,
+        preimageMatchCount: null,
+        postimageMatchCount: null,
+        reason: 'commit-pair preimage source is deferred to slice C2 (land-then-fix fallback); lc cert-#1 is lesson-anchored',
+    };
+}
+// ─── Public API ─────────────────────────────────────
+/**
+ * Evaluate the ADR-112 §4 preimage-differential for one authored fixture against
+ * a compiled rule, switching on the fixture's declared `preimageSource.kind`.
+ *
+ * Returns the raw evidence (`firesOnPreimage`, `silentOnPostimage`, match counts)
+ * plus a differential-level `outcome`. It does NOT mint a §5 run verdict and does
+ * NOT emit controls — those are slice C2/D. The `commit` source is a typed
+ * non-pass (`unsupported-source`) deferred to C2; the union stays total.
+ *
+ * Async-from-the-start so C2 can inject `PreimageDifferentialDeps` for git-tree
+ * reads without a breaking signature change; the C1 lesson path resolves
+ * synchronously under the hood (pure, hermetic).
+ */
+export async function evaluatePreimageDifferential(rule, fixture) {
+    const source = fixture.preimageSource;
+    switch (source.kind) {
+        case 'lesson':
+            return evaluateLessonDifferential(rule, source);
+        case 'commit':
+            return deferredCommitResult();
+        default: {
+            // Exhaustiveness backstop: a future `PreimageSource` kind must be handled
+            // explicitly, never silently admitted as a passing control.
+            const _exhaustive = source;
+            throw new Error(`[Totem Error] evaluatePreimageDifferential: unknown preimageSource kind '${String(_exhaustive.kind)}'`);
+        }
+    }
+}
+//# sourceMappingURL=preimage-differential.js.map

package/dist/spine/preimage-differential.js.map

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

package/dist/spine/preimage-differential.test.d.ts

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

package/dist/spine/preimage-differential.test.d.ts.map

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

package/dist/spine/preimage-differential.test.js

@@ -0,0 +1,223 @@
+import { describe, expect, it } from 'vitest';
+import { evaluatePreimageDifferential } from './preimage-differential.js';
+// ─── Rule helpers (mirror compile-smoke-gate.test.ts) ─
+function regexRule(overrides = {}) {
+    return {
+        lessonHash: 'deadbeef1234',
+        lessonHeading: 'No console.log',
+        pattern: 'console\\.log',
+        message: 'Do not use console.log',
+        engine: 'regex',
+        compiledAt: '2026-04-13T12:00:00Z',
+        ...overrides,
+    };
+}
+function astGrepRule(overrides = {}) {
+    return {
+        lessonHash: 'cafeface5678',
+        lessonHeading: 'No debugger',
+        pattern: '',
+        message: 'Do not commit debugger statements',
+        engine: 'ast-grep',
+        astGrepPattern: 'debugger',
+        compiledAt: '2026-04-13T12:00:00Z',
+        ...overrides,
+    };
+}
+function emptyCatchRule(overrides = {}) {
+    return {
+        lessonHash: 'beefcafe9abc',
+        lessonHeading: 'Empty catch',
+        pattern: '',
+        message: 'Empty catch swallows errors',
+        engine: 'ast-grep',
+        astGrepYamlRule: {
+            rule: {
+                kind: 'catch_clause',
+                not: {
+                    has: {
+                        kind: 'statement_block',
+                        has: {
+                            any: [
+                                { kind: 'expression_statement' },
+                                { kind: 'variable_declaration' },
+                                { kind: 'if_statement' },
+                                { kind: 'return_statement' },
+                                { kind: 'throw_statement' },
+                            ],
+                            stopBy: 'end',
+                        },
+                    },
+                },
+            },
+        },
+        compiledAt: '2026-04-13T12:00:00Z',
+        ...overrides,
+    };
+}
+// ─── Fixture helpers ────────────────────────────────
+function lessonFixture(badExample, goodExample) {
+    return {
+        pr: 130,
+        preimageSource: { kind: 'lesson', lessonRef: 'deadbeefdeadbeef', badExample, goodExample },
+        filePath: 'src/sim/level.rs',
+        matchedSpan: 'L10-L12',
+        contentHash: 'abc123def456',
+    };
+}
+function commitFixture() {
+    return {
+        pr: 130,
+        preimageSource: {
+            kind: 'commit',
+            preimageCommitSha: 'a'.repeat(40),
+            mergeCommitSha: 'b'.repeat(40),
+        },
+        filePath: 'src/sim/level.rs',
+        matchedSpan: 'L10-L12',
+        contentHash: 'abc123def456',
+    };
+}
+// ─── differential-holds (the legitimate control) ─────
+describe('evaluatePreimageDifferential — differential-holds', () => {
+    it('regex: fires on the preimage and is silent on the postimage', async () => {
+        const result = await evaluatePreimageDifferential(regexRule(), lessonFixture('console.log("debug")', 'logger.info("ok")'));
+        expect(result.outcome).toBe('differential-holds');
+        // Non-vacuity: BOTH legs must hold. If the classifier checked only
+        // firesOnPreimage, the over-match case below would also read as "holds".
+        expect(result.firesOnPreimage).toBe(true);
+        expect(result.silentOnPostimage).toBe(true);
+        expect(result.preimageMatchCount).toBeGreaterThanOrEqual(1);
+        expect(result.postimageMatchCount).toBe(0);
+        expect(result.sourceKind).toBe('lesson');
+    });
+    it('ast-grep: fires on the preimage and is silent on the postimage (TS exemplar)', async () => {
+        const result = await evaluatePreimageDifferential(astGrepRule(), lessonFixture('debugger;\n', 'const x = 1;\n'));
+        expect(result.outcome).toBe('differential-holds');
+        expect(result.firesOnPreimage).toBe(true);
+        expect(result.silentOnPostimage).toBe(true);
+        expect(result.preimageMatchCount).toBeGreaterThanOrEqual(1);
+    });
+    it('ast-grep compound (multi-line exemplar): fires on empty catch, silent on a catch with a body', async () => {
+        // Locks multi-line exemplar faithfulness — the differential must survive a
+        // real multi-line snippet, not just a single token.
+        const result = await evaluatePreimageDifferential(emptyCatchRule(), lessonFixture('try {\n  work();\n} catch (err) {\n}\n', 'try {\n  work();\n} catch (err) {\n  log(err);\n}\n'));
+        expect(result.outcome).toBe('differential-holds');
+        expect(result.firesOnPreimage).toBe(true);
+        expect(result.silentOnPostimage).toBe(true);
+    });
+});
+// ─── fix-shaped (the literal Falsifying Metric §1(i)) ─
+describe('evaluatePreimageDifferential — fix-shaped is never a charitable pass (FM §1(i))', () => {
+    it('regex: a matcher that fires on the FIXED form and is silent on the defect is fix-shaped', async () => {
+        // pattern matches the GOOD form (logger.info), not the defect (console.log).
+        const result = await evaluatePreimageDifferential(regexRule({ pattern: 'logger\\.info' }), lessonFixture('console.log("bad")', 'logger.info("fixed")'));
+        expect(result.outcome).toBe('fix-shaped');
+        expect(result.outcome).not.toBe('differential-holds');
+        // Non-vacuity: the classification must rest on BOTH legs being wrong, not
+        // just one. fix-shaped (here) and vacuous-silent (below) share
+        // firesOnPreimage=false but differ on silentOnPostimage — so the silent leg
+        // is load-bearing.
+        expect(result.firesOnPreimage).toBe(false);
+        expect(result.silentOnPostimage).toBe(false);
+    });
+    it('ast-grep: silent on the defect, fires on the fixed form → fix-shaped', async () => {
+        const result = await evaluatePreimageDifferential(astGrepRule(), lessonFixture('const x = 1;\n', 'debugger;\n'));
+        expect(result.outcome).toBe('fix-shaped');
+        expect(result.firesOnPreimage).toBe(false);
+        expect(result.silentOnPostimage).toBe(false);
+    });
+});
+// ─── over-match (the scorer-invisible escape, contract §4/§5.3) ─
+describe('evaluatePreimageDifferential — over-match is surfaced (the silent-on-postimage leg)', () => {
+    it('regex: a matcher that fires on BOTH the defect and the fixed form is over-match, not holds', async () => {
+        const result = await evaluatePreimageDifferential(regexRule(), lessonFixture('console.log("bad")', 'console.log("still here in the fix")'));
+        expect(result.outcome).toBe('over-match');
+        // The cert-critical assertion: this MUST NOT read as differential-holds.
+        expect(result.outcome).not.toBe('differential-holds');
+        expect(result.firesOnPreimage).toBe(true);
+        // Non-vacuity: if the code ignored the postimage, silentOnPostimage would be
+        // true and this would be misclassified as holds — the escape the scorer
+        // cannot catch on a synthetic exemplar.
+        expect(result.silentOnPostimage).toBe(false);
+        expect(result.postimageMatchCount).toBeGreaterThanOrEqual(1);
+    });
+    it('ast-grep: fires on both sides → over-match', async () => {
+        const result = await evaluatePreimageDifferential(astGrepRule(), lessonFixture('debugger;\n', 'debugger;\nconst x = 1;\n'));
+        expect(result.outcome).toBe('over-match');
+        expect(result.silentOnPostimage).toBe(false);
+    });
+});
+// ─── vacuous-silent (fires on neither) ──────────────
+describe('evaluatePreimageDifferential — vacuous-silent (fires on neither)', () => {
+    it('regex: a matcher silent on both sides catches nothing', async () => {
+        const result = await evaluatePreimageDifferential(regexRule(), lessonFixture('const x = 1;', 'const y = 2;'));
+        expect(result.outcome).toBe('vacuous-silent');
+        expect(result.firesOnPreimage).toBe(false);
+        expect(result.silentOnPostimage).toBe(true);
+        // Contrast with fix-shaped (same firesOnPreimage=false): proves the silent
+        // leg distinguishes the two and is not ignored.
+    });
+});
+// ─── needs-adjudication (engine refusal, fail-loud) ──
+describe('evaluatePreimageDifferential — needs-adjudication on engine refusal', () => {
+    it('invalid regex pattern → needs-adjudication with a reason, not a silent clean result', async () => {
+        const result = await evaluatePreimageDifferential(regexRule({ pattern: '(unclosed' }), lessonFixture('console.log("x")', 'logger.info("ok")'));
+        expect(result.outcome).toBe('needs-adjudication');
+        expect(result.reason).toBeDefined();
+        expect(result.reason).toContain('invalid');
+        // The preimage leg could not be evaluated → null, not a false "silent".
+        expect(result.firesOnPreimage).toBeNull();
+    });
+    it('ast-grep rule that throws at runtime (invalid kind) → needs-adjudication', async () => {
+        const result = await evaluatePreimageDifferential(emptyCatchRule({ astGrepYamlRule: { rule: { kind: '!!!INVALID_KIND!!!' } } }), lessonFixture('try {\n} catch (e) {\n}\n', 'const x = 1;\n'));
+        expect(result.outcome).toBe('needs-adjudication');
+        expect(result.reason).toBeDefined();
+    });
+    it('an engine the smoke gate does not cover (tree-sitter ast) → needs-adjudication', async () => {
+        const result = await evaluatePreimageDifferential(regexRule({ engine: 'ast', pattern: '' }), lessonFixture('whatever', 'something else'));
+        expect(result.outcome).toBe('needs-adjudication');
+        expect(result.reason).toBeDefined();
+    });
+    it('a whitespace-only badExample → needs-adjudication, not a silent vacuous result', async () => {
+        // Direct (unparsed) construction can bypass the schema's non-empty refine; a
+        // whitespace preimage carries no evaluable code, so the preimage leg is null.
+        const result = await evaluatePreimageDifferential(regexRule(), lessonFixture('   \n  ', 'logger.info("ok")'));
+        expect(result.outcome).toBe('needs-adjudication');
+        expect(result.firesOnPreimage).toBeNull();
+        expect(result.reason).toContain('badExample');
+    });
+    it('a whitespace-only goodExample → needs-adjudication, NOT a false differential-holds (Greptile #2264)', async () => {
+        // The cert-critical case: the rule fires on the defect, and the postimage is
+        // whitespace. Pre-fix this read as differential-holds (silentOnPostimage true
+        // because there was nothing to match) — masking an unevaluable fixed side.
+        const result = await evaluatePreimageDifferential(regexRule(), lessonFixture('console.log("bad")', '   \n  '));
+        expect(result.outcome).toBe('needs-adjudication');
+        expect(result.outcome).not.toBe('differential-holds');
+        expect(result.silentOnPostimage).toBeNull();
+        expect(result.reason).toContain('goodExample');
+    });
+});
+// ─── commit-source deferral (typed non-pass, slice C2) ─
+describe('evaluatePreimageDifferential — commit source is a typed deferral (slice C2)', () => {
+    it('commit-pair fixture → unsupported-source, never a passing control', async () => {
+        const result = await evaluatePreimageDifferential(astGrepRule(), commitFixture());
+        expect(result.outcome).toBe('unsupported-source');
+        expect(result.outcome).not.toBe('differential-holds');
+        expect(result.sourceKind).toBe('commit');
+        expect(result.firesOnPreimage).toBeNull();
+        expect(result.silentOnPostimage).toBeNull();
+        expect(result.reason).toContain('slice C2');
+    });
+});
+// ─── determinism (Tenet-15) ─────────────────────────
+describe('evaluatePreimageDifferential — determinism', () => {
+    it('is a pure function of (rule, fixture): identical inputs yield identical results', async () => {
+        const rule = astGrepRule();
+        const fixture = lessonFixture('debugger;\n', 'const x = 1;\n');
+        const a = await evaluatePreimageDifferential(rule, fixture);
+        const b = await evaluatePreimageDifferential(rule, fixture);
+        expect(a).toEqual(b);
+    });
+});
+//# sourceMappingURL=preimage-differential.test.js.map

package/dist/spine/preimage-differential.test.js.map

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

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

@@ -7,11 +7,11 @@ export declare const WindtunnelLockSchema: z.ZodEffects<z.ZodObject<{
         timestamp: z.ZodOptional<z.ZodString>;
         commit: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
-        timestamp?: string | undefined;
         commit?: string | undefined;
-    }, {
         timestamp?: string | undefined;
+    }, {
         commit?: string | undefined;
+        timestamp?: string | undefined;
     }>>;
     phase: z.ZodEnum<["harness", "certifying"]>;
     corpus: z.ZodObject<{
@@ -324,8 +324,8 @@ export declare const WindtunnelLockSchema: z.ZodEffects<z.ZodObject<{
         };
     };
     frozenAt?: {
-        timestamp?: string | undefined;
         commit?: string | undefined;
+        timestamp?: string | undefined;
     } | undefined;
 }, {
     schema: "windtunnel.lock.v1";
@@ -390,8 +390,8 @@ export declare const WindtunnelLockSchema: z.ZodEffects<z.ZodObject<{
         };
     };
     frozenAt?: {
-        timestamp?: string | undefined;
         commit?: string | undefined;
+        timestamp?: string | undefined;
     } | undefined;
 }>, {
     schema: "windtunnel.lock.v1";
@@ -456,8 +456,8 @@ export declare const WindtunnelLockSchema: z.ZodEffects<z.ZodObject<{
         };
     };
     frozenAt?: {
-        timestamp?: string | undefined;
         commit?: string | undefined;
+        timestamp?: string | undefined;
     } | undefined;
 }, {
     schema: "windtunnel.lock.v1";
@@ -522,8 +522,8 @@ export declare const WindtunnelLockSchema: z.ZodEffects<z.ZodObject<{
         };
     };
     frozenAt?: {
-        timestamp?: string | undefined;
         commit?: string | undefined;
+        timestamp?: string | undefined;
     } | undefined;
 }>;
 export type WindtunnelLock = z.infer<typeof WindtunnelLockSchema>;

package/dist/store/lance-schema.d.ts

@@ -15,7 +15,7 @@ export declare const StoredChunkSchema: z.ZodObject<{
     endLine: z.ZodNumber;
     metadata: z.ZodString;
 }, "strip", z.ZodTypeAny, {
-    type: "code" | "session_log" | "spec" | "lesson";
+    type: "code" | "lesson" | "session_log" | "spec";
     filePath: string;
     content: string;
     strategy: string;
@@ -26,7 +26,7 @@ export declare const StoredChunkSchema: z.ZodObject<{
     id: string;
     metadata: string;
 }, {
-    type: "code" | "session_log" | "spec" | "lesson";
+    type: "code" | "lesson" | "session_log" | "spec";
     filePath: string;
     content: string;
     strategy: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mmnto/totem",
-  "version": "1.79.0",
+  "version": "1.81.0",
   "description": "Persistent memory and context layer for AI agents",
   "type": "module",
   "engines": {