sigmap 8.19.0 → 8.21.0

package/gen-context.js

@@ -1533,6 +1533,8 @@ __factories["./src/config/defaults"] = function(module, exports) {
       recencyBoost: 1.5,
       // Boost files call-graph-connected to query matches (opt-in, measure-gated)
       callGraphBoost: false,
+      // Blend import-graph centrality into ranking as a small prior (opt-in, measure-gated)
+      centralityBlend: false,
       // Append route pseudo-signatures to the rankable index (opt-in, measure-gated)
       surfaceEnrichment: false,
     },
@@ -5928,6 +5930,10 @@ __factories["./src/extractors/go"] = function(module, exports) {
   function extract(src) {
     if (!src || typeof src !== 'string') return [];
     const sigs = [];
+    const docHints = buildDocHints(src);
+    // Append the godoc hint after the anchor as `  # <hint>` — same convention
+    // as the Python/JS extractors' doc hints.
+    const hinted = (sig, name) => (docHints.has(name) ? `${sig}  # ${docHints.get(name)}` : sig);
 
     const stripped = src
       .replace(/\/\/.*$/gm, '')
@@ -5939,14 +5945,14 @@ __factories["./src/extractors/go"] = function(module, exports) {
     // Structs
     for (const m of stripped.matchAll(/^type\s+(\w+)\s+struct\s*\{/gm)) {
       const end = blockEndIdx(m.index + m[0].length);
-      sigs.push(withAnchor(`type ${m[1]} struct`, lineAt(stripped, m.index), lineAt(stripped, end)));
+      sigs.push(hinted(withAnchor(`type ${m[1]} struct`, lineAt(stripped, m.index), lineAt(stripped, end)), m[1]));
     }
 
     // Interfaces
     for (const m of stripped.matchAll(/^type\s+(\w+)\s+interface\s*\{/gm)) {
       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)));
+      sigs.push(hinted(withAnchor(`type ${m[1]} interface`, lineAt(stripped, m.index), lineAt(stripped, bodyStart + block.length)), m[1]));
       for (const meth of extractInterfaceMethods(block)) {
         sigs.push(withAnchor(`  ${meth.text}`, lineAt(stripped, bodyStart + meth.declIdx), lineAt(stripped, bodyStart + meth.endIdx)));
       }
@@ -5958,7 +5964,7 @@ __factories["./src/extractors/go"] = function(module, exports) {
       const retType = m[4] ? m[4].trim().replace(/\s+/g, ' ') : '';
       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)));
+      sigs.push(hinted(withAnchor(`func ${receiver}${m[2]}(${normalizeParams(m[3])})${retStr}`, lineAt(stripped, m.index), lineAt(stripped, end)), m[2]));
     }
 
     return sigs.slice(0, 25);
@@ -5994,6 +6000,30 @@ __factories["./src/extractors/go"] = function(module, exports) {
     return params.trim().replace(/\s+/g, ' ');
   }
 
+  // Godoc: the `//` comment block directly above a top-level func/type/method
+  // declaration → first prose sentence, 60-char cap. Runs on the ORIGINAL src
+  // (extract strips comments before matching). Compiler directives (`//go:...`)
+  // carry no prose and are skipped.
+  function buildDocHints(src) {
+    const hints = new Map();
+    const re = /((?:^\/\/[^\n]*\n)+)(?:func\s+(?:\(\w+\s+[\w*]+\)\s+)?(\w+)\s*\(|type\s+(\w+)\s+(?:struct|interface)\b)/gm;
+    for (const m of src.matchAll(re)) {
+      const name = m[2] || m[3];
+      const hint = firstDocSentence(m[1]);
+      if (hint && !hints.has(name)) hints.set(name, hint);
+    }
+    return hints;
+  }
+
+  // First non-directive prose line of a `//` block → first sentence, 60-char cap.
+  function firstDocSentence(block) {
+    const line = String(block).split('\n')
+      .map((l) => l.replace(/^\/\/\s?/, '').trim())
+      .find((l) => l && !l.startsWith('go:') && !l.startsWith('nolint'));
+    if (!line) return '';
+    return line.split(/[.!?]/)[0].trim().slice(0, 60);
+  }
+
   module.exports = { extract };
   
 };
