sigmap 6.4.0 → 6.5.0

package/AGENTS.md

@@ -47,18 +47,6 @@ Use this marker block for all appendable context files:
 <!-- Updated by gen-context.js -->
 # Code signatures
 
-## changes (last 5 commits — 0 seconds ago)
-```
-src/learning/weights.js                       +exportWeights  +importWeights  ~resetWeights
-packages/adapters/codex.js                    ~write  ~format
-packages/adapters/claude.js                   ~format  ~write
-packages/adapters/gemini.js                   ~format
-packages/adapters/copilot.js                  ~format
-packages/adapters/cursor.js                   ~format
-packages/adapters/openai.js                   ~format
-packages/adapters/windsurf.js                 ~format
-```
-
 ## packages
 
 ### packages/cli/index.js
@@ -133,22 +121,22 @@ function outputPath(cwd) → string
 function write(context, cwd, opts = {})
 ```
 
-### packages/adapters/gemini.js
+### packages/adapters/copilot.js
 ```
 module.exports = { name, format, outputPath, write }
 function format(context, opts = {}) → string
+function _confidenceMeta(opts)
 function outputPath(cwd) → string
 function write(context, cwd, opts = {})
-function _confidenceMeta(opts)
 ```
 
-### packages/adapters/copilot.js
+### packages/adapters/gemini.js
 ```
 module.exports = { name, format, outputPath, write }
 function format(context, opts = {}) → string
-function _confidenceMeta(opts)
 function outputPath(cwd) → string
 function write(context, cwd, opts = {})
+function _confidenceMeta(opts)
 ```
 
 ### packages/adapters/cursor.js
@@ -547,15 +535,6 @@ function formatAnalysisJSON(stats) → object
 module.exports = { DEFAULTS }
 ```
 
-### src/config/loader.js
-```
-module.exports = { loadConfig, loadBaseConfig }
-function loadBaseConfig(extendsVal, cwd)
-function detectAutoSrcDirs(cwd, excludeList) → string[]
-function loadConfig(cwd) → object
-function deepClone(obj)
-```
-
 ### src/format/dashboard.js
 ```
 module.exports = { generateDashboardHtml, renderHistoryCharts, computeExtractorCoverage, percentile, overBudgetStreak }
@@ -673,6 +652,15 @@ function extractClassMembers(block)
 function normalizeParams(params)
 ```
 
