sigmap 8.11.0 → 8.13.0

package/gen-context.js

@@ -10304,6 +10304,142 @@ __factories["./src/format/verify-report"] = function(module, exports) {
   
 };
 
+// ── ./src/graph/blast-radius ──
+__factories["./src/graph/blast-radius"] = function(module, exports) {
+  
+  /**
+   * Method-level blast-radius scoring (GR2).
+   *
+   * Consumes the D4 call-graph (src/graph/call-graph.js): for each changed file,
+   * resolve the functions it defines, BFS the reverse call edges, and score how
+   * much of the codebase transitively calls into the change. The score is a
+   * documented deterministic formula — no heuristics that vary run to run — so
+   * review-pr findings and PR Evidence lines are byte-stable for a fixed tree.
+   *
+   * Score: min(100, direct×4 + transitive×1). Tiers:
+   *   0 → none · 1–9 → low · 10–29 → medium · 30–59 → high · 60+ → critical
+   */
+
+  const path = require('path');
+  const { buildCallGraph } = __require('./src/graph/call-graph');
+
+  const DIRECT_WEIGHT = 4;
+  const TRANSITIVE_WEIGHT = 1;
+  const IMPACTED_FUNCTIONS_CAP = 12;
+
+  const TEST_FILE_RE = /\.(test|spec)\.[jt]sx?$|(^|\/)test_|_test\.(py|go)$|(^|\/)(tests?|__tests__|spec)\//;
+
+  function tierFor(score) {
+    if (score >= 60) return 'critical';
+    if (score >= 30) return 'high';
+    if (score >= 10) return 'medium';
+    if (score >= 1) return 'low';
+    return 'none';
+  }
+
+  function _normRel(p) {
+    return String(p).replace(/\\/g, '/');
+  }
+
+  // BFS the reverse edges from a set of symbol ids; returns direct/transitive id sets.
+  function _bfs(seedIds, reverse, maxDepth) {
+    const direct = new Set();
+    const transitive = new Set();
+    const visited = new Set(seedIds);
+    let frontier = [];
+    for (const s of seedIds) {
+      for (const nb of (reverse.get(s) || [])) {
+        if (!visited.has(nb)) { direct.add(nb); visited.add(nb); frontier.push(nb); }
+      }
+    }
+    let depth = 1;
+    while (frontier.length && (maxDepth === 0 || depth < maxDepth)) {
+      const next = [];
+      for (const node of frontier) {
+        for (const nb of (reverse.get(node) || [])) {
+          if (!visited.has(nb)) { transitive.add(nb); visited.add(nb); next.push(nb); }
+        }
+      }
+      frontier = next;
+      depth++;
+    }
+    return { direct, transitive };
+  }
+
+  /**
+   * Score the method-level blast radius of a changed-file list.
+   *
+   * @param {string[]} changedFiles repo-relative paths
+   * @param {string} cwd
+   * @param {object} [opts]
+   * @param {object} [opts.graph]  injected call graph (tests); else built from cwd
+   * @param {number} [opts.depth=0] BFS depth limit (0 = unlimited)
+   * @returns {{
+   *   available: boolean,
+   *   files: Array<{ file:string, symbols:number, directCallers:number,
+   *                  transitiveCallers:number, testCallers:number,
+   *                  impactedFunctions:string[], score:number, tier:string }>,
+   *   aggregate: { score:number, tier:string, impactedFunctions:number }
+   * }}
+   */
+  function methodBlastRadius(changedFiles, cwd, opts = {}) {
+    const empty = { available: false, files: [], aggregate: { score: 0, tier: 'none', impactedFunctions: 0 } };
+    let graph;
+    try {
+      graph = opts.graph || buildCallGraph(cwd, opts);
+    } catch (_) {
+      return empty;
+    }
+    if (!graph || !graph.defs || graph.defs.size === 0) return empty;
+
+    // Group defined symbol ids by their (normalized) defining file.
+    const idsByFile = new Map();
+    for (const [id, def] of graph.defs.entries()) {
+      const rel = _normRel(def.file);
+      if (!idsByFile.has(rel)) idsByFile.set(rel, []);
+      idsByFile.get(rel).push(id);
+    }
+
+    const depth = Number.isFinite(opts.depth) ? opts.depth : 0;
+    const files = [];
+    const allImpacted = new Set();
+
+    for (const changed of (changedFiles || []).map(_normRel).sort()) {
+      const ids = idsByFile.get(changed);
+      if (!ids || !ids.length) continue;
+      const { direct, transitive } = _bfs(ids, graph.reverse, depth);
+      const impacted = [...direct, ...transitive].sort();
+      for (const id of impacted) allImpacted.add(id);
+      const testCallers = impacted.filter((id) => {
+        const def = graph.defs.get(id);
+        return def && TEST_FILE_RE.test(_normRel(def.file));
+      }).length;
+      const score = Math.min(100, direct.size * DIRECT_WEIGHT + transitive.size * TRANSITIVE_WEIGHT);
+      files.push({
+        file: changed,
+        symbols: ids.length,
+        directCallers: direct.size,
+        transitiveCallers: transitive.size,
+        testCallers,
+        impactedFunctions: impacted.slice(0, IMPACTED_FUNCTIONS_CAP),
+        score,
+        tier: tierFor(score),
+      });
+    }
+
+    if (!files.length) return empty;
+    const maxScore = files.reduce((m, f) => Math.max(m, f.score), 0);
+    return {
+      available: true,
+      files,
+      aggregate: { score: maxScore, tier: tierFor(maxScore), impactedFunctions: allImpacted.size },
+    };
+  }
+
+  module.exports = { methodBlastRadius, tierFor, DIRECT_WEIGHT, TRANSITIVE_WEIGHT };
+  
+};
+
 // ── ./src/graph/builder ──
 __factories["./src/graph/builder"] = function(module, exports) {
   
@@ -13359,6 +13495,28 @@ __factories["./src/mcp/handlers"] = function(module, exports) {
     }
   }
 
