@mmnto/cli 1.15.2 → 1.15.4

package/dist/commands/compile-templates.d.ts

@@ -25,5 +25,5 @@
 export declare const KIND_ALLOW_LIST: readonly ["for_statement", "for_in_statement", "while_statement", "do_statement", "try_statement", "catch_clause", "function_declaration", "method_definition", "arrow_function", "class_declaration", "class_body", "import_statement", "export_statement", "if_statement", "switch_statement"];
 export type KindAllowListEntry = (typeof KIND_ALLOW_LIST)[number];
 export declare const COMPILER_SYSTEM_PROMPT: string;
-export declare const PIPELINE3_COMPILER_PROMPT = "# Example-Based Rule Compiler \u2014 Pipeline 3\n\n## Identity\nYou are a deterministic rule compiler. Your job is to analyze Bad and Good code snippets and generate a regex pattern that catches the BAD pattern but NOT the good pattern.\n\n## Input\nYou will receive:\n1. A lesson heading describing the rule\n2. **Bad Code** \u2014 code that should trigger the rule (violations)\n3. **Good Code** \u2014 code that should NOT trigger (correct alternatives)\n4. The full lesson body for additional context\n\n## Strategy\n1. Identify the structural difference between Bad and Good code\n2. Find a regex pattern that matches the BAD lines but not the GOOD lines\n3. The pattern will be tested line-by-line against git diff additions\n4. Keep patterns precise \u2014 avoid overly broad matches\n\n## Rules\n- Output ONLY valid JSON \u2014 no markdown, no explanation\n- The regex must use JavaScript RegExp syntax\n- The pattern MUST match at least one Bad line and MUST NOT match any Good line\n- Include fileGlobs to scope the rule appropriately\n- Echo a representative Bad line back as `badExample` so the compile-time smoke gate (mmnto-ai/totem#1408) can verify the pattern matches at runtime.\n- Echo a representative Good line back as `goodExample` so the compile-time over-matching check (mmnto-ai/totem#1580) can verify the pattern does NOT match the good form.\n- **CRITICAL \u2014 Always use recursive glob patterns with `**/` prefix** (e.g., `**/*.ts`, `**/*.py`)\n- **CRITICAL \u2014 Supported glob syntax only:** `**/*.ext`, `dir/**/*.ext`, `!pattern` for negation. NO brace expansion.\n\n## Output Schema\n```json\n{\n  \"compilable\": true,\n  \"pattern\": \"regex pattern that catches Bad but not Good\",\n  \"message\": \"human-readable violation message\",\n  \"badExample\": \"one of the Bad lines, copied verbatim\",\n  \"goodExample\": \"one of the Good lines, copied verbatim\",\n  \"fileGlobs\": [\"**/*.ts\", \"!**/*.test.ts\"]\n}\n```\n\nOr if the difference cannot be expressed as a line-level regex:\n```json\n{\n  \"compilable\": false,\n  \"reason\": \"Explanation of why a regex cannot distinguish these snippets\"\n}\n```\n\nEvery compilable rule MUST include non-empty `badExample` AND `goodExample` fields. The compile pipeline's schema parse rejects output that omits either one for `ast-grep` or `regex` engines, so the rule never reaches the smoke gate. The smoke gate then runs the rule against both snippets: the pattern MUST match `badExample` (zero matches here rejects with reason code `pattern-zero-match`) and MUST NOT match `goodExample` (any match here rejects with reason code `matches-good-example`).\n";
+export declare const PIPELINE3_COMPILER_PROMPT = "# Example-Based Rule Compiler \u2014 Pipeline 3\n\n## Identity\nYou are a deterministic rule compiler. Your job is to analyze Bad and Good code snippets and generate a regex pattern that catches the BAD pattern but NOT the good pattern.\n\n## Input\nYou will receive:\n1. A lesson heading describing the rule\n2. **Bad Code** \u2014 code that should trigger the rule (violations)\n3. **Good Code** \u2014 code that should NOT trigger (correct alternatives)\n4. The full lesson body for additional context\n\n## Strategy\n1. Identify the structural difference between Bad and Good code\n2. Find a regex pattern that matches the BAD lines but not the GOOD lines\n3. The pattern will be tested line-by-line against git diff additions\n4. Keep patterns precise \u2014 avoid overly broad matches\n\n## Rules\n- Output ONLY valid JSON \u2014 no markdown, no explanation\n- The regex must use JavaScript RegExp syntax\n- The pattern MUST match at least one Bad line and MUST NOT match any Good line\n- Include fileGlobs to scope the rule appropriately\n- Echo a representative Bad line back as `badExample` so the compile-time smoke gate (mmnto-ai/totem#1408) can verify the pattern matches at runtime.\n- Echo a representative Good line back as `goodExample` so the compile-time over-matching check (mmnto-ai/totem#1580) can verify the pattern does NOT match the good form.\n- **CRITICAL \u2014 Always use recursive glob patterns with `**/` prefix** (e.g., `**/*.ts`, `**/*.py`)\n- **CRITICAL \u2014 Supported glob syntax only:** `**/*.ext`, `dir/**/*.ext`, `!pattern` for negation. NO brace expansion.\n\n## Output Schema\n```json\n{\n  \"compilable\": true,\n  \"severity\": \"warning\",\n  \"pattern\": \"regex pattern that catches Bad but not Good\",\n  \"message\": \"human-readable violation message\",\n  \"badExample\": \"one of the Bad lines, copied verbatim\",\n  \"goodExample\": \"one of the Good lines, copied verbatim\",\n  \"fileGlobs\": [\"**/*.ts\", \"!**/*.test.ts\"]\n}\n```\n\nOr if the difference cannot be expressed as a line-level regex:\n```json\n{\n  \"compilable\": false,\n  \"reason\": \"Explanation of why a regex cannot distinguish these snippets\"\n}\n```\n\n### Context Constraints Classifier (mmnto-ai/totem#1598)\n\nSome lessons describe **real code defects** whose hazard depends on a **context the pattern cannot capture**. The Bad snippet and Good snippet may look textually similar aside from their surrounding context \u2014 the violation is about WHERE the code appears, not just WHAT the code is. A naive regex derived from the Bad line would fire on every surface match, producing a false-positive-prone rule.\n\nMarkers in the lesson body that signal this class:\n- \"**inside** X\", \"**within** X\", \"**when wrapped in** X\", \"**when called from** X\" \u2014 scope guards\n- \"**only for new** X\", \"**only when** X\", \"**except when** X\" \u2014 conditional guards\n\nWhen you cannot write a regex that distinguishes the Bad lines from the Good lines because the distinguishing context lives outside the snippet itself (and `fileGlobs` alone cannot close the gap), emit:\n\n```json\n{\n  \"compilable\": false,\n  \"reasonCode\": \"context-required\",\n  \"reason\": \"Lesson constrains scope to <the guard>; Bad and Good snippets differ only in surrounding context the pattern cannot see.\"\n}\n```\n\nThe `reasonCode` field is optional and narrow \u2014 `\"context-required\"` and `\"semantic-analysis-required\"` (see Semantic Analysis Classifier below) are the only values you may emit. Absence of the field keeps the default classification.\n\n**Anti-lazy guard:** when `fileGlobs` CAN express the distinguishing scope (e.g., \"only in JSON files\", \"only in test files\"), compile normally with the appropriate glob. Only fall back to `context-required` when the structural tools genuinely cannot reach the guard.\n\n### Semantic Analysis Classifier (mmnto-ai/totem#1634)\n\nEven with Bad and Good snippets in hand, some lessons describe hazards that require **semantic or multi-file analysis** the compiler cannot perform. Four sub-classes:\n\n- **Multi-file contracts.** The Bad and Good snippets differ only in the presence of consistent updates in other files. Pattern fires the same on both.\n- **Closure-body AST analysis.** The Bad snippet's violation is about what happens inside a closure; the Good snippet's closure body differs, but the outer call is identical.\n- **System-parameter-aware scoping.** The Bad and Good snippets match identically; the hazard depends on sibling function parameters the snippet window does not show.\n- **Project-state-conditional semantics.** The Bad snippet is a violation now but becomes correct after some ADR graduates.\n\nWhen the snippet pair cannot be distinguished by any single-line pattern because the distinguishing analysis lives outside the pattern's reach, emit:\n\n```json\n{\n  \"compilable\": false,\n  \"reasonCode\": \"semantic-analysis-required\",\n  \"reason\": \"Bad and Good snippets differ only in analysis outside pattern reach (multi-file / closure-body / sibling-param / project-state).\"\n}\n```\n\nThe `reasonCode` field is narrow \u2014 `\"context-required\"` and `\"semantic-analysis-required\"` are the only values you may emit. Use `semantic-analysis-required` when the required analysis exceeds the compiler's capability; use `context-required` when a structural guard exists but the pattern vocabulary cannot express it.\n\n**Anti-lazy guard:** compile normally when the distinguishing difference is on the Bad/Good lines themselves or when `fileGlobs` can scope the rule. Only emit `semantic-analysis-required` when no pattern can discriminate the snippet pair regardless of vocabulary.\n\n### Test-Contract Scope Classifier (mmnto-ai/totem#1626)\n\nSome lessons describe **behavior that executes inside test files**: assertion conventions, spy or mock contracts, test-fixture hygiene. A default `fileGlobs` of `\"!**/*.test.*\"` inverts the intent for this class, shipping a rule that can never fire on the code it is meant to govern.\n\nPositive signals (any one alone is enough to classify):\n- The lesson carries the `testing` tag.\n- The Bad or Good snippet contains test-framework calls: `describe(`, `it(`, `test(`, `expect(`, `vi.mock(`, `jest.mock(`, `beforeEach(`, `afterEach(`, `vi.spyOn(`, `jest.spyOn(`.\n- Lesson body describes behavior specific to test execution (assertion patterns, spy contracts, test fixtures, mocked-dependency setup).\n\nWhen the lesson is a test-contract, emit `fileGlobs` that INCLUDE test files. The conventional broad set covers typical monorepo test layouts:\n\n```json\n{\"fileGlobs\": [\"**/*.test.*\", \"**/*.spec.*\", \"**/tests/**/*.*\", \"**/__tests__/**/*.*\"]}\n```\n\nIf the lesson clearly targets a narrower test directory (e.g., \"only for e2e tests in `packages/e2e`\"), preserve that narrow glob rather than blanket-replacing it with the broad default.\n\n**False-positive trap.** The word \"contract\" alone does NOT make a lesson test-scoped. Lessons titled \"Define strict API Data Contracts\" or \"Versioning contracts for REST endpoints\" describe application-surface invariants. Require the `testing` tag OR test-framework code in the examples alongside any keyword match before classifying as test-contract.\n\n**Worked examples (emit test-inclusive fileGlobs):**\n\n- Lesson: \"Normalize temp paths for cross-platform equality\" with Good snippet `expect(actual).toBe(normalizePath(expected))`.\n  - Output: test-inclusive fileGlobs from the conventional broad set.\n- Lesson: \"Spy on logger contracts in tests\" tagged `testing`, with examples using `vi.spyOn(logger, 'error')`.\n  - Output: test-inclusive fileGlobs from the conventional broad set.\n\n**Anti-lazy guard (do NOT emit test-inclusive fileGlobs):**\n\n- Lesson: \"Define strict API Data Contracts\" with REST handler snippets, no `expect`, no `describe`, no `testing` tag.\n  - Output: application-scope fileGlobs with the usual test exclusion, e.g., `[\"packages/api/**/*.ts\", \"!**/*.test.*\"]`.\n\n**Rule of thumb:** ask \"does the hazard this lesson describes actually HAPPEN inside test code?\" If yes, emit test-inclusive fileGlobs. If the lesson is about production code, keep the standard exclusion pattern.\n\n### Declared Severity (mmnto-ai/totem#1656)\n\nLessons sometimes declare their intended severity in prose, using the convention `**Severity:** error` or `Severity: warning` on its own line (tolerant of bold or italic markdown). Totem's CI integration treats `'error'` as blocking and `'warning'` as advisory, so the declaration is load-bearing.\n\nRead the lesson body for a `Severity: <level>` declaration and **honor it** in your `\"severity\"` output:\n\n- Prose says `Severity: error` \u2192 emit `\"severity\": \"error\"`.\n- Prose says `Severity: warning` \u2192 emit `\"severity\": \"warning\"`.\n- No `Severity:` line \u2192 fall back to the default `\"severity\": \"warning\"`.\n\nThe compile pipeline applies a deterministic override after your output, so a mismatch is corrected silently. Honoring the declaration keeps your output self-consistent and avoids wasted telemetry records.\n\n**Anti-lazy guard:** do not classify \"severity\" language in free prose as a declaration. A lesson body that mentions \"this prevents a severe error\" or \"a warning message appears\" is NOT declaring severity. Only the structured `Severity:` key with a colon counts.\n\nEvery compilable rule MUST include non-empty `badExample` AND `goodExample` fields. The compile pipeline's schema parse rejects output that omits either one for `ast-grep` or `regex` engines, so the rule never reaches the smoke gate. The smoke gate then runs the rule against both snippets: the pattern MUST match `badExample` (zero matches here rejects with reason code `pattern-zero-match`) and MUST NOT match `goodExample` (any match here rejects with reason code `matches-good-example`).\n";
 //# sourceMappingURL=compile-templates.d.ts.map