+### src/config/loader.js
+```
+module.exports = { loadConfig, loadBaseConfig }
+function loadBaseConfig(extendsVal, cwd)
+function detectAutoSrcDirs(cwd, excludeList) → string[]
+function loadConfig(cwd) → object
+function deepClone(obj)
+```
+
 ### src/learning/weights.js
 ```
 module.exports = { BASELINE, DECAY, MAX_MULT, MIN_MULT, weightsPath, clampMultiplier, normalizeFile, loadWeights, saveWeights, updateWeights, boostFiles, penalizeFiles, resetWeights, exportWeights, importWeights }

package/CHANGELOG.md

@@ -10,6 +10,23 @@ Format: [Semantic Versioning](https://semver.org/)
 
 ---
 
+## [6.5.0] — 2026-04-25
+
+### Added
+
+- **Source Root Resolver (v6.5)** — intelligent auto-detection of source directories for 17 languages and 50+ frameworks (Next.js, Django, Rails, Spring Boot, Flutter, Go, Rust, etc.). Uses multi-signal scoring: manifest files, language/framework detection, file density, git activity, and framework-specific srcDirs. Returns confidence level (high/medium/low) and detailed explanation. Integrated into `loadConfig()` with graceful fallback to legacy heuristics.
+- **`.sigmapignore` pattern matching** — new `.sigmapignore` file support (fallback to `.contextignore`) for excluding directories. Supports simple patterns like `legacy/` and globs like `src/**`.
+- **`sigmap roots` CLI command** — three modes: `--explain` (default, shows detected languages/frameworks and scores), `--json` (structured output), `--fix` (interactive prompt to correct srcDirs and write to config).
+- **Monorepo detection and enumeration** — auto-detects monorepos via pnpm-workspace.yaml, turbo.json, nx.json, lerna.json, and package.json workspaces. Enumerates all sub-packages and common deep paths.
+
+### Fixed
+
+- **Framework-discovery tests** — updated registry entries to include all framework-specific srcDirs expected by legacy detector (Rails: db/spec/test, Laravel: resources/tests, Angular: projects/apps/libs, Next: hooks/utils).
+- **Scoring penalty for framework srcDirs** — test directories (spec, test, tests) no longer penalized when explicitly in framework's srcDirs list.
+- **CLI command ordering** — `roots` command handler now executes before `explain` to prevent flag conflict.
+
+---
+
 ## [6.4.0] — 2026-04-23
 
 ### Changed

package/README.md

@@ -7,6 +7,7 @@
 **SigMap finds the right files before your AI answers.**
 
 [![npm version](https://img.shields.io/npm/v/sigmap?color=7c6af7&label=latest&logo=npm)](https://www.npmjs.com/package/sigmap)
+[![npm downloads](https://img.shields.io/npm/dt/sigmap?color=22c55e&label=downloads&logo=npm)](https://www.npmjs.com/package/sigmap)
 [![CI](https://github.com/manojmallick/sigmap/actions/workflows/ci.yml/badge.svg)](https://github.com/manojmallick/sigmap/actions/workflows/ci.yml)
 [![Zero deps](https://img.shields.io/badge/dependencies-zero-22c55e)](package.json)
 [![License: MIT](https://img.shields.io/badge/License-MIT-7c6af7.svg)](LICENSE)
@@ -37,10 +38,10 @@ Works with Copilot, Claude, Cursor, Windsurf, and any LLM.
 
 ## Why SigMap?
 
-- **80.0% hit@5** — right file found in top 5 results (vs 13.6% baseline)
+- **78.9% hit@5** — right file found in top 5 results (vs 13.6% baseline)
 - **40–98% token reduction** — 2K–4K tokens instead of 80K+
 - **52.2% task success rate** — up from 10% without context
-- **1.68 prompts per task** — down from 2.84
+- **1.69 prompts per task** — down from 2.84
 - **Works with any LLM** — no API key, no cloud, no accounts
 - **Zero npm dependencies** — `npx sigmap` on any machine
 
@@ -50,7 +51,7 @@ Works with Copilot, Claude, Cursor, Windsurf, and any LLM.
 
 | Without SigMap | With SigMap |
 |---|---|
-| ❌ Guessing which files are relevant | ✅ Right file in context — 80% of the time |
+| ❌ Guessing which files are relevant | ✅ Right file in context — 79% of the time |
 | ❌ Sending the full repo to your AI | ✅ Minimal context — only what matters |
 | ❌ Embeddings / vector DB required | ✅ Grounded answers, no infra needed |
 
@@ -74,13 +75,13 @@ Ask → Rank → Context → Validate → Judge → Learn
 ## Benchmark
 
 ```
-Benchmark : sigmap-v6.0-main
-Date      : 2026-04-19
+Benchmark : sigmap-v6.4-main
+Date      : 2026-04-23
 
-Hit@5          : 80.0%   (baseline 13.6%  — 5.8× lift)
-Prompt reduction : 40.8%
+Hit@5          : 78.9%   (baseline 13.6%  — 5.8× lift)
+Prompt reduction : 40.6%
 Task success   : 52.2%   (baseline 10%)
-Prompts / task : 1.68    (baseline 2.84)
+Prompts / task : 1.69    (baseline 2.84)
 Token reduction: 40–98%  (avg 96.9% across 18 real repos)
 ```
 

package/gen-context.js

@@ -5387,7 +5387,7 @@ __factories["./src/mcp/server"] = function(module, exports) {
   
   const SERVER_INFO = {
     name: 'sigmap',
-  version: '6.4.0',
+  version: '6.5.0',
     description: 'SigMap MCP server — code signatures on demand',
   };
   
@@ -7222,7 +7222,7 @@ const path = require('path');
 const os = require('os');
 const { execSync } = require('child_process');
 
-const VERSION = '6.4.0';
+const VERSION = '6.5.0';
 const MARKER = '\n\n## Auto-generated signatures\n<!-- Updated by gen-context.js -->\n';
 
 function requireSourceOrBundled(key) {
@@ -8477,6 +8477,15 @@ function runGenerate(cwd, config, reportMode, reportJson = false) {
     fileEntries.push({ filePath, sigs, deps: extractFileDeps(filePath, content, config), content, mtime });
   }
 
+  // v6.5: Coverage feedback loop — warn if symbol density is suspiciously low
+  const symbolsFound = fileEntries.reduce((n, f) => n + (f.sigs?.length || 0), 0);
+  const filesFound   = fileEntries.length;
+  const coverageRatio = filesFound > 0 ? symbolsFound / filesFound : 1;
+  if (coverageRatio < 0.25 && !config.srcDirs?.length) {
+    process.stderr.write('[sigmap] ⚠ low symbol coverage — source roots may be wrong\n');
+    process.stderr.write('[sigmap]   run: sigmap roots --explain\n');
+  }
+
   const strategy = config.strategy || 'full';
   const beforeCount = fileEntries.length;
 
@@ -9797,6 +9806,54 @@ function main() {
     process.exit(0);
   }
 
+  // v6.5: `sigmap roots` — detect source roots
+  if (args[0] === 'roots') {
+    const { resolveSourceRoots } = requireSourceOrBundled('./src/discovery/source-root-resolver');
+    const result = resolveSourceRoots(cwd);
+
+    if (args.includes('--json')) {
+      console.log(JSON.stringify(result, null, 2));
+      process.exit(0);
+    }
+
+    if (args.includes('--fix')) {
+      console.log('[sigmap] Current detected roots:', result.roots.join(', '));
+      const readline = require('readline');
+      const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+      rl.question('Enter correct srcDirs (comma-separated): ', answer => {
+        const dirs = answer.split(',').map(d => d.trim()).filter(Boolean);
+        const cfgPath = path.join(cwd, 'gen-context.config.json');
+        const cfg = fs.existsSync(cfgPath) ? JSON.parse(fs.readFileSync(cfgPath, 'utf8')) : {};
+        cfg.srcDirs = dirs;
+        fs.writeFileSync(cfgPath, JSON.stringify(cfg, null, 2) + '\n');
+        console.log(`[sigmap] Saved srcDirs: ${dirs.join(', ')} → gen-context.config.json`);
+        rl.close();
+        process.exit(0);
+      });
+      return;
+    }
+
+    // --explain (default)
+    console.log('\nDetected languages:');
+    for (const l of result.languages.slice(0, 4)) {
+      console.log(`  ${l.name.padEnd(16)} ${l.weight.toFixed(2)}`);
+    }
+    console.log('\nDetected frameworks:');
+    if (result.frameworks.length === 0) console.log('  (none)');
+    for (const f of result.frameworks.slice(0, 3)) {
+      console.log(`  ${f.name.padEnd(16)} ${f.confidence.toFixed(2)}`);
+    }
+    console.log('\nChosen source roots:');
+    if (result.roots.length === 0) console.log('  (none — legacy fallback used)');
+    result.roots.forEach((r, i) => {
+      const exp = result.explanation?.find(e => e.dir === r);
+      console.log(`  ${i + 1}. ${r.padEnd(20)} ${exp ? 'score ' + exp.score : ''}`);
+    });
+    console.log('\nMonorepo:', result.isMonorepo ? 'yes' : 'no');
+    console.log('Confidence:', result.confidence);
+    process.exit(0);
+  }
+
   // Feature 1: `sigmap explain <file>` — why a file is included or excluded
   if (args[0] === 'explain' || args.includes('--explain')) {
     const target = args[0] === 'explain'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sigmap",
-  "version": "6.4.0",
+  "version": "6.5.0",
   "description": "Zero-dependency AI context engine — 97% token reduction. No npm install. Runs on Node 18+.",
   "main": "gen-context.js",
   "exports": {

package/packages/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sigmap-cli",
-  "version": "6.4.0",
+  "version": "6.5.0",
   "description": "SigMap CLI wrapper — thin adapter for programmatic CLI invocation",
   "main": "index.js",
   "keywords": [

package/packages/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sigmap-core",
-  "version": "6.4.0",
+  "version": "6.5.0",
   "description": "SigMap core library — zero-dependency code signature extraction, retrieval, and security scanning",
   "main": "index.js",
   "keywords": [

package/src/config/loader.js

@@ -89,14 +89,38 @@ const SUPPORTED_CODE_EXTS = new Set([
 ]);
 
 /**
- * Detect source directories for the given project root by reading manifest
- * files and scanning top-level directories for code files.
+ * Detect source directories for the given project root.
+ * Uses smart resolver (v6.5+) with fallback to legacy heuristics.
  *
  * @param {string} cwd - Project root
  * @param {string[]} excludeList - Folders to skip
  * @returns {string[]}
  */
 function detectAutoSrcDirs(cwd, excludeList) {
+  try {
+    const { resolveSourceRoots } = require('../discovery/source-root-resolver');
+    const result = resolveSourceRoots(cwd, { exclude: excludeList || [] });
+    if (result.roots.length > 0) {
+      if (result.confidence === 'low') {
+        process.stderr.write(
+          '[sigmap] low confidence root detection — run "sigmap roots --explain" to verify\n'
+        );
+      }
+      return result.roots;
+    }
+  } catch (_) {}
+
+  return _legacyDetectAutoSrcDirs(cwd, excludeList);
+}
+
+/**
+ * Legacy source directory detection (fallback).
+ *
+ * @param {string} cwd - Project root
+ * @param {string[]} excludeList - Folders to skip
+ * @returns {string[]}
+ */
+function _legacyDetectAutoSrcDirs(cwd, excludeList) {
   const excludeSet = new Set(excludeList || []);
   const candidates = new Set(DEFAULTS.srcDirs);
 

package/src/discovery/framework-detector.js

@@ -0,0 +1,88 @@
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+const { REGISTRY } = require('./source-root-registry');
+
+module.exports = { detectFrameworks };
+
+function detectFrameworks(cwd) {
+  const detected = [];
+
+  for (const [lang, reg] of Object.entries(REGISTRY)) {
+    if (!reg.frameworks) continue;
+    for (const [name, fw] of Object.entries(reg.frameworks)) {
+      let confidence = 0;
+
+      // Detection files: +0.95 / 0.93 / 0.90 depending on specificity
+      for (const f of (fw.detectionFiles || [])) {
+        if (_existsAnywhere(cwd, f, 3)) { confidence = Math.max(confidence, 0.93); }
+      }
+
+      // Detection deps in package.json
+      if (fw.detectionDeps?.length) {
+        const deps = _readDeps(cwd);
+        for (const dep of fw.detectionDeps) {
+          if (deps.has(dep)) { confidence = Math.max(confidence, 0.90); }
+        }
+      }
+
+      // go.mod and Cargo.toml deps
+      if (lang === 'go' && fw.detectionDeps?.length) {
+        const goMod = _readFile(path.join(cwd, 'go.mod'));
+        for (const dep of fw.detectionDeps) {
+          if (goMod.includes(dep)) { confidence = Math.max(confidence, 0.90); }
+        }
+      }
+      if (lang === 'rust' && fw.detectionDeps?.length) {
+        const cargoToml = _readFile(path.join(cwd, 'Cargo.toml'));
+        for (const dep of fw.detectionDeps) {
+          if (cargoToml.includes(dep)) { confidence = Math.max(confidence, 0.88); }
+        }
+      }
+
+      // Special rules
+      if (fw.specialRule === 'django-app-dirs' && fs.existsSync(path.join(cwd, 'manage.py'))) {
+        confidence = Math.max(confidence, 0.95);
+      }
+      if (fw.specialRule === 'swift-project-dir' && _existsAnywhere(cwd, '.xcodeproj', 2)) {
+        confidence = Math.max(confidence, 0.90);
+      }
+
+      if (confidence > 0) detected.push({ name, language: lang, confidence });
+    }
+  }
+
+  return detected.sort((a, b) => b.confidence - a.confidence);
+}
+
+function _readDeps(cwd) {
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(cwd, 'package.json'), 'utf8'));
+    return new Set([...Object.keys(pkg.dependencies || {}), ...Object.keys(pkg.devDependencies || {})]);
+  } catch { return new Set(); }
+}
+
+function _readFile(p) {
+  try { return fs.readFileSync(p, 'utf8'); } catch { return ''; }
+}
+
+function _existsAnywhere(cwd, filename, maxDepth) {
+  const parts = filename.split('/');
+  if (parts.length > 1) return fs.existsSync(path.join(cwd, filename));
+  return _walkFind(cwd, filename, maxDepth);
+}
+
+function _walkFind(dir, name, depth) {
+  if (depth <= 0) return false;
+  try {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const e of entries) {
+      if (e.name === name) return true;
+      if (e.isDirectory() && depth > 1) {
+        if (_walkFind(path.join(dir, e.name), name, depth - 1)) return true;
+      }
+    }
+  } catch (_) {}
+  return false;
+}

