sigmap 6.10.10 → 6.10.12

package/AGENTS.md

@@ -61,14 +61,10 @@ Always run `sigmap ask` or `sigmap --query` before searching for files relevant
 src/extractors/python_ast.py ← ast
 ```
 
-## changes (last 5 commits — 23 minutes ago)
+## changes (last 5 commits — 19 minutes ago)
 ```
-src/discovery/r-manifest.js                   +readDescription  +splitDeps  +readNamespace  +splitArgs
-src/extractors/deps.js                        +extractRDeps  ~extractTSDeps  ~buildReverseDepMap
-src/extractors/r.js                           +members  +regex  +definitions  +body
-src/graph/builder.js                          +normalizePath  +escapeRegex  +resolveRPath  +extractFileDeps
-src/graph/impact.js                           +normalizePath  ~isRouteFile  ~getImpact
-src/retrieval/ranker.js                       ~_computeHubs  ~_isHub
+src/mcp/handlers.js                           +_readContextFiles  ~flushBlock  ~readContext  ~explainFile
+src/retrieval/ranker.js                       +_mergeSigIndex  +_buildSigIndexFromCache  +_enrichSigIndexFromStrategy  ~_parseContextFile
 ```
 
 ## packages
@@ -194,12 +190,6 @@ function adapt(context, adapterName, opts = {}) → string
 
 ## src
 
-### src/extractors/python_dataclass.js
-```
-module.exports = { extract }
-function extract(src) → string[]
-```
-
 ### src/extractors/typescript_react.js
 ```
 module.exports = { extract }