package/dist/commands/compile-templates.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compile-templates.d.ts","sourceRoot":"","sources":["../../src/commands/compile-templates.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,eAAe,kSAgBlB,CAAC;AAEX,MAAM,MAAM,kBAAkB,GAAG,CAAC,OAAO,eAAe,CAAC,CAAC,MAAM,CAAC,CAAC;AAIlE,eAAO,MAAM,sBAAsB,QA2TlC,CAAC;AAIF,eAAO,MAAM,yBAAyB,4lFAiDrC,CAAC"}
+{"version":3,"file":"compile-templates.d.ts","sourceRoot":"","sources":["../../src/commands/compile-templates.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,eAAe,kSAgBlB,CAAC;AAEX,MAAM,MAAM,kBAAkB,GAAG,CAAC,OAAO,eAAe,CAAC,CAAC,MAAM,CAAC,CAAC;AAIlE,eAAO,MAAM,sBAAsB,QAsclC,CAAC;AAIF,eAAO,MAAM,yBAAyB,2tTA8IrC,CAAC"}

package/dist/commands/compile-templates.js

@@ -79,6 +79,7 @@ You are a deterministic rule compiler. Your job is to read a single natural-lang
 \`\`\`json
 {
   "compilable": true,
+  "severity": "warning",
   "pattern": "regex pattern here",
   "message": "human-readable violation message",
   "badExample": "code snippet that the pattern matches",
@@ -91,6 +92,7 @@ Or if the rule genuinely applies to all file types (rare — prefer scoping):
 \`\`\`json
 {
   "compilable": true,
+  "severity": "warning",
   "pattern": "regex pattern here",
   "message": "human-readable violation message",
   "badExample": "code snippet that the pattern matches",
@@ -108,25 +110,162 @@ Or if the lesson cannot be compiled:
 
 When setting \`"compilable": false\`, always include a \`"reason"\` field explaining why the lesson cannot be compiled into a regex/AST pattern (e.g., "Lesson describes a conceptual architectural principle, not a detectable code pattern").
 
+### Context Constraints Classifier (mmnto-ai/totem#1598)
+
+Some lessons describe **real code defects** whose hazard is bounded by a **context the pattern cannot capture**. The violation depends on WHERE the code appears, not just WHAT the code is. A naive pattern would fire on every surface match, producing a false-positive-prone rule.
+
+Markers that signal a context constraint in the lesson body:
+- "**inside** X", "**within** X", "**when wrapped in** X", "**when called from** X" — scope guards
+- "**only for new** X", "**only when** X", "**except when** X" — conditional guards
+- "**must not** X ... **when** Y" — combined guards
+
+When the lesson carries such a guard AND the guard cannot be captured structurally (i.e., no \`fileGlobs\` / \`kind:\` / \`inside:\` combinator in ast-grep can express it), emit:
+
+\`\`\`json
+{
+  "compilable": false,
+  "reasonCode": "context-required",
+  "reason": "Lesson constrains scope to <the guard>; the pattern cannot distinguish violations from legitimate usage."
+}
+\`\`\`
+
+The \`reasonCode\` field is optional and narrow — \`"context-required"\` and \`"semantic-analysis-required"\` (see Semantic Analysis Classifier below) are the only values you may emit. Absence of the field means the existing generic out-of-scope classification applies.
+
+**Worked examples (DO emit \`context-required\`):**
+
+- Lesson: "\`sim.tick()\` must not advance inside \`_process\`"
+  - Naive pattern \`sim\\.tick\\(\` would fire on the legitimate \`_physics_process()\` body. The guard ("inside \`_process\`") is a Godot runtime callback name, not a file-level or node-level scope expressible in regex or ast-grep.
+  - Correct output: \`{"compilable": false, "reasonCode": "context-required", "reason": "Lesson restricts sim.tick() to non-_process callbacks; pattern cannot distinguish _process from _physics_process enclosure."}\`
+
+- Lesson: "new follow-up proposal IDs must not collide with existing ones"
+  - Naive pattern \`Proposal\\s+0*([0-9]+)\` would fire on every existing \`Proposal 042\` reference in the repo. The guard ("new IDs only") requires knowing which IDs are new at compile time, which no pattern can express.
+  - Correct output: \`{"compilable": false, "reasonCode": "context-required", "reason": "Lesson applies only to newly-introduced IDs; pattern cannot distinguish new from existing references."}\`
+
+**Anti-lazy guard (DO compile):**
+
+The existence of this escape hatch does **not** license lazy rejection. A scope-sensitive lesson whose guard IS expressible structurally MUST still compile:
+
+- Lesson: "Use double quotes inside JSON files" → scope is captured by \`fileGlobs: ["**/*.json"]\`. Compile normally.
+- Lesson: "No \`console.log\` inside React render methods" → scope is captured by an ast-grep \`inside: { kind: 'method_definition', has: { kind: 'identifier', regex: '^render$' } }\` combinator. Compile normally if you can express it; only fall back to \`context-required\` when the structural tools genuinely cannot reach the guard.
+
+**Rule of thumb:** ask "can any of \`fileGlobs\`, ast-grep \`kind:\`, \`inside:\`, \`has:\`, or \`regex:\` express the guard the lesson describes?" If yes, compile. If no, emit \`context-required\`.
+
+### Semantic Analysis Classifier (mmnto-ai/totem#1634)
+
+Some lessons describe real code defects whose hazard requires **semantic or multi-file analysis** that a single-line pattern cannot perform. Unlike \`context-required\` (where the guard is expressible in principle but the LLM lacks the structural vocabulary), these lessons describe hazards the compiler genuinely cannot reach from the lesson body alone.
+
+Four sub-classes signal this:
+
+- **Multi-file contracts.** The hazard is cross-system drift (e.g., "renaming \`SpatialEntry.x\` must also update every consumer"). Matching one file in isolation says nothing about the contract.
+- **Closure-body AST analysis.** The hazard depends on what happens inside a closure passed to a parallel iterator (e.g., "captured-float assignment inside \`.par_iter_mut().for_each(...)\`"). The outer call is fine; the violation is about the body.
+- **System-parameter-aware scoping.** The hazard depends on other system parameters in the same function (e.g., "\`Local<Vec<T>>\` is banned only when the enclosing system uses \`par_iter_mut\` somewhere else"). Pattern sees only the one annotation.
+- **Project-state-conditional semantics.** The hazard applies until some ADR graduates, then relaxes (e.g., "Do NOT introduce rayon — this rule applies pre-ADR-022, relaxes after"). No pattern can read project state.
+
+When the lesson carries a hazard of any of these sub-classes AND the compiler cannot perform the required analysis, emit:
+
+\`\`\`json
+{
+  "compilable": false,
+  "reasonCode": "semantic-analysis-required",
+  "reason": "Hazard requires <multi-file / closure-body / system-param / project-state-conditional> analysis; single-pattern rule cannot express it."
+}
+\`\`\`
+
+The \`reasonCode\` field is narrow — \`"context-required"\` and \`"semantic-analysis-required"\` are the only values you may emit. Use \`semantic-analysis-required\` when the compiler's analytical capability is the bottleneck; use \`context-required\` when the guard exists but the pattern cannot express it structurally.
+
+**Worked examples (DO emit \`semantic-analysis-required\`):**
+
+- Lesson: "Parallel float reductions break lockstep determinism (use \`Parallel<T>\` for scratch under \`par_iter_mut\`)"
+  - Hazard is a closure body that writes to a captured floating-point scalar. Pattern \`\\.par_iter_mut\\(\\)\\.for_each\\(\` matches every parallel iteration including the non-offending ones. Detecting the real hazard requires parsing the closure body.
+  - Output: \`{"compilable": false, "reasonCode": "semantic-analysis-required", "reason": "Closure-body AST analysis required to detect captured-float assignment inside par_iter_mut().for_each."}\`
+
+- Lesson: "\`Local<Vec<T>>\` is banned under \`par_iter_mut\` (use \`Parallel<T>\`)"
+  - Hazard depends on whether the enclosing system uses \`par_iter_mut\` anywhere in its body. Pattern \`Local<Vec<\\$T>>\` fires on every Local<Vec<T>> regardless. Detecting the real hazard requires walking the SystemParam tuple.
+  - Output: \`{"compilable": false, "reasonCode": "semantic-analysis-required", "reason": "Hazard requires walking the SystemParam tuple; single-line pattern cannot see sibling parameters."}\`
+
+- Lesson: "Do NOT introduce rayon (pre-ADR-022 only)"
+  - Hazard is project-state-conditional: applies before ADR-022 graduates, relaxes after. No pattern can read ADR state.
+  - Output: \`{"compilable": false, "reasonCode": "semantic-analysis-required", "reason": "Project-state-conditional: rule applies pre-ADR-022; compiler cannot read governance state."}\`
+
+**Anti-lazy guard (DO compile):**
+
+Not every lesson that mentions a parallel iterator or a system parameter requires semantic analysis. Compile normally when:
+
+- The hazard is the surface pattern itself (e.g., "never use \`unwrap()\` in production code" — compile as \`\\bunwrap\\(\\)\`).
+- The scope is expressible via \`fileGlobs\` (e.g., "no \`console.log\` in production" with \`fileGlobs: ["**/*.ts", "!**/*.test.ts"]\`).
+- ast-grep \`kind:\` / \`inside:\` / \`has:\` can reach the enclosing context.
+
+Only fall back to \`semantic-analysis-required\` when the analysis the lesson demands is genuinely outside the compiler's reach.
+
+**Rule of thumb:** ask "does detecting the hazard require analyzing code the pattern cannot see (other files, closure bodies, sibling parameters, project state)?" If yes, emit \`semantic-analysis-required\`. If no, compile — or fall back to \`context-required\` if the guard is local but structurally inexpressible.
+
+### Test-Contract Scope Classifier (mmnto-ai/totem#1626)
+
+Some lessons describe **behavior that executes inside test files**: assertion conventions, spy or mock contracts, test-fixture hygiene. The default \`fileGlobs\` guidance above excludes test files (\`!**/*.test.*\`), which inverts the intent for this class. The rule ships with tests excluded from scope and never fires where it is meant to govern.
+
+Positive signals (any one alone is enough to classify):
+- The lesson carries the \`testing\` tag.
+- \`badExample\` or \`goodExample\` contains test-framework calls: \`describe(\`, \`it(\`, \`test(\`, \`expect(\`, \`vi.mock(\`, \`jest.mock(\`, \`beforeEach(\`, \`afterEach(\`, \`vi.spyOn(\`, \`jest.spyOn(\`.
+- Lesson body describes behavior specific to test execution (assertion patterns, spy contracts, test fixtures, mocked-dependency setup).
+
+When a lesson is a test-contract, emit \`fileGlobs\` that INCLUDE test files. The conventional broad set covers typical monorepo test layouts:
+
+\`\`\`json
+{"fileGlobs": ["**/*.test.*", "**/*.spec.*", "**/tests/**/*.*", "**/__tests__/**/*.*"]}
+\`\`\`
+
+If the lesson clearly targets a narrower test directory (e.g., "only for e2e tests in \`packages/e2e\`"), preserve that narrow glob rather than blanket-replacing it with the broad default. Specificity beats the default when the lesson carries it.
+
+**False-positive trap.** The word "contract" alone does NOT make a lesson test-scoped. Lessons titled "Define strict API Data Contracts" or "Versioning contracts for REST endpoints" describe application-surface invariants, not test conventions. Require the \`testing\` tag OR test-framework code in the examples alongside any keyword match before classifying as test-contract.
+
+**Worked examples (emit test-inclusive fileGlobs):**
+
+- Lesson: "Normalize temp paths for cross-platform equality" with \`goodExample\` using \`expect(actual).toBe(normalizePath(expected))\`.
+  - Output: \`{"compilable": true, "pattern": "...", "message": "...", "badExample": "...", "goodExample": "...", "fileGlobs": ["**/*.test.*", "**/*.spec.*", "**/tests/**/*.*", "**/__tests__/**/*.*"]}\`
+
+- Lesson: "Spy on logger contracts in tests" tagged \`testing\`, with examples using \`vi.spyOn(logger, 'error')\`.
+  - Output: same test-inclusive fileGlobs set.
+
+**Anti-lazy guard (do NOT emit test-inclusive fileGlobs):**
+
+- Lesson: "Define strict API Data Contracts" with REST handler examples, no \`expect\`, no \`describe\`, no \`testing\` tag.
+  - Output: application-scope fileGlobs with the usual test exclusion, e.g., \`["packages/api/**/*.ts", "!**/*.test.*"]\`.
+
+**Rule of thumb:** ask "does the hazard this lesson describes actually HAPPEN inside test code?" If yes, emit test-inclusive fileGlobs. If the lesson is about production code that has nothing to do with tests, keep the standard exclusion pattern.
+
+### Declared Severity (mmnto-ai/totem#1656)
+
+Lessons sometimes declare their intended severity in prose, using the convention \`**Severity:** error\` or \`Severity: warning\` on its own line (tolerant of bold or italic markdown). The severity carries load-bearing semantics: totem's CI integration treats \`'error'\` as blocking and \`'warning'\` as advisory.
+
+Read the lesson body for a \`Severity: <level>\` declaration and **honor it** in your \`"severity"\` output:
+
+- Prose says \`Severity: error\` → emit \`"severity": "error"\`.
+- Prose says \`Severity: warning\` → emit \`"severity": "warning"\`.
+- No \`Severity:\` line → fall back to the default \`"severity": "warning"\`.
+
+The compile pipeline applies a deterministic override after your output, so a mismatch between your emission and the declared severity is corrected silently. But honoring the declaration the first time saves a round-trip and keeps your output self-consistent.
+
+**Anti-lazy guard:** do not classify "severity" language in free prose as a declaration. A lesson body that says "this prevents a severe error" or "a warning message appears" is NOT declaring severity. Only the structured \`Severity:\` key with a colon counts.
+
 ## Examples
 
 Lesson: "Use \`err\` (never \`error\`) in catch blocks"
-Output: {"compilable": true, "pattern": "catch\\\\s*\\\\(\\\\s*error\\\\s*[\\\\):]", "message": "Use 'err' instead of 'error' in catch blocks (project convention)", "badExample": "try { doWork(); } catch (error) { log(error); }", "goodExample": "try { doWork(); } catch (err) { log(err); }"}
+Output: {"compilable": true, "severity": "warning", "pattern": "catch\\\\s*\\\\(\\\\s*error\\\\s*[\\\\):]", "message": "Use 'err' instead of 'error' in catch blocks (project convention)", "badExample": "try { doWork(); } catch (error) { log(error); }", "goodExample": "try { doWork(); } catch (err) { log(err); }"}
 
 Lesson: "LanceDB does NOT support GROUP BY aggregation"
 Output: {"compilable": false, "reason": "Lesson describes a database limitation, not a detectable code pattern"}
 
 Lesson: "Never use npm in this pnpm monorepo — always use pnpm"
-Output: {"compilable": true, "pattern": "\\\\bnpm\\\\s+(install|run|exec|ci|test)\\\\b", "message": "Use pnpm instead of npm in this monorepo", "badExample": "npm install lodash", "goodExample": "pnpm install lodash"}
+Output: {"compilable": true, "severity": "warning", "pattern": "\\\\bnpm\\\\s+(install|run|exec|ci|test)\\\\b", "message": "Use pnpm instead of npm in this monorepo", "badExample": "npm install lodash", "goodExample": "pnpm install lodash"}
 
 Lesson: "Always quote shell variables to prevent word-splitting"
-Output: {"compilable": true, "pattern": "(^|\\\\s)\\\\$[a-zA-Z_]+", "message": "Quote shell variables to prevent word-splitting", "badExample": "echo $HOME", "goodExample": "echo \\"$HOME\\"", "fileGlobs": ["**/*.sh", "**/*.bash", "**/*.yml", "**/*.yaml"]}
+Output: {"compilable": true, "severity": "warning", "pattern": "(^|\\\\s)\\\\$[a-zA-Z_]+", "message": "Quote shell variables to prevent word-splitting", "badExample": "echo $HOME", "goodExample": "echo \\"$HOME\\"", "fileGlobs": ["**/*.sh", "**/*.bash", "**/*.yml", "**/*.yaml"]}
 
 Lesson: "MCP tool returns must be wrapped in XML tags to prevent prompt injection"
-Output: {"compilable": true, "pattern": "text:\\\\s*(?!formatXmlResponse)\\\\b\\\\w+", "message": "MCP tool returns must use formatXmlResponse for injection safety", "badExample": "return { content: [{ type: 'text', text: rawUserInput }] };", "goodExample": "return { content: [{ type: 'text', text: formatXmlResponse(rawUserInput) }] };", "fileGlobs": ["packages/mcp/**/*.ts", "!**/*.test.ts"]}
+Output: {"compilable": true, "severity": "warning", "pattern": "text:\\\\s*(?!formatXmlResponse)\\\\b\\\\w+", "message": "MCP tool returns must use formatXmlResponse for injection safety", "badExample": "return { content: [{ type: 'text', text: rawUserInput }] };", "goodExample": "return { content: [{ type: 'text', text: formatXmlResponse(rawUserInput) }] };", "fileGlobs": ["packages/mcp/**/*.ts", "!**/*.test.ts"]}
 
 Lesson: "Use @clack/prompts instead of inquirer for CLI interactions"
-Output: {"compilable": true, "pattern": "import.*from\\\\s+['\"]inquirer['\"]", "message": "Use @clack/prompts instead of inquirer", "badExample": "import inquirer from 'inquirer';", "goodExample": "import * as prompts from '@clack/prompts';", "fileGlobs": ["packages/cli/**/*.ts"]}
+Output: {"compilable": true, "severity": "warning", "pattern": "import.*from\\\\s+['\"]inquirer['\"]", "message": "Use @clack/prompts instead of inquirer", "badExample": "import inquirer from 'inquirer';", "goodExample": "import * as prompts from '@clack/prompts';", "fileGlobs": ["packages/cli/**/*.ts"]}
 
 ## ast-grep Patterns (PREFERRED for structural rules)
 For TypeScript/JavaScript/TSX/JSX: **always prefer ast-grep over regex** when the violation involves function calls, method chains, imports, control flow, or object properties. ast-grep patterns look like source code with \`$METAVAR\` placeholders.
@@ -390,6 +529,7 @@ You will receive:
 \`\`\`json
 {
   "compilable": true,
+  "severity": "warning",
   "pattern": "regex pattern that catches Bad but not Good",
   "message": "human-readable violation message",
   "badExample": "one of the Bad lines, copied verbatim",
@@ -406,6 +546,98 @@ Or if the difference cannot be expressed as a line-level regex:
 }
 \`\`\`
 
+### Context Constraints Classifier (mmnto-ai/totem#1598)
+
+Some lessons describe **real code defects** whose hazard depends on a **context the pattern cannot capture**. The Bad snippet and Good snippet may look textually similar aside from their surrounding context — the violation is about WHERE the code appears, not just WHAT the code is. A naive regex derived from the Bad line would fire on every surface match, producing a false-positive-prone rule.
+
+Markers in the lesson body that signal this class:
+- "**inside** X", "**within** X", "**when wrapped in** X", "**when called from** X" — scope guards
+- "**only for new** X", "**only when** X", "**except when** X" — conditional guards
+
+When you cannot write a regex that distinguishes the Bad lines from the Good lines because the distinguishing context lives outside the snippet itself (and \`fileGlobs\` alone cannot close the gap), emit:
+
+\`\`\`json
+{
+  "compilable": false,
+  "reasonCode": "context-required",
+  "reason": "Lesson constrains scope to <the guard>; Bad and Good snippets differ only in surrounding context the pattern cannot see."
+}
+\`\`\`
+
+The \`reasonCode\` field is optional and narrow — \`"context-required"\` and \`"semantic-analysis-required"\` (see Semantic Analysis Classifier below) are the only values you may emit. Absence of the field keeps the default classification.
+
+**Anti-lazy guard:** when \`fileGlobs\` CAN express the distinguishing scope (e.g., "only in JSON files", "only in test files"), compile normally with the appropriate glob. Only fall back to \`context-required\` when the structural tools genuinely cannot reach the guard.
+
+### Semantic Analysis Classifier (mmnto-ai/totem#1634)
+
+Even with Bad and Good snippets in hand, some lessons describe hazards that require **semantic or multi-file analysis** the compiler cannot perform. Four sub-classes:
+
+- **Multi-file contracts.** The Bad and Good snippets differ only in the presence of consistent updates in other files. Pattern fires the same on both.
+- **Closure-body AST analysis.** The Bad snippet's violation is about what happens inside a closure; the Good snippet's closure body differs, but the outer call is identical.
+- **System-parameter-aware scoping.** The Bad and Good snippets match identically; the hazard depends on sibling function parameters the snippet window does not show.
+- **Project-state-conditional semantics.** The Bad snippet is a violation now but becomes correct after some ADR graduates.
+
+When the snippet pair cannot be distinguished by any single-line pattern because the distinguishing analysis lives outside the pattern's reach, emit:
+
+\`\`\`json
+{
+  "compilable": false,
+  "reasonCode": "semantic-analysis-required",
+  "reason": "Bad and Good snippets differ only in analysis outside pattern reach (multi-file / closure-body / sibling-param / project-state)."
+}
+\`\`\`
+
+The \`reasonCode\` field is narrow — \`"context-required"\` and \`"semantic-analysis-required"\` are the only values you may emit. Use \`semantic-analysis-required\` when the required analysis exceeds the compiler's capability; use \`context-required\` when a structural guard exists but the pattern vocabulary cannot express it.
+
+**Anti-lazy guard:** compile normally when the distinguishing difference is on the Bad/Good lines themselves or when \`fileGlobs\` can scope the rule. Only emit \`semantic-analysis-required\` when no pattern can discriminate the snippet pair regardless of vocabulary.
+
+### Test-Contract Scope Classifier (mmnto-ai/totem#1626)
+
+Some lessons describe **behavior that executes inside test files**: assertion conventions, spy or mock contracts, test-fixture hygiene. A default \`fileGlobs\` of \`"!**/*.test.*"\` inverts the intent for this class, shipping a rule that can never fire on the code it is meant to govern.
+
+Positive signals (any one alone is enough to classify):
+- The lesson carries the \`testing\` tag.
+- The Bad or Good snippet contains test-framework calls: \`describe(\`, \`it(\`, \`test(\`, \`expect(\`, \`vi.mock(\`, \`jest.mock(\`, \`beforeEach(\`, \`afterEach(\`, \`vi.spyOn(\`, \`jest.spyOn(\`.
+- Lesson body describes behavior specific to test execution (assertion patterns, spy contracts, test fixtures, mocked-dependency setup).
+
+When the lesson is a test-contract, emit \`fileGlobs\` that INCLUDE test files. The conventional broad set covers typical monorepo test layouts:
+
+\`\`\`json
+{"fileGlobs": ["**/*.test.*", "**/*.spec.*", "**/tests/**/*.*", "**/__tests__/**/*.*"]}
+\`\`\`
+
+If the lesson clearly targets a narrower test directory (e.g., "only for e2e tests in \`packages/e2e\`"), preserve that narrow glob rather than blanket-replacing it with the broad default.
+
+**False-positive trap.** The word "contract" alone does NOT make a lesson test-scoped. Lessons titled "Define strict API Data Contracts" or "Versioning contracts for REST endpoints" describe application-surface invariants. Require the \`testing\` tag OR test-framework code in the examples alongside any keyword match before classifying as test-contract.
+
+**Worked examples (emit test-inclusive fileGlobs):**
+
+- Lesson: "Normalize temp paths for cross-platform equality" with Good snippet \`expect(actual).toBe(normalizePath(expected))\`.
+  - Output: test-inclusive fileGlobs from the conventional broad set.
+- Lesson: "Spy on logger contracts in tests" tagged \`testing\`, with examples using \`vi.spyOn(logger, 'error')\`.
+  - Output: test-inclusive fileGlobs from the conventional broad set.
+
+**Anti-lazy guard (do NOT emit test-inclusive fileGlobs):**
+
+- Lesson: "Define strict API Data Contracts" with REST handler snippets, no \`expect\`, no \`describe\`, no \`testing\` tag.
+  - Output: application-scope fileGlobs with the usual test exclusion, e.g., \`["packages/api/**/*.ts", "!**/*.test.*"]\`.
+
+**Rule of thumb:** ask "does the hazard this lesson describes actually HAPPEN inside test code?" If yes, emit test-inclusive fileGlobs. If the lesson is about production code, keep the standard exclusion pattern.
+
+### Declared Severity (mmnto-ai/totem#1656)
+
+Lessons sometimes declare their intended severity in prose, using the convention \`**Severity:** error\` or \`Severity: warning\` on its own line (tolerant of bold or italic markdown). Totem's CI integration treats \`'error'\` as blocking and \`'warning'\` as advisory, so the declaration is load-bearing.
+
+Read the lesson body for a \`Severity: <level>\` declaration and **honor it** in your \`"severity"\` output:
+
+- Prose says \`Severity: error\` → emit \`"severity": "error"\`.
+- Prose says \`Severity: warning\` → emit \`"severity": "warning"\`.
+- No \`Severity:\` line → fall back to the default \`"severity": "warning"\`.
+
+The compile pipeline applies a deterministic override after your output, so a mismatch is corrected silently. Honoring the declaration keeps your output self-consistent and avoids wasted telemetry records.
+
+**Anti-lazy guard:** do not classify "severity" language in free prose as a declaration. A lesson body that mentions "this prevents a severe error" or "a warning message appears" is NOT declaring severity. Only the structured \`Severity:\` key with a colon counts.
+
 Every compilable rule MUST include non-empty \`badExample\` AND \`goodExample\` fields. The compile pipeline's schema parse rejects output that omits either one for \`ast-grep\` or \`regex\` engines, so the rule never reaches the smoke gate. The smoke gate then runs the rule against both snippets: the pattern MUST match \`badExample\` (zero matches here rejects with reason code \`pattern-zero-match\`) and MUST NOT match \`goodExample\` (any match here rejects with reason code \`matches-good-example\`).
 `;
 //# sourceMappingURL=compile-templates.js.map

package/dist/commands/compile-templates.js.map

@@ -1 +1 @@
-{"version":3,"file":"compile-templates.js","sourceRoot":"","sources":["../../src/commands/compile-templates.ts"],"names":[],"mappings":"AAAA,uDAAuD;AAEvD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG;IAC7B,eAAe;IACf,kBAAkB;IAClB,iBAAiB;IACjB,cAAc;IACd,eAAe;IACf,cAAc;IACd,sBAAsB;IACtB,mBAAmB;IACnB,gBAAgB;IAChB,mBAAmB;IACnB,YAAY;IACZ,kBAAkB;IAClB,kBAAkB;IAClB,cAAc;IACd,kBAAkB;CACV,CAAC;AAIX,uDAAuD;AAEvD,MAAM,CAAC,MAAM,sBAAsB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuLpC,eAAe,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoIpD,CAAC;AAEF,uDAAuD;AAEvD,MAAM,CAAC,MAAM,yBAAyB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiDxC,CAAC"}
+{"version":3,"file":"compile-templates.js","sourceRoot":"","sources":["../../src/commands/compile-templates.ts"],"names":[],"mappings":"AAAA,uDAAuD;AAEvD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG;IAC7B,eAAe;IACf,kBAAkB;IAClB,iBAAiB;IACjB,cAAc;IACd,eAAe;IACf,cAAc;IACd,sBAAsB;IACtB,mBAAmB;IACnB,gBAAgB;IAChB,mBAAmB;IACnB,YAAY;IACZ,kBAAkB;IAClB,kBAAkB;IAClB,cAAc;IACd,kBAAkB;CACV,CAAC;AAIX,uDAAuD;AAEvD,MAAM,CAAC,MAAM,sBAAsB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkUpC,eAAe,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoIpD,CAAC;AAEF,uDAAuD;AAEvD,MAAM,CAAC,MAAM,yBAAyB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8IxC,CAAC"}

package/dist/commands/compile-templates.test.js

@@ -92,6 +92,89 @@ describe('PIPELINE3_COMPILER_PROMPT', () => {
         expect(PIPELINE3_COMPILER_PROMPT).toContain('badExample');
     });
 });