package/src/discovery/language-detector.js

@@ -0,0 +1,74 @@
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+const { REGISTRY } = require('./source-root-registry');
+
+module.exports = { detectLanguages };
+
+const SKIP_DIRS = new Set([
+  'node_modules','dist','build','.git','venv','.venv','target',
+  'DerivedData','Pods','.build','Carthage','coverage','.next','.nuxt',
+  '__pycache__','.pytest_cache','vendor','.bundle','Carthage',
+]);
+
+const EXT_TO_LANG = {
+  '.js': 'javascript', '.mjs': 'javascript', '.cjs': 'javascript',
+  '.ts': 'typescript', '.tsx': 'typescript', '.jsx': 'javascript',
+  '.py': 'python', '.rb': 'ruby', '.go': 'go', '.rs': 'rust',
+  '.java': 'java', '.kt': 'kotlin', '.cs': 'csharp', '.cpp': 'cpp',
+  '.c': 'cpp', '.h': 'cpp', '.hpp': 'cpp', '.swift': 'swift',
+  '.dart': 'dart', '.scala': 'scala', '.php': 'php',
+};
+
+function detectLanguages(cwd) {
+  const weights = {};
+
+  // Signal 1: manifest files (+3 each)
+  for (const [lang, reg] of Object.entries(REGISTRY)) {
+    for (const mf of (reg.manifestFiles || [])) {
+      if (fs.existsSync(path.join(cwd, mf))) {
+        weights[lang] = (weights[lang] || 0) + 3;
+      }
+    }
+  }
+
+  // Signal 2: TypeScript dep in package.json (+2)
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(cwd, 'package.json'), 'utf8'));
+    const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+    if (allDeps.typescript) { weights.typescript = (weights.typescript || 0) + 2; }
+  } catch (_) {}
+
+  // Signal 3: file extension count (walk depth 3, capped at +5 per language)
+  const extCount = {};
+  _walkDepth(cwd, 3, extCount);
+  const maxCount = Math.max(1, ...Object.values(extCount));
+  for (const [ext, count] of Object.entries(extCount)) {
+    const lang = EXT_TO_LANG[ext];
+    if (lang) {
+      weights[lang] = (weights[lang] || 0) + Math.min(5, (count / maxCount) * 5);
+    }
+  }
+
+  // Normalize to [0,1] and sort
+  const maxW = Math.max(1, ...Object.values(weights));
+  return Object.entries(weights)
+    .map(([name, w]) => ({ name, weight: Math.round(w / maxW * 100) / 100 }))
+    .sort((a, b) => b.weight - a.weight);
+}
+
+function _walkDepth(dir, depth, extCount) {
+  if (depth <= 0) return;
+  let entries;
+  try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch (_) { return; }
+  for (const e of entries) {
+    if (SKIP_DIRS.has(e.name)) continue;
+    if (e.isDirectory()) {
+      _walkDepth(path.join(dir, e.name), depth - 1, extCount);
+    } else if (e.isFile()) {
+      const ext = path.extname(e.name).toLowerCase();
+      if (EXT_TO_LANG[ext]) extCount[ext] = (extCount[ext] || 0) + 1;
+    }
+  }
+}