@@ -6126,6 +6156,10 @@ __factories["./src/extractors/java"] = function(module, exports) {
   function extract(src) {
     if (!src || typeof src !== 'string') return [];
     const sigs = [];
+    const docHints = buildDocHints(src);
+    // Append the Javadoc hint after the anchor as `  # <hint>` — same convention
+    // as the Python/JS extractors' doc hints.
+    const hinted = (sig, name) => (docHints.has(name) ? `${sig}  # ${docHints.get(name)}` : sig);
 
     const stripped = src
       .replace(/\/\/.*$/gm, '')
@@ -6136,9 +6170,9 @@ __factories["./src/extractors/java"] = function(module, exports) {
     for (const m of stripped.matchAll(typeRegex)) {
       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)));
+      sigs.push(hinted(withAnchor(`${m[1]} ${m[2]}`, lineAt(stripped, m.index), lineAt(stripped, bodyStart + block.length)), m[2]));
       for (const meth of extractMembers(block)) {
-        sigs.push(withAnchor(`  ${meth.text}`, lineAt(stripped, bodyStart + meth.declIdx), lineAt(stripped, bodyStart + meth.endIdx)));
+        sigs.push(hinted(withAnchor(`  ${meth.text}`, lineAt(stripped, bodyStart + meth.declIdx), lineAt(stripped, bodyStart + meth.endIdx)), meth.name));
       }
     }
 
@@ -6165,6 +6199,7 @@ __factories["./src/extractors/java"] = function(module, exports) {
       const retStr = ret ? ` → ${ret}` : '';
       members.push({
         text: `${m[2]}(${normalizeParams(m[3])})${retStr}`,
+        name: m[2],
         declIdx: m.index + (m[0].length - m[0].trimStart().length),
         endIdx: m.index + m[0].length,
       });
@@ -6182,6 +6217,36 @@ __factories["./src/extractors/java"] = function(module, exports) {
     return type.trim().replace(/\s+/g, ' ').slice(0, 30);
   }
 
+  // Javadoc: the `/** ... */` block directly above a type or public/protected
+  // member declaration → first prose sentence, 60-char cap. Runs on the
+  // ORIGINAL src (extract strips comments before matching). Annotation lines
+  // (`@Override` etc.) between the doc block and the declaration are tolerated.
+  // Body may not contain `*/` so a failed adjacency check can't expand across
+  // code to the next comment block and misattribute the hint.
+  function buildDocHints(src) {
+    const hints = new Map();
+    const patterns = [
+      /\/\*\*((?:[^*]|\*(?!\/))*)\*\/\s*(?:@\w+(?:\([^)]*\))?\s*)*(?:public\s+|protected\s+)?(?:abstract\s+|final\s+)?(?:class|interface|enum)\s+(\w+)/g,
+      /\/\*\*((?:[^*]|\*(?!\/))*)\*\/\s*(?:@\w+(?:\([^)]*\))?\s*)*(?:public|protected)\s+(?:static\s+)?(?:final\s+)?(?:synchronized\s+)?(?:<[^>]+>\s+)?[\w<>\[\], ?.]+\s+(\w+)\s*\(/g,
+    ];
+    for (const re of patterns) {
+      for (const m of src.matchAll(re)) {
+        const hint = firstDocSentence(m[1]);
+        if (hint && !hints.has(m[2])) hints.set(m[2], hint);
+      }
+    }
+    return hints;
+  }
+
+  // First non-tag prose line of a Javadoc body → first sentence, 60-char cap.
+  function firstDocSentence(body) {
+    const line = String(body).split('\n')
+      .map((l) => l.replace(/^\s*\*\s?/, '').trim())
+      .find((l) => l && !l.startsWith('@'));
+    if (!line) return '';
+    return line.split(/[.!?]/)[0].trim().slice(0, 60);
+  }
+
   module.exports = { extract };
   
 };
@@ -6203,7 +6268,12 @@ __factories["./src/extractors/javascript"] = function(module, exports) {
     if (!src || typeof src !== 'string') return [];
     const sigs = [];
     const anchors = [];
+    // docHintFor[i] is the doc-comment hint for sigs[i] (top-level functions
+    // only), appended after the anchor as `  # <hint>` — same convention as the
+    // Python extractor's extractDocHint.
+    const docHintFor = [];
     const returnHints = buildReturnHints(src);
+    const docHints = buildDocHints(src);
 
     // Block comments are blanked newline-by-newline (non-newline chars → spaces)
     // so character offsets AND line numbers stay exact for anchors.
@@ -6238,6 +6308,7 @@ __factories["./src/extractors/javascript"] = function(module, exports) {
       const retStr = formatReturnHint(returnHints.get(m[1]));
       const startLn = lineAt(stripped, m.index);
       sigs.push(`export ${asyncKw}function ${m[1]}(${normalizeParams(m[2])})${retStr}`);
+      docHintFor[sigs.length - 1] = docHints.get(m[1]);
       anchors.push([startLn, fnEndLine(m.index + m[0].length, startLn)]);
     }
 
@@ -6247,6 +6318,7 @@ __factories["./src/extractors/javascript"] = function(module, exports) {
       const retStr = formatReturnHint(returnHints.get(m[1]));
       const startLn = lineAt(stripped, m.index);
       sigs.push(`export const ${m[1]} = ${asyncKw}(${normalizeParams(m[2])}) =>${retStr}`);
+      docHintFor[sigs.length - 1] = docHints.get(m[1]);
       anchors.push([startLn, fnEndLine(m.index + m[0].length, startLn)]);
     }
 
@@ -6267,10 +6339,14 @@ __factories["./src/extractors/javascript"] = function(module, exports) {
       const retStr = formatReturnHint(returnHints.get(m[1]));
       const startLn = lineAt(stripped, m.index);
       sigs.push(`${asyncKw}function ${m[1]}(${normalizeParams(m[2])})${retStr}`);
+      docHintFor[sigs.length - 1] = docHints.get(m[1]);
       anchors.push([startLn, fnEndLine(m.index + m[0].length, startLn)]);
     }
 
-    const withAnchors = sigs.map((s, i) => (anchors[i] ? withAnchor(s, anchors[i][0], anchors[i][1]) : s));
+    const withAnchors = sigs.map((s, i) => {
+      const anchored = anchors[i] ? withAnchor(s, anchors[i][0], anchors[i][1]) : s;
+      return docHintFor[i] ? `${anchored}  # ${docHintFor[i]}` : anchored;
+    });
     return capWithNotice(withAnchors, 25, 'signatures');
   }
 
