@massu/core 1.5.0 → 1.5.2

package/dist/hooks/session-start.js

@@ -15,6 +15,10 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 var __commonJS = (cb, mod) => function __require2() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
+var __export = (target, all) => {
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -7589,6 +7593,160 @@ function parse(toml, { maxDepth = 1e3, integersAsBigInt } = {}) {
   return res;
 }
 
+// src/detect/manifest-registry.ts
+var manifest_registry_exports = {};
+__export(manifest_registry_exports, {
+  getManifestPatterns: () => getManifestPatterns,
+  getManifestRegistry: () => getManifestRegistry,
+  matchManifestPattern: () => matchManifestPattern
+});
+function matchManifestPattern(name2, pattern) {
+  if (pattern.startsWith("*")) {
+    const suffix = pattern.slice(1);
+    if (suffix.includes("*")) {
+      throw new Error(
+        `[manifest-registry] pattern "${pattern}" has more than one wildcard. Only "*.<ext>" extension-globs are supported.`
+      );
+    }
+    return name2.endsWith(suffix);
+  }
+  return name2 === pattern;
+}
+var _registryCache = null;
+function getManifestRegistry() {
+  if (_registryCache !== null) return _registryCache;
+  _registryCache = [
+    {
+      pattern: "package.json",
+      manifestType: "package.json",
+      language: "typescript",
+      runtime: "node",
+      parse: parsePackageJson,
+      signalKey: "packageJson",
+      signalShape: "json"
+    },
+    {
+      pattern: "pyproject.toml",
+      manifestType: "pyproject.toml",
+      language: "python",
+      runtime: "python3",
+      parse: parsePyproject,
+      signalKey: "pyprojectToml",
+      signalShape: "toml"
+    },
+    {
+      pattern: "requirements.txt",
+      manifestType: "requirements.txt",
+      language: "python",
+      runtime: "python3",
+      parse: parseRequirementsTxt,
+      // Captured via pyprojectToml sibling already; no separate signal.
+      signalKey: null,
+      signalShape: "string"
+    },
+    {
+      pattern: "Pipfile",
+      manifestType: "Pipfile",
+      language: "python",
+      runtime: "python3",
+      parse: parsePipfile,
+      // Captured via pyprojectToml sibling already; no separate signal.
+      signalKey: null,
+      signalShape: "string"
+    },
+    {
+      pattern: "Cargo.toml",
+      manifestType: "Cargo.toml",
+      language: "rust",
+      runtime: "cargo",
+      parse: parseCargoToml,
+      signalKey: "cargoToml",
+      signalShape: "toml"
+    },
+    {
+      pattern: "Package.swift",
+      manifestType: "Package.swift",
+      language: "swift",
+      runtime: "xcode",
+      parse: parsePackageSwift,
+      // No AST adapter consumer yet (swift-swiftui doesn't need it).
+      signalKey: null,
+      signalShape: "string"
+    },
+    {
+      pattern: "go.mod",
+      manifestType: "go.mod",
+      language: "go",
+      runtime: "go",
+      parse: parseGoMod,
+      signalKey: "goMod",
+      signalShape: "string"
+    },
+    {
+      pattern: "pom.xml",
+      manifestType: "pom.xml",
+      language: "java",
+      runtime: "jvm",
+      parse: parsePomXml,
+      signalKey: "pomXml",
+      signalShape: "string"
+    },
+    {
+      pattern: "build.gradle",
+      manifestType: "build.gradle",
+      language: "java",
+      runtime: "jvm",
+      parse: parseBuildGradle,
+      signalKey: "gradleBuild",
+      signalShape: "string"
+    },
+    {
+      pattern: "build.gradle.kts",
+      manifestType: "build.gradle",
+      language: "java",
+      runtime: "jvm",
+      parse: parseBuildGradle,
+      signalKey: "gradleBuild",
+      signalShape: "string"
+    },
+    {
+      pattern: "Gemfile",
+      manifestType: "Gemfile",
+      language: "ruby",
+      runtime: "ruby",
+      parse: parseGemfile,
+      signalKey: "gemfile",
+      signalShape: "string"
+    },
+    // Plan 1.5.1 — closes CR-39 violation (1.5.0 init failed for Phoenix
+    // + ASP.NET fixtures). Both rely on AST adapters that already work
+    // in introspect; the gap was solely package-detector unaware of the
+    // manifest filenames.
+    {
+      pattern: "mix.exs",
+      manifestType: "mix.exs",
+      language: "elixir",
+      runtime: "beam",
+      parse: parseMixExs,
+      signalKey: "mixExs",
+      signalShape: "string"
+    },
+    {
+      pattern: "*.csproj",
+      manifestType: "*.csproj",
+      language: "csharp",
+      runtime: "dotnet",
+      parse: parseCsproj,
+      signalKey: "csproj",
+      signalShape: "string"
+    }
+  ];
+  return _registryCache;
+}
+function getManifestPatterns() {
+  return getManifestRegistry().map((e) => e.pattern);
+}
+
 // src/detect/package-detector.ts
 var WORKSPACE_DIRS = ["apps", "packages", "services", "libs", "modules"];
 var IGNORED_DIRS = /* @__PURE__ */ new Set([
@@ -7612,19 +7770,6 @@ var IGNORED_DIRS = /* @__PURE__ */ new Set([
   "DerivedData",
   "Pods"
 ]);
-var MANIFEST_FILES = [
-  "package.json",
-  "pyproject.toml",
-  "requirements.txt",
-  "Pipfile",
-  "Cargo.toml",
-  "Package.swift",
-  "go.mod",
-  "pom.xml",
-  "build.gradle",
-  "build.gradle.kts",
-  "Gemfile"
-];
 function safeRead(path) {
   try {
     if (!existsSync3(path)) return null;
@@ -8029,46 +8174,86 @@ function parseGemfile(path, directory, root, _warnings) {
     manifestType: "Gemfile"
   };
 }
+function parseMixExs(path, directory, root, _warnings) {
+  const raw = safeRead(path);
+  if (raw === null) return null;
+  const deps = [];
+  const depPattern = /\{\s*:([a-z][a-z0-9_]*)\s*,/g;
+  let m;
+  while ((m = depPattern.exec(raw)) !== null) {
+    if (!deps.includes(m[1])) deps.push(m[1]);
+  }
+  const appMatch = /\bapp\s*:\s*:([a-z][a-z0-9_]*)/.exec(raw);
+  const name2 = appMatch ? appMatch[1] : null;
+  return {
+    path,
+    relativePath: normalizeRelative(root, path),
+    directory,
+    language: "elixir",
+    runtime: "beam",
+    name: name2,
+    version: null,
+    dependencies: deps,
+    devDependencies: [],
+    scripts: [],
+    manifestType: "mix.exs"
+  };
+}
+function parseCsproj(path, directory, root, _warnings) {
+  const raw = safeRead(path);
+  if (raw === null) return null;
+  const deps = [];
+  const pkgRefPattern = /<PackageReference\s+[^>]*Include\s*=\s*"([^"]+)"/gi;
+  let m;
+  while ((m = pkgRefPattern.exec(raw)) !== null) {
+    if (!deps.includes(m[1])) deps.push(m[1]);
+  }
+  const sdkMatch = /<Project\s+[^>]*Sdk\s*=\s*"([^"]+)"/i.exec(raw);
+  if (sdkMatch && !deps.includes(sdkMatch[1])) {
+    deps.push(sdkMatch[1]);
+  }
+  const fname = path.split(/[/\\]/).pop() ?? "";
+  const name2 = fname.endsWith(".csproj") ? fname.slice(0, -".csproj".length) : null;
+  return {
+    path,
+    relativePath: normalizeRelative(root, path),
+    directory,
+    language: "csharp",
+    runtime: "dotnet",
+    name: name2,
+    version: null,
+    dependencies: deps,
+    devDependencies: [],
+    scripts: [],
+    manifestType: "*.csproj"
+  };
+}
 function detectManifestsInDir(dir, root, warnings) {
+  const { getManifestRegistry: getManifestRegistry2, matchManifestPattern: matchManifestPattern2 } = manifest_registry_exports;
   const out2 = [];
-  for (const fname of MANIFEST_FILES) {
-    const path = join(dir, fname);
-    if (!existsSync3(path)) continue;
-    let m = null;
-    switch (fname) {
-      case "package.json":
-        m = parsePackageJson(path, dir, root, warnings);
-        break;
-      case "pyproject.toml":
-        m = parsePyproject(path, dir, root, warnings);
-        break;
-      case "requirements.txt":
-        m = parseRequirementsTxt(path, dir, root, warnings);
-        break;
-      case "Pipfile":
-        m = parsePipfile(path, dir, root, warnings);
-        break;
-      case "Cargo.toml":
-        m = parseCargoToml(path, dir, root, warnings);
-        break;
-      case "Package.swift":
-        m = parsePackageSwift(path, dir, root, warnings);
-        break;
-      case "go.mod":
-        m = parseGoMod(path, dir, root, warnings);
-        break;
-      case "pom.xml":
-        m = parsePomXml(path, dir, root, warnings);
-        break;
-      case "build.gradle":
-      case "build.gradle.kts":
-        m = parseBuildGradle(path, dir, root, warnings);
-        break;
-      case "Gemfile":
-        m = parseGemfile(path, dir, root, warnings);
-        break;
+  let dirEntries = null;
+  for (const entry of getManifestRegistry2()) {
+    if (!entry.pattern.startsWith("*")) {
+      const path = join(dir, entry.pattern);
+      if (!existsSync3(path)) continue;
+      const m = entry.parse(path, dir, root, warnings);
+      if (m !== null) out2.push(m);
+    } else {
+      if (dirEntries === null) {
+        try {
+          dirEntries = readdirSync(dir);
+        } catch {
+          dirEntries = [];
+        }
+      }
+      for (const fname of dirEntries) {
+        if (!matchManifestPattern2(fname, entry.pattern)) continue;
+        const path = join(dir, fname);
+        if (!existsSync3(path)) continue;
+        const m = entry.parse(path, dir, root, warnings);
+        if (m !== null) out2.push(m);
+      }
     }
-    if (m !== null) out2.push(m);
   }
   return out2;
 }
@@ -8181,6 +8366,13 @@ var DETECTION_RULES = [
   { language: "go", kind: "framework", keyword: "github.com/labstack/echo", value: "echo", priority: 10 },
   { language: "go", kind: "framework", keyword: "github.com/gofiber/fiber", value: "fiber", priority: 10 },
   { language: "go", kind: "framework", keyword: "github.com/go-chi/chi", value: "chi", priority: 9 },
+  // chi versioned import paths (Go convention: github.com/<org>/<name>/v<N>).
+  // matchRule does exact case-insensitive set lookup, so the unversioned and
+  // each major-version path each need their own rule.
+  { language: "go", kind: "framework", keyword: "github.com/go-chi/chi/v2", value: "chi", priority: 9 },
+  { language: "go", kind: "framework", keyword: "github.com/go-chi/chi/v3", value: "chi", priority: 9 },
+  { language: "go", kind: "framework", keyword: "github.com/go-chi/chi/v4", value: "chi", priority: 9 },
+  { language: "go", kind: "framework", keyword: "github.com/go-chi/chi/v5", value: "chi", priority: 9 },
   { language: "go", kind: "test_framework", keyword: "github.com/stretchr/testify", value: "testify", priority: 8 },
   { language: "go", kind: "orm", keyword: "gorm.io/gorm", value: "gorm", priority: 10 },
   // Swift (SPM dependency names, best-effort)
@@ -8196,7 +8388,26 @@ var DETECTION_RULES = [
   { language: "ruby", kind: "framework", keyword: "rails", value: "rails", priority: 10 },
   { language: "ruby", kind: "framework", keyword: "sinatra", value: "sinatra", priority: 9 },
   { language: "ruby", kind: "test_framework", keyword: "rspec", value: "rspec", priority: 10 },
-  { language: "ruby", kind: "orm", keyword: "activerecord", value: "activerecord", priority: 10 }
+  { language: "ruby", kind: "orm", keyword: "activerecord", value: "activerecord", priority: 10 },
+  // Plan 1.5.1: elixir + csharp framework rules. Closes the CR-39 gap
+  // where Phoenix + ASP.NET projects produced `framework.languages.<lang>`
+  // entries WITHOUT a `framework:` value, which prevented variant
+  // templates from being looked up.
+  { language: "elixir", kind: "framework", keyword: "phoenix", value: "phoenix", priority: 10 },
+  { language: "elixir", kind: "test_framework", keyword: "ex_unit", value: "ex-unit", priority: 10 },
+  { language: "elixir", kind: "orm", keyword: "ecto", value: "ecto", priority: 10 },
+  // ASP.NET Core surfaces via several PackageReference names; the canonical
+  // ones in modern .NET projects are .App and .Mvc. matchRule does exact
+  // (case-insensitive) lookup against the deps set parseCsproj extracts.
+  { language: "csharp", kind: "framework", keyword: "Microsoft.AspNetCore.App", value: "aspnet-core", priority: 10 },
+  { language: "csharp", kind: "framework", keyword: "Microsoft.AspNetCore.Mvc", value: "aspnet-core", priority: 10 },
+  { language: "csharp", kind: "framework", keyword: "Microsoft.AspNetCore", value: "aspnet-core", priority: 9 },
+  // SDK-style projects: `<Project Sdk="Microsoft.NET.Sdk.Web">` is the
+  // canonical ASP.NET Core declaration in modern .NET. parseCsproj
+  // surfaces the Sdk attribute as a dep so this rule can match.
+  { language: "csharp", kind: "framework", keyword: "Microsoft.NET.Sdk.Web", value: "aspnet-core", priority: 10 },
+  { language: "csharp", kind: "test_framework", keyword: "xunit", value: "xunit", priority: 10 },
+  { language: "csharp", kind: "orm", keyword: "EntityFrameworkCore", value: "ef-core", priority: 10 }
 ];
 function matchRule(rules, language, kind, deps) {
   let best = null;
@@ -8312,7 +8523,10 @@ var EXTENSIONS = {
   swift: ["swift"],
   go: ["go"],
   java: ["java", "kt"],
-  ruby: ["rb"]
+  ruby: ["rb"],
+  // Plan 1.5.1 — closing CR-39 init gap for Phoenix + ASP.NET projects.
+  elixir: ["ex", "exs"],
+  csharp: ["cs"]
 };
 var TEST_FILE_PATTERNS = {
   python: [/_test\.py$/, /test_[^/]*\.py$/],
@@ -8322,7 +8536,11 @@ var TEST_FILE_PATTERNS = {
   swift: [/Tests\//],
   go: [/_test\.go$/],
   java: [/Test[^/]*\.(java|kt)$/, /[^/]*Test\.(java|kt)$/],
-  ruby: [/_spec\.rb$/, /_test\.rb$/]
+  ruby: [/_spec\.rb$/, /_test\.rb$/],
+  // Phoenix/ExUnit canonical: `test/**_test.exs`. ASP.NET / xUnit
+  // canonical: `*Tests.cs` or `*.Tests/...`.
+  elixir: [/_test\.exs$/, /\/test\//],
+  csharp: [/Tests?\.cs$/, /\.Tests?\//]
 };
 var TEST_DIR_KEYWORDS = ["tests", "test", "__tests__", "spec", "specs"];
 function extsFor(language) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@massu/core",
-  "version": "1.5.0",
+  "version": "1.5.2",
   "type": "module",
   "description": "AI Engineering Governance MCP Server - Session memory, knowledge system, feature registry, code intelligence, rule enforcement, tiered tooling (12 free / 72 total), 55+ workflow commands, 11 agents, 20+ patterns",
   "main": "src/server.ts",

package/src/commands/init.ts

@@ -543,6 +543,145 @@ export function buildConfigFromDetection(
   return config;
 }
 
+/**
+ * Plan 1.5.1 §3 — variant template merge.
+ *
+ * Map from detected `framework.languages.<lang>.framework` value → variant
+ * template directory under `packages/core/templates/`. Most detected
+ * frameworks map 1:1 to a template dir of the same name, but a few have
+ * naming divergence (e.g., detection emits `spring-boot` but the template
+ * dir is `spring`; detection emits `chi` but the template dir is `go-chi`).
+ *
+ * The mapping is intentionally tight — only frameworks with an actual
+ * variant template under `templates/` are listed. Adding a new framework
+ * = one entry here + one templates/<id>/massu.config.yaml file. The
+ * `manifest-registry-drift.test.ts` already gates the manifest side; the
+ * `init-end-to-end.test.ts` gates this map.
+ */
+const FRAMEWORK_TO_TEMPLATE_ID: Record<string, string> = {
+  rails: 'rails',
+  phoenix: 'phoenix',
+  'aspnet-core': 'aspnet',
+  'spring-boot': 'spring',
+  chi: 'go-chi',
+  flask: 'python-flask',
+};
+
+/**
+ * After `buildConfigFromDetection` produces a baseline config, look up the
+ * variant template for the detected framework (if any) and selectively
+ * merge fields. The variant wins on a small allowlist:
+ *   - `framework.router`
+ *   - `framework.orm`
+ *   - `framework.ui`
+ *   - `paths.source`
+ *   - `verification.<lang>.{lint,syntax,test,type,build}` — variant lint
+ *     is the canonical project-style command (rubocop, credo, etc.) and
+ *     should not be overridden by the generic detection default.
+ *
+ * The variant template's `framework.type`, `framework.languages`,
+ * `project.name`, `domains`, and `rules` are NOT merged — those come from
+ * detection and reflect the actual repo state. Allowlist keeps the merge
+ * precise; future fields require an explicit decision.
+ */
+export function applyVariantTemplate(
+  config: Record<string, unknown>,
+  templatesDir: string | null,
+): Record<string, unknown> {
+  if (!templatesDir) return config;
+  const fw = config.framework as Record<string, unknown> | undefined;
+  if (!fw) return config;
+  const langs = fw.languages as Record<string, unknown> | undefined;
+  if (!langs || typeof langs !== 'object') return config;
+
+  // Find the first language that has a `framework` value with a known
+  // variant template. Most projects have ONE primary language; in
+  // monorepos the detection-driven primary is what we honor.
+  let templateId: string | null = null;
+  for (const langEntry of Object.values(langs)) {
+    if (langEntry && typeof langEntry === 'object') {
+      const fwName = (langEntry as Record<string, unknown>).framework;
+      if (typeof fwName === 'string' && FRAMEWORK_TO_TEMPLATE_ID[fwName]) {
+        templateId = FRAMEWORK_TO_TEMPLATE_ID[fwName];
+        break;
+      }
+    }
+  }
+  if (templateId === null) return config;
+
+  const templatePath = resolve(templatesDir, templateId, 'massu.config.yaml');
+  if (!existsSync(templatePath)) return config;
+
+  let template: Record<string, unknown>;
+  try {
+    // pattern-scanner-allow: yaml-parse — reason: this loads a per-framework
+    // variant config-template shipped inside @massu/core. getConfig() reads
+    // the project's massu.config.yaml from cwd; this is a SEPARATE file
+    // (the template) that doesn't pass through that cache and isn't a Zod-
+    // validated config — it's a partial override map.
+    template = yamlParse(readFileSync(templatePath, 'utf-8')) as Record<string, unknown>;
+  } catch {
+    return config;
+  }
+
+  const out = { ...config };
+  const tplFw = template.framework as Record<string, unknown> | undefined;
+  const outFw = (out.framework as Record<string, unknown>) ?? {};
+  if (tplFw) {
+    if (typeof tplFw.router === 'string' && (!outFw.router || outFw.router === 'none')) {
+      outFw.router = tplFw.router;
+    }
+    if (typeof tplFw.orm === 'string' && (!outFw.orm || outFw.orm === 'none')) {
+      outFw.orm = tplFw.orm;
+    }
+    if (typeof tplFw.ui === 'string' && (!outFw.ui || outFw.ui === 'none')) {
+      outFw.ui = tplFw.ui;
+    }
+  }
+  out.framework = outFw;
+
+  const tplPaths = template.paths as Record<string, unknown> | undefined;
+  const outPaths = (out.paths as Record<string, unknown>) ?? {};
+  if (tplPaths && typeof tplPaths.source === 'string' && tplPaths.source) {
+    outPaths.source = tplPaths.source;
+  }
+  out.paths = outPaths;
+
+  const tplVerify = template.verification as Record<string, Record<string, unknown>> | undefined;
+  const outVerify = (out.verification as Record<string, Record<string, unknown>>) ?? {};
+  if (tplVerify) {
+    for (const [lang, tplLangVerify] of Object.entries(tplVerify)) {
+      if (!tplLangVerify || typeof tplLangVerify !== 'object') continue;
+      const outLangVerify = outVerify[lang] ?? {};
+      // Variant wins on lint + syntax (canonical project commands like
+      // rubocop, credo, golangci-lint that the generic detection layer
+      // doesn't know to suggest). For test/type/build, prefer detection-
+      // derived values when present (e.g., monorepo `cd packages/foo`
+      // prefixing) and fall back to variant template otherwise.
+      for (const key of ['lint', 'syntax']) {
+        if (typeof tplLangVerify[key] === 'string' && tplLangVerify[key]) {
+          outLangVerify[key] = tplLangVerify[key];
+        }
+      }
+      for (const key of ['test', 'type', 'build']) {
+        if (
+          typeof tplLangVerify[key] === 'string' &&
+          tplLangVerify[key] &&
+          !outLangVerify[key]
+        ) {
+          outLangVerify[key] = tplLangVerify[key];
+        }
+      }
+      outVerify[lang] = outLangVerify;
+    }
+  }
+  if (Object.keys(outVerify).length > 0) {
+    out.verification = outVerify;
+  }
+
+  return out;
+}
+
 /**
  * Serialize a built config object into YAML with a header comment.
  * Safe for `writeConfigAtomic` and for `fs.writeFileSync` directly.
@@ -761,7 +900,17 @@ export function listTemplates(): readonly string[] {
 export function resolveTemplatesDir(): string | null {
   const cwd = process.cwd();
   const candidates = [
+    // Project-local install: `<project>/node_modules/@massu/core/templates`.
     resolve(cwd, 'node_modules/@massu/core/templates'),
+    // Bundled cli.js layout: cli.js sits at `<package>/dist/cli.js`, so
+    // templates live one level up at `<package>/templates`. (Plan 1.5.1
+    // bug discovery: pre-existing layout assumed `dist/commands/init.js`
+    // depth which never matched the bundled cli, so resolveTemplatesDir
+    // returned null in production for both `--template` mode AND the
+    // applyVariantTemplate path.)
+    resolve(__dirname, '../templates'),
+    // Legacy nested layouts retained as fallbacks (in case a future
+    // build moves cli.js back into a subdirectory).
     resolve(__dirname, '../../templates'),
     resolve(__dirname, '../../../templates'),
   ];
@@ -1228,8 +1377,16 @@ export async function runInit(argv?: string[], overrides?: InitOptions): Promise
     }
   }
 
-  // Build config + write atomically.
-  const config = buildConfigFromDetection({ projectRoot, detection });
+  // Build config + apply variant template + write atomically. Plan 1.5.1
+  // §3: the framework-specific variant template under
+  // packages/core/templates/<id>/massu.config.yaml supplies router,
+  // paths.source, and verification.<lang>.lint that the generic
+  // detection-derived baseline doesn't know to set. Pre-1.5.1 init
+  // emitted configs with `router: none` even for clear-Rails / clear-
+  // Phoenix / clear-Spring projects (CR-39 violation per the Plan 1.5.1
+  // 5-fixture verification).
+  const baseConfig = buildConfigFromDetection({ projectRoot, detection });
+  const config = applyVariantTemplate(baseConfig, resolveTemplatesDir());
   const content = renderConfigYaml(config);
   const writeRes = writeConfigAtomic(configPath, content);
   if (!writeRes.validated) {

package/src/detect/framework-detector.ts

@@ -138,6 +138,13 @@ export const DETECTION_RULES: DetectionRule[] = [
   { language: 'go', kind: 'framework', keyword: 'github.com/labstack/echo', value: 'echo', priority: 10 },
   { language: 'go', kind: 'framework', keyword: 'github.com/gofiber/fiber', value: 'fiber', priority: 10 },
   { language: 'go', kind: 'framework', keyword: 'github.com/go-chi/chi', value: 'chi', priority: 9 },
+  // chi versioned import paths (Go convention: github.com/<org>/<name>/v<N>).
+  // matchRule does exact case-insensitive set lookup, so the unversioned and
+  // each major-version path each need their own rule.
+  { language: 'go', kind: 'framework', keyword: 'github.com/go-chi/chi/v2', value: 'chi', priority: 9 },
+  { language: 'go', kind: 'framework', keyword: 'github.com/go-chi/chi/v3', value: 'chi', priority: 9 },
+  { language: 'go', kind: 'framework', keyword: 'github.com/go-chi/chi/v4', value: 'chi', priority: 9 },
+  { language: 'go', kind: 'framework', keyword: 'github.com/go-chi/chi/v5', value: 'chi', priority: 9 },
   { language: 'go', kind: 'test_framework', keyword: 'github.com/stretchr/testify', value: 'testify', priority: 8 },
   { language: 'go', kind: 'orm', keyword: 'gorm.io/gorm', value: 'gorm', priority: 10 },
 
@@ -157,6 +164,25 @@ export const DETECTION_RULES: DetectionRule[] = [
   { language: 'ruby', kind: 'framework', keyword: 'sinatra', value: 'sinatra', priority: 9 },
   { language: 'ruby', kind: 'test_framework', keyword: 'rspec', value: 'rspec', priority: 10 },
   { language: 'ruby', kind: 'orm', keyword: 'activerecord', value: 'activerecord', priority: 10 },
+  // Plan 1.5.1: elixir + csharp framework rules. Closes the CR-39 gap
+  // where Phoenix + ASP.NET projects produced `framework.languages.<lang>`
+  // entries WITHOUT a `framework:` value, which prevented variant
+  // templates from being looked up.
+  { language: 'elixir', kind: 'framework', keyword: 'phoenix', value: 'phoenix', priority: 10 },
+  { language: 'elixir', kind: 'test_framework', keyword: 'ex_unit', value: 'ex-unit', priority: 10 },
+  { language: 'elixir', kind: 'orm', keyword: 'ecto', value: 'ecto', priority: 10 },
+  // ASP.NET Core surfaces via several PackageReference names; the canonical
+  // ones in modern .NET projects are .App and .Mvc. matchRule does exact
+  // (case-insensitive) lookup against the deps set parseCsproj extracts.
+  { language: 'csharp', kind: 'framework', keyword: 'Microsoft.AspNetCore.App', value: 'aspnet-core', priority: 10 },
+  { language: 'csharp', kind: 'framework', keyword: 'Microsoft.AspNetCore.Mvc', value: 'aspnet-core', priority: 10 },
+  { language: 'csharp', kind: 'framework', keyword: 'Microsoft.AspNetCore', value: 'aspnet-core', priority: 9 },
+  // SDK-style projects: `<Project Sdk="Microsoft.NET.Sdk.Web">` is the
+  // canonical ASP.NET Core declaration in modern .NET. parseCsproj
+  // surfaces the Sdk attribute as a dep so this rule can match.
+  { language: 'csharp', kind: 'framework', keyword: 'Microsoft.NET.Sdk.Web', value: 'aspnet-core', priority: 10 },
+  { language: 'csharp', kind: 'test_framework', keyword: 'xunit', value: 'xunit', priority: 10 },
+  { language: 'csharp', kind: 'orm', keyword: 'EntityFrameworkCore', value: 'ef-core', priority: 10 },
 ];
 
 /**