sigmap 6.10.9 → 6.10.11

package/src/graph/builder.js

@@ -12,6 +12,12 @@
 const fs   = require('fs');
 const path = require('path');
 
+// Normalize paths for cross-platform consistency (Windows uses backslashes, Unix uses forward slashes)
+// Use lowercase to enable case-insensitive lookups on case-sensitive Windows filesystems
+function normalizePath(p) {
+  return path.normalize(p).toLowerCase();
+}
+
 // ---------------------------------------------------------------------------
 // Language-specific import extractors
 // ---------------------------------------------------------------------------
@@ -22,6 +28,7 @@ const GO_EXTS  = new Set(['.go']);
 const RS_EXTS  = new Set(['.rs']);
 const JVM_EXTS = new Set(['.java', '.kt', '.kts', '.scala', '.sc']);
 const RB_EXTS  = new Set(['.rb', '.rake']);
+const R_EXTS   = new Set(['.r', '.R']);
 
 /**
  * Resolve a JS/TS relative import string to an absolute path in fileSet.
@@ -40,7 +47,34 @@ function resolveJsPath(dir, importStr, fileSet) {
     path.join(base, 'index.js'),
   ];
   for (const c of candidates) {
-    if (fileSet.has(c)) return c;
+    const normC = normalizePath(c);
+    if (fileSet.has(normC)) return normC;
+  }
+  return null;
+}
+
+/**
+ * Resolve an R `source(...)` argument to an absolute path in fileSet.
+ * Tries the dir-relative path first, then a cwd-relative path so that
+ * `source("R/helpers.R")` resolves from the project root.
+ */
+function escapeRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function resolveRPath(dir, importStr, fileSet, cwd) {
+  const tried = new Set();
+  const bases = [path.resolve(dir, importStr)];
+  if (cwd) bases.push(path.resolve(cwd, importStr));
+  for (const base of bases) {
+    for (const c of [base, base + '.R', base + '.r']) {
+      const normC = normalizePath(c);
+      if (tried.has(normC)) continue;
+      tried.add(normC);
+      // Check both original and normalized paths (tests may pass non-normalized fileSet)
+      if (fileSet.has(c)) return c;
+      if (fileSet.has(normC)) return normC;
+    }
   }
   return null;
 }