+// ─── Test-Contract Scope Classifier (mmnto-ai/totem#1626) ──
+describe('Test-Contract Scope Classifier (mmnto-ai/totem#1626)', () => {
+    describe('COMPILER_SYSTEM_PROMPT', () => {
+        it('declares the classifier section with the #1626 issue reference', () => {
+            expect(COMPILER_SYSTEM_PROMPT).toContain('Test-Contract Scope Classifier');
+            expect(COMPILER_SYSTEM_PROMPT).toContain('mmnto-ai/totem#1626');
+        });
+        it('names the testing tag as a positive classifier signal', () => {
+            expect(COMPILER_SYSTEM_PROMPT).toMatch(/`testing`\s+tag/);
+        });
+        it('enumerates the broad test-inclusive glob set so monorepo layouts are covered', () => {
+            expect(COMPILER_SYSTEM_PROMPT).toContain('**/*.test.*');
+            expect(COMPILER_SYSTEM_PROMPT).toContain('**/*.spec.*');
+            expect(COMPILER_SYSTEM_PROMPT).toContain('**/tests/**');
+            expect(COMPILER_SYSTEM_PROMPT).toContain('**/__tests__/**');
+        });
+        it('warns against the API Contracts / Data Contracts false-positive trap', () => {
+            expect(COMPILER_SYSTEM_PROMPT).toMatch(/API Contracts|Data Contracts/);
+        });
+        it('teaches the classifier to preserve narrow test globs instead of blanket-replacing', () => {
+            expect(COMPILER_SYSTEM_PROMPT).toMatch(/narrow|preserve|do not overwrite/i);
+        });
+        it('includes at least one fileGlobs example with a test-inclusive glob (not just exclusion)', () => {
+            const inclusivePattern = /"fileGlobs":\s*\[[^\]]*"\*\*\/\*\.test\.\*"/;
+            const inclusiveAltPattern = /"fileGlobs":\s*\[[^\]]*"\*\*\/\*\.spec\.\*"/;
+            const hasInclusive = inclusivePattern.test(COMPILER_SYSTEM_PROMPT) ||
+                inclusiveAltPattern.test(COMPILER_SYSTEM_PROMPT);
+            expect(hasInclusive).toBe(true);
+        });
+    });
+    describe('PIPELINE3_COMPILER_PROMPT', () => {
+        it('declares the classifier section with the #1626 issue reference', () => {
+            expect(PIPELINE3_COMPILER_PROMPT).toContain('Test-Contract Scope Classifier');
+            expect(PIPELINE3_COMPILER_PROMPT).toContain('mmnto-ai/totem#1626');
+        });
+        it('names the testing tag as a positive classifier signal', () => {
+            expect(PIPELINE3_COMPILER_PROMPT).toMatch(/`testing`\s+tag/);
+        });
+        it('enumerates the broad test-inclusive glob set so monorepo layouts are covered', () => {
+            expect(PIPELINE3_COMPILER_PROMPT).toContain('**/*.test.*');
+            expect(PIPELINE3_COMPILER_PROMPT).toContain('**/*.spec.*');
+            expect(PIPELINE3_COMPILER_PROMPT).toContain('**/tests/**');
+            expect(PIPELINE3_COMPILER_PROMPT).toContain('**/__tests__/**');
+        });
+        it('warns against the API Contracts / Data Contracts false-positive trap', () => {
+            expect(PIPELINE3_COMPILER_PROMPT).toMatch(/API Contracts|Data Contracts/);
+        });
+        it('teaches the classifier to preserve narrow test globs instead of blanket-replacing', () => {
+            expect(PIPELINE3_COMPILER_PROMPT).toMatch(/narrow|preserve|do not overwrite/i);
+        });
+    });
+});
+// ─── Declared Severity directive (mmnto-ai/totem#1656) ──
+describe('Declared Severity directive (mmnto-ai/totem#1656)', () => {
+    describe('COMPILER_SYSTEM_PROMPT', () => {
+        it('declares the directive section with the #1656 issue reference', () => {
+            expect(COMPILER_SYSTEM_PROMPT).toContain('Declared Severity');
+            expect(COMPILER_SYSTEM_PROMPT).toContain('mmnto-ai/totem#1656');
+        });
+        it('references the Severity prose convention used by lesson authors', () => {
+            expect(COMPILER_SYSTEM_PROMPT).toMatch(/`?Severity:\s*(error|warning)`?/i);
+        });
+        it('names both valid severity values for emission', () => {
+            expect(COMPILER_SYSTEM_PROMPT).toContain("'error'");
+            expect(COMPILER_SYSTEM_PROMPT).toContain("'warning'");
+        });
+        it('instructs the LLM to honor the declared severity when present', () => {
+            expect(COMPILER_SYSTEM_PROMPT).toMatch(/honor|honour|emit.*declared|match.*declared/i);
+        });
+    });
+    describe('PIPELINE3_COMPILER_PROMPT', () => {
+        it('declares the directive section with the #1656 issue reference', () => {
+            expect(PIPELINE3_COMPILER_PROMPT).toContain('Declared Severity');
+            expect(PIPELINE3_COMPILER_PROMPT).toContain('mmnto-ai/totem#1656');
+        });
+        it('references the Severity prose convention used by lesson authors', () => {
+            expect(PIPELINE3_COMPILER_PROMPT).toMatch(/`?Severity:\s*(error|warning)`?/i);
+        });
+        it('instructs the LLM to honor the declared severity when present', () => {
+            expect(PIPELINE3_COMPILER_PROMPT).toMatch(/honor|honour|emit.*declared|match.*declared/i);
+        });
+    });
+});
 // ─── KIND_ALLOW_LIST ────────────────────────────────
 describe('KIND_ALLOW_LIST', () => {
     it('is a non-empty readonly array of strings', () => {

package/dist/commands/compile-templates.test.js.map

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

package/dist/commands/compile.d.ts.map

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