@@ -6319,6 +6395,36 @@ __factories["./src/extractors/javascript"] = function(module, exports) {
     return hints;
   }
 
+  // First prose sentence of the JSDoc block immediately preceding a top-level
+  // function (same three shapes as buildReturnHints). Mirrors the Python
+  // extractor's extractDocHint: first sentence only, 60-char cap.
+  function buildDocHints(src) {
+    const hints = new Map();
+    // Body may not contain `*/` — otherwise a failed adjacency check would let
+    // the match expand across a whole function to the next comment block and
+    // misattribute the hint.
+    const patterns = [
+      /\/\*\*((?:[^*]|\*(?!\/))*)\*\/\s*(?:export\s+)?(?:async\s+)?function\s+(\w+)\s*\(/g,
+      /\/\*\*((?:[^*]|\*(?!\/))*)\*\/\s*export\s+const\s+(\w+)\s*=\s*(?:async\s+)?\(/g,
+    ];
+    for (const re of patterns) {
+      for (const m of src.matchAll(re)) {
+        const hint = firstDocSentence(m[1]);
+        if (hint && !hints.has(m[2])) hints.set(m[2], hint);
+      }
+    }
+    return hints;
+  }
+
+  // First non-tag prose line of a JSDoc body → first sentence, 60-char cap.
+  function firstDocSentence(body) {
+    const line = String(body).split('\n')
+      .map((l) => l.replace(/^\s*\*\s?/, '').trim())
+      .find((l) => l && !l.startsWith('@'));
+    if (!line) return '';
+    return line.split(/[.!?]/)[0].trim().slice(0, 60);
+  }
+
   function normalizeType(type) {
     if (!type) return '';
     return type.trim().replace(/\s+/g, ' ').slice(0, 25);
@@ -7639,6 +7745,10 @@ __factories["./src/extractors/rust"] = function(module, exports) {
   function extract(src) {
     if (!src || typeof src !== 'string') return [];
     const sigs = [];
+    const docHints = buildDocHints(src);
+    // Append the doc-comment hint after the anchor as `  # <hint>` — same
+    // convention as the Python/JS extractors' doc hints.
+    const hinted = (sig, name) => (docHints.has(name) ? `${sig}  # ${docHints.get(name)}` : sig);
 
     const stripped = src
       .replace(/\/\/.*$/gm, '')
@@ -7660,19 +7770,19 @@ __factories["./src/extractors/rust"] = function(module, exports) {
     // Structs
     for (const m of stripped.matchAll(/^pub\s+struct\s+(\w+)(?:<[^{]*>)?/gm)) {
       const [s, e] = rangeFor(m.index, m.index + m[0].length);
-      sigs.push(withAnchor(`pub struct ${m[1]}`, s, e));
+      sigs.push(hinted(withAnchor(`pub struct ${m[1]}`, s, e), m[1]));
     }
 
     // Enums
     for (const m of stripped.matchAll(/^pub\s+enum\s+(\w+)(?:<[^{]*>)?/gm)) {
       const [s, e] = rangeFor(m.index, m.index + m[0].length);
-      sigs.push(withAnchor(`pub enum ${m[1]}`, s, e));
+      sigs.push(hinted(withAnchor(`pub enum ${m[1]}`, s, e), m[1]));
     }
 
     // Traits
     for (const m of stripped.matchAll(/^pub\s+trait\s+(\w+)(?:<[^{]*>)?/gm)) {
       const [s, e] = rangeFor(m.index, m.index + m[0].length);
-      sigs.push(withAnchor(`pub trait ${m[1]}`, s, e));
+      sigs.push(hinted(withAnchor(`pub trait ${m[1]}`, s, e), m[1]));
     }
 
     // impl blocks
@@ -7681,7 +7791,7 @@ __factories["./src/extractors/rust"] = function(module, exports) {
       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)));
+        sigs.push(hinted(withAnchor(`  ${fn.text}`, lineAt(stripped, bodyStart + fn.declIdx), lineAt(stripped, bodyStart + fn.endIdx)), fn.name));
       }
     }
 
@@ -7690,7 +7800,7 @@ __factories["./src/extractors/rust"] = function(module, exports) {
       const asyncKw = m[0].includes('async') ? 'async ' : '';
       const retStr = extractReturnType(m[3]);
       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));
+      sigs.push(hinted(withAnchor(`pub ${asyncKw}fn ${m[1]}(${normalizeParams(m[2])})${retStr}`, s, e), m[1]));
     }
 
     return sigs.slice(0, 25);
@@ -7714,6 +7824,7 @@ __factories["./src/extractors/rust"] = function(module, exports) {
       const retStr = extractReturnType(m[3]);
       methods.push({
         text: `pub ${asyncKw}fn ${m[1]}(${normalizeParams(m[2])})${retStr}`,
+        name: m[1],
         declIdx: m.index + (m[0].length - m[0].trimStart().length),
         endIdx: m.index + m[0].length,
       });
@@ -7734,6 +7845,29 @@ __factories["./src/extractors/rust"] = function(module, exports) {
     return ` → ${rt.length > 30 ? rt.slice(0, 27) + '...' : rt}`;
   }
 
+  // Rustdoc: the `///` block directly above a declaration → first prose
+  // sentence, 60-char cap. Runs on the ORIGINAL src (extract strips comments
+  // before matching). Attribute lines (`#[...]`) between the doc block and the
+  // declaration are tolerated.
+  function buildDocHints(src) {
+    const hints = new Map();
+    const re = /((?:^[ \t]*\/\/\/[^\n]*\n)+)(?:[ \t]*#\[[^\n]*\n)*[ \t]*pub(?:\s+async)?\s+(?:fn|struct|enum|trait)\s+(\w+)/gm;
+    for (const m of src.matchAll(re)) {
+      const hint = firstDocSentence(m[1]);
+      if (hint && !hints.has(m[2])) hints.set(m[2], hint);
+    }
+    return hints;
+  }
+
+  // First prose line of a `///` block → first sentence, 60-char cap.
+  function firstDocSentence(block) {
+    const line = String(block).split('\n')
+      .map((l) => l.replace(/^[ \t]*\/\/\/\s?/, '').trim())
+      .find((l) => l);
+    if (!line) return '';
+    return line.split(/[.!?]/)[0].trim().slice(0, 60);
+  }
+
   module.exports = { extract };
   
 };
@@ -8307,6 +8441,11 @@ __factories["./src/extractors/typescript"] = function(module, exports) {
   function extract(src) {
     if (!src || typeof src !== 'string') return [];
     const sigs = [];
+    // docHintFor[i] is the doc-comment hint for sigs[i] (exported top-level
+    // functions only), appended after the anchor as `  # <hint>` — same
+    // convention as the Python extractor's extractDocHint.
+    const docHintFor = [];
+    const docHints = buildDocHints(src);
     // anchors[i] is [start, end] for a top-level sig, or null for an indented member.
     // Kept parallel to `sigs` so existing push/mutation logic stays untouched;
     // anchors are applied once at return.
@@ -8374,6 +8513,7 @@ __factories["./src/extractors/typescript"] = function(module, exports) {
       const retStr = retType ? ` → ${retType}` : '';
       const bodyStart = m.index + m[0].length;
       sigs.push(`export ${asyncKw}function ${m[1]}(${params})${retStr}`);
+      docHintFor[sigs.length - 1] = docHints.get(m[1]);
       anchors.push([lineAt(stripped, m.index), lineAt(stripped, blockEndIdx(bodyStart))]);
 
       // Hooks: capture compact return object shape for use* functions.
@@ -8398,6 +8538,7 @@ __factories["./src/extractors/typescript"] = function(module, exports) {
       const asyncKw = /=\s*async\s+/.test(m[0]) ? 'async ' : '';
       const params = normalizeParams(m[2]);
       sigs.push(`export const ${m[1]} = ${asyncKw}(${params}) =>`);
+      docHintFor[sigs.length - 1] = docHints.get(m[1]);
       const bodyStart = stripped.indexOf('{', m.index + m[0].length);
       const endLn = bodyStart !== -1
         ? lineAt(stripped, blockEndIdx(bodyStart + 1))
@@ -8447,7 +8588,10 @@ __factories["./src/extractors/typescript"] = function(module, exports) {
       }
     }
 
-    const withAnchors = sigs.map((s, i) => (anchors[i] ? withAnchor(s, anchors[i][0], anchors[i][1]) : s));
+    const withAnchors = sigs.map((s, i) => {
+      const anchored = anchors[i] ? withAnchor(s, anchors[i][0], anchors[i][1]) : s;
+      return docHintFor[i] ? `${anchored}  # ${docHintFor[i]}` : anchored;
+    });
     return capWithNotice(withAnchors, 35, 'signatures');
   }
 
@@ -8512,6 +8656,36 @@ __factories["./src/extractors/typescript"] = function(module, exports) {
     return params.trim().replace(/\s+/g, ' ').replace(/:[^,)]+/g, '').trim();
   }
 
+  // First prose sentence of the JSDoc block immediately preceding an exported
+  // top-level function (function or arrow-const form). Mirrors the Python
+  // extractor's extractDocHint: first sentence only, 60-char cap.
+  function buildDocHints(src) {
+    const hints = new Map();
+    // Body may not contain `*/` — otherwise a failed adjacency check would let
+    // the match expand across a whole function to the next comment block and
+    // misattribute the hint.
+    const patterns = [
+      /\/\*\*((?:[^*]|\*(?!\/))*)\*\/\s*export\s+(?:async\s+)?function\s+(\w+)\s*[<(]/g,
+      /\/\*\*((?:[^*]|\*(?!\/))*)\*\/\s*export\s+const\s+(\w+)\s*[:=]/g,
+    ];
+    for (const re of patterns) {
+      for (const m of src.matchAll(re)) {
+        const hint = firstDocSentence(m[1]);
+        if (hint && !hints.has(m[2])) hints.set(m[2], hint);
+      }
+    }
+    return hints;
+  }
+
+  // First non-tag prose line of a JSDoc body → first sentence, 60-char cap.
+  function firstDocSentence(body) {
+    const line = String(body).split('\n')
+      .map((l) => l.replace(/^\s*\*\s?/, '').trim())
+      .find((l) => l && !l.startsWith('@'));
+    if (!line) return '';
+    return line.split(/[.!?]/)[0].trim().slice(0, 60);
+  }
+
   module.exports = { extract };
   
 };
@@ -11725,6 +11899,71 @@ __factories["./src/graph/call-graph"] = function(module, exports) {
   
 };
 
+// ── ./src/graph/centrality ──
+__factories["./src/graph/centrality"] = function(module, exports) {
+  
+  /**
+   * Zero-dependency import-graph centrality (Semantic Bridge II, B3).
+   *
+   * Power iteration over the forward dependency graph: rank flows from each
+   * importer to the files it imports, so heavily-referenced files accumulate
+   * centrality and one-off helpers do not. Deterministic — fixed damping,
+   * fixed iteration count, nodes processed in sorted order.
+   *
+   * The result feeds the opt-in `retrieval.centralityBlend` ranking prior
+   * (see src/retrieval/ranker.js) — a principled deepening of the existing
+   * graph-boost idea, not a replacement for query relevance.
+   */
+
+  const DAMPING = 0.85;
+  const ITERATIONS = 20;
+
+  /**
+   * Compute a normalized centrality score for every file in a dependency graph.
+   *
+   * @param {{ forward: Map<string, string[]> }} graph - forward dependency graph
+   *        (file → files it imports), as built by src/graph/builder.js
+   * @returns {Map<string, number>} file → centrality in (0, 1], max-normalized;
+   *          empty Map when the graph is missing or empty
+   */
+  function computeCentrality(graph) {
+    if (!graph || !(graph.forward instanceof Map) || graph.forward.size === 0) return new Map();
+
+    const nodes = new Set(graph.forward.keys());
+    for (const deps of graph.forward.values()) {
+      for (const dep of deps || []) nodes.add(dep);
+    }
+    const nodeList = [...nodes].sort();
+    const n = nodeList.length;
+    const indexOf = new Map(nodeList.map((file, i) => [file, i]));
+    const outLinks = nodeList.map((file) =>
+      (graph.forward.get(file) || []).map((dep) => indexOf.get(dep)).filter((i) => i !== undefined));
+
+    let ranks = new Array(n).fill(1 / n);
+    for (let iter = 0; iter < ITERATIONS; iter++) {
+      const next = new Array(n).fill((1 - DAMPING) / n);
+      let dangling = 0;
+      for (let i = 0; i < n; i++) {
+        if (outLinks[i].length === 0) { dangling += ranks[i]; continue; }
+        const share = (DAMPING * ranks[i]) / outLinks[i].length;
+        for (const j of outLinks[i]) next[j] += share;
+      }
+      // Dangling mass (files that import nothing) is redistributed uniformly.
+      const danglingShare = (DAMPING * dangling) / n;
+      for (let i = 0; i < n; i++) next[i] += danglingShare;
+      ranks = next;
+    }
+
+    const max = Math.max(...ranks) || 1;
+    const result = new Map();
+    for (let i = 0; i < n; i++) result.set(nodeList[i], ranks[i] / max);
+    return result;
+  }
+
+  module.exports = { computeCentrality, DAMPING, ITERATIONS };
+  
+};
+
 // ── ./src/graph/impact ──
 __factories["./src/graph/impact"] = function(module, exports) {
   
@@ -13882,8 +14121,9 @@ __factories["./src/mcp/handlers"] = function(module, exports) {
       // Build dependency graph for neighbor boost — non-fatal if it fails
       let graph = null;
       try { graph = buildFromCwd(cwd); } catch (_) {}
-      // Opt-in call-graph neighbor boost + surface enrichment — non-fatal
+      // Opt-in call-graph neighbor boost + surface enrichment + centrality blend — non-fatal
       let callGraph = null;
+      let centrality = null;
       try {
         const { loadConfig } = __require('./src/config/loader');
         const retrieval = loadConfig(cwd).retrieval;
@@ -13893,8 +14133,11 @@ __factories["./src/mcp/handlers"] = function(module, exports) {
         if (retrieval && retrieval.surfaceEnrichment) {
           __require('./src/retrieval/enrich-from-maps').enrichWithSurfaces(index, cwd);
         }
+        if (retrieval && retrieval.centralityBlend && graph) {
+          centrality = __require('./src/graph/centrality').computeCentrality(graph);
+        }
       } catch (_) {}
-      const results = rank(args.query, index, { topK, cwd, graph, callGraph });
+      const results = rank(args.query, index, { topK, cwd, graph, callGraph, centrality });
       return formatRankTable(results, args.query);
     } catch (err) {
       return `_query_context failed: ${err.message}_`;
@@ -14607,7 +14850,7 @@ __factories["./src/mcp/server"] = function(module, exports) {
 
   const SERVER_INFO = {
     name: 'sigmap',
-    version: '8.19.0',
+    version: '8.21.0',
     description: 'SigMap MCP server — code signatures on demand',
   };
 
@@ -15737,6 +15980,9 @@ __factories["./src/retrieval/ranker"] = function(module, exports) {
     callHop: 0.30, // call-graph file neighbor (opt-in retrieval.callGraphBoost)
   };
 
+  // Max additive prior for import-graph centrality (opt-in retrieval.centralityBlend)
+  const CENTRALITY_BLEND_WEIGHT = 0.3;
+
   // Intent-specific weight adjustments
   const INTENT_WEIGHTS = {
     search:     DEFAULT_WEIGHTS,
@@ -15869,6 +16115,8 @@ __factories["./src/retrieval/ranker"] = function(module, exports) {
    * @param {{ forward: Map<string,string[]> }} [opts.graph] - dependency graph for neighbor boost
    * @param {{ forward: Map<string,string[]> }} [opts.callGraph] - file-level call-graph edges
    *        (from buildCallFileGraph) for the opt-in call-neighbor boost
+   * @param {Map<string,number>} [opts.centrality] - absolute file → normalized
+   *        centrality (from computeCentrality) for the opt-in centrality blend
    * @returns {{ file: string, score: number, sigs: string[], tokens: number, intent: string, signals: object }[]}
    */
   function rank(query, sigIndex, opts) {
@@ -16017,6 +16265,26 @@ __factories["./src/retrieval/ranker"] = function(module, exports) {
       }
     }
 
+    // Centrality blend (opt-in via retrieval.centralityBlend): a small additive
+    // prior from import-graph centrality so heavily-referenced files rank above
+    // one-off helpers on ambiguous queries. Applied only to positively-scored
+    // files — a tie-breaker among matches, never a way to surface non-matches.
+    const centrality = (opts && opts.centrality instanceof Map && opts.centrality.size > 0) ? opts.centrality : null;
+    if (centrality && cwd) {
+      const path = require('path');
+      for (const entry of scored) {
+        if (entry.score <= 0) continue;
+        const abs = path.resolve(cwd, entry.file);
+        // The graph builder lowercases paths (normalizePath) — probe both forms.
+        const c = centrality.get(abs) || centrality.get(abs.toLowerCase());
+        if (c) {
+          const bonus = CENTRALITY_BLEND_WEIGHT * c;
+          entry.score += bonus;
+          entry.signals.centrality = bonus;
+        }
+      }
+    }
+
     // Compute confidence levels based on score distribution
     if (scored.length > 0) {
       const scores = scored.map(s => s.score);
@@ -16292,7 +16560,7 @@ __factories["./src/retrieval/ranker"] = function(module, exports) {
     return 'search';
   }
 
-  module.exports = { rank, buildSigIndex, scoreFile, formatRankTable, formatRankJSON, DEFAULT_WEIGHTS, GRAPH_BOOST_AMOUNTS, detectIntent };
+  module.exports = { rank, buildSigIndex, scoreFile, formatRankTable, formatRankJSON, DEFAULT_WEIGHTS, GRAPH_BOOST_AMOUNTS, CENTRALITY_BLEND_WEIGHT, detectIntent };
   
 };
 
@@ -17202,6 +17470,96 @@ __factories["./src/session/memory"] = function(module, exports) {
   
 };
 
+// ── ./src/session/memory-inspect ──
+__factories["./src/session/memory-inspect"] = function(module, exports) {
+  
+  /**
+   * memory-inspect.js — one view over SigMap's existing cross-session stores.
+   * No new storage: reads the JSON/NDJSON files the session, notes, weights,
+   * evidence, and tracking modules already own under `.context/`.
+   */
+
+  const fs = require('fs');
+  const path = require('path');
+
+  /** store name → { file, kind } (kind drives the entry count). */
+  const STORES = {
+    session: { file: 'session.json', kind: 'json' },
+    notes: { file: 'notes.ndjson', kind: 'ndjson' },
+    weights: { file: 'weights.json', kind: 'weights' },
+    evidence: { file: 'evidence-pack.json', kind: 'json' },
+    gain: { file: 'gain.ndjson', kind: 'ndjson' },
+    usage: { file: 'usage.ndjson', kind: 'ndjson' },
+  };
+
+  /** Stores `clearMemory` may delete ('gain'/'usage' have their own reset flows). */
+  const CLEARABLE = ['session', 'notes', 'weights', 'evidence'];
+
+  function storePath(cwd, name) {
+    return path.join(cwd, '.context', STORES[name].file);
+  }
+
+  function countEntries(kind, filePath) {
+    try {
+      if (kind === 'ndjson') {
+        return fs.readFileSync(filePath, 'utf8').split('\n').filter(Boolean).length;
+      }
+      if (kind === 'weights') {
+        const w = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+        return Object.keys((w && w.files) || w || {}).length;
+      }
+      return 1; // json: a single snapshot object
+    } catch (_) {
+      return 0;
+    }
+  }
+
+  /**
+   * Describe every cross-session store.
+   * @param {string} cwd
+   * @returns {Array<{store:string, path:string, exists:boolean, entries:number, bytes:number, modified:string|null, clearable:boolean}>}
+   */
+  function inspectMemory(cwd) {
+    return Object.entries(STORES).map(([store, { file, kind }]) => {
+      const p = storePath(cwd, store);
+      let stat = null;
+      try { stat = fs.statSync(p); } catch (_) {}
+      return {
+        store,
+        path: path.join('.context', file),
+        exists: !!stat,
+        entries: stat ? countEntries(kind, p) : 0,
+        bytes: stat ? stat.size : 0,
+        modified: stat ? new Date(stat.mtimeMs).toISOString() : null,
+        clearable: CLEARABLE.includes(store),
+      };
+    });
+  }
+
+  /**
+   * Delete one clearable store (or 'all' clearable stores).
+   * @param {string} cwd
+   * @param {string} store - session|notes|weights|evidence|all
+   * @returns {string[]} names of stores actually removed
+   */
+  function clearMemory(cwd, store) {
+    const targets = store === 'all' ? CLEARABLE : [store];
+    for (const t of targets) {
+      if (!CLEARABLE.includes(t)) {
+        throw new Error(`unknown or protected store "${t}" — clearable: ${CLEARABLE.join(', ')}, all`);
+      }
+    }
+    const removed = [];
+    for (const t of targets) {
+      try { fs.unlinkSync(storePath(cwd, t)); removed.push(t); } catch (_) {}
+    }
+    return removed;
+  }
+
+  module.exports = { inspectMemory, clearMemory, STORES, CLEARABLE };
+  
+};
+
 // ── ./src/session/notes ──
 __factories["./src/session/notes"] = function(module, exports) {
   
@@ -19710,7 +20068,7 @@ function __tryGit(args, opts = {}) {
   catch (_) { return ''; }
 }
 
-const VERSION = '8.19.0';
+const VERSION = '8.21.0';
 const MARKER = '\n\n## Auto-generated signatures\n<!-- Updated by gen-context.js -->\n';
 
 function requireSourceOrBundled(key) {
@@ -21593,6 +21951,8 @@ Usage:
   ${cmd} evidence "<query>"                Build a deterministic Evidence Pack (JSON) → .context/evidence-pack.json
   ${cmd} evidence "<query>" --markdown     Emit the Markdown handoff rendering to stdout
   ${cmd} evidence "<query>" --top <n> --budget <n> --out <path>   Tune ranked files / token budget / write rendered output
+  ${cmd} memory                            List cross-session stores (.context/) — entries, size, age
+  ${cmd} memory --clear <store>            Clear one store: session|notes|weights|evidence|all (--json supported)
   ${cmd} note "<text>"                     Append a note to the cross-session decision log
   ${cmd} note                              List recent notes (also: note --list <N>)
   ${cmd} status                            Show repo state — branch, dirty files, index freshness, notes
@@ -22042,8 +22402,16 @@ function main() {
     if (config && config.retrieval && config.retrieval.surfaceEnrichment) {
       try { requireSourceOrBundled('./src/retrieval/enrich-from-maps').enrichWithSurfaces(sigIndex, cwd); } catch (_) {}
     }
+    // Opt-in import-graph centrality blend (retrieval.centralityBlend) — non-fatal
+    let askCentrality = null;
+    if (config && config.retrieval && config.retrieval.centralityBlend) {
+      try {
+        const askCentralityGraph = requireSourceOrBundled('./src/graph/builder').buildFromCwd(cwd);
+        askCentrality = requireSourceOrBundled('./src/graph/centrality').computeCentrality(askCentralityGraph);
+      } catch (_) {}
+    }
 
-    let ranked = rank(query, sigIndex, { topK: 5, weights: intentWeights, cwd, callGraph: askCallGraph });
+    let ranked = rank(query, sigIndex, { topK: 5, weights: intentWeights, cwd, callGraph: askCallGraph, centrality: askCentrality });
 
     // v6.10: Workspace scoping — infer package from query and apply boost
     const workspaces = detectWorkspaces(cwd);
@@ -22986,6 +23354,56 @@ function main() {
 
   // `sigmap note "<text>"` — append to the cross-session decision log.
   // With no text, lists recent notes (also `note --list [N]`).
+  // `sigmap memory` — one view over the cross-session stores in .context/.
+  if (args[0] === 'memory') {
+    const jsonOut = args.includes('--json');
+    const { inspectMemory, clearMemory } = requireSourceOrBundled('./src/session/memory-inspect');
+    const clearIdx = args.indexOf('--clear');
+
+    if (clearIdx !== -1) {
+      const store = args[clearIdx + 1];
+      if (!store || store.startsWith('--')) {
+        console.error('[sigmap] usage: sigmap memory --clear <session|notes|weights|evidence|all>');
+        process.exit(1);
+      }
+      let removed;
+      try {
+        removed = clearMemory(cwd, store);
+      } catch (err) {
+        console.error(`[sigmap] ${err.message}`);
+        process.exit(1);
+      }
+      if (jsonOut) {
+        process.stdout.write(JSON.stringify({ cleared: removed }) + '\n');
+      } else {
+        console.log(removed.length
+          ? `[sigmap] cleared: ${removed.join(', ')}`
+          : `[sigmap] nothing to clear for "${store}"`);
+      }
+      process.exit(0);
+    }
+
+    const stores = inspectMemory(cwd);
+    if (jsonOut) {
+      process.stdout.write(JSON.stringify({ stores }) + '\n');
+      process.exit(0);
+    }
+    const fmtAge = (iso) => {
+      if (!iso) return '—';
+      const m = Math.floor((Date.now() - Date.parse(iso)) / 60000);
+      const h = Math.floor(m / 60), d = Math.floor(h / 24);
+      return d > 0 ? `${d}d ago` : h > 0 ? `${h}h ago` : `${m}m ago`;
+    };
+    const fmtKB = (b) => (b >= 1024 ? `${(b / 1024).toFixed(1)}KB` : `${b}B`);
+    console.log('[sigmap] cross-session memory (.context/)');
+    for (const s of stores) {
+      const state = s.exists ? `${String(s.entries).padStart(5)} entries  ${fmtKB(s.bytes).padStart(8)}  ${fmtAge(s.modified)}` : '    — empty';
+      console.log(`  ${s.store.padEnd(9)} ${state}${s.clearable ? '' : '   (reset via its own command)'}`);
+    }
+    console.log('  clear: sigmap memory --clear <session|notes|weights|evidence|all>');
+    process.exit(0);
+  }
+
   if (args[0] === 'note') {
     const jsonOut = args.includes('--json');
     const { addNote, readNotes, formatNotes } = requireSourceOrBundled('./src/session/notes');
@@ -24224,7 +24642,15 @@ function main() {
       if (config && config.retrieval && config.retrieval.surfaceEnrichment) {
         try { requireSourceOrBundled('./src/retrieval/enrich-from-maps').enrichWithSurfaces(index, cwd); } catch (_) {}
       }
-      const results = rank(query, index, { topK, recencyBoost, cwd, callGraph: queryCallGraph });
+      // Opt-in import-graph centrality blend (retrieval.centralityBlend) — non-fatal
+      let queryCentrality = null;
+      if (config && config.retrieval && config.retrieval.centralityBlend) {
+        try {
+          const centralityGraph = requireSourceOrBundled('./src/graph/builder').buildFromCwd(cwd);
+          queryCentrality = requireSourceOrBundled('./src/graph/centrality').computeCentrality(centralityGraph);
+        } catch (_) {}
+      }
+      const results = rank(query, index, { topK, recencyBoost, cwd, callGraph: queryCallGraph, centrality: queryCentrality });
       if (args.includes('--context')) {
         const miniCtx  = buildMiniContext(results, cwd);
         const ctxOut   = path.join(cwd, '.context', 'query-context.md');