@mmnto/totem 1.14.8 → 1.14.9

package/dist/compile-smoke-gate.test.js

@@ -0,0 +1,202 @@
+import { describe, expect, it } from 'vitest';
+import { matchAstGrepPattern } from './ast-grep-query.js';
+import { runSmokeGate } from './compile-smoke-gate.js';
+// ─── Helpers ────────────────────────────────────────
+function makeRegexRule(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 makeAstGrepStringRule(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 makeCompoundRule(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,
+    };
+}
+// ─── runSmokeGate: regex rules ───────────────────────
+describe('runSmokeGate — regex engine', () => {
+    it('matches when the badExample contains the pattern', () => {
+        const rule = makeRegexRule();
+        const result = runSmokeGate(rule, 'console.log("debug")');
+        expect(result.matched).toBe(true);
+        expect(result.matchCount).toBeGreaterThanOrEqual(1);
+    });
+    it('does not match when the badExample is clean', () => {
+        const rule = makeRegexRule();
+        const result = runSmokeGate(rule, 'const x = 1;');
+        expect(result.matched).toBe(false);
+        expect(result.matchCount).toBe(0);
+    });
+    it('returns matched false for an empty badExample', () => {
+        const rule = makeRegexRule();
+        const result = runSmokeGate(rule, '');
+        expect(result.matched).toBe(false);
+        expect(result.matchCount).toBe(0);
+    });
+    it('returns matched false when the regex itself is invalid', () => {
+        const rule = makeRegexRule({ pattern: '(unclosed' });
+        const result = runSmokeGate(rule, 'console.log(1)');
+        expect(result.matched).toBe(false);
+        expect(result.matchCount).toBe(0);
+        expect(result.reason).toContain('invalid');
+    });
+});
+// ─── runSmokeGate: flat ast-grep rules ───────────────
+describe('runSmokeGate — ast-grep flat pattern', () => {
+    it('matches when the pattern hits the badExample', () => {
+        const rule = makeAstGrepStringRule();
+        const result = runSmokeGate(rule, 'debugger;\n');
+        expect(result.matched).toBe(true);
+        expect(result.matchCount).toBeGreaterThanOrEqual(1);
+    });
+    it('does not match when the pattern misses the badExample', () => {
+        const rule = makeAstGrepStringRule();
+        const result = runSmokeGate(rule, 'const x = 1;\n');
+        expect(result.matched).toBe(false);
+        expect(result.matchCount).toBe(0);
+    });
+    it('returns matched false when the pattern itself throws at runtime', () => {
+        // Invalid kind — the ast-grep engine throws. The gate must surface
+        // this as a non-match with a reason rather than propagating.
+        const rule = makeAstGrepStringRule({ astGrepPattern: undefined });
+        const invalid = makeAstGrepStringRule({ astGrepPattern: 'catch ($E) { $$$ }' });
+        // Force an invalid string pattern so findAll throws.
+        const result = runSmokeGate(invalid, 'try { work() } catch (err) {}');
+        // A bare catch string pattern is multi-root and throws; the gate
+        // swallows the throw and reports no match with a reason.
+        expect(result.matched).toBe(false);
+        expect(rule).toBeDefined(); // silence unused
+    });
+});
+// ─── runSmokeGate: compound ast-grep rules ───────────
+describe('runSmokeGate — ast-grep compound (astGrepYamlRule)', () => {
+    it('matches when the compound rule fires on the badExample', () => {
+        const rule = makeCompoundRule();
+        const result = runSmokeGate(rule, 'try {\n  work();\n} catch (err) {\n}\n');
+        expect(result.matched).toBe(true);
+    });
+    it('does not match when the compound rule misses the badExample', () => {
+        const rule = makeCompoundRule();
+        const result = runSmokeGate(rule, 'try {\n  work();\n} catch (err) {\n  log(err);\n}\n');
+        expect(result.matched).toBe(false);
+        expect(result.matchCount).toBe(0);
+    });
+    it('returns matched false with a reason when the compound rule throws', () => {
+        const rule = makeCompoundRule({
+            astGrepYamlRule: { rule: { kind: '!!!INVALID_KIND!!!' } },
+        });
+        const result = runSmokeGate(rule, 'const x = 1;\n');
+        expect(result.matched).toBe(false);
+        expect(result.reason).toBeDefined();
+    });
+});
+// ─── extension inference (GCA WARN on design review) ─
+describe('runSmokeGate badExample extension inference', () => {
+    it('defaults to a TSX parser so JSX-flavored bad examples still parse', () => {
+        const rule = makeAstGrepStringRule({
+            astGrepPattern: 'console.log($$$)',
+        });
+        const jsxSnippet = 'const page = <div>{console.log("hi")}</div>;\n';
+        const result = runSmokeGate(rule, jsxSnippet);
+        expect(result.matched).toBe(true);
+    });
+    it('honors a concrete extension from the rule fileGlobs when present', () => {
+        const rule = makeAstGrepStringRule({
+            fileGlobs: ['**/*.ts'],
+            astGrepPattern: 'debugger',
+        });
+        const tsSnippet = 'debugger;\n';
+        const result = runSmokeGate(rule, tsSnippet);
+        expect(result.matched).toBe(true);
+    });
+    // Regression for CR finding on PR #1415: multi-extension fileGlobs must
+    // try every declared extension, not just the first match. Otherwise
+    // a rule scoped to both `.js` and `.jsx` would gate on JavaScript only
+    // and false-reject JSX-flavored bad examples, breaking parity with
+    // runtime (which picks Lang.Tsx for `.jsx` files).
+    it('tries every positive extension in fileGlobs, not just the first match', () => {
+        const rule = makeAstGrepStringRule({
+            fileGlobs: ['**/*.js', '**/*.jsx'],
+            astGrepPattern: 'console.log($$$)',
+        });
+        // JSX-flavored snippet: would fail under JavaScript parser but matches
+        // under Tsx. Runtime would also use Tsx for a real `.jsx` file.
+        const jsxSnippet = 'const el = <div>{console.log("hi")}</div>;\n';
+        const result = runSmokeGate(rule, jsxSnippet);
+        expect(result.matched).toBe(true);
+    });
+    // Regression for CR finding on PR #1415: an unscoped rule with a TS
+    // angle-bracket cast must not be false-rejected by a TSX-only fallback.
+    // TS allows `<Foo>bar` as a type cast; TSX rejects it as an ambiguous
+    // JSX tag open. The gate tries `.ts` before `.tsx` in the fallback set.
+    it('accepts TS angle-bracket cast syntax on unscoped rules (not just TSX)', () => {
+        const rule = makeAstGrepStringRule({
+            fileGlobs: undefined, // unscoped
+            astGrepPattern: '<$TYPE>$EXPR',
+        });
+        const tsSnippet = 'const x = <Foo>bar;\n';
+        const result = runSmokeGate(rule, tsSnippet);
+        expect(result.matched).toBe(true);
+    });
+});
+// ─── runtime-parity invariant ────────────────────────
+describe('runSmokeGate runtime parity invariant', () => {
+    it('uses the same engine entry points as the runtime — gate-pass implies runtime-match', () => {
+        // If runSmokeGate reports matched === true with a non-zero matchCount,
+        // matchAstGrepPattern (the runtime entry point) invoked on the same
+        // snippet must also produce at least one match. The gate is a thin
+        // wrapper around that exact function, so this is a structural
+        // guarantee - the test locks in the guarantee against drift.
+        const rule = makeAstGrepStringRule();
+        const snippet = 'debugger;\nconst x = 1;\n';
+        const result = runSmokeGate(rule, snippet);
+        expect(result.matched).toBe(true);
+        // Reuse the same engine entry point to verify runtime parity.
+        const matches = matchAstGrepPattern(snippet, '.ts', 'debugger', snippet.split('\n').map((_, i) => i + 1));
+        expect(matches.length).toBeGreaterThanOrEqual(1);
+    });
+});
+//# sourceMappingURL=compile-smoke-gate.test.js.map

package/dist/compile-smoke-gate.test.js.map

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

package/dist/compiler-schema.d.ts

@@ -1,5 +1,42 @@
 import { z } from 'zod';
-export declare const CompiledRuleSchema: z.ZodObject<{
+/**
+ * Schema mirroring `@ast-grep/napi`'s `NapiConfig` interface for compound
+ * structural rules. The `rule` key is required at the Zod layer so the
+ * parse-time failure is loud and readable; the inner tree shape is handed
+ * off to `@ast-grep/napi` at the engine boundary for the authoritative
+ * validity check (see `validateAstGrepPattern`). `passthrough()` lets
+ * future napi fields (e.g. `constraints`, `transform`) survive a parse
+ * without a schema bump.
+ *
+ * The rule body is a recursive structural tree (combinators like `all`,
+ * `any`, `not`, `inside`, `has`, `precedes`, `follows`). Rather than
+ * modelling the full recursive schema with `z.lazy()`, we accept any
+ * object shape here and lean on napi to reject malformed trees. That
+ * keeps the Zod layer cheap and the authoritative check centralized.
+ */
+export declare const NapiConfigSchema: z.ZodObject<{
+    rule: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    rule: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    rule: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.ZodTypeAny, "passthrough">>;
+export type NapiConfig = z.infer<typeof NapiConfigSchema>;
+/**
+ * Named alias of `NapiConfigSchema` for grep-ability. The field on
+ * `CompiledRule` is named `astGrepYamlRule` (see ADR-087); the alias
+ * lets a reader search for `AstGrepYamlRuleSchema` and land on the
+ * right definition without first knowing it's a napi config.
+ */
+export declare const AstGrepYamlRuleSchema: z.ZodObject<{
+    rule: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    rule: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    rule: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.ZodTypeAny, "passthrough">>;
+export type AstGrepYamlRule = NapiConfig;
+export declare const CompiledRuleSchema: z.ZodEffects<z.ZodObject<{
     /** SHA-256 hash (first 16 hex chars) of heading + body — detects edits */
     lessonHash: z.ZodString;
     /** Human-readable heading from the lesson (for diagnostics) */
@@ -12,8 +49,33 @@ export declare const CompiledRuleSchema: z.ZodObject<{
     engine: z.ZodEnum<["regex", "ast", "ast-grep"]>;
     /** Tree-sitter S-expression query (required when engine is 'ast') */
     astQuery: z.ZodOptional<z.ZodString>;
-    /** ast-grep pattern — string for simple patterns, object for compound rules (has/inside/not) */
-    astGrepPattern: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>;
+    /**
+     * Flat ast-grep pattern source (a single JS/TS expression). Mutually
+     * exclusive with `astGrepYamlRule` when `engine === 'ast-grep'`; the
+     * superRefine below enforces that.
+     */
+    astGrepPattern: z.ZodOptional<z.ZodString>;
+    /**
+     * Compound ast-grep rule (NapiConfig shape). Holds structural trees
+     * that cannot be expressed as a single source snippet (all / any /
+     * not / inside / has / precedes / follows combinators). Mutually
+     * exclusive with `astGrepPattern`; see the superRefine on this
+     * schema. Smoke-test wiring lands in mmnto/totem#1408.
+     */
+    astGrepYamlRule: z.ZodOptional<z.ZodObject<{
+        rule: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        rule: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        rule: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.ZodTypeAny, "passthrough">>>;
+    /**
+     * Optional code snippet the rule is expected to match. Stored from
+     * compiler output so the smoke-test runner (wired in
+     * mmnto/totem#1408) can re-validate the rule offline. Optional in
+     * 1.14.9; flips to required when #1408 turns on the gate.
+     */
+    badExample: z.ZodOptional<z.ZodString>;
     /** ISO timestamp of when this rule was compiled */
     compiledAt: z.ZodString;
     /** ISO timestamp of when this rule was first created (survives recompilation) */
@@ -42,15 +104,19 @@ export declare const CompiledRuleSchema: z.ZodObject<{
      */
     manual: z.ZodOptional<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
+    message: string;
     lessonHash: string;
     lessonHeading: string;
     pattern: string;
-    message: string;
     engine: "regex" | "ast" | "ast-grep";
     compiledAt: string;
     status?: "active" | "archived" | undefined;
     astQuery?: string | undefined;
-    astGrepPattern?: string | Record<string, unknown> | undefined;
+    astGrepPattern?: string | undefined;
+    astGrepYamlRule?: z.objectOutputType<{
+        rule: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+    badExample?: string | undefined;
     createdAt?: string | undefined;
     fileGlobs?: string[] | undefined;
     category?: "security" | "architecture" | "style" | "performance" | undefined;
@@ -58,15 +124,59 @@ export declare const CompiledRuleSchema: z.ZodObject<{
     archivedReason?: string | undefined;
     manual?: boolean | undefined;
 }, {
+    message: string;
+    lessonHash: string;
+    lessonHeading: string;
+    pattern: string;
+    engine: "regex" | "ast" | "ast-grep";
+    compiledAt: string;
+    status?: "active" | "archived" | undefined;
+    astQuery?: string | undefined;
+    astGrepPattern?: string | undefined;
+    astGrepYamlRule?: z.objectInputType<{
+        rule: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+    badExample?: string | undefined;
+    createdAt?: string | undefined;
+    fileGlobs?: string[] | undefined;
+    category?: "security" | "architecture" | "style" | "performance" | undefined;
+    severity?: "error" | "warning" | undefined;
+    archivedReason?: string | undefined;
+    manual?: boolean | undefined;
+}>, {
+    message: string;
     lessonHash: string;
     lessonHeading: string;
     pattern: string;
+    engine: "regex" | "ast" | "ast-grep";
+    compiledAt: string;
+    status?: "active" | "archived" | undefined;
+    astQuery?: string | undefined;
+    astGrepPattern?: string | undefined;
+    astGrepYamlRule?: z.objectOutputType<{
+        rule: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+    badExample?: string | undefined;
+    createdAt?: string | undefined;
+    fileGlobs?: string[] | undefined;
+    category?: "security" | "architecture" | "style" | "performance" | undefined;
+    severity?: "error" | "warning" | undefined;
+    archivedReason?: string | undefined;
+    manual?: boolean | undefined;
+}, {
     message: string;
+    lessonHash: string;
+    lessonHeading: string;
+    pattern: string;
     engine: "regex" | "ast" | "ast-grep";
     compiledAt: string;
     status?: "active" | "archived" | undefined;
     astQuery?: string | undefined;
-    astGrepPattern?: string | Record<string, unknown> | undefined;
+    astGrepPattern?: string | undefined;
+    astGrepYamlRule?: z.objectInputType<{
+        rule: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+    badExample?: string | undefined;
     createdAt?: string | undefined;
     fileGlobs?: string[] | undefined;
     category?: "security" | "architecture" | "style" | "performance" | undefined;
@@ -100,7 +210,7 @@ export declare const NonCompilableEntrySchema: z.ZodEffects<z.ZodUnion<[z.ZodStr
 export type NonCompilableEntry = z.infer<typeof NonCompilableEntrySchema>;
 export declare const CompiledRulesFileSchema: z.ZodObject<{
     version: z.ZodLiteral<1>;
-    rules: z.ZodArray<z.ZodObject<{
+    rules: z.ZodArray<z.ZodEffects<z.ZodObject<{
         /** SHA-256 hash (first 16 hex chars) of heading + body — detects edits */
         lessonHash: z.ZodString;
         /** Human-readable heading from the lesson (for diagnostics) */
@@ -113,8 +223,33 @@ export declare const CompiledRulesFileSchema: z.ZodObject<{
         engine: z.ZodEnum<["regex", "ast", "ast-grep"]>;
         /** Tree-sitter S-expression query (required when engine is 'ast') */
         astQuery: z.ZodOptional<z.ZodString>;
-        /** ast-grep pattern — string for simple patterns, object for compound rules (has/inside/not) */
-        astGrepPattern: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>;
+        /**
+         * Flat ast-grep pattern source (a single JS/TS expression). Mutually
+         * exclusive with `astGrepYamlRule` when `engine === 'ast-grep'`; the
+         * superRefine below enforces that.
+         */
+        astGrepPattern: z.ZodOptional<z.ZodString>;
+        /**
+         * Compound ast-grep rule (NapiConfig shape). Holds structural trees
+         * that cannot be expressed as a single source snippet (all / any /
+         * not / inside / has / precedes / follows combinators). Mutually
+         * exclusive with `astGrepPattern`; see the superRefine on this
+         * schema. Smoke-test wiring lands in mmnto/totem#1408.
+         */
+        astGrepYamlRule: z.ZodOptional<z.ZodObject<{
+            rule: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            rule: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            rule: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.ZodTypeAny, "passthrough">>>;
+        /**
+         * Optional code snippet the rule is expected to match. Stored from
+         * compiler output so the smoke-test runner (wired in
+         * mmnto/totem#1408) can re-validate the rule offline. Optional in
+         * 1.14.9; flips to required when #1408 turns on the gate.
+         */
+        badExample: z.ZodOptional<z.ZodString>;
         /** ISO timestamp of when this rule was compiled */
         compiledAt: z.ZodString;
         /** ISO timestamp of when this rule was first created (survives recompilation) */
@@ -143,15 +278,19 @@ export declare const CompiledRulesFileSchema: z.ZodObject<{
          */
         manual: z.ZodOptional<z.ZodBoolean>;
     }, "strip", z.ZodTypeAny, {
+        message: string;
         lessonHash: string;
         lessonHeading: string;
         pattern: string;
-        message: string;
         engine: "regex" | "ast" | "ast-grep";
         compiledAt: string;
         status?: "active" | "archived" | undefined;
         astQuery?: string | undefined;
-        astGrepPattern?: string | Record<string, unknown> | undefined;
+        astGrepPattern?: string | undefined;
+        astGrepYamlRule?: z.objectOutputType<{
+            rule: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.ZodTypeAny, "passthrough"> | undefined;
+        badExample?: string | undefined;
         createdAt?: string | undefined;
         fileGlobs?: string[] | undefined;
         category?: "security" | "architecture" | "style" | "performance" | undefined;
@@ -159,15 +298,59 @@ export declare const CompiledRulesFileSchema: z.ZodObject<{
         archivedReason?: string | undefined;
         manual?: boolean | undefined;
     }, {
+        message: string;
         lessonHash: string;
         lessonHeading: string;
         pattern: string;
+        engine: "regex" | "ast" | "ast-grep";
+        compiledAt: string;
+        status?: "active" | "archived" | undefined;
+        astQuery?: string | undefined;
+        astGrepPattern?: string | undefined;
+        astGrepYamlRule?: z.objectInputType<{
+            rule: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.ZodTypeAny, "passthrough"> | undefined;
+        badExample?: string | undefined;
+        createdAt?: string | undefined;
+        fileGlobs?: string[] | undefined;
+        category?: "security" | "architecture" | "style" | "performance" | undefined;
+        severity?: "error" | "warning" | undefined;
+        archivedReason?: string | undefined;
+        manual?: boolean | undefined;
+    }>, {
         message: string;
+        lessonHash: string;
+        lessonHeading: string;
+        pattern: string;
         engine: "regex" | "ast" | "ast-grep";
         compiledAt: string;
         status?: "active" | "archived" | undefined;
         astQuery?: string | undefined;
-        astGrepPattern?: string | Record<string, unknown> | undefined;
+        astGrepPattern?: string | undefined;
+        astGrepYamlRule?: z.objectOutputType<{
+            rule: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.ZodTypeAny, "passthrough"> | undefined;
+        badExample?: string | undefined;
+        createdAt?: string | undefined;
+        fileGlobs?: string[] | undefined;
+        category?: "security" | "architecture" | "style" | "performance" | undefined;
+        severity?: "error" | "warning" | undefined;
+        archivedReason?: string | undefined;
+        manual?: boolean | undefined;
+    }, {
+        message: string;
+        lessonHash: string;
+        lessonHeading: string;
+        pattern: string;
+        engine: "regex" | "ast" | "ast-grep";
+        compiledAt: string;
+        status?: "active" | "archived" | undefined;
+        astQuery?: string | undefined;
+        astGrepPattern?: string | undefined;
+        astGrepYamlRule?: z.objectInputType<{
+            rule: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.ZodTypeAny, "passthrough"> | undefined;
+        badExample?: string | undefined;
         createdAt?: string | undefined;
         fileGlobs?: string[] | undefined;
         category?: "security" | "architecture" | "style" | "performance" | undefined;
@@ -199,15 +382,19 @@ export declare const CompiledRulesFileSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     version: 1;
     rules: {
+        message: string;
         lessonHash: string;
         lessonHeading: string;
         pattern: string;
-        message: string;
         engine: "regex" | "ast" | "ast-grep";
         compiledAt: string;
         status?: "active" | "archived" | undefined;
         astQuery?: string | undefined;
-        astGrepPattern?: string | Record<string, unknown> | undefined;
+        astGrepPattern?: string | undefined;
+        astGrepYamlRule?: z.objectOutputType<{
+            rule: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.ZodTypeAny, "passthrough"> | undefined;
+        badExample?: string | undefined;
         createdAt?: string | undefined;
         fileGlobs?: string[] | undefined;
         category?: "security" | "architecture" | "style" | "performance" | undefined;
@@ -222,15 +409,19 @@ export declare const CompiledRulesFileSchema: z.ZodObject<{
 }, {
     version: 1;
     rules: {
+        message: string;
         lessonHash: string;
         lessonHeading: string;
         pattern: string;
-        message: string;
         engine: "regex" | "ast" | "ast-grep";
         compiledAt: string;
         status?: "active" | "archived" | undefined;
         astQuery?: string | undefined;
-        astGrepPattern?: string | Record<string, unknown> | undefined;
+        astGrepPattern?: string | undefined;
+        astGrepYamlRule?: z.objectInputType<{
+            rule: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.ZodTypeAny, "passthrough"> | undefined;
+        badExample?: string | undefined;
         createdAt?: string | undefined;
         fileGlobs?: string[] | undefined;
         category?: "security" | "architecture" | "style" | "performance" | undefined;
@@ -244,35 +435,90 @@ export declare const CompiledRulesFileSchema: z.ZodObject<{
     })[] | undefined;
 }>;
 export type CompiledRulesFile = z.infer<typeof CompiledRulesFileSchema>;
-/** Schema for the structured JSON the LLM returns when compiling a lesson. */
-export declare const CompilerOutputSchema: z.ZodObject<{
+export declare const CompilerOutputSchema: z.ZodEffects<z.ZodObject<{
     compilable: z.ZodBoolean;
     pattern: z.ZodOptional<z.ZodString>;
     message: z.ZodOptional<z.ZodString>;
     fileGlobs: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     engine: z.ZodOptional<z.ZodEnum<["regex", "ast", "ast-grep"]>>;
     astQuery: z.ZodOptional<z.ZodString>;
-    astGrepPattern: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>;
+    /** Flat ast-grep pattern source. Mutually exclusive with `astGrepYamlRule`. */
+    astGrepPattern: z.ZodOptional<z.ZodString>;
+    /** Compound ast-grep rule (NapiConfig). Mutually exclusive with `astGrepPattern`. */
+    astGrepYamlRule: z.ZodOptional<z.ZodObject<{
+        rule: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        rule: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        rule: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.ZodTypeAny, "passthrough">>>;
+    /**
+     * Code snippet the rule is expected to match. Flipped from optional to
+     * engine-conditional required in mmnto-ai/totem#1409 - regex and
+     * ast-grep rules must carry a non-empty snippet so the compile-time
+     * smoke gate (#1408) can execute the rule against known-bad code
+     * before it lands in compiled-rules.json. The Zod field stays
+     * optional here; the `refineBadExampleRequired` superRefine below
+     * enforces the engine-conditional requirement so the error message
+     * can name the engine and cite the ticket.
+     */
+    badExample: z.ZodOptional<z.ZodString>;
     severity: z.ZodOptional<z.ZodEnum<["error", "warning"]>>;
     /** LLM explanation for why a lesson was marked non-compilable */
     reason: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     compilable: boolean;
-    pattern?: string | undefined;
     message?: string | undefined;
+    pattern?: string | undefined;
     engine?: "regex" | "ast" | "ast-grep" | undefined;
     astQuery?: string | undefined;
-    astGrepPattern?: string | Record<string, unknown> | undefined;
+    astGrepPattern?: string | undefined;
+    astGrepYamlRule?: z.objectOutputType<{
+        rule: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+    badExample?: string | undefined;
     fileGlobs?: string[] | undefined;
     severity?: "error" | "warning" | undefined;
     reason?: string | undefined;
 }, {
     compilable: boolean;
+    message?: string | undefined;
+    pattern?: string | undefined;
+    engine?: "regex" | "ast" | "ast-grep" | undefined;
+    astQuery?: string | undefined;
+    astGrepPattern?: string | undefined;
+    astGrepYamlRule?: z.objectInputType<{
+        rule: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+    badExample?: string | undefined;
+    fileGlobs?: string[] | undefined;
+    severity?: "error" | "warning" | undefined;
+    reason?: string | undefined;
+}>, {
+    compilable: boolean;
+    message?: string | undefined;
     pattern?: string | undefined;
+    engine?: "regex" | "ast" | "ast-grep" | undefined;
+    astQuery?: string | undefined;
+    astGrepPattern?: string | undefined;
+    astGrepYamlRule?: z.objectOutputType<{
+        rule: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+    badExample?: string | undefined;
+    fileGlobs?: string[] | undefined;
+    severity?: "error" | "warning" | undefined;
+    reason?: string | undefined;
+}, {
+    compilable: boolean;
     message?: string | undefined;
+    pattern?: string | undefined;
     engine?: "regex" | "ast" | "ast-grep" | undefined;
     astQuery?: string | undefined;
-    astGrepPattern?: string | Record<string, unknown> | undefined;
+    astGrepPattern?: string | undefined;
+    astGrepYamlRule?: z.objectInputType<{
+        rule: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+    badExample?: string | undefined;
     fileGlobs?: string[] | undefined;
     severity?: "error" | "warning" | undefined;
     reason?: string | undefined;
@@ -310,7 +556,23 @@ export interface RuleEventContext {
     justification?: string;
     /** AST context where the rule fired (code, string, comment, regex). */
     astContext?: AstContext;
+    /**
+     * Populated on `'failure'` events only. Holds the error message surfaced by
+     * the runtime engine (ast-grep `findAll`, regex `exec`, etc.) so `totem
+     * doctor` telemetry can aggregate rules that fail at execution time. Not
+     * used by `'trigger'` or `'suppress'` events. Kept as a string rather than
+     * the raw `unknown` so the callback interface stays cheap to consume.
+     */
+    failureReason?: string;
 }
-/** Callback for observability — invoked when a rule is suppressed or triggered. */
-export type RuleEventCallback = (event: 'trigger' | 'suppress', lessonHash: string, context?: RuleEventContext) => void;
+/**
+ * Callback for observability - invoked when a rule is suppressed, triggered,
+ * or fails at runtime. The `'failure'` variant was added in mmnto/totem#1408
+ * alongside per-rule try/catch in `executeQuery`. It is intentionally distinct
+ * from `'suppress'`: suppression is a user-initiated directive (totem-ignore /
+ * totem-context), while failure is a runtime engine error on a rule that
+ * otherwise compiled. The #1412 postmerge GCA fix established this boundary,
+ * so the two values must NEVER be conflated in the Trap Ledger.
+ */
+export type RuleEventCallback = (event: 'trigger' | 'suppress' | 'failure', lessonHash: string, context?: RuleEventContext) => void;
 //# sourceMappingURL=compiler-schema.d.ts.map