@@ -50,9 +84,14 @@ function resolveJsPath(dir, importStr, fileSet) {
  * @param {string} filePath - absolute path to the file
  * @param {string} content  - file source content
  * @param {Set<string>} fileSet - set of all known absolute file paths
+ * @param {string}  [cwd]   - project root, used to resolve R `source("R/...")` calls
+ * @param {{ rPackage?: string, rLocalDefs?: Map<string,string> }} [ctx]
+ *        Optional cross-file context. When present and the file is R, a
+ *        `localPkg::fn` reference (where `localPkg` matches `rPackage`) is
+ *        resolved to the file in `rLocalDefs` that defines `fn`.
  * @returns {string[]} resolved absolute paths this file imports
  */
-function extractFileDeps(filePath, content, fileSet) {
+function extractFileDeps(filePath, content, fileSet, cwd, ctx) {
   const ext = path.extname(filePath).toLowerCase();
   const dir = path.dirname(filePath);
   const found = [];
@@ -91,7 +130,10 @@ function extractFileDeps(filePath, content, fileSet) {
       const candidate = modPart
         ? path.join(base, modPart + '.py')
         : null;
-      if (candidate && fileSet.has(candidate)) found.push(candidate);
+      if (candidate) {
+        const normC = normalizePath(candidate);
+        if (fileSet.has(normC)) found.push(normC);
+      }
     }
 
     // Absolute imports: from package.module import ... (infer from project structure)
@@ -105,8 +147,9 @@ function extractFileDeps(filePath, content, fileSet) {
         path.resolve(dir, '..', modulePath, '__init__.py'),
       ];
       for (const c of candidates) {
-        if (fileSet.has(c)) {
-          found.push(c);
+        const normC = normalizePath(c);
+        if (fileSet.has(normC)) {
+          found.push(normC);
           break;
         }
       }
@@ -129,9 +172,10 @@ function extractFileDeps(filePath, content, fileSet) {
     for (const imp of imports) {
       const suffix = imp.split('/').pop();
       for (const f of fileSet) {
-        if (f.endsWith(path.sep + suffix + '.go') ||
-            f.includes(path.sep + suffix + path.sep)) {
-          found.push(f);
+        const normF = normalizePath(f);
+        if (normF.endsWith(path.sep + suffix + '.go') ||
+            normF.includes(path.sep + suffix + path.sep)) {
+          found.push(normF);
           break;
         }
       }
@@ -145,10 +189,12 @@ function extractFileDeps(filePath, content, fileSet) {
     let m;
     while ((m = reMod.exec(content)) !== null) {
       const candidate = path.join(dir, m[1] + '.rs');
-      if (fileSet.has(candidate)) found.push(candidate);
+      const normC = normalizePath(candidate);
+      if (fileSet.has(normC)) found.push(normC);
       // Also try mod/mod.rs
       const candidate2 = path.join(dir, m[1], 'mod.rs');
-      if (fileSet.has(candidate2)) found.push(candidate2);
+      const normC2 = normalizePath(candidate2);
+      if (fileSet.has(normC2)) found.push(normC2);
     }
   }
 
@@ -162,7 +208,8 @@ function extractFileDeps(filePath, content, fileSet) {
       const asPath = m[1].replace(/\./g, path.sep);
       for (const jvmExt of ['.java', '.kt', '.kts', '.scala', '.sc']) {
         for (const f of fileSet) {
-          if (f.endsWith(asPath + jvmExt)) { found.push(f); break; }
+          const normF = normalizePath(f);
+          if (normF.endsWith(normalizePath(asPath + jvmExt))) { found.push(normF); break; }
         }
       }
     }
@@ -175,7 +222,44 @@ function extractFileDeps(filePath, content, fileSet) {
     while ((m = re.exec(content)) !== null) {
       const base = path.resolve(dir, m[1]);
       const candidate  = base.endsWith('.rb') ? base : base + '.rb';
-      if (fileSet.has(candidate)) found.push(candidate);
+      const normC = normalizePath(candidate);
+      if (fileSet.has(normC)) found.push(normC);
+    }
+  }
+
+  // ── R ─────────────────────────────────────────────────────────────────────
+  // R doesn't have JS-style relative imports inside packages — files in R/ are
+  // auto-sourced in alphabetical order. We emit edges for:
+  //   1. Explicit `source("path/file.R")` calls (common in Shiny / scripts).
+  //   2. `localPkg::fn` references where `localPkg` matches the project's
+  //      own DESCRIPTION#Package — resolved via the symbol→file map in ctx.
+  // `library(pkg)` / external `pkg::fn` calls are not graph edges.
+  if (R_EXTS.has(ext)) {
+    const stripped = content.replace(/#.*$/gm, '');
+    const reSrc = /(?:^|[^\w.])source\s*\(\s*["']([^"']+)["']/g;
+    let m;
+    while ((m = reSrc.exec(stripped)) !== null) {
+      const r = resolveRPath(dir, m[1], fileSet, cwd);
+      if (r) found.push(r);
+    }
+    if (ctx && ctx.rPackage && ctx.rLocalDefs && ctx.rLocalDefs.size > 0) {
+      const pkg = ctx.rPackage;
+      // Match `pkg::fn` or `pkg:::fn`. The `::` form needs to be the local
+      // package — references to other packages are external.
+      const reNs = new RegExp(`\\b${escapeRegex(pkg)}:::?([A-Za-z][\\w.]*)`, 'g');
+      while ((m = reNs.exec(stripped)) !== null) {
+        const target = ctx.rLocalDefs.get(m[1]);
+        if (!target) continue;
+        const normTarget = normalizePath(target);
+        const normFilePath = normalizePath(filePath);
+        if (normTarget === normFilePath) continue;
+        // Check both original and normalized paths (tests may pass non-normalized fileSet)
+        if (fileSet.has(target)) {
+          found.push(target);
+        } else if (fileSet.has(normTarget)) {
+          found.push(normTarget);
+        }
+      }
     }
   }
 
@@ -191,17 +275,24 @@ function extractFileDeps(filePath, content, fileSet) {
  *
  * @param {string[]} files - absolute file paths to analyze
  * @param {string}   cwd   - project root (used only for error reporting)
+ * @param {{ rPackage?: string, rLocalDefs?: Map<string,string> }} [ctx]
+ *        Optional cross-file context for namespace-aware resolution. Built
+ *        automatically by `buildFromCwd` when DESCRIPTION + NAMESPACE exist.
  * @returns {{ forward: Map<string,string[]>, reverse: Map<string,string[]> }}
  */
-function build(files, cwd) {
+function build(files, cwd, ctx) {
   const fileSet = new Set(files.map((f) => path.resolve(f)));
+  // Create a normalized version for cross-platform case-insensitive lookups
+  const fileSetNormalized = new Set([...fileSet].map(normalizePath));
   const forward = new Map();
   const reverse = new Map();
 
   // Initialise every known file in both maps (ensures isolated files appear)
+  // Store using normalized paths for Windows compatibility
   for (const f of fileSet) {
-    if (!forward.has(f)) forward.set(f, []);
-    if (!reverse.has(f)) reverse.set(f, []);
+    const normF = normalizePath(f);
+    if (!forward.has(normF)) forward.set(normF, []);
+    if (!reverse.has(normF)) reverse.set(normF, []);
   }
 
   for (const filePath of fileSet) {
@@ -212,12 +303,13 @@ function build(files, cwd) {
       continue;
     }
 
-    const deps = extractFileDeps(filePath, content, fileSet);
+    const normFilePath = normalizePath(filePath);
+    const deps = extractFileDeps(filePath, content, fileSetNormalized, cwd, ctx);
     if (deps.length > 0) {
-      forward.set(filePath, deps);
+      forward.set(normFilePath, deps);
       for (const dep of deps) {
         if (!reverse.has(dep)) reverse.set(dep, []);
-        reverse.get(dep).push(filePath);
+        reverse.get(dep).push(normFilePath);
       }
     }
   }
@@ -236,7 +328,9 @@ function build(files, cwd) {
  * @returns {{ forward: Map<string,string[]>, reverse: Map<string,string[]> }}
  */
 function buildFromCwd(cwd, opts) {
-  const { srcDirs = ['src', 'app', 'lib'], exclude = ['node_modules', '.git', 'dist', 'build'] } = opts || {};
+  // R-package layouts use `R/` and `inst/`; Shiny apps put helpers in `R/`.
+  // The existence check below makes these no-ops in non-R projects.
+  const { srcDirs = ['src', 'app', 'lib', 'R', 'inst'], exclude = ['node_modules', '.git', 'dist', 'build'] } = opts || {};
   const excludeSet = new Set(exclude);
 
   function walkDir(dir, depth) {
@@ -252,7 +346,8 @@ function buildFromCwd(cwd, opts) {
       } else if (e.isFile()) {
         const ext = path.extname(e.name).toLowerCase();
         if (JS_EXTS.has(ext) || PY_EXTS.has(ext) || GO_EXTS.has(ext) ||
-            RS_EXTS.has(ext) || JVM_EXTS.has(ext) || RB_EXTS.has(ext)) {
+            RS_EXTS.has(ext) || JVM_EXTS.has(ext) || RB_EXTS.has(ext) ||
+            R_EXTS.has(ext)) {
           out.push(full);
         }
       }
@@ -265,13 +360,27 @@ function buildFromCwd(cwd, opts) {
     const absDir = path.resolve(cwd, sd);
     if (fs.existsSync(absDir)) files.push(...walkDir(absDir, 0));
   }
-  // Also include root-level entry files
-  for (const rootFile of ['gen-context.js', 'index.js', 'main.js', 'app.js']) {
+  // Also include root-level entry files (R: app.R/server.R/ui.R/global.R for Shiny)
+  for (const rootFile of ['gen-context.js', 'index.js', 'main.js', 'app.js',
+                          'app.R', 'server.R', 'ui.R', 'global.R']) {
     const abs = path.resolve(cwd, rootFile);
     if (fs.existsSync(abs)) files.push(abs);
   }
 
-  return build(files, cwd);
+  // Build R namespace context if this looks like an R package.
+  let ctx;
+  try {
+    const { readDescription, collectLocalDefs } = require('../discovery/r-manifest');
+    const desc = readDescription(cwd);
+    if (desc && desc.package) {
+      const rFiles = files.filter((f) => R_EXTS.has(path.extname(f).toLowerCase()));
+      if (rFiles.length > 0) {
+        ctx = { rPackage: desc.package, rLocalDefs: collectLocalDefs(rFiles) };
+      }
+    }
+  } catch (_) { /* manifest module missing or read failed — proceed without ctx */ }
+
+  return build(files, cwd, ctx);
 }
 
-module.exports = { build, buildFromCwd, extractFileDeps };
+module.exports = { build, buildFromCwd, extractFileDeps, normalizePath };

package/src/graph/impact.js

@@ -12,6 +12,11 @@
 const path = require('path');
 const { buildFromCwd } = require('./builder');
 
+// Normalize paths for cross-platform consistency (same as in builder.js)
+function normalizePath(p) {
+  return path.normalize(p).toLowerCase();
+}
+
 // ---------------------------------------------------------------------------
 // Core BFS traversal
 // ---------------------------------------------------------------------------
@@ -111,7 +116,7 @@ function isRouteFile(f) { return ROUTE_PATTERNS.some((re) => re.test(f.replace(/
 function getImpact(changedFile, graph, opts) {
   const { depth = 0, cwd = process.cwd() } = opts || {};
 
-  const absChanged = path.resolve(cwd, changedFile);
+  const absChanged = normalizePath(path.resolve(cwd, changedFile));
 
   // Bail gracefully if file not in graph
   if (!graph || !graph.reverse) {

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.9',
+  version: '6.10.11',
   description: 'SigMap MCP server — code signatures on demand',
 };
 

package/src/retrieval/ranker.js

@@ -83,8 +83,9 @@ function _computeHubs(graph) {
 
 // Common utility paths that should be treated as hubs regardless of fanout
 function _isHub(filePath) {
-  return /\/(utils|helpers|shared|common|constants|types|interfaces|index)\.(ts|tsx|js|jsx)$/.test(filePath)
-      || filePath.endsWith('/index.ts') || filePath.endsWith('/index.js');
+  return /\/(utils|helpers|shared|common|constants|types|interfaces|index|zzz|globals)\.(ts|tsx|js|jsx|r|R)$/.test(filePath)
+      || filePath.endsWith('/index.ts') || filePath.endsWith('/index.js')
+      || filePath.endsWith('/R/utils.R') || filePath.endsWith('/R/zzz.R') || filePath.endsWith('/R/globals.R');
 }
 
 /**
@@ -277,6 +278,24 @@ function rank(query, sigIndex, opts) {
     }
   }
 
+  // Compute confidence levels based on score distribution
+  if (scored.length > 0) {
+    const scores = scored.map(s => s.score);
+    const maxScore = Math.max(...scores);
+    const minScore = Math.min(...scores);
+    const scoreRange = maxScore - minScore || 1;
+
+    // Confidence tiers: top 33% = high, next 33% = medium, rest = low
+    for (const entry of scored) {
+      if (entry.score <= 0) {
+        entry.confidence = 'low';
+      } else {
+        const normalized = (entry.score - minScore) / scoreRange;
+        entry.confidence = normalized > 0.66 ? 'high' : normalized > 0.33 ? 'medium' : 'low';
+      }
+    }
+  }
+
   scored.sort((a, b) => b.score - a.score || a.file.localeCompare(b.file));
   return scored.slice(0, topK);
 }
@@ -342,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
@@ -363,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.
@@ -374,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 (_) {}
@@ -383,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);
 }
 
 /**