sigmap 8.10.0 → 8.12.0

package/CHANGELOG.md

@@ -10,6 +10,27 @@ Format: [Semantic Versioning](https://semver.org/)
 
 ---
 
+## [8.12.0] — 2026-07-11
+
+Minor release — **`sigmap wiki`** (D9, the final unstarted in-boundary item from the master plan §3.5 backlog). With this, every in-boundary initiative D1–D9 has shipped.
+
+### Added
+- **`sigmap wiki` — deterministic architecture narrative (#465, PR #466):** writes `.context/WIKI.md` composed entirely from data SigMap already computes — overview (indexed files, modules, signature tokens, health grade), module rollup with key files, dependency flow (hub files, entry points, cycle count from the import graph), conventions summary, and navigation pointers. Template prose only: **no LLM, no network, no timestamps** — two consecutive runs on an unchanged repo are byte-identical (regression-tested). `--out <path>` overrides the target; `--json` emits the structured data instead. Graph paths are relativized against the builder's normalized base so hubs/entries render repo-relative on macOS tmpdirs.
+
+---
+
+## [8.11.0] — 2026-07-11
+
+Minor release — the **terse signature encoder** (D7 from the master plan), shipped under its measure-first gate: the public reduction number comes from a benchmark run on this repo, never borrowed from another tool's prose-compression claims.
+
+### Added
+- **`--terse` — deterministic terse signature encoding (#462, PR #463):** opt-in compaction of the generated signature block (`function `→`fn `, tightened params/arrows/exports). Measured on this repo by `npm run benchmark:terse`: **10,232 → 8,580 sig tokens (−16.1%)** across 143 files / 780 signature lines. The `:start-end` line anchor and any trailing doc hint are preserved byte-exactly, so `get_lines`, evidence packs, `parseAnchor`, and symbol extraction keep working; the ranker parses terse context files (regression-tested). `terse: false` config default — default output is byte-identical when off. New `benchmark:terse` npm script (`scripts/run-terse-benchmark.mjs`) is the only legitimate source for this number.
+
+### Changed
+- **README:** replaced the flaky Star History embed with a reliable link (PR #461); added the 'Verified on MseeP' badge below the MseeP security badge (PR #460).
+
+---
+
 ## [8.10.0] — 2026-07-09
 
 Minor release — **honesty fixes** from a brutal code-review audit of the CLI surface: closing the gap between what each command *claims* and what it *does*. All changes are zero-dependency, deterministic, and the bundle stays reproducible from `src/`. ~40 new regression tests.

package/README.md

@@ -16,6 +16,7 @@
 [![Discover on ShyPD](https://img.shields.io/badge/ShyPD-Discover-7c6af7?logo=data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgaGVpZ2h0PSIxNiIgdmlld0JveD0iMCAwIDE2IDE2Ij48Y2lyY2xlIGN4PSI4IiBjeT0iOCIgcj0iOCIgZmlsbD0id2hpdGUiLz48L3N2Zz4=&logoColor=7c6af7)](https://shypd.ai/tools/sigmap)
 
 [![MseeP.ai Security Assessment Badge](https://mseep.net/pr/manojmallick-sigmap-badge.png)](https://mseep.ai/app/manojmallick-sigmap)
+[![Verified on MseeP](https://mseep.ai/badge.svg)](https://mseep.ai/app/193cd37f-1ef3-43c3-80bc-86e23fd12924)
 
 </div>
 
@@ -121,8 +122,8 @@ Ask → Rank → Context → Validate → Judge → Learn
 
 <!--SM:benchmarkBlock-->
 ```
-Benchmark : sigmap-v8.10-main (21 repositories, including R language)
-Date      : 2026-07-09
+Benchmark : sigmap-v8.12-main (21 repositories, including R language)
+Date      : 2026-07-11
 
 Hit@5          : 87.8%   (baseline 13.6%  — 6.5× lift)
 Token reduction: 97.0%   (across 21 repos)
@@ -339,9 +340,7 @@ If SigMap saves you context or API spend, a ⭐ on [GitHub](https://github.com/m
 
 🌍 See where SigMap's stargazers are around the world on the **[StarMapper star map →](https://starmapper.bruniaux.com/manojmallick/sigmap)**.
 
-<a href="https://star-history.com/#manojmallick/sigmap&Date">
-  <img src="https://api.star-history.com/svg?repos=manojmallick/sigmap&type=Date" alt="SigMap Star History Chart" width="600" />
-</a>
+📈 Watch SigMap's growth on the **[Star History chart →](https://star-history.com/#manojmallick/sigmap&Date)**.
 
 [Report an issue](https://github.com/manojmallick/sigmap/issues) · [Changelog](CHANGELOG.md)
 

package/gen-context.js

@@ -1501,6 +1501,9 @@ __factories["./src/config/defaults"] = function(module, exports) {
     // Include a compact `name@version` list of installed direct deps (D8)
     versionPins: true,
 
+    // Terse signature encoding — deterministic compaction of sig lines (D7, opt-in)
+    terse: false,
+
     // Include TODO/FIXME/HACK/XXX comments as compact section
     todos: true,
 
@@ -10011,6 +10014,96 @@ __factories["./src/format/llms-txt"] = function(module, exports) {
   
 };
 
+// ── ./src/format/terse ──
+__factories["./src/format/terse"] = function(module, exports) {
+  
+  /**
+   * Terse signature encoder (D7).
+   *
+   * Deterministic compaction of signature lines for the generated context —
+   * opt-in via `--terse` / `terse: true`. Every transform is a fixed string
+   * rewrite (no heuristics, no LLM), so terse output stays byte-stable.
+   *
+   * The line anchor (`  :start-end`) and everything after it (Python/R doc
+   * hints) are preserved byte-exactly: `parseAnchor`, `get_lines`, and the
+   * evidence pack keep working on terse output. Symbol extraction is safe too —
+   * `extractName` in src/extractors/prdiff.js already recognizes `fn <name>`.
+   */
+
+  /** First `  :start[-end]` anchor token (two-space prefix, as emitted by line-anchor.js). */
+  const ANCHOR_RE = /\s{2}:\d+(?:-\d+)?(?=\s|$)/;
+
+  /**
+   * Split a signature into the compactable text and the byte-preserved suffix
+   * (anchor + any trailing doc hint).
+   * @param {string} sig
+   * @returns {{ text: string, suffix: string }}
+   */
+  function splitAnchor(sig) {
+    const s = String(sig);
+    const m = ANCHOR_RE.exec(s);
+    if (!m) return { text: s, suffix: '' };
+    return { text: s.slice(0, m.index), suffix: s.slice(m.index) };
+  }
+
+  /**
+   * Compact one signature line. Leading whitespace (member indentation) is kept.
+   * @param {string} sig
+   * @returns {string}
+   */
+  function encodeTerseSig(sig) {
+    const { text, suffix } = splitAnchor(sig);
+    let t = text
+      .replace(/\basync function\b/g, 'async fn')
+      .replace(/\bfunction\b/g, 'fn')
+      .replace(/\s+→\s+/g, '→')
+      .replace(/,\s+/g, ',')
+      .replace(/\s+=\s+/g, '=')
+      .replace(/\{\s+/g, '{')
+      .replace(/\s+\}/g, '}')
+      .replace(/(\S)\s{2,}(?=\S)/g, '$1 ')
+      .replace(/^module\.exports=/, 'exports=');
+    return t + suffix;
+  }
+
+  /**
+   * Compact an array of signature lines.
+   * @param {string[]} sigs
+   * @returns {string[]}
+   */
+  function encodeTerseSigs(sigs) {
+    return (sigs || []).map(encodeTerseSig);
+  }
+
+  /** Estimated tokens of joined signature lines (same chars/4 rule as elsewhere). */
+  function _tokens(sigs) {
+    return Math.ceil(sigs.join('\n').length / 4);
+  }
+
+  /**
+   * Measure the real reduction terse encoding buys over a set of signature
+   * lists — the D7 "measure first" gate. Never quote a number this didn't produce.
+   * @param {string[][]} sigsList one string[] per file
+   * @returns {{ beforeTokens: number, afterTokens: number, reductionPct: number }}
+   */
+  function measureTerse(sigsList) {
+    let beforeTokens = 0;
+    let afterTokens = 0;
+    for (const sigs of sigsList || []) {
+      if (!sigs || !sigs.length) continue;
+      beforeTokens += _tokens(sigs);
+      afterTokens += _tokens(encodeTerseSigs(sigs));
+    }
+    const reductionPct = beforeTokens > 0
+      ? Math.round(((beforeTokens - afterTokens) / beforeTokens) * 1000) / 10
+      : 0;
+    return { beforeTokens, afterTokens, reductionPct };
+  }
+
+  module.exports = { encodeTerseSig, encodeTerseSigs, measureTerse, splitAnchor };
+  
+};
+
 // ── ./src/format/usage-guidance ──
 __factories["./src/format/usage-guidance"] = function(module, exports) {
   
@@ -13950,7 +14043,7 @@ __factories["./src/mcp/server"] = function(module, exports) {
 
   const SERVER_INFO = {
     name: 'sigmap',
-    version: '8.10.0',
+    version: '8.12.0',
     description: 'SigMap MCP server — code signatures on demand',
   };
 
@@ -18532,6 +18625,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) {
   
@@ -18640,7 +18987,7 @@ function __tryGit(args, opts = {}) {
   catch (_) { return ''; }
 }
 
-const VERSION = '8.10.0';
+const VERSION = '8.12.0';
 const MARKER = '\n\n## Auto-generated signatures\n<!-- Updated by gen-context.js -->\n';
 
 function requireSourceOrBundled(key) {
@@ -19317,6 +19664,21 @@ function formatOutput(fileEntries, cwd, routingEnabled, config, extras) {
     groups[group].push({ rel, sigs: entry.sigs });
   }
 
+  // D7: terse signature encoding — anchors preserved byte-exactly
+  const terseOn = !!(config && config.terse);
+  let encodeTerseSigs = null;
+  if (terseOn) {
+    try {
+      const terseMod = requireSourceOrBundled('./src/format/terse');
+      encodeTerseSigs = terseMod.encodeTerseSigs;
+      const m = terseMod.measureTerse(fileEntries.map((e) => e.sigs));
+      console.warn(`[sigmap] terse: sig block ${m.beforeTokens} → ${m.afterTokens} tokens (-${m.reductionPct}%)`);
+    } catch (err) {
+      encodeTerseSigs = null;
+      console.warn(`[sigmap] terse encoding skipped: ${err.message}`);
+    }
+  }
+
   for (const [group, entries] of Object.entries(groups).sort()) {
     lines.push(`## ${group}`);
     lines.push('');
@@ -19326,7 +19688,7 @@ function formatOutput(fileEntries, cwd, routingEnabled, config, extras) {
       const usedByStr = usedBy && usedBy.length ? ` (used by: ${usedBy.join(', ')})` : '';
       lines.push(`### ${rel}${usedByStr}`);
       lines.push('```');
-      lines.push(...sigs);
+      lines.push(...(encodeTerseSigs ? encodeTerseSigs(sigs) : sigs));
       lines.push('```');
       lines.push('');
     }
@@ -20440,6 +20802,7 @@ Usage:
   ${cmd} --monorepo                        Generate per-package context (monorepo)
   ${cmd} --each                            Run for every repo in the current directory
   ${cmd} --routing                         Include model routing hints in output
+  ${cmd} --terse                           Compact signature encoding (deterministic; line anchors preserved)
   ${cmd} --format cache                    Also write Anthropic prompt-cache JSON
   ${cmd} --track                           Append run metrics to .context/usage.ndjson
   ${cmd} --watch                           Generate + watch for file changes
@@ -20498,6 +20861,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)
@@ -20826,6 +21190,11 @@ function main() {
     config.testCoverage = true;
   }
 
+  // --terse: compact signature encoding without editing config (D7)
+  if (args.includes('--terse')) {
+    config.terse = true;
+  }
+
   // ── --output <file> — parse early so every subsequent block can use it ─────
   // Resolves the custom output path and merges it into config.customOutput.
   // Also persists the resolved relative path to gen-context.config.json so
@@ -22113,6 +22482,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.

package/llms-full.txt

@@ -11,13 +11,13 @@ 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.10.0 | Benchmark: sigmap-v8.10-main (2026-07-09)
+# Version: 8.12.0 | Benchmark: sigmap-v8.12-main (2026-07-11)
 # 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.10-main, 2026-07-09)
+## Core metrics (benchmark: sigmap-v8.12-main, 2026-07-11)
 
 | Metric | Without SigMap | With SigMap |
 |--------|----------------|-------------|
@@ -55,6 +55,7 @@ sigmap                                   Generate context once and exit
 sigmap --monorepo                        Generate per-package context (monorepo)
 sigmap --each                            Run for every repo in the current directory
 sigmap --routing                         Include model routing hints in output
+sigmap --terse                           Compact signature encoding (deterministic; line anchors preserved)
 sigmap --format cache                    Also write Anthropic prompt-cache JSON
 sigmap --track                           Append run metrics to .context/usage.ndjson
 sigmap --watch                           Generate + watch for file changes
@@ -113,6 +114,7 @@ sigmap verify-plan <plan.md|->           Check a plan vs the live index — file
 sigmap review-pr                         Audit a diff — scope drift, god-node edits, missing tests, security files (--staged, --base, --json, --markdown)
 sigmap review-pr --markdown              PR Evidence Report — branded Markdown (signatures + blast radius + tests) to post as a PR comment
 sigmap create "<task>"                   Grounded-creation pipeline: scaffold → verify-plan → verify-ai-output → review-pr (--staged)
+sigmap wiki                              Deterministic architecture wiki from signatures + graph — no LLM (--json, --out <path>)
 sigmap squeeze <file|->                  Minimize a pasted stacktrace/CI-log/JSON blob (--json for stats)
 sigmap squeeze --response <file|->       Minimize an agent/tool response (same engine; also exposed as the squeeze_output MCP tool)
 sigmap ask "<query>" --squeeze           Auto-accept input minimization (no prompt; for scripts/CI)
@@ -325,6 +327,7 @@ tracking = false
 mcp = {"autoRegister":true}
 depMap = true
 versionPins = true
+terse = false
 todos = true
 changes = true
 changesCommits = 10

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.10.0 | Benchmark: sigmap-v8.10-main (2026-07-09)
+# Version: 8.12.0 | Benchmark: sigmap-v8.12-main (2026-07-11)
 # 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,7 +23,7 @@ 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.10-main, 2026-07-09)
+## Core metrics (benchmark: sigmap-v8.12-main, 2026-07-11)
 
 - hit@5 retrieval: 87.8% vs 13.6% random baseline (6.5× lift)
 - Token reduction: 97.0% average across benchmark repos

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sigmap",
-  "version": "8.10.0",
+  "version": "8.12.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": {
@@ -29,6 +29,7 @@
     "benchmark:verify": "node scripts/run-verify-benchmark.mjs",
     "benchmark:squeeze": "node scripts/run-squeeze-benchmark.mjs --save",
     "benchmark:test-discovery": "node scripts/run-test-discovery-benchmark.mjs --save",
+    "benchmark:terse": "node scripts/run-terse-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.10.0",
+  "version": "8.12.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.10.0",
+  "version": "8.12.0",
   "description": "SigMap core library — zero-dependency code signature extraction, retrieval, and security scanning",
   "main": "index.js",
   "keywords": [

package/src/config/defaults.js

@@ -117,6 +117,9 @@ const DEFAULTS = {
   // Include a compact `name@version` list of installed direct deps (D8)
   versionPins: true,
 
+  // Terse signature encoding — deterministic compaction of sig lines (D7, opt-in)
+  terse: false,
+
   // Include TODO/FIXME/HACK/XXX comments as compact section
   todos: true,