sigmap 8.16.1 → 8.18.0

package/llms-full.txt

@@ -11,19 +11,19 @@ ranking keeps the relevant context in scope (cutting tokens ~97% as a side
 effect), with no LLM calls, embeddings, or vector database. Works with Claude,
 Cursor, GitHub Copilot, Aider, Windsurf, local LLMs, and MCP.
 
-# Version: 8.16.1 | Benchmark: sigmap-v8.16-main (2026-07-11)
+# Version: 8.18.0 | Benchmark: sigmap-v8.18-main (2026-07-12)
 # Source: auto-generated from package.json, version.json, benchmarks/latest.json, src/mcp/tools.js, src/config/defaults.js
 # Regenerate: npm run generate:llms   |   Validate: npm run validate:llms
 
 ---
 
-## Core metrics (benchmark: sigmap-v8.16-main, 2026-07-11)
+## Core metrics (benchmark: sigmap-v8.18-main, 2026-07-12)
 
 | Metric | Without SigMap | With SigMap |
 |--------|----------------|-------------|
-| Retrieval hit@5 | 13.6% (random) | 87.8% (6.5× lift) |
-| Token reduction | — | 97.0% average |
-| Task success proxy | 10% | 67.8% |
+| Retrieval hit@5 | 13.6% (random) | 86.7% (6.4× lift) |
+| Token reduction | — | 96.9% average |
+| Task success proxy | 10% | 68.9% |
 | Prompts per task | 2.84 | 1.44 (49.2% fewer) |
 | Supported languages | — | 33 |
 | MCP tools | — | 20 |
@@ -343,7 +343,7 @@ testCoverage = false
 testDirs = ["tests","test","__tests__","spec"]
 sigCache = false
 impactRadius = false