+  /**
+   * get_method_impact({ symbol, direction?, depth? }) → string
+   *
+   * Method-level blast radius (GR2): every function that transitively calls
+   * `symbol` (direction 'callers', default), or everything it calls ('callees').
+   */
+  function getMethodImpact(args, cwd) {
+    if (!args || !args.symbol) return 'Missing required argument: symbol';
+
+    try {
+      const { methodImpact, methodCallees, formatCallGraph } = __require('./src/graph/call-graph');
+      const kind = args.direction === 'callees' ? 'callees' : 'callers';
+      const depth = Math.max(0, parseInt(args.depth, 10) || 0);
+      const result = kind === 'callees'
+        ? methodCallees(args.symbol, cwd, { depth })
+        : methodImpact(args.symbol, cwd, { depth });
+      return formatCallGraph(result, kind);
+    } catch (err) {
+      return `_get_method_impact failed: ${err.message}_`;
+    }
+  }
+
   /**
    * get_impact({ file, depth? }) → string
    *
@@ -13872,7 +14030,7 @@ __factories["./src/mcp/handlers"] = function(module, exports) {
     return header + sq.squeezed;
   }
 
-  module.exports = { readContext, searchSignatures, getMap, createCheckpoint, getRouting, explainFile, listModules, queryContext, getImpact, getLines, readMemory, getCalleeSignatures, notifyFileCreated, notifySymbolAdded, notifyFileDeleted, getDiffContext, getArchitectureOverview, verifySuggestion, squeezeOutput };
+  module.exports = { readContext, searchSignatures, getMap, createCheckpoint, getRouting, explainFile, listModules, queryContext, getMethodImpact, getImpact, getLines, readMemory, getCalleeSignatures, notifyFileCreated, notifySymbolAdded, notifyFileDeleted, getDiffContext, getArchitectureOverview, verifySuggestion, squeezeOutput };
   
 };
 
@@ -14039,11 +14197,11 @@ __factories["./src/mcp/server"] = function(module, exports) {
 
   const readline = require('readline');
   const { TOOLS } = __require('./src/mcp/tools');
-  const { readContext, searchSignatures, getMap, createCheckpoint, getRouting, explainFile, listModules, queryContext, getImpact, getLines, readMemory, getCalleeSignatures, notifyFileCreated, notifySymbolAdded, notifyFileDeleted, getDiffContext, getArchitectureOverview, verifySuggestion, squeezeOutput } = __require('./src/mcp/handlers');
+  const { readContext, searchSignatures, getMap, createCheckpoint, getRouting, explainFile, listModules, queryContext, getMethodImpact, getImpact, getLines, readMemory, getCalleeSignatures, notifyFileCreated, notifySymbolAdded, notifyFileDeleted, getDiffContext, getArchitectureOverview, verifySuggestion, squeezeOutput } = __require('./src/mcp/handlers');
 
   const SERVER_INFO = {
     name: 'sigmap',
-    version: '8.11.0',
+    version: '8.13.0',
     description: 'SigMap MCP server — code signatures on demand',
   };
 
@@ -14099,6 +14257,7 @@ __factories["./src/mcp/server"] = function(module, exports) {
         else if (name === 'explain_file') text = explainFile(args, cwd);
         else if (name === 'list_modules') text = listModules(args, cwd);
         else if (name === 'query_context') text = queryContext(args, cwd);
+        else if (name === 'get_method_impact') text = getMethodImpact(args, cwd);
         else if (name === 'get_impact') text = getImpact(args, cwd);
         else if (name === 'get_lines') text = getLines(args, cwd);
         else if (name === 'read_memory') text = readMemory(args, cwd);
@@ -14170,12 +14329,12 @@ __factories["./src/mcp/server"] = function(module, exports) {
 __factories["./src/mcp/tools"] = function(module, exports) {
   
   /**
-   * MCP tool definitions for SigMap (19 tools).
+   * MCP tool definitions for SigMap (20 tools).
    * read_context, search_signatures, get_map, create_checkpoint, get_routing,
-   * explain_file, list_modules, query_context, get_impact, get_lines, read_memory,
-   * get_callee_signatures, sigmap_notify_file_created, sigmap_notify_symbol_added,
-   * sigmap_notify_file_deleted, get_diff_context, get_architecture_overview,
-   * verify_suggestion, squeeze_output.
+   * explain_file, list_modules, query_context, get_method_impact, get_impact,
+   * get_lines, read_memory, get_callee_signatures, sigmap_notify_file_created,
+   * sigmap_notify_symbol_added, sigmap_notify_file_deleted, get_diff_context,
+   * get_architecture_overview, verify_suggestion, squeeze_output.
    */
 
   const TOOLS = [
@@ -14317,6 +14476,35 @@ __factories["./src/mcp/tools"] = function(module, exports) {
         required: ['query'],
       },
     },