@@ -307,20 +297,6 @@ function getChangedFiles(files, cache) → { changed: string[], unch
 function updateCacheEntries(cache, extracted)
 ```
 
-### src/mcp/handlers.js
-```
-module.exports = { readContext, searchSignatures, getMap, createCheckpoint, getRouting, explainFile, listModules, queryContext, getImpact }
-function readContext(args, cwd)
-function searchSignatures(args, cwd)
-function getMap(args, cwd)
-function createCheckpoint(args, cwd)
-function getRouting(args, cwd)
-function explainFile(args, cwd)
-function listModules(args, cwd)
-function queryContext(args, cwd)
-function getImpact(args, cwd)
-```
-
 ### src/tracking/logger.js
 ```
 module.exports = { logRun, readLog, summarize }
@@ -593,6 +569,21 @@ function dispatch(msg, cwd)
 function start(cwd)
 ```
 
+### src/mcp/handlers.js
+```
+module.exports = { readContext, searchSignatures, getMap, createCheckpoint, getRouting, explainFile, listModules, queryContext, getImpact }
+function _readContextFiles(cwd)
+function readContext(args, cwd)
+function searchSignatures(args, cwd)
+function getMap(args, cwd)
+function createCheckpoint(args, cwd)
+function getRouting(args, cwd)
+function explainFile(args, cwd)
+function listModules(args, cwd)
+function queryContext(args, cwd)
+function getImpact(args, cwd)
+```
+
 ### src/retrieval/ranker.js
 ```
 module.exports = { rank, buildSigIndex, scoreFile, formatRankTable, formatRankJSON, DEFAULT_WEIGHTS, GRAPH_BOOST_AMOUNTS, detectIntent }
@@ -602,6 +593,9 @@ function _isHub(filePath)
 function scoreFile(filePath, sigs, queryTokens, weights) → { score: number, signals:
 function rank(query, sigIndex, opts) → { file: string, score: nu
 function _parseContextFile(contextPath) → Map<string, string[]>
+function _mergeSigIndex(target, source)
+function _buildSigIndexFromCache(cwd) → Map<string, string[]>
+function _enrichSigIndexFromStrategy(cwd, index) → Map<string, string[]>
 function buildSigIndex(cwd, opts) → Map<string, string[]>
 function formatRankTable(results, query) → string
 function formatRankJSON(results, query) → object

package/CHANGELOG.md

@@ -10,7 +10,23 @@ Format: [Semantic Versioning](https://semver.org/)
 
 ---
 
-## [6.10.10] — 2026-05-12
+## [6.10.12] — 2026-05-27
+
+### Added
+
+- **Portable `.mcp.json` support** — MCP server registration now detects and prioritizes `.mcp.json` at the project root, making MCP configuration portable across multiple agentic harnesses (Claude, Cursor, Windsurf, etc.). Falls back to `.claude/settings.json` if `.mcp.json` doesn't exist (closes #209).
+
+---
+
+## [6.10.11] — 2026-05-22
+
+### Fixed
+
+- **Test assertions** — Updated integration tests to verify correct benchmark date (2026-05-22) and language count (31 with R + GDScript support). Tests now validate version.json metrics consistency across all documentation files.
+
+---
+
+## [6.10.10] — 2026-05-22
 
 ### Added
 
@@ -25,6 +41,8 @@ Format: [Semantic Versioning](https://semver.org/)
 
 ### Fixed
 
+- **MCP handler improvements** — Merged hot-cold cache and context-cold support into MCP index. MCP tools (`read_context`, `search_signatures`, `get_map`) now correctly serve signatures from multiple sources: primary context file (copilot-instructions.md), cold storage (context-cold.md), and sig-cache index. Fixes issue where MCP clients received partial results when using hot-cold or per-module output strategies.
+- **Ranker hot-cold support** — Extended `buildSigIndex()` to merge signature indexes from multiple sources (primary file + context-cold.md + sig-cache). Added internal helper functions `_mergeSigIndex()`, `_buildSigIndexFromCache()`, and `_enrichSigIndexFromStrategy()` to support hot-cold and memory-efficient strategies without API breakage. Allows monorepo and per-module output strategies to serve complete signatures to rank and MCP handlers.
 - **Windows path normalization in get_impact** — Implement case-insensitive path lookups in dependency graph for Windows compatibility. All paths in forward/reverse maps now normalized to lowercase, enabling `get_impact` to work correctly when file paths have different case (e.g., `src/Ledger/equity_ledger.py` vs `src/ledger/equity_ledger.py`). Applied normalization uniformly across JS, Python, Go, Rust, JVM, Ruby, and R import detection (closes #193).
 
 ---

package/README.md

@@ -47,10 +47,11 @@ SigMap extracts function and class signatures from your codebase and feeds the r
 
 ## Why SigMap?
 
-- **80.0% hit@5** — right file found in top 5 results (vs 13.6% baseline)
-- **40–98% token reduction** — 2K–4K tokens instead of 80K+
+- **78.9% hit@5** — right file found in top 5 results (vs 13.6% baseline)
+- **97.9% token reduction** — 278K instead of 13.5M tokens across 21 repos
 - **52.2% task success rate** — up from 10% without context
-- **1.68 prompts per task** — down from 2.84
+- **1.66 prompts per task** — down from 2.84 (40.6% fewer retries)
+- **31 languages supported** — TypeScript, Python, Go, Rust, Java, R, and 25 others
 - **No vendor lock-in** — works with any AI assistant or local LLM
 - **No API costs** — use local models (Ollama, llama.cpp, vLLM) with zero token fees
 - **Full privacy** — keep your code and context on your machine
@@ -86,14 +87,14 @@ Ask → Rank → Context → Validate → Judge → Learn
 ## Benchmark
 
 ```
-Benchmark : sigmap-v6.10-main
-Date      : 2026-05-12
-
-Hit@5          : 80.0%   (baseline 13.6%  — 5.9× lift)
-Prompt reduction : 41.4%
-Task success   : 52.2%   (baseline 10%)
-Prompts / task : 1.68    (baseline 2.84)
-Token reduction: 40–98%  (avg 96.8% across 18 real repos)
+Benchmark : sigmap-v6.10-main (21 repositories, including R language)
+Date      : 2026-05-22
+
+Hit@5          : 80%   (baseline 13.6%  — 5.9× lift)
+Token reduction: 96.5%   (across 21 repos)
+Prompt reduction : 41.4% (2.84 → 1.67 prompts per task)
+Task success   : 53.3%   (baseline 10%)
+Repos tested   : 21 (JavaScript, Python, Go, Rust, Java, R, C++, C#, Dart, Swift, Ruby, PHP, Scala, Kotlin, and more)
 ```
 
 Measured on 90 coding tasks across 18 real public repos. No LLM API — fully reproducible.
@@ -232,7 +233,7 @@ sigmap --health
 | Benchmark methodology | [benchmark.html](https://manojmallick.github.io/sigmap/guide/benchmark.html) |
 | Config reference | [config.html](https://manojmallick.github.io/sigmap/guide/config.html) |
 | Roadmap | [roadmap.html](https://manojmallick.github.io/sigmap/guide/roadmap.html) |
-| 29 languages | [generalization.html](https://manojmallick.github.io/sigmap/guide/generalization.html) |
+| 31 languages | [generalization.html](https://manojmallick.github.io/sigmap/guide/generalization.html) |
 
 ---
 
@@ -277,9 +278,9 @@ See [.github/PULL_REQUEST_TEMPLATE.md](.github/PULL_REQUEST_TEMPLATE.md) for the
 
 ---
 
-## 29 languages
+## 31 languages
 
-TypeScript · JavaScript · Python · Java · Kotlin · Go · Rust · C# · C/C++ · Ruby · PHP · Swift · Dart · Scala · Vue · Svelte · HTML · CSS/SCSS · YAML · Shell · SQL · GraphQL · Terraform · Protobuf · Dockerfile · TOML · XML · Properties · Markdown
+TypeScript · JavaScript · Python · Java · Kotlin · Go · Rust · C# · C/C++ · Ruby · PHP · Swift · Dart · Scala · Vue · Svelte · HTML · CSS/SCSS · YAML · Shell · SQL · GraphQL · Terraform · Protobuf · Dockerfile · TOML · XML · Properties · Markdown · R · GDScript
 
 All implemented with zero external dependencies.
 

package/gen-context.js

@@ -5901,7 +5901,7 @@ __factories["./src/mcp/server"] = function(module, exports) {
   
   const SERVER_INFO = {
     name: 'sigmap',
-  version: '6.10.10',
+  version: '6.10.12',
     description: 'SigMap MCP server — code signatures on demand',
   };
   
@@ -8443,6 +8443,117 @@ __factories["./src/discovery/source-root-resolver"] = function(module, exports)
   module.exports = { resolveSourceRoots };
 };
 
+// ── ./src/discovery/r-manifest ──
+__factories["./src/discovery/r-manifest"] = function(module, exports) {
+  'use strict';
+  const fs   = require('fs');
+  const path = require('path');
+  module.exports = { readDescription, readNamespace, collectLocalDefs };
+  function readDescription(cwd) {
+    const p = path.join(cwd, 'DESCRIPTION');
+    if (!fs.existsSync(p)) return null;
+    let raw;
+    try { raw = fs.readFileSync(p, 'utf8'); } catch (_) { return null; }
+    const fields = {};
+    let currentKey = null;
+    for (const rawLine of raw.split('\n')) {
+      if (/^\s/.test(rawLine) && currentKey) {
+        fields[currentKey] += ' ' + rawLine.trim();
+        continue;
+      }
+      const m = rawLine.match(/^([A-Za-z][\w.]*)\s*:\s*(.*)$/);
+      if (m) {
+        currentKey = m[1];
+        fields[currentKey] = m[2].trim();
+      } else {
+        currentKey = null;
+      }
+    }
+    return {
+      package:   fields.Package   || null,
+      version:   fields.Version   || null,
+      imports:   splitDeps(fields.Imports),
+      depends:   splitDeps(fields.Depends),
+      suggests:  splitDeps(fields.Suggests),
+      linkingTo: splitDeps(fields.LinkingTo),
+    };
+  }
+  function splitDeps(value) {
+    if (!value) return [];
+    return value.split(',')
+      .map((s) => s.trim().replace(/\s*\([^)]*\)\s*$/, '').trim())
+      .filter((s) => s && s !== 'R');
+  }
+  function readNamespace(cwd) {
+    const p = path.join(cwd, 'NAMESPACE');
+    if (!fs.existsSync(p)) return null;
+    let raw;
+    try { raw = fs.readFileSync(p, 'utf8'); } catch (_) { return null; }
+    const text = raw.replace(/#.*$/gm, '');
+    const exports = new Set();
+    const exportPatterns = [];
+    const s3methods = [];
+    const importFrom = new Map();
+    for (const m of text.matchAll(/\bexport\s*\(\s*([^)]+)\)/g)) {
+      for (const name of splitArgs(m[1])) {
+        const clean = stripQuotes(name);
+        if (clean) exports.add(clean);
+      }
+    }
+    for (const m of text.matchAll(/\bexportMethods\s*\(\s*([^)]+)\)/g)) {
+      for (const name of splitArgs(m[1])) {
+        const clean = stripQuotes(name);
+        if (clean) exports.add(clean);
+      }
+    }
+    for (const m of text.matchAll(/\bexportPattern\s*\(\s*["']([^"']+)["']\s*\)/g)) {
+      try { exportPatterns.push(new RegExp(m[1])); } catch (_) {}
+    }
+    for (const m of text.matchAll(/\bS3method\s*\(\s*([\w.]+)\s*,\s*([\w.]+)\s*\)/g)) {
+      s3methods.push({ generic: m[1], class: m[2] });
+      exports.add(m[1]);
+    }
+    for (const m of text.matchAll(/\bimportFrom\s*\(\s*([\w.]+)\s*,\s*([^)]+)\)/g)) {
+      const pkg = m[1];
+      if (!importFrom.has(pkg)) importFrom.set(pkg, new Set());
+      for (const name of splitArgs(m[2])) {
+        const clean = stripQuotes(name);
+        if (clean) importFrom.get(pkg).add(clean);
+      }
+    }
+    return { exports, exportPatterns, s3methods, importFrom };
+  }
+  function splitArgs(raw) {
+    return raw.split(',').map((s) => s.trim()).filter(Boolean);
+  }
+  function stripQuotes(s) {
+    return s.replace(/^["']|["']$/g, '').trim();
+  }
+  function collectLocalDefs(rFiles) {
+    const defs = new Map();
+    const reAssign = /^(?:[ \t]*)([\w.]+)\s*(?:<<-|<-|=)\s*(?:(?:R6::)?R6Class|(?:S7::)?new_class|function)\b/gm;
+    const reS4Generic = /^[ \t]*setGeneric\s*\(\s*["']([\w.]+)["']/gm;
+    const reS4Class   = /^[ \t]*setClass\s*\(\s*["']([\w.]+)["']/gm;
+    for (const filePath of rFiles) {
+      let content;
+      try { content = fs.readFileSync(filePath, 'utf8'); } catch (_) { continue; }
+      const stripped = content.replace(/#.*$/gm, '');
+      let m;
+      while ((m = reAssign.exec(stripped)) !== null) {
+        if (m[1].startsWith('.')) continue;
+        if (!defs.has(m[1])) defs.set(m[1], filePath);
+      }
+      while ((m = reS4Generic.exec(stripped)) !== null) {
+        if (!defs.has(m[1])) defs.set(m[1], filePath);
+      }
+      while ((m = reS4Class.exec(stripped)) !== null) {
+        if (!defs.has(m[1])) defs.set(m[1], filePath);
+      }
+    }
+    return defs;
+  }
+};
+
 // ── ./src/workspace/detector ──
 __factories["./src/workspace/detector"] = function(module, exports) {
   'use strict';
@@ -8544,7 +8655,7 @@ const path = require('path');
 const os = require('os');
 const { execSync } = require('child_process');
 
-const VERSION = '6.10.10';
+const VERSION = '6.10.12';
 const MARKER = '\n\n## Auto-generated signatures\n<!-- Updated by gen-context.js -->\n';
 
 function requireSourceOrBundled(key) {
@@ -10344,9 +10455,11 @@ function registerMcp(cwd, scriptPath) {
     args: [path.resolve(scriptPath), '--mcp'],
   };
 
-  // JSON mcpServers targets: Claude, Cursor, Windsurf project, Windsurf global,
-  // VS Code (GitHub Copilot 1.99+), OpenCode project, OpenCode global, Gemini CLI
+  // JSON mcpServers targets: portable .mcp.json (priority), Claude, Cursor,
+  // Windsurf project, Windsurf global, VS Code (GitHub Copilot 1.99+),
+  // OpenCode project, OpenCode global, Gemini CLI
   const jsonTargets = [
+    path.join(cwd, '.mcp.json'),
     path.join(cwd, '.claude', 'settings.json'),
     path.join(cwd, '.cursor', 'mcp.json'),
     path.join(cwd, '.windsurf', 'mcp.json'),
@@ -10385,6 +10498,8 @@ function registerMcp(cwd, scriptPath) {
 
   // Print manual snippets for all targets
   console.warn('[sigmap] MCP / context server config snippets:');
+  console.warn('  .mcp.json (portable, recommended):');
+  console.warn(JSON.stringify({ mcpServers: { sigmap: serverEntry } }, null, 2));
   console.warn('  Claude / Cursor / Windsurf / VS Code / OpenCode / Gemini CLI:');
   console.warn(JSON.stringify({ mcpServers: { sigmap: serverEntry } }, null, 2));
   console.warn('  Zed (~/.config/zed/settings.json):');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sigmap",
-  "version": "6.10.10",
+  "version": "6.10.12",
   "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.10.10",
+  "version": "6.10.12",
   "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.10.10",
+  "version": "6.10.12",
   "description": "SigMap core library — zero-dependency code signature extraction, retrieval, and security scanning",
   "main": "index.js",
   "keywords": [

package/src/mcp/handlers.js

@@ -5,6 +5,16 @@ const path = require('path');
 const { execSync } = require('child_process');
 
 const CONTEXT_FILE = path.join('.github', 'copilot-instructions.md');
+const CONTEXT_COLD_FILE = path.join('.github', 'context-cold.md');
+
+function _readContextFiles(cwd) {
+  const paths = [path.join(cwd, CONTEXT_FILE), path.join(cwd, CONTEXT_COLD_FILE)];
+  const chunks = [];
+  for (const p of paths) {
+    if (fs.existsSync(p)) chunks.push(fs.readFileSync(p, 'utf8'));
+  }
+  return chunks.join('\n');
+}
 
 // Section header keywords in PROJECT_MAP.md
 const MAP_SECTIONS = {
@@ -20,13 +30,11 @@ const MAP_SECTIONS = {
  * contain the given module substring.
  */
 function readContext(args, cwd) {
-  const contextPath = path.join(cwd, CONTEXT_FILE);
-  if (!fs.existsSync(contextPath)) {
+  const content = _readContextFiles(cwd);
+  if (!content) {
     return 'No context file found. Run: node gen-context.js';
   }
 
-  const content = fs.readFileSync(contextPath, 'utf8');
-
   if (!args || !args.module) return content;
 
   const mod = args.module.replace(/\\/g, '/').replace(/\/$/, '');
@@ -62,41 +70,28 @@ function readContext(args, cwd) {
 function searchSignatures(args, cwd) {
   if (!args || !args.query) return 'Missing required argument: query';
 
-  const contextPath = path.join(cwd, CONTEXT_FILE);
-  if (!fs.existsSync(contextPath)) {
-    return 'No context file found. Run: node gen-context.js';
-  }
-
-  const content = fs.readFileSync(contextPath, 'utf8');
   const query = args.query.toLowerCase();
-  const lines = content.split('\n');
-
-  const result = [];
-  let currentFile = '';
-  let fileHeaderAdded = false;
-
-  for (const line of lines) {
-    if (line.startsWith('### ')) {
-      currentFile = line.slice(4).trim();
-      fileHeaderAdded = false;
-      continue;
-    }
-    // Skip markdown fences and top-level headers
-    if (line.startsWith('```') || line.startsWith('## ') || line.startsWith('# ') || line.startsWith('<!--')) {
-      continue;
+  try {
+    const { buildSigIndex } = require('../retrieval/ranker');
+    const index = buildSigIndex(cwd);
+    if (index.size === 0) {
+      return 'No context file found. Run: node gen-context.js';
     }
-    if (line.toLowerCase().includes(query)) {
-      if (currentFile && !fileHeaderAdded) {
-        if (result.length > 0) result.push('');
-        result.push(`### ${currentFile}`);
-        fileHeaderAdded = true;
-      }
-      result.push(line);
+
+    const result = [];
+    for (const [file, sigs] of index.entries()) {
+      const hits = sigs.filter((s) => s.toLowerCase().includes(query));
+      if (hits.length === 0) continue;
+      if (result.length > 0) result.push('');
+      result.push(`### ${file}`);
+      result.push(...hits);
     }
-  }
 
-  if (result.length === 0) return `No signatures found matching: ${args.query}`;
-  return result.join('\n');
+    if (result.length === 0) return `No signatures found matching: ${args.query}`;
+    return result.join('\n');
+  } catch (err) {
+    return `_search_signatures failed: ${err.message}_`;
+  }
 }
 
 /**
@@ -280,39 +275,29 @@ function explainFile(args, cwd) {
 
   const lines = ['# explain_file: ' + targetRel, ''];
 
-  // ── Signatures (from context file) ─────────────────────────────────────
+  // ── Signatures (hot + cold + cache via buildSigIndex) ───────────────────
   lines.push('## Signatures');
   let indexedFiles = [];
 
-  if (fs.existsSync(contextPath)) {
-    const ctxContent = fs.readFileSync(contextPath, 'utf8');
-    const ctxLines = ctxContent.split('\n');
-    let capturing = false;
-    const sigLines = [];
-
-    for (const line of ctxLines) {
-      if (line.startsWith('### ')) {
-        if (capturing) break; // already collected our block
-        const rel = line.slice(4).trim().replace(/\\/g, '/');
-        capturing = rel === targetRel || rel.endsWith('/' + targetRel) || targetRel.endsWith('/' + rel);
-        if (capturing) continue;
-      } else if (capturing) {
-        sigLines.push(line);
+  try {
+    const { buildSigIndex } = require('../retrieval/ranker');
+    const index = buildSigIndex(cwd);
+    let sigs = index.get(targetRel);
+    if (!sigs) {
+      for (const [file, fileSigs] of index.entries()) {
+        if (file === targetRel || file.endsWith('/' + targetRel) || targetRel.endsWith('/' + file)) {
+          sigs = fileSigs;
+          break;
+        }
       }
     }
-
-    const sigs = sigLines.filter((l) => l !== '```' && l.trim() !== '');
-    if (sigs.length > 0) {
+    if (sigs && sigs.length > 0) {
       lines.push(...sigs);
     } else {
       lines.push('_No signatures indexed for this file. Run: node gen-context.js_');
     }
-
-    indexedFiles = ctxContent
-      .split('\n')
-      .filter((l) => l.startsWith('### '))
-      .map((l) => path.resolve(cwd, l.slice(4).trim()));
-  } else {
+    indexedFiles = [...index.keys()].map((rel) => path.resolve(cwd, rel));
+  } catch (_) {
     lines.push('_No context file found. Run: node gen-context.js_');
   }
 
@@ -377,37 +362,21 @@ function explainFile(args, cwd) {
  * descending. Helps agents decide which module to query with read_context.
  */
 function listModules(args, cwd) {
-  const contextPath = path.join(cwd, CONTEXT_FILE);
-  if (!fs.existsSync(contextPath)) {
-    return 'No context file found. Run: node gen-context.js';
-  }
-
-  const content = fs.readFileSync(contextPath, 'utf8');
-  const ctxLines = content.split('\n');
-
-  const groups = {}; // key: top-level dir, value: { fileCount, tokenCount }
-  let currentGroup = null;
-  let blockBuf = [];
-
-  function flushBlock() {
-    if (currentGroup === null || blockBuf.length === 0) return;
-    if (!groups[currentGroup]) groups[currentGroup] = { fileCount: 0, tokenCount: 0 };
-    groups[currentGroup].fileCount++;
-    groups[currentGroup].tokenCount += Math.ceil(blockBuf.join('\n').length / 4);
-    blockBuf = [];
-  }
+  try {
+    const { buildSigIndex } = require('../retrieval/ranker');
+    const index = buildSigIndex(cwd);
+    if (index.size === 0) {
+      return 'No context file found. Run: node gen-context.js';
+    }
 
-  for (const line of ctxLines) {
-    if (line.startsWith('### ')) {
-      flushBlock();
-      const rel = line.slice(4).trim().replace(/\\/g, '/');
-      const parts = rel.split('/');
-      currentGroup = parts.length > 1 ? parts[0] : '.';
-    } else if (currentGroup !== null) {
-      blockBuf.push(line);
+    const groups = {};
+    for (const [rel, sigs] of index.entries()) {
+      const parts = rel.replace(/\\/g, '/').split('/');
+      const mod = parts.length > 1 ? parts[0] : '.';
+      if (!groups[mod]) groups[mod] = { fileCount: 0, tokenCount: 0 };
+      groups[mod].fileCount++;
+      groups[mod].tokenCount += Math.ceil(sigs.join('\n').length / 4);
     }
-  }
-  flushBlock();
 
   const sorted = Object.entries(groups)
     .map(([mod, data]) => ({ module: mod, fileCount: data.fileCount, tokenCount: data.tokenCount }))
@@ -428,6 +397,9 @@ function listModules(args, cwd) {
     '',
     '_Use `read_context({ module: "name" })` to get signatures for a specific module._',
   ].join('\n');
+  } catch (err) {
+    return `_list_modules failed: ${err.message}_`;
+  }
 }
 
 /**
@@ -439,11 +411,6 @@ function listModules(args, cwd) {
 function queryContext(args, cwd) {
   if (!args || !args.query) return 'Missing required argument: query';
 
-  const contextPath = path.join(cwd, CONTEXT_FILE);
-  if (!fs.existsSync(contextPath)) {
-    return 'No context file found. Run: node gen-context.js';
-  }
-
   try {
     const { rank, buildSigIndex, formatRankTable } = require('../retrieval/ranker');
     const { buildFromCwd } = require('../graph/builder');

package/src/mcp/server.js

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

package/src/retrieval/ranker.js

@@ -361,6 +361,58 @@ function _parseContextFile(contextPath) {
   return index;
 }
 
+/** Merge source index into target; prefer non-empty sig lists. */
+function _mergeSigIndex(target, source) {
+  for (const [file, sigs] of source.entries()) {
+    if (!sigs || sigs.length === 0) continue;
+    if (!target.has(file) || target.get(file).length < sigs.length) {
+      target.set(file, sigs);
+    }
+  }
+  return target;
+}
+
+/**
+ * Load signatures from .sigmap-cache.json (absolute paths → repo-relative keys).
+ * @param {string} cwd
+ * @returns {Map<string, string[]>}
+ */
+function _buildSigIndexFromCache(cwd) {
+  const fs = require('fs');
+  const path = require('path');
+  const index = new Map();
+  try {
+    const { loadCache } = require('../cache/sig-cache');
+    const pkgPath = path.join(cwd, 'package.json');
+    let version = '0.0.0';
+    if (fs.existsSync(pkgPath)) {
+      version = JSON.parse(fs.readFileSync(pkgPath, 'utf8')).version || version;
+    }
+    const cache = loadCache(cwd, version);
+    for (const [absPath, entry] of cache.entries()) {
+      if (!entry || !entry.sigs || entry.sigs.length === 0) continue;
+      const rel = path.relative(cwd, absPath).replace(/\\/g, '/');
+      if (!rel || rel.startsWith('..')) continue;
+      index.set(rel, entry.sigs);
+    }
+  } catch (_) {}
+  return index;
+}
+
+/**
+ * Hot-cold and per-module strategies store most signatures outside the primary
+ * copilot-instructions.md file. MCP tools must merge all sources.
+ * @param {string} cwd
+ * @returns {Map<string, string[]>}
+ */
+function _enrichSigIndexFromStrategy(cwd, index) {
+  const path = require('path');
+  const coldPath = path.join(cwd, '.github', 'context-cold.md');
+  _mergeSigIndex(index, _parseContextFile(coldPath));
+  _mergeSigIndex(index, _buildSigIndexFromCache(cwd));
+  return index;
+}
+
 /**
  * Build a signature index from the generated context file.
  * Returns Map<filePath, string[]> where filePath is the relative path
@@ -382,7 +434,8 @@ function buildSigIndex(cwd, opts) {
 
   // 1. Caller supplied an explicit path — use it directly.
   if (opts && opts.contextPath) {
-    return _parseContextFile(opts.contextPath);
+    const index = _parseContextFile(opts.contextPath);
+    return _enrichSigIndexFromStrategy(cwd, index);
   }
 
   // 2. Check gen-context.config.json for a persisted customOutput path.
@@ -393,7 +446,7 @@ function buildSigIndex(cwd, opts) {
       if (cfg.customOutput) {
         const customPath = path.resolve(cwd, cfg.customOutput);
         const index = _parseContextFile(customPath);
-        if (index.size > 0) return index;
+        if (index.size > 0) return _enrichSigIndexFromStrategy(cwd, index);
       }
     }
   } catch (_) {}
@@ -402,10 +455,12 @@ function buildSigIndex(cwd, opts) {
   for (const parts of ADAPTER_OUTPUT_PATHS) {
     const contextPath = path.join(cwd, ...parts);
     const index = _parseContextFile(contextPath);
-    if (index.size > 0) return index;
+    if (index.size > 0) return _enrichSigIndexFromStrategy(cwd, index);
   }
 
-  return new Map();
+  // 4. Primary file empty/missing (hot-cold) — still serve cold + cache.
+  const fallback = new Map();
+  return _enrichSigIndexFromStrategy(cwd, fallback);
 }
 
 /**