@mmnto/totem 1.15.2 → 1.15.4

package/dist/compile-lesson.test.js

@@ -204,6 +204,115 @@ describe('buildCompiledRule', () => {
         const result = buildCompiledRule(parsed, lesson, existingByHash);
         expect(result.rule.severity).toBe('warning');
     });
+    // ─── Declared severity override (mmnto-ai/totem#1656) ──
+    it('honors declaredSeverityOverride when LLM emits a different severity', () => {
+        const parsed = {
+            compilable: true,
+            pattern: 'test',
+            message: 'test',
+            engine: 'regex',
+            severity: 'warning',
+        };
+        const result = buildCompiledRule(parsed, lesson, existingByHash, {
+            declaredSeverityOverride: 'error',
+        });
+        expect(result.rule.severity).toBe('error');
+        expect(result.severityOverride).toEqual({ from: 'warning', to: 'error' });
+    });
+    it('honors declaredSeverityOverride when LLM emits no severity', () => {
+        const parsed = {
+            compilable: true,
+            pattern: 'test',
+            message: 'test',
+            engine: 'regex',
+        };
+        const result = buildCompiledRule(parsed, lesson, existingByHash, {
+            declaredSeverityOverride: 'error',
+        });
+        expect(result.rule.severity).toBe('error');
+        expect(result.severityOverride).toEqual({ from: undefined, to: 'error' });
+    });
+    it('omits severityOverride marker when declared severity matches LLM output', () => {
+        const parsed = {
+            compilable: true,
+            pattern: 'test',
+            message: 'test',
+            engine: 'regex',
+            severity: 'error',
+        };
+        const result = buildCompiledRule(parsed, lesson, existingByHash, {
+            declaredSeverityOverride: 'error',
+        });
+        expect(result.rule.severity).toBe('error');
+        expect(result.severityOverride).toBeUndefined();
+    });
+    it('omits severityOverride marker when no declared severity provided', () => {
+        const parsed = {
+            compilable: true,
+            pattern: 'test',
+            message: 'test',
+            engine: 'regex',
+            severity: 'warning',
+        };
+        const result = buildCompiledRule(parsed, lesson, existingByHash);
+        expect(result.rule.severity).toBe('warning');
+        expect(result.severityOverride).toBeUndefined();
+    });
+    it('omits severityOverride marker when declared warning matches the default fallback', () => {
+        // LLM emits no severity AND declared is 'warning'. The emitted severity
+        // would have defaulted to 'warning' anyway, so the override changes
+        // nothing in the final rule. Marker must not fire — it would be
+        // telemetry noise on every lesson that declares its severity as warning.
+        const parsed = {
+            compilable: true,
+            pattern: 'test',
+            message: 'test',
+            engine: 'regex',
+            // severity deliberately omitted (undefined)
+        };
+        const result = buildCompiledRule(parsed, lesson, existingByHash, {
+            declaredSeverityOverride: 'warning',
+        });
+        expect(result.rule.severity).toBe('warning');
+        expect(result.severityOverride).toBeUndefined();
+    });
+    it('preserves severityOverride on rejection paths too', () => {
+        // CR round-3 finding on mmnto-ai/totem#1658: if the LLM drifts on
+        // severity AND emits an invalid pattern, the rejection path must still
+        // surface severityOverride so telemetry captures exactly the
+        // prompt-drift cases this signal is meant to detect.
+        const parsed = {
+            compilable: true,
+            pattern: '(unclosed',
+            message: 'test',
+            engine: 'regex',
+            severity: 'warning',
+        };
+        const result = buildCompiledRule(parsed, lesson, existingByHash, {
+            declaredSeverityOverride: 'error',
+        });
+        expect(result.rule).toBeNull();
+        expect(result.rejectReason).toContain('Rejected regex');
+        expect(result.severityOverride).toEqual({ from: 'warning', to: 'error' });
+    });
+    it('does not fabricate severityOverride on rejection paths when declared severity matches', () => {
+        // Inverse of the above: rejection path + no actual drift = no marker.
+        // The rejection is still reported; only the severity-override signal
+        // stays absent.
+        const parsed = {
+            compilable: true,
+            pattern: '(unclosed',
+            message: 'test',
+            engine: 'regex',
+            severity: 'error',
+        };
+        const result = buildCompiledRule(parsed, lesson, existingByHash, {
+            declaredSeverityOverride: 'error',
+        });
+        expect(result.rule).toBeNull();
+        expect(result.rejectReason).toContain('Rejected regex');
+        expect(result.severityOverride).toBeUndefined();
+    });
 });
 // ─── self-suppression guard (#1177) ────────────────
 describe('self-suppression guard (#1177)', () => {
@@ -1211,6 +1320,92 @@ describe('compileLesson', () => {
             expect(result.reason).toBeUndefined();
         }
     });
+    it('routes LLM context-required signal to reasonCode context-required (Pipeline 2, mmnto-ai/totem#1598)', async () => {
+        const deps = {
+            parseCompilerResponse: vi.fn().mockReturnValue({
+                compilable: false,
+                reasonCode: 'context-required',
+                reason: 'Lesson constrains scope to an enclosing function ("inside _process") the pattern cannot express.',
+            }),
+            runOrchestrator: vi.fn().mockResolvedValue('response'),
+            existingByHash: new Map(),
+            callbacks: { onWarn: vi.fn(), onDim: vi.fn() },
+        };
+        const result = await compileLesson(lesson, 'system prompt', deps);
+        expect(result.status).toBe('skipped');
+        if (result.status === 'skipped') {
+            expect(result.reasonCode).toBe('context-required');
+        }
+    });
+    it('routes LLM semantic-analysis-required signal to reasonCode semantic-analysis-required (Pipeline 2, mmnto-ai/totem#1634)', async () => {
+        const deps = {
+            parseCompilerResponse: vi.fn().mockReturnValue({
+                compilable: false,
+                reasonCode: 'semantic-analysis-required',
+                reason: 'Lesson requires closure-body AST analysis (captured-float assignment inside par_iter_mut().for_each).',
+            }),
+            runOrchestrator: vi.fn().mockResolvedValue('response'),
+            existingByHash: new Map(),
+            callbacks: { onWarn: vi.fn(), onDim: vi.fn() },
+        };
+        const result = await compileLesson(lesson, 'system prompt', deps);
+        expect(result.status).toBe('skipped');
+        if (result.status === 'skipped') {
+            expect(result.reasonCode).toBe('semantic-analysis-required');
+        }
+    });
+    it('falls back to out-of-scope when LLM omits reasonCode on a non-compilable response', async () => {
+        // Backward compatibility: LLM responses that mark compilable:false without
+        // the reasonCode field continue to route through the generic out-of-scope
+        // exit path. Only the narrow context-required signal opts into the new
+        // classifier bucket.
+        const deps = {
+            parseCompilerResponse: vi.fn().mockReturnValue({
+                compilable: false,
+                reason: 'Describes a conceptual principle, not a code pattern',
+            }),
+            runOrchestrator: vi.fn().mockResolvedValue('response'),
+            existingByHash: new Map(),
+            callbacks: { onWarn: vi.fn(), onDim: vi.fn() },
+        };
+        const result = await compileLesson(lesson, 'system prompt', deps);
+        expect(result.status).toBe('skipped');
+        if (result.status === 'skipped') {
+            expect(result.reasonCode).toBe('out-of-scope');
+        }
+    });
+    it('anti-lazy: compiles a structurally-capturable scope-sensitive lesson when LLM supplies a pattern', async () => {
+        // The context-required escape hatch (mmnto-ai/totem#1598) risks lazy-
+        // rejection of lessons whose scope CAN be captured structurally (fileGlobs,
+        // kind-scoped ast-grep, etc.). Lock in that a valid compilable response
+        // with a pattern still compiles even when the lesson body literally
+        // contains the escape-hatch trigger keywords ("inside", "only for new").
+        // The compiler routing must trust `compilable:true` and must not scan the
+        // lesson body for escape-hatch triggers. CR PR mmnto-ai/totem#1639 round-1
+        // flagged that a fixture without scope markers left this invariant
+        // untested; the explicit scope-sensitive body closes that gap.
+        const scopeSensitiveLesson = {
+            index: 0,
+            heading: 'Use logger inside request handlers (anti-lazy #1598)',
+            body: 'Always use logger inside request handlers; only for new handlers, console.log is forbidden. The scope here IS expressible structurally via fileGlobs, so the LLM must compile despite the "inside" and "only for new" trigger keywords in the body.',
+            hash: 'antilazy1598scopesensitive',
+        };
+        const deps = {
+            parseCompilerResponse: vi.fn().mockReturnValue({
+                compilable: true,
+                pattern: 'console\\.log',
+                message: 'Use logger inside request handlers instead of console.log',
+                engine: 'regex',
+                badExample: 'console.log("debug")',
+                goodExample: 'logger.info("debug")',
+            }),
+            runOrchestrator: vi.fn().mockResolvedValue('response'),
+            existingByHash: new Map(),
+            callbacks: { onWarn: vi.fn(), onDim: vi.fn() },
+        };
+        const result = await compileLesson(scopeSensitiveLesson, 'system prompt', deps);
+        expect(result.status).toBe('compiled');
+    });
     it('calls onWarn callback on failures', async () => {
         const deps = {
             parseCompilerResponse: vi.fn().mockReturnValue(null),
@@ -1470,6 +1665,40 @@ describe('compileLesson Pipeline 3 (Bad/Good snippets)', () => {
         expect(result.status).toBe('skipped');
         expect(deps.callbacks.onDim).toHaveBeenCalledWith(pipeline3Lesson.heading, expect.stringContaining('Pipeline 3'));
     });
+    it('routes LLM context-required signal to reasonCode context-required (Pipeline 3, mmnto-ai/totem#1598)', async () => {
+        const deps = {
+            parseCompilerResponse: vi.fn().mockReturnValue({
+                compilable: false,
+                reasonCode: 'context-required',
+                reason: 'Lesson constrains scope to "only for NEW proposal IDs"; pattern cannot distinguish new from existing.',
+            }),
+            runOrchestrator: vi.fn().mockResolvedValue('response'),
+            existingByHash: new Map(),
+            callbacks: { onWarn: vi.fn(), onDim: vi.fn() },
+        };
+        const result = await compileLesson(pipeline3Lesson, 'system prompt', deps);
+        expect(result.status).toBe('skipped');
+        if (result.status === 'skipped') {
+            expect(result.reasonCode).toBe('context-required');
+        }
+    });
+    it('routes LLM semantic-analysis-required signal to reasonCode semantic-analysis-required (Pipeline 3, mmnto-ai/totem#1634)', async () => {
+        const deps = {
+            parseCompilerResponse: vi.fn().mockReturnValue({
+                compilable: false,
+                reasonCode: 'semantic-analysis-required',
+                reason: 'Multi-file contract: rule applies cross-system; single-lesson-body pattern cannot express the multi-file hazard.',
+            }),
+            runOrchestrator: vi.fn().mockResolvedValue('response'),
+            existingByHash: new Map(),
+            callbacks: { onWarn: vi.fn(), onDim: vi.fn() },
+        };
+        const result = await compileLesson(pipeline3Lesson, 'system prompt', deps);
+        expect(result.status).toBe('skipped');
+        if (result.status === 'skipped') {
+            expect(result.reasonCode).toBe('semantic-analysis-required');
+        }
+    });
     it('rejects at the smoke gate when the pattern does not match the Bad snippet (mmnto/totem#1408)', async () => {
         const deps = {
             parseCompilerResponse: vi.fn().mockReturnValue({