+    {
+      name: 'get_method_impact',
+      description:
+        'Method-level blast radius for a symbol: every FUNCTION that (transitively) calls it — ' +
+        'or, with direction "callees", every repo function it calls. Finer-grained than the ' +
+        'file-level get_impact: tells an agent which functions break, not just which files. ' +
+        'JS/TS + Python call-graph; deterministic, no LLM.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          symbol: {
+            type: 'string',
+            description:
+              'Function/method name (e.g. "validateToken") or a full "file#name" id ' +
+              '(e.g. "src/auth/session.js#validateToken") to disambiguate.',
+          },
+          direction: {
+            type: 'string',
+            enum: ['callers', 'callees'],
+            description: '"callers" (default) = blast radius; "callees" = what the symbol calls.',
+          },
+          depth: {
+            type: 'number',
+            description: 'BFS depth limit (default 0 = unlimited).',
+          },
+        },
+        required: ['symbol'],
+      },
+    },
     {
       name: 'get_impact',
       description:
@@ -15723,6 +15911,12 @@ __factories["./src/review/pr-evidence"] = function(module, exports) {
       impactByFile = new Map(analyzeImpact(srcPaths, cwd, { depth }).map((r) => [r.file, r.impact]));
     } catch (_) { /* graph optional */ }
 
+    // GR2: method-level blast radius per changed file (reviewPr already computed
+    // it when the call graph resolved — reuse, don't rebuild the graph).
+    const methodBlastByFile = new Map(
+      (review.methodBlast && review.methodBlast.files || []).map((m) => [m.file, m])
+    );
+
     const fileReports = files.map((f) => {
       const deleted = f.status === 'D';
       let signatures = [];
@@ -15731,6 +15925,7 @@ __factories["./src/review/pr-evidence"] = function(module, exports) {
       }
       const impact = impactByFile.get(f.path) || null;
       return {
+        methodBlast: methodBlastByFile.get(f.path.replace(/\\/g, '/')) || null,
         path: f.path,
         status: f.status,
         riskLabel: riskLabelFor(f.path),
@@ -15773,6 +15968,7 @@ __factories["./src/review/pr-evidence"] = function(module, exports) {
         else if (f.type === 'security-file') L.push(`- ⚠️ **sensitive path touched** (path heuristic, not a content scan) — \`${f.file}\``);
         else if (f.type === 'secret-detected') L.push(`- 🔑 **secret detected** (${f.secret}) — \`${f.file}\``);
         else if (f.type === 'god-node') L.push(`- ⚠️ **god node** — \`${f.file}\` → ${f.count} dependents (high blast radius)`);
+        else if (f.type === 'method-blast') L.push(`- ⚠️ **method blast radius ${f.tier}** — \`${f.file}\` → ${f.functions} function(s) transitively call into this change (score ${f.score}/100)`);
         else if (f.type === 'scope-drift') L.push(`- ⚠️ **scope drift** — ${f.count} top-level dirs touched (${f.dirs.join(', ')})`);
       }
       L.push('');
@@ -15794,6 +15990,15 @@ __factories["./src/review/pr-evidence"] = function(module, exports) {
       } else {
         L.push('**Blast radius:** _(not in dependency graph — new or leaf file)_');
       }
+      if (f.methodBlast && (f.methodBlast.directCallers + f.methodBlast.transitiveCallers) > 0) {
+        const mb = f.methodBlast;
+        const total = mb.directCallers + mb.transitiveCallers;
+        L.push(
+          `**Method blast radius:** ${total} function(s) impacted (score ${mb.score}/100, ${mb.tier}) — ` +
+          mb.impactedFunctions.slice(0, 6).map((id) => '`' + id + '`').join(', ') +
+          (total > 6 ? ` +${total - 6} more` : '')
+        );
+      }
       if (f.relatedTests.length) L.push(`Related tests: ${f.relatedTests.slice(0, 8).map((t) => '`' + t + '`').join(', ')}`);
 
       if (f.signatures.length) {
@@ -15860,7 +16065,7 @@ __factories["./src/review/review-pr"] = function(module, exports) {
    * @param {object} [opts]
    * @param {number} [opts.godNodeThreshold=15]
    * @param {number} [opts.scopeThreshold=5]
-   * @returns {{ findings: object[], blast: object[], summary: object }}
+   * @returns {{ findings: object[], blast: object[], methodBlast: object|null, summary: object }}
    */
   function reviewPr(changedFiles, cwd, opts = {}) {
     const godThreshold = opts.godNodeThreshold != null ? opts.godNodeThreshold : GOD_NODE_THRESHOLD;
@@ -15921,6 +16126,27 @@ __factories["./src/review/review-pr"] = function(module, exports) {
       blast.sort((a, b) => b.totalImpact - a.totalImpact);
     }
 
+    // 3b. Method-level blast radius (GR2) — how many FUNCTIONS transitively call
+    // into the change, scored deterministically. Graph optional, like 3.
+    let methodBlast = null;
+    if (srcChanged.length) {
+      try {
+        const { methodBlastRadius } = __require('./src/graph/blast-radius');
+        const mb = methodBlastRadius(srcChanged, cwd, opts.methodBlastOpts || {});
+        if (mb.available) {
+          methodBlast = mb;
+          for (const f of mb.files) {
+            if (f.tier === 'high' || f.tier === 'critical') {
+              findings.push({
+                type: 'method-blast', file: f.file, severity: 'warn',
+                functions: f.directCallers + f.transitiveCallers, score: f.score, tier: f.tier,
+              });
+            }
+          }
+        }
+      } catch (_) { /* call graph optional */ }
+    }
+
     // 4. Scope drift: distinct top-level directories touched.
     const dirs = [...new Set(paths.map((p) => (p.includes('/') ? p.split('/')[0] : '.')))];
     if (dirs.length > scopeThreshold) {
@@ -15931,6 +16157,7 @@ __factories["./src/review/review-pr"] = function(module, exports) {
     return {
       findings,
       blast,
+      methodBlast,
       summary: {
         filesChanged: files.length,
         sourceChanged: srcChanged.length,
@@ -18625,6 +18852,260 @@ __factories["./src/verify/parsers"] = function(module, exports) {
   
 };
 
+// ── ./src/wiki/generate ──
+__factories["./src/wiki/generate"] = function(module, exports) {
+  
+  /**
+   * Wiki generation (D9) — `sigmap wiki`.
+   *
+   * Deterministic architecture narrative composed from data SigMap already
+   * computes: the signature index, the dependency graph, conventions, and the
+   * health score. Template prose only — no LLM, no network, no timestamps —
+   * so two runs on an unchanged repo produce byte-identical markdown.
+   */
+
+  const fs = require('fs');
+  const path = require('path');
+
+  const HUB_LIMIT = 8;
+  const ENTRY_LIMIT = 8;
+  const MODULE_LIMIT = 20;
+  const KEY_FILE_LIMIT = 3;
+
+  // Graph keys come from src/graph/builder's normalizePath (normalized +
+  // lowercased), so relativize against the same normalization of cwd.
+  function _rel(cwd, f) {
+    return path.relative(path.normalize(cwd).toLowerCase(), f).replace(/\\/g, '/');
+  }
+
+  function _pct(fraction) {
+    return Math.round(fraction * 100);
+  }
+
+  /** Project name + version from package.json, falling back to the dir name. */
+  function _identity(cwd) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(path.join(cwd, 'package.json'), 'utf8'));
+      if (pkg && pkg.name) return { name: pkg.name, version: pkg.version || null };
+    } catch (_) {}
+    return { name: path.basename(cwd), version: null };
+  }
+
+  /** Module rollup from the signature index (keys are cwd-relative paths). */
+  function _modules(index) {
+    const groups = new Map();
+    let totalTokens = 0;
+    for (const [rel, sigs] of index.entries()) {
+      const parts = String(rel).replace(/\\/g, '/').split('/');
+      const mod = parts.length > 1 ? parts[0] : '.';
+      const tokens = Math.ceil((sigs || []).join('\n').length / 4);
+      totalTokens += tokens;
+      if (!groups.has(mod)) groups.set(mod, { name: mod, files: 0, tokens: 0, fileSigs: [] });
+      const g = groups.get(mod);
+      g.files++;
+      g.tokens += tokens;
+      g.fileSigs.push({ file: rel, sigCount: (sigs || []).length });
+    }
+    const modules = [...groups.values()]
+      .sort((a, b) => b.tokens - a.tokens || a.name.localeCompare(b.name))
+      .slice(0, MODULE_LIMIT)
+      .map((g) => ({
+        name: g.name,
+        files: g.files,
+        tokens: g.tokens,
+        keyFiles: g.fileSigs
+          .sort((a, b) => b.sigCount - a.sigCount || a.file.localeCompare(b.file))
+          .slice(0, KEY_FILE_LIMIT)
+          .map((f) => f.file),
+      }));
+    return { modules, totalTokens };
+  }
+
+  /** Hubs, entry points, and cycle count from the dependency graph. */
+  function _flow(cwd) {
+    try {
+      const { buildFromCwd } = __require('./src/graph/builder');
+      const { detectCycles } = __require('./src/map/import-graph');
+      const graph = buildFromCwd(cwd);
+      if (!graph || !graph.forward || graph.forward.size === 0) return null;
+
+      const importersOf = (f) => (graph.reverse.get(f) || []).length;
+      const hubs = [...graph.reverse.entries()]
+        .map(([f, importers]) => ({ file: _rel(cwd, f), importers: importers.length }))
+        .filter((h) => h.importers > 0)
+        .sort((a, b) => b.importers - a.importers || a.file.localeCompare(b.file))
+        .slice(0, HUB_LIMIT);
+
+      const entryPoints = [...graph.forward.entries()]
+        .filter(([f, deps]) => deps.length > 0 && importersOf(f) === 0)
+        .map(([f, deps]) => ({ file: _rel(cwd, f), imports: deps.length }))
+        .sort((a, b) => b.imports - a.imports || a.file.localeCompare(b.file))
+        .slice(0, ENTRY_LIMIT);
+
+      let cycles = 0;
+      try { cycles = detectCycles(graph.forward).length; } catch (_) {}
+
+      return { hubs, entryPoints, cycles, edges: graph.forward.size };
+    } catch (_) {
+      return null;
+    }
+  }
+
+  /** Conventions summary; index keys are resolved back to absolute paths. */
+  function _conventions(cwd, index) {
+    try {
+      const { extractConventions } = __require('./src/conventions/extract');
+      const files = [...index.keys()].map((rel) => path.join(cwd, rel));
+      const c = extractConventions(cwd, files);
+      return {
+        fileNaming: c.fileNaming
+          ? { dominant: c.fileNaming.dominant, pct: _pct(c.fileNaming.dominantPct || 0), tier: c.fileNaming.tier }
+          : null,
+        exportStyle: c.exportStyle
+          ? { dominant: c.exportStyle.dominant, pct: _pct(c.exportStyle.dominantPct || 0), tier: c.exportStyle.tier }
+          : null,
+        testFramework: c.testFramework || null,
+      };
+    } catch (_) {
+      return null;
+    }
+  }
+
+  function _health(cwd) {
+    try {
+      const { score } = __require('./src/health/scorer');
+      const h = score(cwd);
+      return { score: h.score, grade: h.grade };
+    } catch (_) {
+      return null;
+    }
+  }
+
+  /**
+   * Build the wiki. Every data source is optional — a repo with no context file
+   * or no resolvable graph still yields a valid document.
+   * @param {string} cwd
+   * @param {object} [opts]
+   * @param {string} [opts.version] SigMap version stamped in the header
+   * @returns {{ data: object, markdown: string }}
+   */
+  function buildWiki(cwd, opts = {}) {
+    let index = new Map();
+    try {
+      const { buildSigIndex } = __require('./src/retrieval/ranker');
+      index = buildSigIndex(cwd);
+    } catch (_) {}
+
+    const identity = _identity(cwd);
+    const { modules, totalTokens } = _modules(index);
+    const flow = _flow(cwd);
+    const conventions = index.size ? _conventions(cwd, index) : null;
+    const health = _health(cwd);
+
+    const data = {
+      name: identity.name,
+      version: identity.version,
+      files: index.size,
+      modules,
+      totalTokens,
+      flow,
+      conventions,
+      health,
+    };
+
+    return { data, markdown: renderWikiMarkdown(data, opts.version) };
+  }
+
+  /**
+   * Render the narrative markdown. Pure function of `data` — no clocks, no
+   * randomness — so output is byte-stable for a fixed repo state.
+   * @param {object} data
+   * @param {string} [sigmapVersion]
+   * @returns {string}
+   */
+  function renderWikiMarkdown(data, sigmapVersion) {
+    const L = [];
+    const title = data.version ? `${data.name} v${data.version}` : data.name;
+    L.push(`# ${title} — Architecture Wiki`);
+    L.push('');
+    L.push(`_Deterministically generated from signatures + dependency graph by SigMap${sigmapVersion ? ` v${sigmapVersion}` : ''} — no LLM. Regenerate: \`sigmap wiki\`._`);
+    L.push('');
+
+    L.push('## Overview');
+    if (data.files === 0) {
+      L.push('No signature index found yet — run `sigmap` (or `node gen-context.js`) to generate context, then regenerate this wiki.');
+    } else {
+      const fileWord = data.files === 1 ? 'indexed file' : 'indexed files';
+      const modWord = data.modules.length === 1 ? 'top-level module' : 'top-level modules';
+      L.push(`The codebase spans **${data.files} ${fileWord}** across **${data.modules.length} ${modWord}**, with ~${data.totalTokens} tokens of extracted signatures.`);
+      if (data.health) {
+        L.push(`Context health: **${data.health.score}/100 (${data.health.grade})**.`);
+      }
+    }
+    L.push('');
+
+    if (data.modules.length) {
+      L.push('## Modules');
+      L.push('| Module | Files | Sig tokens | Key files |');
+      L.push('|--------|-------|------------|-----------|');
+      for (const m of data.modules) {
+        L.push(`| \`${m.name}\` | ${m.files} | ~${m.tokens} | ${m.keyFiles.map((f) => `\`${f}\``).join(', ')} |`);
+      }
+      const top = data.modules[0];
+      L.push('');
+      L.push(`The largest module by signature volume is \`${top.name}\` (${top.files} files, ~${top.tokens} tokens) — start there for the core logic.`);
+      L.push('');
+    }
+
+    if (data.flow) {
+      L.push('## Dependency flow');
+      if (data.flow.hubs.length) {
+        L.push('The most depended-on files — changes here have the widest blast radius:');
+        L.push('');
+        L.push('| Hub file | Importers |');
+        L.push('|----------|-----------|');
+        for (const h of data.flow.hubs) L.push(`| \`${h.file}\` | ${h.importers} |`);
+        L.push('');
+      }
+      if (data.flow.entryPoints.length) {
+        L.push('Entry points (imported by nothing, importing the rest):');
+        L.push('');
+        for (const e of data.flow.entryPoints) L.push(`- \`${e.file}\` → ${e.imports} imports`);
+        L.push('');
+      }
+      L.push(data.flow.cycles
+        ? `**Dependency cycles:** ${data.flow.cycles} — untangle these first when refactoring.`
+        : '**Dependency cycles:** none detected.');
+      L.push('');
+    }
+
+    if (data.conventions) {
+      L.push('## Conventions');
+      const c = data.conventions;
+      const bits = [];
+      if (c.fileNaming && c.fileNaming.dominant) bits.push(`file naming is predominantly **${c.fileNaming.dominant}** (${c.fileNaming.pct}%, ${c.fileNaming.tier})`);
+      if (c.exportStyle && c.exportStyle.dominant) bits.push(`exports use the **${c.exportStyle.dominant}** style (${c.exportStyle.pct}%, ${c.exportStyle.tier})`);
+      if (c.testFramework) bits.push(`tests run on **${c.testFramework}**`);
+      L.push(bits.length
+        ? `In this repo, ${bits.join('; ')}. New code should match.`
+        : 'No dominant conventions detected (repo too small or styles mixed).');
+      L.push('');
+    }
+
+    L.push('## Navigating');
+    L.push('- `sigmap ask "<question>"` — ranked, budgeted mini-context for any task');
+    L.push('- `sigmap --impact <file>` / `--callers <symbol>` — blast radius before you change something');
+    L.push('- `sigmap evidence "<query>"` — machine-consumable Evidence Pack (JSON) for agents/CI');
+    L.push('- MCP: `get_architecture_overview`, `get_map`, `get_callee_signatures` for live agent access');
+    L.push('');
+
+    return L.join('\n');
+  }
+
+  module.exports = { buildWiki, renderWikiMarkdown };
+  
+};
+
 // ── ./src/workspace/detector ──
 __factories["./src/workspace/detector"] = function(module, exports) {
   
@@ -18733,7 +19214,7 @@ function __tryGit(args, opts = {}) {
   catch (_) { return ''; }
 }
 
-const VERSION = '8.11.0';
+const VERSION = '8.13.0';
 const MARKER = '\n\n## Auto-generated signatures\n<!-- Updated by gen-context.js -->\n';
 
 function requireSourceOrBundled(key) {
@@ -20607,6 +21088,7 @@ Usage:
   ${cmd} review-pr                         Audit a diff — scope drift, god-node edits, missing tests, security files (--staged, --base, --json, --markdown)
   ${cmd} review-pr --markdown              PR Evidence Report — branded Markdown (signatures + blast radius + tests) to post as a PR comment
   ${cmd} create "<task>"                   Grounded-creation pipeline: scaffold → verify-plan → verify-ai-output → review-pr (--staged)
+  ${cmd} wiki                              Deterministic architecture wiki from signatures + graph — no LLM (--json, --out <path>)
   ${cmd} squeeze <file|->                  Minimize a pasted stacktrace/CI-log/JSON blob (--json for stats)
   ${cmd} squeeze --response <file|->       Minimize an agent/tool response (same engine; also exposed as the squeeze_output MCP tool)
   ${cmd} ask "<query>" --squeeze           Auto-accept input minimization (no prompt; for scripts/CI)
@@ -22227,6 +22709,30 @@ function main() {
     process.exit(result.ok ? 0 : 1);
   }
 
+  // D9: `sigmap wiki` — deterministic architecture narrative (no LLM).
+  if (args[0] === 'wiki') {
+    const { buildWiki } = requireSourceOrBundled('./src/wiki/generate');
+    const result = buildWiki(cwd, { version: VERSION });
+    if (args.includes('--json')) {
+      process.stdout.write(JSON.stringify(result.data, null, 2) + '\n');
+      process.exit(0);
+    }
+    const outIdx = args.indexOf('--out');
+    const outRel = outIdx >= 0 && args[outIdx + 1] && !args[outIdx + 1].startsWith('--')
+      ? args[outIdx + 1]
+      : path.join('.context', 'WIKI.md');
+    const outPath = path.resolve(cwd, outRel);
+    try {
+      fs.mkdirSync(path.dirname(outPath), { recursive: true });
+      fs.writeFileSync(outPath, result.markdown, 'utf8');
+    } catch (e) {
+      console.error(`[sigmap] cannot write ${outPath}: ${e.message}`);
+      process.exit(1);
+    }
+    console.log(`[sigmap] wiki → ${path.relative(cwd, outPath)} (${result.data.files} files · ${result.data.modules.length} modules)`);
+    process.exit(0);
+  }
+
   // Layer 3: `sigmap conventions` — extract & report repo coding conventions
   // (file naming, export style, test framework) for TS/JS/Python so generated
   // code matches the house style. Writes .context/conventions.json.