package/src/discovery/sigmapignore.js

@@ -0,0 +1,29 @@
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+
+module.exports = { loadIgnorePatterns, matchesIgnorePattern };
+
+function loadIgnorePatterns(cwd) {
+  for (const fname of ['.sigmapignore', '.contextignore']) {
+    const p = path.join(cwd, fname);
+    if (fs.existsSync(p)) {
+      return fs.readFileSync(p, 'utf8')
+        .split('\n')
+        .map(l => l.trim())
+        .filter(l => l && !l.startsWith('#'));
+    }
+  }
+  return [];
+}
+
+function matchesIgnorePattern(dirName, patterns) {
+  for (const pat of patterns) {
+    const clean = pat.replace(/\/$/, '');
+    if (clean === dirName) return true;
+    if (clean.endsWith('/**') && dirName.startsWith(clean.slice(0, -3))) return true;
+    if (clean.endsWith('/*') && dirName.startsWith(clean.slice(0, -2))) return true;
+  }
+  return false;
+}

package/src/discovery/source-root-registry.js

@@ -0,0 +1,166 @@
+'use strict';
+
+const REGISTRY = {
+  javascript: {
+    manifestFiles: ['package.json'],
+    frameworks: {
+      nextjs:    { detectionFiles: ['next.config.js','next.config.ts','next.config.mjs'], detectionDeps: ['next'],               srcDirs: ['app','src/app','pages','src/pages','src','components','lib','hooks','utils'], entrypoints: ['app/page.tsx','pages/index.tsx'] },
+      nestjs:    { detectionFiles: ['nest-cli.json'],                                    detectionDeps: ['@nestjs/core'],        srcDirs: ['src'], entrypoints: ['src/main.ts','src/app.module.ts'] },
+      express:   { detectionFiles: [],                                                    detectionDeps: ['express'],             srcDirs: ['src','routes','middleware','controllers','services'], entrypoints: ['src/index.js','server.js','app.js'] },
+      fastify:   { detectionFiles: [],                                                    detectionDeps: ['fastify'],             srcDirs: ['src','routes','plugins'], entrypoints: ['src/index.js'] },
+      react:     { detectionFiles: [],                                                    detectionDeps: ['react'],               srcDirs: ['src','components','hooks','context','pages','app','lib','utils'] },
+      vue:       { detectionFiles: ['vue.config.js','vue.config.ts'],                    detectionDeps: ['vue'],                 srcDirs: ['src','components','composables','pages','views'] },
+      nuxt:      { detectionFiles: ['nuxt.config.js','nuxt.config.ts'],                  detectionDeps: ['nuxt'],                srcDirs: ['pages','components','composables','server','middleware','plugins'] },
+      svelte:    { detectionFiles: ['svelte.config.js'],                                 detectionDeps: ['svelte','@sveltejs/kit'], srcDirs: ['src','src/routes','src/lib'] },
+      angular:   { detectionFiles: ['angular.json'],                                     detectionDeps: ['@angular/core'],       srcDirs: ['src','src/app','projects','apps','libs'] },
+      gatsby:    { detectionFiles: ['gatsby-config.js','gatsby-config.ts'],              detectionDeps: ['gatsby'],              srcDirs: ['src','gatsby'] },
+      vite:      { detectionFiles: ['vite.config.js','vite.config.ts'],                  detectionDeps: ['vite'],                srcDirs: ['src'] },
+      remix:     { detectionFiles: ['remix.config.js'],                                  detectionDeps: ['@remix-run/react'],    srcDirs: ['app'] },
+      trpc:      { detectionFiles: [],                                                    detectionDeps: ['@trpc/server'],        srcDirs: ['src','server','routers'] },
+    },
+    srcDirs:  ['src','lib','index.js','server.js','app.js'],
+    penalties: ['dist','build','.next','.nuxt','coverage','storybook-static'],
+  },
+
+  typescript: {
+    manifestFiles: ['package.json','tsconfig.json'],
+    frameworks: {
+      nextjs:  { detectionFiles: ['next.config.ts','next.config.mjs'], detectionDeps: ['next'],            srcDirs: ['app','src/app','pages','src','components','lib','hooks','utils'] },
+      nestjs:  { detectionFiles: ['nest-cli.json'],                     detectionDeps: ['@nestjs/core'],   srcDirs: ['src'], entrypoints: ['src/main.ts'] },
+      angular: { detectionFiles: ['angular.json'],                      detectionDeps: ['@angular/core'],  srcDirs: ['src','src/app','projects','apps','libs'] },
+    },
+    srcDirs:  ['src','lib','packages'],
+    penalties: ['dist','build','.next'],
+  },
+
+  python: {
+    manifestFiles: ['requirements.txt','pyproject.toml','setup.py','Pipfile'],
+    frameworks: {
+      django:  { detectionFiles: ['manage.py'],           detectionDeps: ['Django'],  srcDirs: [],         specialRule: 'django-app-dirs', entrypoints: ['manage.py'] },
+      fastapi: { detectionFiles: [],                       detectionDeps: ['fastapi'], srcDirs: ['app','src','routers','api'], entrypoints: ['main.py','app/main.py'] },
+      flask:   { detectionFiles: ['wsgi.py','app.py'],    detectionDeps: ['Flask'],   srcDirs: ['app','src'], entrypoints: ['app.py','wsgi.py'] },
+      celery:  { detectionFiles: [],                       detectionDeps: ['celery'],  srcDirs: ['tasks','workers','app'] },
+    },
+    srcDirs:  ['.'],
+    penalties: ['venv','.venv','__pycache__','.pytest_cache','htmlcov'],
+  },
+
+  go: {
+    manifestFiles: ['go.mod'],
+    frameworks: {
+      gin:   { detectionFiles: [], detectionDeps: ['github.com/gin-gonic/gin'],      srcDirs: ['internal','cmd','pkg','api','handler','middleware'] },
+      echo:  { detectionFiles: [], detectionDeps: ['github.com/labstack/echo'],      srcDirs: ['internal','cmd','handler','middleware'] },
+      fiber: { detectionFiles: [], detectionDeps: ['github.com/gofiber/fiber'],      srcDirs: ['internal','cmd','handler','routes'] },
+      grpc:  { detectionFiles: [], detectionDeps: ['google.golang.org/grpc'],        srcDirs: ['internal','proto','server','client'] },
+      chi:   { detectionFiles: [], detectionDeps: ['github.com/go-chi/chi'],         srcDirs: ['internal','cmd','handler'] },
+    },
+    srcDirs:  ['internal','cmd','pkg','api'],
+    penalties: ['vendor'],
+  },
+
+  rust: {
+    manifestFiles: ['Cargo.toml'],
+    frameworks: {
+      actix: { detectionFiles: [], detectionDeps: ['actix-web'], srcDirs: ['src'] },
+      axum:  { detectionFiles: [], detectionDeps: ['axum'],      srcDirs: ['src'] },
+      tauri: { detectionFiles: ['src-tauri/tauri.conf.json'], detectionDeps: ['tauri'], srcDirs: ['src','src-tauri/src'] },
+    },
+    srcDirs:  ['src'],
+    penalties: ['target'],
+  },
+
+  java: {
+    manifestFiles: ['pom.xml','build.gradle'],
+    frameworks: {
+      spring:   { detectionFiles: [], detectionDeps: ['spring-boot'], srcDirs: ['src/main/java','src/main/kotlin','src/main/resources'] },
+      quarkus:  { detectionFiles: [], detectionDeps: ['io.quarkus'],  srcDirs: ['src/main/java'] },
+      android:  { detectionFiles: ['AndroidManifest.xml'],            srcDirs: ['app/src/main/java','app/src/main','src'] },
+      micronaut:{ detectionFiles: [], detectionDeps: ['io.micronaut'],srcDirs: ['src/main/java'] },
+    },
+    srcDirs:  ['src/main/java','src'],
+    penalties: ['target','build'],
+  },
+
+  kotlin: {
+    manifestFiles: ['build.gradle.kts'],
+    frameworks: {
+      spring:  { detectionFiles: [], detectionDeps: ['spring-boot'],    srcDirs: ['src/main/kotlin'] },
+      android: { detectionFiles: ['AndroidManifest.xml'],               srcDirs: ['app/src/main/kotlin','app/src/main/java'] },
+      ktor:    { detectionFiles: [], detectionDeps: ['io.ktor'],         srcDirs: ['src'] },
+      compose: { detectionFiles: [], detectionDeps: ['compose-runtime'], srcDirs: ['app/src/main/kotlin','src'] },
+    },
+    srcDirs:  ['src/main/kotlin','src'],
+    penalties: ['build','.gradle'],
+  },
+
+  csharp: {
+    manifestFiles: ['.csproj','.sln'],
+    frameworks: {
+      aspnet:  { detectionFiles: ['appsettings.json'], detectionDeps: ['Microsoft.AspNetCore'], srcDirs: ['Controllers','Services','Models','Middleware','Pages'] },
+      blazor:  { detectionFiles: [], detectionDeps: ['Microsoft.AspNetCore.Components'],        srcDirs: ['Components','Pages','Services'] },
+      unity:   { detectionFiles: ['ProjectSettings/ProjectSettings.asset'],                     srcDirs: ['Assets/Scripts','Assets'] },
+      maui:    { detectionFiles: [], detectionDeps: ['Microsoft.Maui'],                          srcDirs: ['src','Pages','ViewModels'] },
+    },
+    srcDirs:  ['src','Controllers','Services','Models'],
+    penalties: ['bin','obj','.vs'],
+  },
+
+  php: {
+    manifestFiles: ['composer.json'],
+    frameworks: {
+      laravel:   { detectionFiles: ['artisan'],           srcDirs: ['app','routes','config','database','resources','tests'], entrypoints: ['artisan'] },
+      symfony:   { detectionFiles: ['symfony.lock'],      srcDirs: ['src','config','templates'], specialRule: 'symfony-bundle-dirs' },
+      wordpress: { detectionFiles: ['wp-config.php'],     srcDirs: ['wp-content/themes','wp-content/plugins','wp-content/mu-plugins'] },
+      slim:      { detectionFiles: [],                    detectionDeps: ['slim/slim'], srcDirs: ['src','app','routes'] },
+    },
+    srcDirs:  ['src','app'],
+    penalties: ['vendor'],
+  },
+
+  ruby: {
+    manifestFiles: ['Gemfile'],
+    frameworks: {
+      rails:   { detectionFiles: ['config/routes.rb'],   srcDirs: ['app','lib','config','db','spec','test'], entrypoints: ['config/routes.rb'] },
+      sinatra: { detectionFiles: ['config.ru','app.rb'], srcDirs: ['.','lib'],            entrypoints: ['app.rb','config.ru'] },
+      hanami:  { detectionFiles: [],                     detectionDeps: ['hanami'],       srcDirs: ['apps','lib','slices'] },
+    },
+    srcDirs:  ['app','lib'],
+    penalties: ['vendor','coverage','.bundle'],
+  },
+
+  swift: {
+    manifestFiles: ['Package.swift'],
+    frameworks: {
+      vapor:   { detectionFiles: [],              detectionDeps: ['vapor/vapor'], srcDirs: ['Sources','App'] },
+      swiftui: { detectionFiles: ['.xcodeproj'],  srcDirs: [],                    specialRule: 'swift-project-dir' },
+      swiftpm: { detectionFiles: ['Package.swift'],srcDirs: ['Sources'] },
+    },
+    srcDirs:  ['Sources','Source'],
+    penalties: ['.build','DerivedData','Pods','Carthage'],
+  },
+
+  dart: {
+    manifestFiles: ['pubspec.yaml'],
+    frameworks: {
+      flutter:    { detectionFiles: [],                   detectionDeps: ['flutter'],    srcDirs: ['lib','lib/src'], entrypoints: ['lib/main.dart'] },
+      serverpod:  { detectionFiles: [],                   detectionDeps: ['serverpod'],  srcDirs: ['lib','endpoints','models'] },
+      'dart-frog':{ detectionFiles: ['dart_frog.yaml'],   srcDirs: ['routes','lib'] },
+    },
+    srcDirs:  ['lib','lib/src'],
+    penalties: ['.dart_tool','build'],
+  },
+
+  scala: {
+    manifestFiles: ['build.sbt'],
+    frameworks: {
+      akka:  { detectionFiles: [], detectionDeps: ['akka'], srcDirs: ['src/main/scala','src'] },
+      play:  { detectionFiles: [], detectionDeps: ['play'], srcDirs: ['app','conf'] },
+      spark: { detectionFiles: [], detectionDeps: ['spark'],srcDirs: ['src/main/scala'] },
+      zio:   { detectionFiles: [], detectionDeps: ['zio'],  srcDirs: ['src/main/scala'] },
+    },
+    srcDirs:  ['src/main/scala','src'],
+    penalties: ['target'],
+  },
+};
+
+module.exports = { REGISTRY };