-retrieval = {"topK":10,"recencyBoost":1.5,"callGraphBoost":false}
+retrieval = {"topK":10,"recencyBoost":1.5,"callGraphBoost":false,"surfaceEnrichment":false}
 impact = {"depth":3,"includeSigs":true}
 ```
 

package/llms.txt

@@ -11,7 +11,7 @@ ranking keeps the relevant context in scope (cutting tokens ~97% as a side
 effect), with no LLM calls, embeddings, or vector database. Works with Claude,
 Cursor, GitHub Copilot, Aider, Windsurf, local LLMs, and MCP.
 
-# Version: 8.16.1 | Benchmark: sigmap-v8.16-main (2026-07-11)
+# Version: 8.18.0 | Benchmark: sigmap-v8.18-main (2026-07-12)
 # Source: auto-generated from package.json, version.json, benchmarks/latest.json, src/mcp/tools.js, src/config/defaults.js
 # Regenerate: npm run generate:llms   |   Validate: npm run validate:llms
 
@@ -23,11 +23,11 @@ Cursor, GitHub Copilot, Aider, Windsurf, local LLMs, and MCP.
 - No blast-radius awareness before editing a hub file — `--impact` shows every file a change touches.
 - Pasted stack traces, CI logs, and JSON bloat the prompt — `squeeze` minimizes them and enriches the top frame from the symbol index.
 
-## Core metrics (benchmark: sigmap-v8.16-main, 2026-07-11)
+## Core metrics (benchmark: sigmap-v8.18-main, 2026-07-12)
 
-- hit@5 retrieval: 87.8% vs 13.6% random baseline (6.5× lift)
-- Token reduction: 97.0% average across benchmark repos
-- Task success: 67.8% vs 10% without SigMap
+- hit@5 retrieval: 86.7% vs 13.6% random baseline (6.4× lift)
+- Token reduction: 96.9% average across benchmark repos
+- Task success: 68.9% vs 10% without SigMap
 - Prompts per task: 1.44 vs 2.84 baseline (49.2% fewer)
 - Languages: 33 supported · MCP tools: 20
 - Dependencies: zero npm runtime dependencies · fully offline

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sigmap",
-  "version": "8.16.1",
+  "version": "8.18.0",
   "description": "The deterministic, verifiable grounding layer for AI code work — a zero-dependency signature-and-evidence map that grounds Claude, Cursor, Copilot, Aider, Windsurf, local LLMs & MCP agents against your real code (repo + installed libraries) so they stop hallucinating files, imports & APIs. Runs offline via npx; byte-stable output; ~97% token reduction as proof.",
   "main": "packages/core/index.js",
   "exports": {
@@ -31,6 +31,7 @@
     "benchmark:test-discovery": "node scripts/run-test-discovery-benchmark.mjs --save",
     "benchmark:terse": "node scripts/run-terse-benchmark.mjs --save",
     "benchmark:callgraph-boost": "node scripts/run-callgraph-boost-benchmark.mjs --save",
+    "benchmark:surface-enrichment": "node scripts/run-surface-enrichment-benchmark.mjs --save",
     "validate:squeeze": "node scripts/run-squeeze-benchmark.mjs --gate",
     "health": "node gen-context.js --health",
     "map": "node gen-project-map.js",

package/packages/cli/package.json

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

package/src/config/defaults.js

@@ -149,6 +149,8 @@ const DEFAULTS = {
     recencyBoost: 1.5,
     // Boost files call-graph-connected to query matches (opt-in, measure-gated)
     callGraphBoost: false,
+    // Append route pseudo-signatures to the rankable index (opt-in, measure-gated)
+    surfaceEnrichment: false,
   },
 
   // Impact layer settings (v2.5)

package/src/extractors/csharp.js

@@ -1,7 +1,11 @@
 'use strict';
 
+const { lineAt, withAnchor } = require('./line-anchor');
+
 /**
  * Extract signatures from C# source code.
+ * Signatures carry `:start-end` line anchors (Surgical Context); the comment
+ * strip below is newline-preserving so anchor lines match the original file.
  * @param {string} src - Raw file content
  * @returns {string[]} Array of signature strings
  */
@@ -11,14 +15,18 @@ function extract(src) {
 
   const stripped = src
     .replace(/\/\/.*$/gm, '')
-    .replace(/\/\*[\s\S]*?\*\//g, '');
+    .replace(/\/\*[\s\S]*?\*\//g, (s) => s.replace(/[^\n]/g, ' '));
 
   // Classes and interfaces
   const typeRe = /^\s*(?:public\s+|internal\s+|protected\s+)?(?:abstract\s+|sealed\s+|static\s+)?(class|interface|enum|record|struct)\s+(\w+)(?:<[^{]*>)?(?:\s*:\s*[\w<>, .]+)?\s*\{/gm;
   for (const m of stripped.matchAll(typeRe)) {
-    sigs.push(`${m[1]} ${m[2]}`);
-    const block = extractBlock(stripped, m.index + m[0].length);
-    for (const meth of extractMembers(block)) sigs.push(`  ${meth}`);
+    const declIdx = m.index + (m[0].length - m[0].trimStart().length);
+    const bodyStart = m.index + m[0].length;
+    const block = extractBlock(stripped, bodyStart);
+    sigs.push(withAnchor(`${m[1]} ${m[2]}`, lineAt(stripped, declIdx), lineAt(stripped, bodyStart + block.length)));
+    for (const meth of extractMembers(block)) {
+      sigs.push(withAnchor(`  ${meth.text}`, lineAt(stripped, bodyStart + meth.declIdx), lineAt(stripped, bodyStart + meth.endIdx)));
+    }
   }
 
   return sigs.slice(0, 25);
@@ -41,7 +49,11 @@ function extractMembers(block) {
   for (const m of block.matchAll(methodRe)) {
     const ret = normalizeType(m[1]);
     const retStr = ret ? ` → ${ret}` : '';
-    members.push(`${m[2]}(${normalizeParams(m[3])})${retStr}`);
+    members.push({
+      text: `${m[2]}(${normalizeParams(m[3])})${retStr}`,
+      declIdx: m.index + (m[0].length - m[0].trimStart().length),
+      endIdx: m.index + m[0].length,
+    });
   }
   return members.slice(0, 8);
 }

package/src/extractors/dart.js

@@ -1,7 +1,11 @@
 'use strict';
 
+const { lineAt, withAnchor } = require('./line-anchor');
+
 /**
  * Extract signatures from Dart source code.
+ * Signatures carry `:start-end` line anchors (Surgical Context); the comment
+ * strip below is newline-preserving so anchor lines match the original file.
  * @param {string} src - Raw file content
  * @returns {string[]} Array of signature strings
  */
@@ -11,21 +15,37 @@ function extract(src) {
 
   const stripped = src
     .replace(/\/\/.*$/gm, '')
-    .replace(/\/\*[\s\S]*?\*\//g, '');
+    .replace(/\/\*[\s\S]*?\*\//g, (s) => s.replace(/[^\n]/g, ' '));
+
+  // Anchor range: scan past same-line trivia (`async`, `=>` stops) to a body `{`.
+  const rangeFor = (declIdx, afterIdx) => {
+    let k = afterIdx;
+    while (k < stripped.length && /[ \tA-Za-z0-9_]/.test(stripped[k])) k++;
+    if (stripped[k] === '{') {
+      const end = k + 1 + extractBlock(stripped, k + 1).length;
+      return [lineAt(stripped, declIdx), lineAt(stripped, end)];
+    }
+    const line = lineAt(stripped, declIdx);
+    return [line, line];
+  };
 
   // Classes and abstract classes
   for (const m of stripped.matchAll(/^(?:abstract\s+)?class\s+(\w+)(?:<[^{]*>)?(?:\s+extends\s+[\w<>, ]+)?(?:\s+(?:implements|with|on)\s+[\w<>, ]+)?\s*\{/gm)) {
     const abs = m[0].trimStart().startsWith('abstract') ? 'abstract ' : '';
-    sigs.push(`${abs}class ${m[1]}`);
-    const block = extractBlock(stripped, m.index + m[0].length);
-    for (const meth of extractMembers(block)) sigs.push(`  ${meth}`);
+    const bodyStart = m.index + m[0].length;
+    const block = extractBlock(stripped, bodyStart);
+    sigs.push(withAnchor(`${abs}class ${m[1]}`, lineAt(stripped, m.index), lineAt(stripped, bodyStart + block.length)));
+    for (const meth of extractMembers(block)) {
+      sigs.push(withAnchor(`  ${meth.text}`, lineAt(stripped, bodyStart + meth.declIdx), lineAt(stripped, bodyStart + meth.endIdx)));
+    }
   }
 
   // Top-level functions — capture return type (prefix before name) and show as suffix
   for (const m of stripped.matchAll(/^((?:Future<[\w<>?,\s]*>|[\w<>?]+))\s+(\w+)\s*\(([^)]*)\)/gm)) {
     if (m[2].startsWith('_')) continue;
-    const retStr = (m[1] && m[1] !== 'void') ? ` \u2192 ${m[1].replace(/\s+/g, '').slice(0, 25)}` : '';
-    sigs.push(`${m[2]}(${normalizeParams(m[3])})${retStr}`);
+    const retStr = (m[1] && m[1] !== 'void') ? ` → ${m[1].replace(/\s+/g, '').slice(0, 25)}` : '';
+    const [s, e] = rangeFor(m.index, m.index + m[0].length);
+    sigs.push(withAnchor(`${m[2]}(${normalizeParams(m[3])})${retStr}`, s, e));
   }
 
   return sigs.slice(0, 25);
@@ -46,8 +66,12 @@ function extractMembers(block) {
   const members = [];
   for (const m of block.matchAll(/^\s+(?:@override\s+)?(?:@\w+\s+)*((?:Future<[\w<>?,\s]*>|[\w<>?]+))\s+(\w+)\s*\(([^)]*)\)/gm)) {
     if (m[2].startsWith('_')) continue;
-    const retStr = (m[1] && m[1] !== 'void') ? ` \u2192 ${m[1].replace(/\s+/g, '').slice(0, 25)}` : '';
-    members.push(`${m[2]}(${normalizeParams(m[3])})${retStr}`);
+    const retStr = (m[1] && m[1] !== 'void') ? ` → ${m[1].replace(/\s+/g, '').slice(0, 25)}` : '';
+    members.push({
+      text: `${m[2]}(${normalizeParams(m[3])})${retStr}`,
+      declIdx: m.index + (m[0].length - m[0].trimStart().length),
+      endIdx: m.index + m[0].length,
+    });
   }
   return members.slice(0, 8);
 }

package/src/extractors/go.js

@@ -1,7 +1,11 @@
 'use strict';
 
+const { lineAt, withAnchor } = require('./line-anchor');
+
 /**
  * Extract signatures from Go source code.
+ * Signatures carry `:start-end` line anchors (Surgical Context); the comment
+ * strip below is newline-preserving so anchor lines match the original file.
  * @param {string} src - Raw file content
  * @returns {string[]} Array of signature strings
  */
@@ -11,26 +15,34 @@ function extract(src) {
 
   const stripped = src
     .replace(/\/\/.*$/gm, '')
-    .replace(/\/\*[\s\S]*?\*\//g, '');
+    .replace(/\/\*[\s\S]*?\*\//g, (s) => s.replace(/[^\n]/g, ' '));
+
+  // Index of the closing brace for a block opened just before startIndex.
+  const blockEndIdx = (startIndex) => startIndex + extractBlock(stripped, startIndex).length;
 
   // Structs
   for (const m of stripped.matchAll(/^type\s+(\w+)\s+struct\s*\{/gm)) {
-    sigs.push(`type ${m[1]} struct`);
+    const end = blockEndIdx(m.index + m[0].length);
+    sigs.push(withAnchor(`type ${m[1]} struct`, lineAt(stripped, m.index), lineAt(stripped, end)));
   }
 
   // Interfaces
   for (const m of stripped.matchAll(/^type\s+(\w+)\s+interface\s*\{/gm)) {
-    sigs.push(`type ${m[1]} interface`);
-    const block = extractBlock(stripped, m.index + m[0].length);
-    for (const method of extractInterfaceMethods(block)) sigs.push(`  ${method}`);
+    const bodyStart = m.index + m[0].length;
+    const block = extractBlock(stripped, bodyStart);
+    sigs.push(withAnchor(`type ${m[1]} interface`, lineAt(stripped, m.index), lineAt(stripped, bodyStart + block.length)));
+    for (const meth of extractInterfaceMethods(block)) {
+      sigs.push(withAnchor(`  ${meth.text}`, lineAt(stripped, bodyStart + meth.declIdx), lineAt(stripped, bodyStart + meth.endIdx)));
+    }
   }
 
   // Functions and methods — capture return type between ) and {
   for (const m of stripped.matchAll(/^func\s+(?:\((\w+)\s+[\w*]+\)\s+)?(\w+)\s*\(([^)]*)\)([^{]*)\{/gm)) {
     const receiver = m[1] ? `(${m[1]}) ` : '';
     const retType = m[4] ? m[4].trim().replace(/\s+/g, ' ') : '';
-    const retStr = retType ? ` \u2192 ${retType.slice(0, 30)}` : '';
-    sigs.push(`func ${receiver}${m[2]}(${normalizeParams(m[3])})${retStr}`);
+    const retStr = retType ? ` → ${retType.slice(0, 30)}` : '';
+    const end = blockEndIdx(m.index + m[0].length);
+    sigs.push(withAnchor(`func ${receiver}${m[2]}(${normalizeParams(m[3])})${retStr}`, lineAt(stripped, m.index), lineAt(stripped, end)));
   }
 
   return sigs.slice(0, 25);
@@ -51,8 +63,12 @@ function extractInterfaceMethods(block) {
   const methods = [];
   for (const m of block.matchAll(/^\s+(\w+)\s*\(([^)]*)\)([^\n]*)/gm)) {
     const retType = m[3] ? m[3].trim().replace(/\s+/g, ' ') : '';
-    const retStr = retType ? ` \u2192 ${retType.slice(0, 30)}` : '';
-    methods.push(`${m[1]}(${normalizeParams(m[2])})${retStr}`);
+    const retStr = retType ? ` → ${retType.slice(0, 30)}` : '';
+    methods.push({
+      text: `${m[1]}(${normalizeParams(m[2])})${retStr}`,
+      declIdx: m.index + (m[0].length - m[0].trimStart().length),
+      endIdx: m.index + m[0].length,
+    });
   }
   return methods.slice(0, 8);
 }

package/src/extractors/java.js

@@ -1,7 +1,11 @@
 'use strict';
 
+const { lineAt, withAnchor } = require('./line-anchor');
+
 /**
  * Extract signatures from Java source code.
+ * Signatures carry `:start-end` line anchors (Surgical Context); the comment
+ * strip below is newline-preserving so anchor lines match the original file.
  * @param {string} src - Raw file content
  * @returns {string[]} Array of signature strings
  */
@@ -11,14 +15,17 @@ function extract(src) {
 
   const stripped = src
     .replace(/\/\/.*$/gm, '')
-    .replace(/\/\*[\s\S]*?\*\//g, '');
+    .replace(/\/\*[\s\S]*?\*\//g, (s) => s.replace(/[^\n]/g, ' '));
 
   // Classes and interfaces
   const typeRegex = /^(?:public\s+|protected\s+)?(?:abstract\s+|final\s+)?(class|interface|enum)\s+(\w+)(?:\s+extends\s+[\w<>, .]+)?(?:\s+implements\s+[\w<>, .]+)?\s*\{/gm;
   for (const m of stripped.matchAll(typeRegex)) {
-    sigs.push(`${m[1]} ${m[2]}`);
-    const block = extractBlock(stripped, m.index + m[0].length);
-    for (const meth of extractMembers(block)) sigs.push(`  ${meth}`);
+    const bodyStart = m.index + m[0].length;
+    const block = extractBlock(stripped, bodyStart);
+    sigs.push(withAnchor(`${m[1]} ${m[2]}`, lineAt(stripped, m.index), lineAt(stripped, bodyStart + block.length)));
+    for (const meth of extractMembers(block)) {
+      sigs.push(withAnchor(`  ${meth.text}`, lineAt(stripped, bodyStart + meth.declIdx), lineAt(stripped, bodyStart + meth.endIdx)));
+    }
   }
 
   return sigs.slice(0, 25);
@@ -42,7 +49,11 @@ function extractMembers(block) {
   for (const m of block.matchAll(methodRe)) {
     const ret = normalizeType(m[1]);
     const retStr = ret ? ` → ${ret}` : '';
-    members.push(`${m[2]}(${normalizeParams(m[3])})${retStr}`);
+    members.push({
+      text: `${m[2]}(${normalizeParams(m[3])})${retStr}`,
+      declIdx: m.index + (m[0].length - m[0].trimStart().length),
+      endIdx: m.index + m[0].length,
+    });
   }
   return members.slice(0, 8);
 }

package/src/extractors/kotlin.js

@@ -1,7 +1,11 @@
 'use strict';
 
+const { lineAt, withAnchor } = require('./line-anchor');
+
 /**
  * Extract signatures from Kotlin source code.
+ * Signatures carry `:start-end` line anchors (Surgical Context); the comment
+ * strip below is newline-preserving so anchor lines match the original file.
  * @param {string} src - Raw file content
  * @returns {string[]} Array of signature strings
  */
@@ -11,21 +15,37 @@ function extract(src) {
 
   const stripped = src
     .replace(/\/\/.*$/gm, '')
-    .replace(/\/\*[\s\S]*?\*\//g, '');
+    .replace(/\/\*[\s\S]*?\*\//g, (s) => s.replace(/[^\n]/g, ' '));
+
+  // Anchor range: scan past same-line modifiers to a body `{` (range) else single line.
+  const rangeFor = (declIdx, afterIdx) => {
+    let k = afterIdx;
+    while (k < stripped.length && /[ \tA-Za-z0-9_]/.test(stripped[k])) k++;
+    if (stripped[k] === '{') {
+      const end = k + 1 + extractBlock(stripped, k + 1).length;
+      return [lineAt(stripped, declIdx), lineAt(stripped, end)];
+    }
+    const line = lineAt(stripped, declIdx);
+    return [line, line];
+  };
 
   // Classes, objects, interfaces
   for (const m of stripped.matchAll(/^(?:public\s+|internal\s+)?(?:data\s+|sealed\s+|abstract\s+|open\s+)?(class|object|interface)\s+(\w+)(?:[^{]*)\{/gm)) {
-    sigs.push(`${m[1]} ${m[2]}`);
-    const block = extractBlock(stripped, m.index + m[0].length);
-    for (const meth of extractMembers(block)) sigs.push(`  ${meth}`);
+    const bodyStart = m.index + m[0].length;
+    const block = extractBlock(stripped, bodyStart);
+    sigs.push(withAnchor(`${m[1]} ${m[2]}`, lineAt(stripped, m.index), lineAt(stripped, bodyStart + block.length)));
+    for (const meth of extractMembers(block)) {
+      sigs.push(withAnchor(`  ${meth.text}`, lineAt(stripped, bodyStart + meth.declIdx), lineAt(stripped, bodyStart + meth.endIdx)));
+    }
   }
 
   // Top-level functions — capture `: RetType` after params
   for (const m of stripped.matchAll(/^(?:public\s+|internal\s+)?(?:suspend\s+)?fun\s+(\w+)\s*(?:<[^(]*>)?\s*\(([^)]*)\)(?:\s*:\s*([^\n{=]+))?/gm)) {
     const suspend = m[0].includes('suspend') ? 'suspend ' : '';
     const retType = m[3] ? m[3].trim().replace(/\s+/g, ' ') : '';
-    const retStr = retType ? ` \u2192 ${retType.slice(0, 25)}` : '';
-    sigs.push(`${suspend}fun ${m[1]}(${normalizeParams(m[2])})${retStr}`);
+    const retStr = retType ? ` → ${retType.slice(0, 25)}` : '';
+    const [s, e] = rangeFor(m.index, m.index + m[0].length);
+    sigs.push(withAnchor(`${suspend}fun ${m[1]}(${normalizeParams(m[2])})${retStr}`, s, e));
   }
 
   return sigs.slice(0, 25);
@@ -48,8 +68,12 @@ function extractMembers(block) {
     if (m[1].startsWith('_')) continue;
     const suspend = m[0].includes('suspend') ? 'suspend ' : '';
     const retType = m[3] ? m[3].trim().replace(/\s+/g, ' ') : '';
-    const retStr = retType ? ` \u2192 ${retType.slice(0, 25)}` : '';
-    members.push(`${suspend}fun ${m[1]}(${normalizeParams(m[2])})${retStr}`);
+    const retStr = retType ? ` → ${retType.slice(0, 25)}` : '';
+    members.push({
+      text: `${suspend}fun ${m[1]}(${normalizeParams(m[2])})${retStr}`,
+      declIdx: m.index + (m[0].length - m[0].trimStart().length),
+      endIdx: m.index + m[0].length,
+    });
   }
   return members.slice(0, 8);
 }

package/src/extractors/php.js

@@ -1,7 +1,11 @@
 'use strict';
 
+const { lineAt, withAnchor } = require('./line-anchor');
+
 /**
  * Extract signatures from PHP source code.
+ * Signatures carry `:start-end` line anchors (Surgical Context); the comment
+ * strips below are newline-preserving so anchor lines match the original file.
  * @param {string} src - Raw file content
  * @returns {string[]} Array of signature strings
  */
@@ -12,23 +16,40 @@ function extract(src) {
   const stripped = src
     .replace(/\/\/.*$/gm, '')
     .replace(/#.*$/gm, '')
-    .replace(/\/\*[\s\S]*?\*\//g, '');
+    .replace(/\/\*[\s\S]*?\*\//g, (s) => s.replace(/[^\n]/g, ' '));
+
+  // Anchor range: scan past same-line trivia to a body `{` (range) else single line.
+  const rangeFor = (declIdx, afterIdx) => {
+    let k = afterIdx;
+    while (k < stripped.length && /[ \tA-Za-z0-9_:?\\]/.test(stripped[k])) k++;
+    if (stripped[k] === '{' || (stripped[k] === '\n' && stripped[k + 1] === '{')) {
+      const open = stripped[k] === '{' ? k : k + 1;
+      const end = open + 1 + extractBlock(stripped, open + 1).length;
+      return [lineAt(stripped, declIdx), lineAt(stripped, end)];
+    }
+    const line = lineAt(stripped, declIdx);
+    return [line, line];
+  };
 
   // Classes and interfaces
   const typeRe = /^(?:abstract\s+)?(?:class|interface|trait)\s+(\w+)(?:\s+extends\s+\w+)?(?:\s+implements\s+[\w, ]+)?\s*\{/gm;
   for (const m of stripped.matchAll(typeRe)) {
     const kind = m[0].trimStart().startsWith('interface') ? 'interface' :
       m[0].trimStart().startsWith('trait') ? 'trait' : 'class';
-    sigs.push(`${kind} ${m[1]}`);
-    const block = extractBlock(stripped, m.index + m[0].length);
-    for (const meth of extractMembers(block)) sigs.push(`  ${meth}`);
+    const bodyStart = m.index + m[0].length;
+    const block = extractBlock(stripped, bodyStart);
+    sigs.push(withAnchor(`${kind} ${m[1]}`, lineAt(stripped, m.index), lineAt(stripped, bodyStart + block.length)));
+    for (const meth of extractMembers(block)) {
+      sigs.push(withAnchor(`  ${meth.text}`, lineAt(stripped, bodyStart + meth.declIdx), lineAt(stripped, bodyStart + meth.endIdx)));
+    }
   }
 
   // Top-level functions
   for (const m of stripped.matchAll(/^function\s+(\w+)\s*\(([^)]*)\)\s*(?::\s*([^\n{]+))?/gm)) {
     const ret = normalizeType(m[3]);
     const retStr = ret ? ` → ${ret}` : '';
-    sigs.push(`function ${m[1]}(${normalizeParams(m[2])})${retStr}`);
+    const [s, e] = rangeFor(m.index, m.index + m[0].length);
+    sigs.push(withAnchor(`function ${m[1]}(${normalizeParams(m[2])})${retStr}`, s, e));
   }
 
   return sigs.slice(0, 25);
@@ -53,7 +74,11 @@ function extractMembers(block) {
     const isStatic = m[0].includes('static ') ? 'static ' : '';
     const ret = normalizeType(m[3]);
     const retStr = ret ? ` → ${ret}` : '';
-    members.push(`${isStatic}function ${m[1]}(${normalizeParams(m[2])})${retStr}`);
+    members.push({
+      text: `${isStatic}function ${m[1]}(${normalizeParams(m[2])})${retStr}`,
+      declIdx: m.index + (m[0].length - m[0].trimStart().length),
+      endIdx: m.index + m[0].length,
+    });
   }
   return members.slice(0, 8);
 }

package/src/extractors/rust.js

@@ -1,7 +1,11 @@
 'use strict';
 
+const { lineAt, withAnchor } = require('./line-anchor');
+
 /**
  * Extract signatures from Rust source code.
+ * Signatures carry `:start-end` line anchors (Surgical Context); the comment
+ * strip below is newline-preserving so anchor lines match the original file.
  * @param {string} src - Raw file content
  * @returns {string[]} Array of signature strings
  */
@@ -11,35 +15,55 @@ function extract(src) {
 
   const stripped = src
     .replace(/\/\/.*$/gm, '')
-    .replace(/\/\*[\s\S]*?\*\//g, '');
+    .replace(/\/\*[\s\S]*?\*\//g, (s) => s.replace(/[^\n]/g, ' '));
+
+  // Anchor range for a declaration at declIdx whose header ends at afterIdx:
+  // if a `{` body follows, range to its closing brace; else single-line.
+  const rangeFor = (declIdx, afterIdx) => {
+    let k = afterIdx;
+    while (k < stripped.length && /[ \t]/.test(stripped[k])) k++;
+    if (stripped[k] === '{') {
+      const end = k + 1 + extractBlock(stripped, k + 1).length;
+      return [lineAt(stripped, declIdx), lineAt(stripped, end)];
+    }
+    const line = lineAt(stripped, declIdx);
+    return [line, line];
+  };
 
   // Structs
   for (const m of stripped.matchAll(/^pub\s+struct\s+(\w+)(?:<[^{]*>)?/gm)) {
-    sigs.push(`pub struct ${m[1]}`);
+    const [s, e] = rangeFor(m.index, m.index + m[0].length);
+    sigs.push(withAnchor(`pub struct ${m[1]}`, s, e));
   }
 
   // Enums
   for (const m of stripped.matchAll(/^pub\s+enum\s+(\w+)(?:<[^{]*>)?/gm)) {
-    sigs.push(`pub enum ${m[1]}`);
+    const [s, e] = rangeFor(m.index, m.index + m[0].length);
+    sigs.push(withAnchor(`pub enum ${m[1]}`, s, e));
   }
 
   // Traits
   for (const m of stripped.matchAll(/^pub\s+trait\s+(\w+)(?:<[^{]*>)?/gm)) {
-    sigs.push(`pub trait ${m[1]}`);
+    const [s, e] = rangeFor(m.index, m.index + m[0].length);
+    sigs.push(withAnchor(`pub trait ${m[1]}`, s, e));
   }
 
   // impl blocks
   for (const m of stripped.matchAll(/^impl(?:<[^>]*>)?\s+(?:[\w:]+\s+for\s+)?(\w+)(?:<[^{]*>)?\s*\{/gm)) {
-    sigs.push(`impl ${m[1]}`);
-    const block = extractBlock(stripped, m.index + m[0].length);
-    for (const fn of extractMethods(block)) sigs.push(`  ${fn}`);
+    const bodyStart = m.index + m[0].length;
+    const block = extractBlock(stripped, bodyStart);
+    sigs.push(withAnchor(`impl ${m[1]}`, lineAt(stripped, m.index), lineAt(stripped, bodyStart + block.length)));
+    for (const fn of extractMethods(block)) {
+      sigs.push(withAnchor(`  ${fn.text}`, lineAt(stripped, bodyStart + fn.declIdx), lineAt(stripped, bodyStart + fn.endIdx)));
+    }
   }
 
   // Top-level pub fns — capture everything after ) up to { or ; for return type
   for (const m of stripped.matchAll(/^pub(?:\s+async)?\s+fn\s+(\w+)(?:<[^(]*>)?\s*\(([^)]*)\)([^{;]*)/gm)) {
     const asyncKw = m[0].includes('async') ? 'async ' : '';
     const retStr = extractReturnType(m[3]);
-    sigs.push(`pub ${asyncKw}fn ${m[1]}(${normalizeParams(m[2])})${retStr}`);
+    const [s, e] = rangeFor(m.index, m.index + m[0].length);
+    sigs.push(withAnchor(`pub ${asyncKw}fn ${m[1]}(${normalizeParams(m[2])})${retStr}`, s, e));
   }
 
   return sigs.slice(0, 25);
@@ -61,7 +85,11 @@ function extractMethods(block) {
   for (const m of block.matchAll(/^\s+pub(?:\s+async)?\s+fn\s+(\w+)(?:<[^(]*>)?\s*\(([^)]*)\)([^{;]*)/gm)) {
     const asyncKw = m[0].includes('async') ? 'async ' : '';
     const retStr = extractReturnType(m[3]);
-    methods.push(`pub ${asyncKw}fn ${m[1]}(${normalizeParams(m[2])})${retStr}`);
+    methods.push({
+      text: `pub ${asyncKw}fn ${m[1]}(${normalizeParams(m[2])})${retStr}`,
+      declIdx: m.index + (m[0].length - m[0].trimStart().length),
+      endIdx: m.index + m[0].length,
+    });
   }
   return methods.slice(0, 8);
 }
@@ -76,7 +104,7 @@ function extractReturnType(afterParen) {
   const m = afterParen.match(/->\s*([^{;]+)/);
   if (!m) return '';
   const rt = m[1].trim().replace(/\s+/g, ' ');
-  return ` \u2192 ${rt.length > 30 ? rt.slice(0, 27) + '...' : rt}`;
+  return ` → ${rt.length > 30 ? rt.slice(0, 27) + '...' : rt}`;
 }
 
 module.exports = { extract };

package/src/extractors/scala.js

@@ -1,7 +1,11 @@
 'use strict';
 
+const { lineAt, withAnchor } = require('./line-anchor');
+
 /**
  * Extract signatures from Scala source code.
+ * Signatures carry `:start-end` line anchors (Surgical Context); the comment
+ * strip below is newline-preserving so anchor lines match the original file.
  * @param {string} src - Raw file content
  * @returns {string[]} Array of signature strings
  */
@@ -11,7 +15,7 @@ function extract(src) {
 
   const stripped = src
     .replace(/\/\/.*$/gm, '')
-    .replace(/\/\*[\s\S]*?\*\//g, '');
+    .replace(/\/\*[\s\S]*?\*\//g, (s) => s.replace(/[^\n]/g, ' '));
 
   // Classes, traits, objects
   const typeRe = /^(?:case\s+)?(?:class|trait|object)\s+(\w+)(?:\[[\w, ]+\])?(?:[^{]*)\{/gm;
@@ -19,9 +23,12 @@ function extract(src) {
     const kind = m[0].trimStart().startsWith('case class') ? 'case class' :
       m[0].trimStart().startsWith('trait') ? 'trait' :
       m[0].trimStart().startsWith('object') ? 'object' : 'class';
-    sigs.push(`${kind} ${m[1]}`);
-    const block = extractBlock(stripped, m.index + m[0].length);
-    for (const fn of extractMembers(block)) sigs.push(`  ${fn}`);
+    const bodyStart = m.index + m[0].length;
+    const block = extractBlock(stripped, bodyStart);
+    sigs.push(withAnchor(`${kind} ${m[1]}`, lineAt(stripped, m.index), lineAt(stripped, bodyStart + block.length)));
+    for (const fn of extractMembers(block)) {
+      sigs.push(withAnchor(`  ${fn.text}`, lineAt(stripped, bodyStart + fn.declIdx), lineAt(stripped, bodyStart + fn.endIdx)));
+    }
   }
 
   // Top-level defs
@@ -30,7 +37,8 @@ function extract(src) {
     const params = m[2] ? `(${normalizeParams(m[2])})` : '';
     const ret = normalizeType(m[3]);
     const retStr = ret ? ` → ${ret}` : '';
-    sigs.push(`def ${m[1]}${params}${retStr}`);
+    const line = lineAt(stripped, m.index);
+    sigs.push(withAnchor(`def ${m[1]}${params}${retStr}`, line, line));
   }
 
   return sigs.slice(0, 25);
@@ -54,7 +62,11 @@ function extractMembers(block) {
     const params = m[2] ? `(${normalizeParams(m[2])})` : '';
     const ret = normalizeType(m[3]);
     const retStr = ret ? ` → ${ret}` : '';
-    members.push(`def ${m[1]}${params}${retStr}`);
+    members.push({
+      text: `def ${m[1]}${params}${retStr}`,
+      declIdx: m.index + (m[0].length - m[0].trimStart().length),
+      endIdx: m.index + m[0].length,
+    });
   }
   return members.slice(0, 8);
 }