package/src/discovery/source-root-resolver.js

@@ -0,0 +1,181 @@
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+const { REGISTRY }              = require('./source-root-registry');
+const { detectLanguages }       = require('./language-detector');
+const { detectFrameworks }      = require('./framework-detector');
+const { scoreCandidate, getRecentlyChangedDirs, ROOT_ENTRYPOINTS } = require('./source-root-scorer');
+const { loadIgnorePatterns, matchesIgnorePattern } = require('./sigmapignore');
+
+module.exports = { resolveSourceRoots };
+
+const MONOREPO_MARKERS = ['pnpm-workspace.yaml','turbo.json','nx.json','lerna.json'];
+const MAX_ROOTS = 6;
+
+function resolveSourceRoots(cwd, opts = {}) {
+  const ignorePatterns = loadIgnorePatterns(cwd);
+  const languages      = detectLanguages(cwd);
+  const frameworks     = detectFrameworks(cwd);
+  const recentDirs     = getRecentlyChangedDirs(cwd);
+  const isMonorepo     = _detectMonorepo(cwd);
+
+  const primaryLang   = languages[0]?.name;
+  const primaryFw     = frameworks[0];
+  const registry      = primaryLang ? REGISTRY[primaryLang] : null;
+
+  // Build framework-derived context
+  const fwEntry        = primaryFw && registry?.frameworks?.[primaryFw.name];
+  const frameworkSrcDirs   = new Set(fwEntry?.srcDirs || registry?.srcDirs || []);
+  const entrypoints        = fwEntry?.entrypoints || [];
+  const frameworkPenalties = registry?.penalties || [];
+
+  const context = { frameworks, languages, recentDirs, frameworkSrcDirs, entrypoints, frameworkPenalties };
+
+  // Enumerate candidates
+  const candidates = _enumerateCandidates(cwd, isMonorepo, ignorePatterns, opts.exclude || []);
+
+  // Score each candidate
+  const scored = candidates
+    .map(({ name, full }) => ({
+      dir:   name,
+      full,
+      score: scoreCandidate(name, full, context),
+    }))
+    .filter(c => c.score > 0)
+    .sort((a, b) => b.score - a.score);
+
+  // Handle special rules
+  let roots = _applySpecialRules(scored, cwd, primaryFw, fwEntry, frameworks);
+
+  // Dedupe nested paths (prefer parent)
+  roots = _dedupeNested(roots);
+
+  // Cap at MAX_ROOTS
+  roots = roots.slice(0, MAX_ROOTS).map(r => r.dir);
+
+  // Fallback: if nothing scored, return empty (caller falls back to legacy)
+  const confidence = _computeConfidence(frameworks, languages, scored.length);
+
+  return {
+    roots,
+    languages,
+    frameworks,
+    confidence,
+    explanation: scored.slice(0, 8).map(c => ({
+      dir:   c.dir,
+      score: c.score,
+      reason: `score: ${c.score}`,
+    })),
+    isMonorepo,
+  };
+}
+
+function _detectMonorepo(cwd) {
+  for (const m of MONOREPO_MARKERS) {
+    if (fs.existsSync(path.join(cwd, m))) return true;
+  }
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(cwd, 'package.json'), 'utf8'));
+    if (pkg.workspaces) return true;
+  } catch (_) {}
+  return false;
+}
+
+function _enumerateCandidates(cwd, isMonorepo, ignorePatterns, excludeList) {
+  const candidates = [];
+  const excSet     = new Set(excludeList);
+
+  // Root-level dirs
+  try {
+    for (const e of fs.readdirSync(cwd, { withFileTypes: true })) {
+      if (!e.isDirectory()) continue;
+      if (excSet.has(e.name)) continue;
+      if (matchesIgnorePattern(e.name, ignorePatterns)) continue;
+      candidates.push({ name: e.name, full: path.join(cwd, e.name) });
+    }
+  } catch (_) {}
+
+  // Monorepo sub-packages: packages/*/src, apps/*/src, services/*/src
+  if (isMonorepo) {
+    for (const top of ['packages','apps','services','modules']) {
+      const topFull = path.join(cwd, top);
+      if (!fs.existsSync(topFull)) continue;
+      try {
+        for (const pkg of fs.readdirSync(topFull, { withFileTypes: true })) {
+          if (!pkg.isDirectory()) continue;
+          const srcFull = path.join(topFull, pkg.name, 'src');
+          if (fs.existsSync(srcFull)) {
+            candidates.push({ name: `${top}/${pkg.name}/src`, full: srcFull });
+          }
+          // Also consider the package root itself
+          candidates.push({ name: `${top}/${pkg.name}`, full: path.join(topFull, pkg.name) });
+        }
+      } catch (_) {}
+    }
+  }
+
+  // Deep paths known by language/framework (e.g. src/main/java, src-tauri/src)
+  const DEEP_PATHS = [
+    'src/main/java','src/main/kotlin','src/main/scala',
+    'src-tauri/src','Sources/App','app/src/main/java','app/src/main/kotlin',
+  ];
+  for (const dp of DEEP_PATHS) {
+    const full = path.join(cwd, dp);
+    if (fs.existsSync(full)) candidates.push({ name: dp, full });
+  }
+
+  return candidates;
+}
+
+function _applySpecialRules(scored, cwd, primaryFw, fwEntry, frameworks) {
+  let roots = [...scored];
+
+  // Django: walk root dirs for any containing models.py or views.py
+  if (primaryFw?.name === 'django' || frameworks.some(f => f.name === 'django')) {
+    try {
+      for (const e of fs.readdirSync(cwd, { withFileTypes: true })) {
+        if (!e.isDirectory()) continue;
+        const d = path.join(cwd, e.name);
+        if (fs.existsSync(path.join(d, 'models.py')) || fs.existsSync(path.join(d, 'views.py'))) {
+          if (!roots.find(r => r.dir === e.name)) {
+            roots.push({ dir: e.name, full: d, score: 5.0 });
+          }
+        }
+      }
+    } catch (_) {}
+    roots.sort((a, b) => b.score - a.score);
+  }
+
+  // Swift project dir: dirs with ≥3 .swift files
+  if (frameworks.some(f => f.name === 'swiftui')) {
+    try {
+      for (const e of fs.readdirSync(cwd, { withFileTypes: true })) {
+        if (!e.isDirectory()) continue;
+        const d = path.join(cwd, e.name);
+        const swiftCount = (fs.readdirSync(d).filter(f => f.endsWith('.swift'))).length;
+        if (swiftCount >= 3 && !roots.find(r => r.dir === e.name)) {
+          roots.push({ dir: e.name, full: d, score: 4.0 });
+        }
+      }
+    } catch (_) {}
+    roots.sort((a, b) => b.score - a.score);
+  }
+
+  return roots;
+}
+
+function _dedupeNested(scored) {
+  const result = [];
+  for (const c of scored) {
+    const isNested = result.some(r => c.dir.startsWith(r.dir + '/'));
+    if (!isNested) result.push(c);
+  }
+  return result;
+}
+
+function _computeConfidence(frameworks, languages, scoredCount) {
+  if (frameworks.length > 0 && frameworks[0].confidence >= 0.90) return 'high';
+  if (languages.length > 0 && scoredCount > 0) return 'medium';
+  return 'low';
+}

package/src/discovery/source-root-scorer.js

@@ -0,0 +1,98 @@
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const CODE_EXTS = new Set([
+  '.js','.mjs','.cjs','.ts','.tsx','.jsx',
+  '.py','.rb','.go','.rs','.java','.kt',
+  '.cs','.cpp','.c','.h','.swift','.dart','.scala','.php',
+]);
+
+const AUTO_SKIP = new Set([
+  'node_modules','dist','build','.git','.next','.nuxt','vendor',
+  'DerivedData','Pods','target','coverage','__pycache__','.venv','venv',
+  '.build','Carthage','storybook-static','.gradle','bin','obj','.vs',
+]);
+
+const PENALTY_DIRS = new Set([
+  'test','tests','spec','__tests__','e2e','docs','doc','docs-vp',
+  'examples','example','fixtures','mocks','__mocks__','demo','samples','migrations',
+  'benchmarks','scripts',
+]);
+
+const ROOT_ENTRYPOINTS = {
+  go:         ['main.go'],
+  python:     ['app.py','main.py','wsgi.py','asgi.py'],
+  javascript: ['index.js','server.js','app.js'],
+  typescript: ['index.ts','main.ts'],
+  rust:       [],
+  php:        ['index.php'],
+};
+
+function getRecentlyChangedDirs(cwd) {
+  try {
+    const out = execSync('git log --name-only --format="" HEAD~10 2>/dev/null', { cwd, timeout: 3000 }).toString();
+    return new Set(out.split('\n').filter(Boolean).map(f => f.split('/')[0]));
+  } catch { return new Set(); }
+}
+
+function scoreCandidate(dirName, fullPath, context) {
+  const { frameworks, languages, recentDirs, frameworkSrcDirs, entrypoints, frameworkPenalties } = context;
+
+  // Auto-skip noise
+  if (AUTO_SKIP.has(dirName)) return -99;
+  if (!fs.existsSync(fullPath)) return -99;
+
+  let score = 0;
+
+  // Framework match: +3.0 if this dir is in the framework's srcDirs
+  if (frameworkSrcDirs.has(dirName)) score += 3.0;
+
+  // Count source files in dir (depth 2)
+  const sourceFileCount = _countSourceFiles(fullPath, 2);
+  const density = Math.min(1.0, sourceFileCount / 10);
+
+  // Language density: +2.5
+  score += density * 2.5;
+
+  // Symbol density: +2.0 if ≥3 source files
+  if (sourceFileCount >= 3) score += 2.0;
+
+  // Entrypoint: +1.5 if a known entrypoint lives in this dir
+  if ((entrypoints || []).some(ep => ep.startsWith(dirName + '/'))) score += 1.5;
+
+  // Manifest proximity: +1.0 if a manifest file is in this dir
+  if (fs.existsSync(path.join(fullPath, 'package.json')) ||
+      fs.existsSync(path.join(fullPath, 'go.mod')) ||
+      fs.existsSync(path.join(fullPath, 'Cargo.toml')) ||
+      fs.existsSync(path.join(fullPath, 'pom.xml'))) {
+    score += 1.0;
+  }
+
+  // Git activity bonus: +2.0 if recently committed files exist here
+  if (recentDirs.has(dirName)) score += 2.0;
+
+  // Noise penalty: -3.0 (unless directory is in framework's srcDirs)
+  if (PENALTY_DIRS.has(dirName.toLowerCase()) && !frameworkSrcDirs.has(dirName)) score -= 3.0;
+
+  // Framework penalty dirs
+  if ((frameworkPenalties || []).includes(dirName)) score -= 3.0;
+
+  return Math.round(score * 100) / 100;
+}
+
+function _countSourceFiles(dir, depth) {
+  if (depth <= 0) return 0;
+  let count = 0;
+  try {
+    for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
+      if (e.isFile() && CODE_EXTS.has(path.extname(e.name).toLowerCase())) count++;
+      else if (e.isDirectory() && depth > 1) count += _countSourceFiles(path.join(dir, e.name), depth - 1);
+    }
+  } catch (_) {}
+  return count;
+}
+
+module.exports = { scoreCandidate, getRecentlyChangedDirs, ROOT_ENTRYPOINTS };

package/src/mcp/server.js

@@ -18,7 +18,7 @@ const { readContext, searchSignatures, getMap, createCheckpoint, getRouting, exp
 
 const SERVER_INFO = {
   name: 'sigmap',
-  version: '6.4.0',
+  version: '6.5.0',
   description: 'SigMap MCP server — code signatures on demand',
 };