sigmap 6.14.0 → 7.0.0

package/gen-context.js

@@ -3164,55 +3164,78 @@ __factories["./src/extractors/coverage"] = function(module, exports) {
 
 // ── ./src/extractors/prdiff ──
 __factories["./src/extractors/prdiff"] = function(module, exports) {
+'use strict';
 
-  'use strict';
-
-  /**
-   * Compare signature arrays and produce compact diff markers.
-   * @param {string[]} baseSigs
-   * @param {string[]} currentSigs
-   * @returns {{added:string[], removed:string[], modified:string[]}}
-   */
-  function diffSignatures(baseSigs, currentSigs) {
-    const base = new Set(baseSigs || []);
-    const curr = new Set(currentSigs || []);
-
-    const added = [...curr].filter((s) => !base.has(s));
-    const removed = [...base].filter((s) => !curr.has(s));
-
-    const byName = (arr) => {
-      const m = new Map();
-      for (const s of arr) {
-        const n = extractName(s);
-        if (!n) continue;
-        if (!m.has(n)) m.set(n, []);
-        m.get(n).push(s);
-      }
-      return m;
-    };
-
-    const aBy = byName(added);
-    const rBy = byName(removed);
-    const modified = [];
+/**
+ * Compare signature arrays and produce compact diff markers.
+ * @param {string[]} baseSigs
+ * @param {string[]} currentSigs
+ * @returns {{added:string[], removed:string[], modified:string[]}}
+ */
+function diffSignatures(baseSigs, currentSigs) {
+  const base = new Set(baseSigs || []);
+  const curr = new Set(currentSigs || []);
+
+  const added = [...curr].filter((s) => !base.has(s));
+  const removed = [...base].filter((s) => !curr.has(s));
+
+  const byName = (arr) => {
+    const m = new Map();
+    for (const s of arr) {
+      const n = extractName(s);
+      if (!n) continue;
+      if (!m.has(n)) m.set(n, []);
+      m.get(n).push(s);
+    }
+    return m;
+  };
 
-    for (const [name] of aBy) {
-      if (rBy.has(name)) modified.push(name);
-    }
+  const aBy = byName(added);
+  const rBy = byName(removed);
+  const modified = [];
 
-    return { added, removed, modified };
+  for (const [name] of aBy) {
+    if (rBy.has(name)) modified.push(name);
   }
 
-  function extractName(sig) {
-    if (!sig) return '';
-    const t = sig.trim();
-    const m = t.match(/(?:def|function|func|class|interface|trait|struct|enum|record)?\s*([A-Za-z_][A-Za-z0-9_]*)\s*(?:\(|$)/);
-    return m ? m[1] : '';
-  }
+  return { added, removed, modified };
+}
+
+/**
+ * Extract the declared symbol name from a signature line.
+ *
+ * Robust to the real forms SigMap emits — `export class X`, `const x = () =>`,
+ * `async function x`, members, a trailing `:start-end` anchor, and `→ return`
+ * suffixes. Anchored so it never returns a mid-string fragment (the old regex
+ * could turn a signature into a 2-char name like `is`), and returns '' for
+ * non-symbol lines (`module.exports = {…}`, markdown headers) instead of guessing.
+ */
+function extractName(sig) {
+  if (!sig) return '';
+  // Drop a trailing `:start-end` (or `:line`) line anchor.
+  let t = String(sig).replace(/\s*:\d+(?:-\d+)?\s*$/, '').trim();
+  // Re-export / barrel lines carry no single declared name.
+  if (/^(?:module\.)?exports\b/.test(t) || /^export\s*\{/.test(t) || /^export\s+\*/.test(t)) return '';
+  // Strip leading modifiers so the keyword/name is at the start.
+  t = t.replace(/^export\s+/, '')
+       .replace(/^default\s+/, '')
+       .replace(/^(?:public|private|protected|static|abstract|final|override|readonly)\s+/g, '')
+       .replace(/^async\s+/, '');
+  let m;
+  // Declared forms: function/def/func/fn/class/interface/trait/struct/enum/record/type <name>
+  if ((m = t.match(/^(?:def|function|func|fn|class|interface|trait|struct|enum|record|type)\s+([A-Za-z_$][\w$]*)/))) return m[1];
+  // const/let/var/val <name> = …  (arrow functions, assigned values)
+  if ((m = t.match(/^(?:const|let|var|val)\s+([A-Za-z_$][\w$]*)/))) return m[1];
+  // Call / method form: <name>(…)
+  if ((m = t.match(/^([A-Za-z_$][\w$]*)\s*\(/))) return m[1];
+  // Lone identifier (e.g. a collapsed `symbol` after the anchor was stripped).
+  if ((m = t.match(/^([A-Za-z_$][\w$]*)$/))) return m[1];
+  return '';
+}
 
-  module.exports = { diffSignatures, extractName };
+module.exports = { diffSignatures, extractName };
 
 };
-
 // ── ./src/extractors/r ──
 __factories["./src/extractors/r"] = function(module, exports) {
 
@@ -5506,487 +5529,570 @@ __factories["./src/graph/impact"] = function(module, exports) {
 
 // ── ./src/mcp/handlers ──
 __factories["./src/mcp/handlers"] = function(module, exports) {
-  
-  const fs   = require('fs');
-  const path = require('path');
-  const { execSync } = require('child_process');
-  
-  const CONTEXT_FILE = path.join('.github', 'copilot-instructions.md');
-  
-  // Section header keywords in PROJECT_MAP.md
-  const MAP_SECTIONS = {
-    imports: '### Import graph',
-    classes: '### Class hierarchy',
-    routes: '### Route table',
-  };
-  
-  /**
-   * read_context({ module? }) → string
-   *
-   * Returns the full context file, or just the sections whose file paths
-   * contain the given module substring.
-   */
-  function readContext(args, cwd) {
-    const contextPath = path.join(cwd, CONTEXT_FILE);
-    if (!fs.existsSync(contextPath)) {
-      return 'No context file found. Run: node gen-context.js';
-    }
-  
-    const content = fs.readFileSync(contextPath, 'utf8');
-  
-    if (!args || !args.module) return content;
-  
-    const mod = args.module.replace(/\\/g, '/').replace(/\/$/, '');
-    const lines = content.split('\n');
-    const result = [];
-    let capturing = false;
-  
-    for (const line of lines) {
-      if (line.startsWith('### ')) {
-        const filePath = line.slice(4).trim().replace(/\\/g, '/');
-        // Match if file path starts with mod or contains /mod/ or /mod
-        capturing =
-          filePath === mod ||
-          filePath.startsWith(mod + '/') ||
-          filePath.includes('/' + mod + '/') ||
-          filePath.includes('/' + mod);
-        if (capturing) result.push(line);
-        continue;
-      }
-      if (capturing) result.push(line);
-    }
-  
-    if (result.length === 0) return `No signatures found for module: ${mod}`;
-    return result.join('\n');
-  }
-  
-  /**
-   * search_signatures({ query }) → string
-   *
-   * Case-insensitive search through all signature lines.
-   * Returns matching lines grouped by file path.
-   */
-  function searchSignatures(args, cwd) {
-    if (!args || !args.query) return 'Missing required argument: query';
-    const query = args.query.toLowerCase();
+'use strict';
 
-    try {
-      const { buildSigIndex } = __require('./src/retrieval/ranker');
-      const index = buildSigIndex(cwd);
-      if (index.size === 0) {
-        return 'No context file found. Run: node gen-context.js';
-      }
+const fs   = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
 
-      const result = [];
-      for (const [file, sigs] of index.entries()) {
-        const hits = sigs.filter((s) => s.toLowerCase().includes(query));
-        if (hits.length === 0) continue;
-        if (result.length > 0) result.push('');
-        result.push(`### ${file}`);
-        result.push(...hits);
-      }
+const CONTEXT_FILE = path.join('.github', 'copilot-instructions.md');
+const CONTEXT_COLD_FILE = path.join('.github', 'context-cold.md');
 
-      if (result.length === 0) return `No signatures found matching: ${args.query}`;
-      return result.join('\n');
-    } catch (err) {
-      return `_search_signatures failed: ${err.message}_`;
-    }
+function _readContextFiles(cwd) {
+  const paths = [path.join(cwd, CONTEXT_FILE), path.join(cwd, CONTEXT_COLD_FILE)];
+  const chunks = [];
+  for (const p of paths) {
+    if (fs.existsSync(p)) chunks.push(fs.readFileSync(p, 'utf8'));
   }
-  
-  /**
-   * get_map({ type }) → string
-   *
-   * Returns a section from PROJECT_MAP.md.
-   * type: 'imports' | 'classes' | 'routes'
-   */
-  function getMap(args, cwd) {
-    if (!args || !args.type) return 'Missing required argument: type';
-  
-    const header = MAP_SECTIONS[args.type];
-    if (!header) {
-      return `Unknown map type: "${args.type}". Use: imports, classes, routes`;
-    }
-  
-    const mapPath = path.join(cwd, 'PROJECT_MAP.md');
-    if (!fs.existsSync(mapPath)) {
-      return 'PROJECT_MAP.md not found. Run: node gen-project-map.js';
-    }
-  
-    const content = fs.readFileSync(mapPath, 'utf8');
-    const idx = content.indexOf(header);
-    if (idx === -1) {
-      return `Section "${header}" not found in PROJECT_MAP.md`;
+  return chunks.join('\n');
+}
+
+// Section header keywords in PROJECT_MAP.md
+const MAP_SECTIONS = {
+  imports: '### Import graph',
+  classes: '### Class hierarchy',
+  routes: '### Route table',
+};
+
+/**
+ * read_context({ module? }) → string
+ *
+ * Returns the full context file, or just the sections whose file paths
+ * contain the given module substring.
+ */
+function readContext(args, cwd) {
+  const content = _readContextFiles(cwd);
+  if (!content) {
+    return 'No context file found. Run: node gen-context.js';
+  }
+
+  if (!args || !args.module) return content;
+
+  const mod = args.module.replace(/\\/g, '/').replace(/\/$/, '');
+  const lines = content.split('\n');
+  const result = [];
+  let capturing = false;
+
+  for (const line of lines) {
+    if (line.startsWith('### ')) {
+      const filePath = line.slice(4).trim().replace(/\\/g, '/');
+      // Match if file path starts with mod or contains /mod/ or /mod
+      capturing =
+        filePath === mod ||
+        filePath.startsWith(mod + '/') ||
+        filePath.includes('/' + mod + '/') ||
+        filePath.includes('/' + mod);
+      if (capturing) result.push(line);
+      continue;
     }
-  
-    // Extract from this header to the next ### header
-    const after = content.slice(idx);
-    const nextMatch = after.slice(header.length).search(/\n###\s/);
-    return nextMatch === -1 ? after : after.slice(0, header.length + nextMatch);
+    if (capturing) result.push(line);
   }
-  
-  /**
-   * create_checkpoint({ note? }) → string
-   *
-   * Returns a markdown checkpoint summarising current project state:
-   * - Timestamp and optional user note
-   * - Active git branch + last 5 commit messages
-   * - Token count of current context file
-   * - List of modules present in the context
-   * - Route count (if PROJECT_MAP.md exists)
-   */
-  function createCheckpoint(args, cwd) {
-    const note = (args && args.note) ? args.note.trim() : '';
-    const now = new Date().toISOString().replace('T', ' ').slice(0, 19) + ' UTC';
-    const lines = [
-      '# SigMap Checkpoint',
-      `**Created:** ${now}`,
-    ];
-  
-    if (note) lines.push(`**Note:** ${note}`);
-    lines.push('');
-  
-    // ── Git info ────────────────────────────────────────────────────────────
-    lines.push('## Git state');
-    try {
-      const branch = execSync('git rev-parse --abbrev-ref HEAD', {
-        cwd, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'],
-      }).trim();
-      lines.push(`**Branch:** ${branch}`);
-    } catch (_) {
-      lines.push('**Branch:** (not a git repo)');
-    }
-  
-    try {
-      const log = execSync(
-        'git log --oneline -5 --no-decorate 2>/dev/null',
-        { cwd, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }
-      ).trim();
-      if (log) {
-        lines.push('');
-        lines.push('**Recent commits:**');
-        for (const l of log.split('\n')) lines.push(`- ${l}`);
-      }
-    } catch (_) {} // ignore — not every project uses git
-    lines.push('');
-  
-    // ── Context stats ────────────────────────────────────────────────────────
-    lines.push('## Context snapshot');
-    const contextPath = path.join(cwd, CONTEXT_FILE);
-    if (fs.existsSync(contextPath)) {
-      const content = fs.readFileSync(contextPath, 'utf8');
-      const tokens = Math.ceil(content.length / 4);
-  
-      // Count modules (### headers are file paths)
-      const modules = content.split('\n').filter((l) => l.startsWith('### ')).map((l) => l.slice(4).trim());
-      lines.push(`**Token count:** ~${tokens}`);
-      lines.push(`**Modules in context:** ${modules.length}`);
-  
-      if (modules.length > 0) {
-        lines.push('');
-        lines.push('**Modules:**');
-        for (const m of modules.slice(0, 20)) lines.push(`- ${m}`);
-        if (modules.length > 20) lines.push(`- … and ${modules.length - 20} more`);
-      }
-    } else {
-      lines.push('_No context file found. Run: node gen-context.js_');
+
+  if (result.length === 0) return `No signatures found for module: ${mod}`;
+  return result.join('\n');
+}
+
+/**
+ * search_signatures({ query }) → string
+ *
+ * Case-insensitive search through all signature lines.
+ * Returns matching lines grouped by file path.
+ */
+function searchSignatures(args, cwd) {
+  if (!args || !args.query) return 'Missing required argument: query';
+
+  const query = args.query.toLowerCase();
+  try {
+    const { buildSigIndex } = __require('./src/retrieval/ranker');
+    const index = buildSigIndex(cwd);
+    if (index.size === 0) {
+      return 'No context file found. Run: node gen-context.js';
     }
-    lines.push('');
-  
-    // ── Route summary ────────────────────────────────────────────────────────
-    const mapPath = path.join(cwd, 'PROJECT_MAP.md');
-    if (fs.existsSync(mapPath)) {
-      const mapContent = fs.readFileSync(mapPath, 'utf8');
-      const routeLines = mapContent.split('\n').filter((l) => l.startsWith('| ') && !l.startsWith('| Method') && !l.startsWith('|---'));
-      if (routeLines.length > 0) {
-        lines.push('## Routes');
-        lines.push(`**Total routes detected:** ${routeLines.length}`);
-        lines.push('');
-        for (const r of routeLines.slice(0, 10)) lines.push(r);
-        if (routeLines.length > 10) lines.push(`| … | +${routeLines.length - 10} more | |`);
-        lines.push('');
-      }
+
+    const result = [];
+    for (const [file, sigs] of index.entries()) {
+      const hits = sigs.filter((s) => s.toLowerCase().includes(query));
+      if (hits.length === 0) continue;
+      if (result.length > 0) result.push('');
+      result.push(`### ${file}`);
+      result.push(...hits);
     }
-  
-    lines.push('---');
-    lines.push('_Generated by SigMap `create_checkpoint`_');
-  
-    return lines.join('\n');
+
+    if (result.length === 0) return `No signatures found matching: ${args.query}`;
+    return result.join('\n');
+  } catch (err) {
+    return `_search_signatures failed: ${err.message}_`;
   }
-  
-  /**
-   * get_routing({}) → string
-   *
-   * Reads the current context file, classifies all indexed files by complexity,
-   * and returns a formatted markdown routing guide showing which files belong
-   * to the fast/balanced/powerful model tier.
-   */
-  function getRouting(args, cwd) {
-    const contextPath = path.join(cwd, CONTEXT_FILE);
-    if (!fs.existsSync(contextPath)) {
-      return (
-        '_No context file found. Run `node gen-context.js --routing` first._\n\n' +
-        'This generates routing hints that map each file to a model tier:\n' +
-        '- **fast** (haiku/gpt-4o-mini) — config, markup, trivial utilities\n' +
-        '- **balanced** (sonnet/gpt-4o) — standard application code\n' +
-        '- **powerful** (opus/gpt-4-turbo) — complex, security-critical, or large modules'
-      );
-    }
-  
-    // Parse file list from context (### headings are file paths)
-    const content = fs.readFileSync(contextPath, 'utf8');
-    const fileRels = content.split('\n')
-      .filter((l) => l.startsWith('### '))
-      .map((l) => l.slice(4).trim());
-  
-    // Build synthetic fileEntries for the classifier
-    // We don't have live sig arrays here, so rebuild from the context blocks
-    const entries = [];
-    const blocks = content.split(/^### /m).slice(1); // slice past the header
-    for (const block of blocks) {
-      const firstLine = block.split('\n')[0].trim();
-      const codeBlock = block.match(/```\n([\s\S]*?)```/);
-      const sigs = codeBlock ? codeBlock[1].trim().split('\n').filter(Boolean) : [];
-      entries.push({ filePath: path.join(cwd, firstLine), sigs });
-    }
-  
-    try {
-      const { classifyAll } = __require('./src/routing/classifier');
-      const { formatRoutingSection } = __require('./src/routing/hints');
-      const groups = classifyAll(entries, cwd);
-      return formatRoutingSection(groups);
-    } catch (err) {
-      return `_Routing classification failed: ${err.message}_`;
-    }
+}
+
+/**
+ * get_map({ type }) → string
+ *
+ * Returns a section from PROJECT_MAP.md.
+ * type: 'imports' | 'classes' | 'routes'
+ */
+function getMap(args, cwd) {
+  if (!args || !args.type) return 'Missing required argument: type';
+
+  const header = MAP_SECTIONS[args.type];
+  if (!header) {
+    return `Unknown map type: "${args.type}". Use: imports, classes, routes`;
   }
-  
-  function explainFile(args, cwd) {
-    if (!args || !args.path) return 'Missing required argument: path';
-  
-    const targetRel = args.path.replace(/\\/g, '/').replace(/^\//, '');
-    const targetAbs = path.resolve(cwd, targetRel);
-    const contextPath = path.join(cwd, CONTEXT_FILE);
-  
-    const lines = ['# explain_file: ' + targetRel, ''];
-  
-    lines.push('## Signatures');
-    let indexedFiles = [];
-  
-    if (fs.existsSync(contextPath)) {
-      const ctxContent = fs.readFileSync(contextPath, 'utf8');
-      const ctxLines = ctxContent.split('\n');
-      let capturing = false;
-      const sigLines = [];
-  
-      for (const line of ctxLines) {
-        if (line.startsWith('### ')) {
-          if (capturing) break;
-          const rel = line.slice(4).trim().replace(/\\/g, '/');
-          capturing = rel === targetRel || rel.endsWith('/' + targetRel) || targetRel.endsWith('/' + rel);
-          if (capturing) continue;
-        } else if (capturing) {
-          sigLines.push(line);
-        }
-      }
-  
-      const sigs = sigLines.filter((l) => l !== '```' && l.trim() !== '');
-      if (sigs.length > 0) {
-        lines.push(...sigs);
-      } else {
-        lines.push('_No signatures indexed for this file. Run: node gen-context.js_');
-      }
-  
-      indexedFiles = ctxContent
-        .split('\n')
-        .filter((l) => l.startsWith('### '))
-        .map((l) => path.resolve(cwd, l.slice(4).trim()));
-    } else {
-      lines.push('_No context file found. Run: node gen-context.js_');
-    }
-  
-    if (!fs.existsSync(targetAbs)) {
-      lines.push('');
-      lines.push('> File not found on disk: ' + targetRel);
-      return lines.join('\n');
-    }
-  
-    lines.push('');
-  
-    lines.push('## Imports (direct dependencies)');
-    try {
-      const { extractImports } = __require('./src/map/import-graph');
-      const fileContent = fs.readFileSync(targetAbs, 'utf8');
-      const fileSet = new Set(indexedFiles);
-      fileSet.add(targetAbs);
-      const imports = extractImports(targetAbs, fileContent, fileSet);
-      if (imports.length > 0) {
-        for (const imp of imports) lines.push('- ' + path.relative(cwd, imp).replace(/\\/g, '/'));
-      } else {
-        lines.push('_No resolvable relative imports found._');
-      }
-    } catch (err) {
-      lines.push('_Could not analyze imports: ' + err.message + '_');
-    }
-  
-    lines.push('');
-  
-    lines.push('## Callers (files that import this file)');
-    try {
-      const { extractImports } = __require('./src/map/import-graph');
-      const fileSet = new Set(indexedFiles);
-      fileSet.add(targetAbs);
-      const callers = [];
-      for (const f of indexedFiles) {
-        if (f === targetAbs || !fs.existsSync(f)) continue;
-        try {
-          const fc = fs.readFileSync(f, 'utf8');
-          const imps = extractImports(f, fc, fileSet);
-          if (imps.includes(targetAbs)) callers.push(path.relative(cwd, f).replace(/\\/g, '/'));
-        } catch (_) {}
-      }
-      if (callers.length > 0) {
-        for (const c of callers) lines.push('- ' + c);
-      } else {
-        lines.push('_No indexed files import this file._');
-      }
-    } catch (err) {
-      lines.push('_Could not analyze callers: ' + err.message + '_');
-    }
-  
-    return lines.join('\n');
+
+  const mapPath = path.join(cwd, 'PROJECT_MAP.md');
+  if (!fs.existsSync(mapPath)) {
+    return 'PROJECT_MAP.md not found. Run: node gen-project-map.js';
   }
-  
-  function listModules(args, cwd) {
-    try {
-      const { buildSigIndex } = __require('./src/retrieval/ranker');
-      const index = buildSigIndex(cwd);
-      if (index.size === 0) {
-        return 'No context file found. Run: node gen-context.js';
-      }
 
-      const groups = {};
-      for (const [rel, sigs] of index.entries()) {
-        const parts = rel.split('/');
-        const mod = parts.length > 1 ? parts[0] : '.';
-        if (!groups[mod]) groups[mod] = { fileCount: 0, tokenCount: 0 };
-        groups[mod].fileCount++;
-        groups[mod].tokenCount += Math.ceil(sigs.join('\n').length / 4);
-      }
+  const content = fs.readFileSync(mapPath, 'utf8');
+  const idx = content.indexOf(header);
+  if (idx === -1) {
+    return `Section "${header}" not found in PROJECT_MAP.md`;
+  }
 
-      const sorted = Object.entries(groups)
-        .map(([mod, data]) => ({ module: mod, fileCount: data.fileCount, tokenCount: data.tokenCount }))
-        .sort((a, b) => b.tokenCount - a.tokenCount);
+  // Extract from this header to the next ### header
+  const after = content.slice(idx);
+  const nextMatch = after.slice(header.length).search(/\n###\s/);
+  return nextMatch === -1 ? after : after.slice(0, header.length + nextMatch);
+}
 
-      if (sorted.length === 0) return 'No modules found in context file.';
+/**
+ * create_checkpoint({ note? }) → string
+ *
+ * Returns a markdown checkpoint summarising current project state:
+ * - Timestamp and optional user note
+ * - Active git branch + last 5 commit messages
+ * - Token count of current context file
+ * - List of modules present in the context
+ * - Route count (if PROJECT_MAP.md exists)
+ */
+function createCheckpoint(args, cwd) {
+  const note = (args && args.note) ? args.note.trim() : '';
+  const now = new Date().toISOString().replace('T', ' ').slice(0, 19) + ' UTC';
+  const lines = [
+    '# SigMap Checkpoint',
+    `**Created:** ${now}`,
+  ];
 
-      const total = sorted.reduce((s, m) => s + m.tokenCount, 0);
+  if (note) lines.push(`**Note:** ${note}`);
+  lines.push('');
 
-      return [
-        '# Modules',
-        '',
-        '| Module | Files | Tokens |',
-        '|--------|-------|--------|',
-        ...sorted.map((m) => `| ${m.module} | ${m.fileCount} | ~${m.tokenCount} |`),
-        '',
-        `**Total context tokens: ~${total}**`,
-        '',
-        '_Use `read_context({ module: "name" })` to get signatures for a specific module._',
-      ].join('\n');
-    } catch (err) {
-      return `_list_modules failed: ${err.message}_`;
-    }
-  }
-  
-  function queryContext(args, cwd) {
-    if (!args || !args.query) return 'Missing required argument: query';
-    const contextPath = path.join(cwd, CONTEXT_FILE);
-    if (!fs.existsSync(contextPath)) return 'No context file found. Run: node gen-context.js';
-    try {
-      const { rank, buildSigIndex, formatRankTable } = __require('./src/retrieval/ranker');
-      const index = buildSigIndex(cwd);
-      if (index.size === 0) return 'No signatures indexed. Run: node gen-context.js';
-      const topK = Math.min(Math.max(1, parseInt(args.topK, 10) || 10), 25);
-      const results = rank(args.query, index, { topK, cwd });
-      return formatRankTable(results, args.query);
-    } catch (err) {
-      return `_query_context failed: ${err.message}_`;
-    }
+  // ── Git info ────────────────────────────────────────────────────────────
+  lines.push('## Git state');
+  try {
+    const branch = execSync('git rev-parse --abbrev-ref HEAD', {
+      cwd, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+    lines.push(`**Branch:** ${branch}`);
+  } catch (_) {
+    lines.push('**Branch:** (not a git repo)');
   }
-  
-  function getImpact(args, cwd) {
-    if (!args || !args.file) return 'Missing required argument: file';
-    try {
-      const { analyzeImpact, formatImpact } = __require('./src/graph/impact');
-      const depth = Math.max(0, parseInt(args.depth, 10) || 3);
-      const results = analyzeImpact(args.file, cwd, { depth });
-      return results.map((r) => formatImpact(r.impact)).join('\n\n---\n\n');
-    } catch (err) {
-      return `_get_impact failed: ${err.message}_`;
+
+  try {
+    const log = execSync(
+      'git log --oneline -5 --no-decorate 2>/dev/null',
+      { cwd, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }
+    ).trim();
+    if (log) {
+      lines.push('');
+      lines.push('**Recent commits:**');
+      for (const l of log.split('\n')) lines.push(`- ${l}`);
     }
-  }
+  } catch (_) {} // ignore — not every project uses git
+  lines.push('');
 
-  function getLines(args, cwd) {
-    if (!args || !args.file) return 'Missing required argument: file';
+  // ── Context stats ────────────────────────────────────────────────────────
+  lines.push('## Context snapshot');
+  const contextPath = path.join(cwd, CONTEXT_FILE);
+  if (fs.existsSync(contextPath)) {
+    const content = fs.readFileSync(contextPath, 'utf8');
+    const tokens = Math.ceil(content.length / 4);
 
-    const rel = String(args.file).replace(/\\/g, '/').replace(/^\//, '');
-    const abs = path.resolve(cwd, rel);
+    // Count modules (### headers are file paths)
+    const modules = content.split('\n').filter((l) => l.startsWith('### ')).map((l) => l.slice(4).trim());
+    lines.push(`**Token count:** ~${tokens}`);
+    lines.push(`**Modules in context:** ${modules.length}`);
 
-    // Sandbox: refuse paths that resolve outside the project root.
-    const root = path.resolve(cwd);
-    if (abs !== root && !abs.startsWith(root + path.sep)) {
-      return `Refused: ${rel} resolves outside the project root`;
+    if (modules.length > 0) {
+      lines.push('');
+      lines.push('**Modules:**');
+      for (const m of modules.slice(0, 20)) lines.push(`- ${m}`);
+      if (modules.length > 20) lines.push(`- … and ${modules.length - 20} more`);
     }
-    if (!fs.existsSync(abs) || !fs.statSync(abs).isFile()) {
-      return `File not found: ${rel}`;
+  } else {
+    lines.push('_No context file found. Run: node gen-context.js_');
+  }
+  lines.push('');
+
+  // ── Route summary ────────────────────────────────────────────────────────
+  const mapPath = path.join(cwd, 'PROJECT_MAP.md');
+  if (fs.existsSync(mapPath)) {
+    const mapContent = fs.readFileSync(mapPath, 'utf8');
+    const routeLines = mapContent.split('\n').filter((l) => l.startsWith('| ') && !l.startsWith('| Method') && !l.startsWith('|---'));
+    if (routeLines.length > 0) {
+      lines.push('## Routes');
+      lines.push(`**Total routes detected:** ${routeLines.length}`);
+      lines.push('');
+      for (const r of routeLines.slice(0, 10)) lines.push(r);
+      if (routeLines.length > 10) lines.push(`| … | +${routeLines.length - 10} more | |`);
+      lines.push('');
     }
+  }
 
-    const start = parseInt(args.start, 10);
-    const end = parseInt(args.end, 10);
-    if (!Number.isFinite(start) || !Number.isFinite(end)) {
-      return 'Arguments "start" and "end" must be numbers (1-based line numbers).';
-    }
+  lines.push('---');
+  lines.push('_Generated by SigMap `create_checkpoint`_');
 
-    let lines;
-    try {
-      lines = fs.readFileSync(abs, 'utf8').split('\n');
-    } catch (err) {
-      return `Could not read ${rel}: ${err.message}`;
-    }
+  return lines.join('\n');
+}
 
-    const total = lines.length;
-    const from = Math.max(1, Math.min(start, end));
-    const to = Math.min(total, Math.max(start, end));
-    if (from > total) return `${rel} has only ${total} lines; requested ${start}-${end}`;
+/**
+ * get_routing({}) → string
+ *
+ * Reads the current context file, classifies all indexed files by complexity,
+ * and returns a formatted markdown routing guide showing which files belong
+ * to the fast/balanced/powerful model tier.
+ */
+function getRouting(args, cwd) {
+  const contextPath = path.join(cwd, CONTEXT_FILE);
+  if (!fs.existsSync(contextPath)) {
+    return (
+      '_No context file found. Run `node gen-context.js --routing` first._\n\n' +
+      'This generates routing hints that map each file to a model tier:\n' +
+      '- **fast** (haiku/gpt-4o-mini) — config, markup, trivial utilities\n' +
+      '- **balanced** (sonnet/gpt-4o) — standard application code\n' +
+      '- **powerful** (opus/gpt-4-turbo) — complex, security-critical, or large modules'
+    );
+  }
 
-    const slice = lines.slice(from - 1, to);
+  // Parse file list from context (### headings are file paths)
+  const content = fs.readFileSync(contextPath, 'utf8');
+  const fileRels = content.split('\n')
+    .filter((l) => l.startsWith('### '))
+    .map((l) => l.slice(4).trim());
 
-    let safeLines = slice;
-    try {
-      const { scan } = __require('./src/security/scanner');
-      safeLines = scan(slice, rel).safe;
-    } catch (_) {}
+  // Build synthetic fileEntries for the classifier
+  // We don't have live sig arrays here, so rebuild from the context blocks
+  const entries = [];
+  const blocks = content.split(/^### /m).slice(1); // slice past the header
+  for (const block of blocks) {
+    const firstLine = block.split('\n')[0].trim();
+    const codeBlock = block.match(/```\n([\s\S]*?)```/);
+    const sigs = codeBlock ? codeBlock[1].trim().split('\n').filter(Boolean) : [];
+    entries.push({ filePath: path.join(cwd, firstLine), sigs });
+  }
 
-    return [
-      `# ${rel}:${from}-${to}`,
-      '```',
-      ...safeLines,
-      '```',
-    ].join('\n');
+  try {
+    const { classifyAll } = __require('./src/routing/classifier');
+    const { formatRoutingSection } = __require('./src/routing/hints');
+    const groups = classifyAll(entries, cwd);
+    return formatRoutingSection(groups);
+  } catch (err) {
+    return `_Routing classification failed: ${err.message}_`;
   }
+}
 
-  module.exports = { readContext, searchSignatures, getMap, createCheckpoint, getRouting, explainFile, listModules, queryContext, getImpact, getLines };
-};
+/**
+ * explain_file({ path }) → string
+ *
+ * Returns a file's signatures, its direct imports, and files that import it.
+ * path: relative path from project root (e.g. 'src/services/auth.ts')
+ */
+function explainFile(args, cwd) {
+  if (!args || !args.path) return 'Missing required argument: path';
 
-// ── ./src/learning/weights ──
-__factories["./src/learning/weights"] = function(module, exports) {
-  'use strict';
+  const targetRel = args.path.replace(/\\/g, '/').replace(/^\//, '');
+  const targetAbs = path.resolve(cwd, targetRel);
+  const contextPath = path.join(cwd, CONTEXT_FILE);
 
-  const fs = require('fs');
-  const path = require('path');
+  const lines = ['# explain_file: ' + targetRel, ''];
 
-  const DECAY = 0.95;
-  const MAX_MULT = 3.0;
-  const MIN_MULT = 0.30;
-  const BASELINE = 1.0;
+  // ── Signatures (hot + cold + cache via buildSigIndex) ───────────────────
+  lines.push('## Signatures');
+  let indexedFiles = [];
+
+  try {
+    const { buildSigIndex } = __require('./src/retrieval/ranker');
+    const index = buildSigIndex(cwd);
+    let sigs = index.get(targetRel);
+    if (!sigs) {
+      for (const [file, fileSigs] of index.entries()) {
+        if (file === targetRel || file.endsWith('/' + targetRel) || targetRel.endsWith('/' + file)) {
+          sigs = fileSigs;
+          break;
+        }
+      }
+    }
+    if (sigs && sigs.length > 0) {
+      lines.push(...sigs);
+    } else {
+      lines.push('_No signatures indexed for this file. Run: node gen-context.js_');
+    }
+    indexedFiles = [...index.keys()].map((rel) => path.resolve(cwd, rel));
+  } catch (_) {
+    lines.push('_No context file found. Run: node gen-context.js_');
+  }
+
+  if (!fs.existsSync(targetAbs)) {
+    lines.push('');
+    lines.push('> File not found on disk: ' + targetRel);
+    return lines.join('\n');
+  }
+
+  lines.push('');
+
+  // ── Direct imports ────────────────────────────────────────────────────────
+  lines.push('## Imports (direct dependencies)');
+  try {
+    const { extractImports } = __require('./src/map/import-graph');
+    const fileContent = fs.readFileSync(targetAbs, 'utf8');
+    const fileSet = new Set(indexedFiles);
+    fileSet.add(targetAbs);
+    const imports = extractImports(targetAbs, fileContent, fileSet);
+    if (imports.length > 0) {
+      for (const imp of imports) lines.push('- ' + path.relative(cwd, imp).replace(/\\/g, '/'));
+    } else {
+      lines.push('_No resolvable relative imports found._');
+    }
+  } catch (err) {
+    lines.push('_Could not analyze imports: ' + err.message + '_');
+  }
+
+  lines.push('');
+
+  // ── Callers (reverse-import lookup) ──────────────────────────────────────
+  lines.push('## Callers (files that import this file)');
+  try {
+    const { extractImports } = __require('./src/map/import-graph');
+    const fileSet = new Set(indexedFiles);
+    fileSet.add(targetAbs);
+    const callers = [];
+    for (const f of indexedFiles) {
+      if (f === targetAbs || !fs.existsSync(f)) continue;
+      try {
+        const fc = fs.readFileSync(f, 'utf8');
+        const imps = extractImports(f, fc, fileSet);
+        if (imps.includes(targetAbs)) callers.push(path.relative(cwd, f).replace(/\\/g, '/'));
+      } catch (_) {}
+    }
+    if (callers.length > 0) {
+      for (const c of callers) lines.push('- ' + c);
+    } else {
+      lines.push('_No indexed files import this file._');
+    }
+  } catch (err) {
+    lines.push('_Could not analyze callers: ' + err.message + '_');
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * list_modules({}) → string
+ *
+ * Lists all srcDir modules present in the context file, sorted by token count
+ * descending. Helps agents decide which module to query with read_context.
+ */
+function listModules(args, cwd) {
+  try {
+    const { buildSigIndex } = __require('./src/retrieval/ranker');
+    const index = buildSigIndex(cwd);
+    if (index.size === 0) {
+      return 'No context file found. Run: node gen-context.js';
+    }
+
+    const groups = {};
+    for (const [rel, sigs] of index.entries()) {
+      const parts = rel.replace(/\\/g, '/').split('/');
+      const mod = parts.length > 1 ? parts[0] : '.';
+      if (!groups[mod]) groups[mod] = { fileCount: 0, tokenCount: 0 };
+      groups[mod].fileCount++;
+      groups[mod].tokenCount += Math.ceil(sigs.join('\n').length / 4);
+    }
+
+  const sorted = Object.entries(groups)
+    .map(([mod, data]) => ({ module: mod, fileCount: data.fileCount, tokenCount: data.tokenCount }))
+    .sort((a, b) => b.tokenCount - a.tokenCount);
+
+  if (sorted.length === 0) return 'No modules found in context file.';
+
+  const total = sorted.reduce((s, m) => s + m.tokenCount, 0);
+
+  return [
+    '# Modules',
+    '',
+    '| Module | Files | Tokens |',
+    '|--------|-------|--------|',
+    ...sorted.map((m) => `| ${m.module} | ${m.fileCount} | ~${m.tokenCount} |`),
+    '',
+    `**Total context tokens: ~${total}**`,
+    '',
+    '_Use `read_context({ module: "name" })` to get signatures for a specific module._',
+  ].join('\n');
+  } catch (err) {
+    return `_list_modules failed: ${err.message}_`;
+  }
+}
+
+/**
+ * query_context({ query, topK? }) → string
+ *
+ * Ranks context-file entries by relevance to the query and returns the
+ * top-K most relevant files with their signatures and scores.
+ */
+function queryContext(args, cwd) {
+  if (!args || !args.query) return 'Missing required argument: query';
+
+  try {
+    const { rank, buildSigIndex, formatRankTable } = __require('./src/retrieval/ranker');
+    const { buildFromCwd } = __require('./src/graph/builder');
+    const index = buildSigIndex(cwd);
+    if (index.size === 0) return 'No signatures indexed. Run: node gen-context.js';
+
+    const topK = Math.min(Math.max(1, parseInt(args.topK, 10) || 10), 25);
+    // Build dependency graph for neighbor boost — non-fatal if it fails
+    let graph = null;
+    try { graph = buildFromCwd(cwd); } catch (_) {}
+    const results = rank(args.query, index, { topK, cwd, graph });
+    return formatRankTable(results, args.query);
+  } catch (err) {
+    return `_query_context failed: ${err.message}_`;
+  }
+}
+
+/**
+ * get_impact({ file, depth? }) → string
+ *
+ * Returns a formatted markdown impact report for the given file:
+ * direct importers, transitive importers, affected tests, affected routes.
+ */
+function getImpact(args, cwd) {
+  if (!args || !args.file) return 'Missing required argument: file';
+
+  try {
+    const { analyzeImpact, formatImpact } = __require('./src/graph/impact');
+    const depth = Math.max(0, parseInt(args.depth, 10) || 3);
+    const results = analyzeImpact(args.file, cwd, { depth });
+    if (results.length === 0) return `No impact data for: ${args.file}`;
+    return results.map((r) => formatImpact(r.impact)).join('\n\n---\n\n');
+  } catch (err) {
+    return `_get_impact failed: ${err.message}_`;
+  }
+}
+
+/**
+ * get_lines({ file, start, end }) → string
+ *
+ * Surgical Context demand-driven fetch: returns an exact, clamped line range from a
+ * source file. The path is resolved inside the project root (no traversal escape) and
+ * the returned lines are secret-scanned via the same redactor used for signatures.
+ */
+function getLines(args, cwd) {
+  if (!args || !args.file) return 'Missing required argument: file';
+
+  const rel = String(args.file).replace(/\\/g, '/').replace(/^\//, '');
+  const abs = path.resolve(cwd, rel);
+
+  // Sandbox: refuse paths that resolve outside the project root.
+  const root = path.resolve(cwd);
+  if (abs !== root && !abs.startsWith(root + path.sep)) {
+    return `Refused: ${rel} resolves outside the project root`;
+  }
+  if (!fs.existsSync(abs) || !fs.statSync(abs).isFile()) {
+    return `File not found: ${rel}`;
+  }
+
+  const start = parseInt(args.start, 10);
+  const end = parseInt(args.end, 10);
+  if (!Number.isFinite(start) || !Number.isFinite(end)) {
+    return 'Arguments "start" and "end" must be numbers (1-based line numbers).';
+  }
+
+  let lines;
+  try {
+    lines = fs.readFileSync(abs, 'utf8').split('\n');
+  } catch (err) {
+    return `Could not read ${rel}: ${err.message}`;
+  }
+
+  const total = lines.length;
+  const from = Math.max(1, Math.min(start, end));
+  const to = Math.min(total, Math.max(start, end));
+  if (from > total) return `${rel} has only ${total} lines; requested ${start}-${end}`;
+
+  const slice = lines.slice(from - 1, to);
+
+  // Redaction scan: reuse the signature secret scanner line-by-line.
+  let safeLines = slice;
+  try {
+    const { scan } = __require('./src/security/scanner');
+    safeLines = scan(slice, rel).safe;
+  } catch (_) {} // non-fatal: fall back to raw slice
+
+  return [
+    `# ${rel}:${from}-${to}`,
+    '```',
+    ...safeLines,
+    '```',
+  ].join('\n');
+}
+
+/**
+ * read_memory({ limit? }) → string
+ *
+ * Recall the cross-session decision log (notes) plus the last ranking-session
+ * focus, formatted for an agent to consume at the start of a task.
+ */
+function readMemory(args, cwd) {
+  let limit = parseInt(args && args.limit, 10);
+  if (!Number.isFinite(limit) || limit <= 0) limit = 10;
+  limit = Math.min(limit, 50);
+
+  const out = ['# SigMap memory'];
+
+  let notes = [];
+  try {
+    const { readNotes, formatNotes } = __require('./src/session/notes');
+    notes = readNotes(cwd, limit);
+    out.push('');
+    out.push(`## Recent notes (${notes.length})`);
+    // Most recent first for quick scanning.
+    out.push(formatNotes(notes.slice().reverse()));
+  } catch (_) {
+    out.push('');
+    out.push('_No notes available._');
+  }
+
+  // Last ranking-session focus (if any) — extends src/session/memory.js.
+  try {
+    const { loadSession } = __require('./src/session/memory');
+    const s = loadSession(cwd);
+    if (s && (s.lastQuery || (s.topFiles && s.topFiles.length))) {
+      out.push('');
+      out.push('## Last session');
+      if (s.lastQuery) out.push(`**Last query:** ${s.lastQuery}`);
+      if (s.topFiles && s.topFiles.length) {
+        out.push(`**Focus files:** ${s.topFiles.map((f) => f.file).slice(0, 5).join(', ')}`);
+      }
+    }
+  } catch (_) { /* session optional */ }
+
+  return out.join('\n');
+}
+
+module.exports = { readContext, searchSignatures, getMap, createCheckpoint, getRouting, explainFile, listModules, queryContext, getImpact, getLines, readMemory };
+
+};
+// ── ./src/learning/weights ──
+__factories["./src/learning/weights"] = function(module, exports) {
+  'use strict';
+
+  const fs = require('fs');
+  const path = require('path');
+
+  const DECAY = 0.95;
+  const MAX_MULT = 3.0;
+  const MIN_MULT = 0.30;
+  const BASELINE = 1.0;
 
   function weightsPath(cwd) {
     return path.join(cwd, '.context', 'weights.json');
@@ -6135,344 +6241,364 @@ __factories["./src/learning/weights"] = function(module, exports) {
 
 // ── ./src/mcp/server ──
 __factories["./src/mcp/server"] = function(module, exports) {
-  
-  /**
-   * SigMap MCP server — zero npm dependencies.
-   *
-   * Wire protocol: JSON-RPC 2.0 over stdio.
-   * One JSON object per line on both stdin and stdout.
-   *
-   * Supported methods:
-   *   initialize        → serverInfo + capabilities
-   *   tools/list        → 10 tool definitions
-   *   tools/call        → dispatch to handler, return result
-   */
+'use strict';
+
+/**
+ * SigMap MCP server — zero npm dependencies.
+ *
+ * Wire protocol: JSON-RPC 2.0 over stdio.
+ * One JSON object per line on both stdin and stdout.
+ *
+ * Supported methods:
+ *   initialize        → serverInfo + capabilities
+ *   tools/list        → 11 tool definitions
+ *   tools/call        → dispatch to handler, return result
+ */
 
-  const readline = require('readline');
-  const { TOOLS } = __require('./src/mcp/tools');
-  const { readContext, searchSignatures, getMap, createCheckpoint, getRouting, explainFile, listModules, queryContext, getImpact, getLines } = __require('./src/mcp/handlers');
+const readline = require('readline');
+const { TOOLS } = __require('./src/mcp/tools');
+const { readContext, searchSignatures, getMap, createCheckpoint, getRouting, explainFile, listModules, queryContext, getImpact, getLines, readMemory } = __require('./src/mcp/handlers');
 
-  const SERVER_INFO = {
-    name: 'sigmap',
-  version: '6.14.0',
-    description: 'SigMap MCP server — code signatures on demand',
-  };
-  
-  // ---------------------------------------------------------------------------
-  // JSON-RPC helpers
-  // ---------------------------------------------------------------------------
-  function respond(id, result) {
-    process.stdout.write(JSON.stringify({ jsonrpc: '2.0', id, result }) + '\n');
+const SERVER_INFO = {
+  name: 'sigmap',
+  version: '7.0.0',
+  description: 'SigMap MCP server — code signatures on demand',
+};
+
+// ---------------------------------------------------------------------------
+// JSON-RPC helpers
+// ---------------------------------------------------------------------------
+function respond(id, result) {
+  process.stdout.write(JSON.stringify({ jsonrpc: '2.0', id, result }) + '\n');
+}
+
+function respondError(id, code, message) {
+  process.stdout.write(
+    JSON.stringify({ jsonrpc: '2.0', id, error: { code, message } }) + '\n'
+  );
+}
+
+// ---------------------------------------------------------------------------
+// Method dispatcher
+// ---------------------------------------------------------------------------
+function dispatch(msg, cwd) {
+  const { method, id, params } = msg;
+
+  // Notifications (no id) need no response
+  if (method === 'notifications/initialized' || method === 'notifications/cancelled') {
+    return;
   }
-  
-  function respondError(id, code, message) {
-    process.stdout.write(
-      JSON.stringify({ jsonrpc: '2.0', id, error: { code, message } }) + '\n'
-    );
+
+  if (method === 'initialize') {
+    respond(id, {
+      protocolVersion: (params && params.protocolVersion) || '2024-11-05',
+      serverInfo: SERVER_INFO,
+      capabilities: { tools: {} },
+    });
+    return;
   }
-  
-  // ---------------------------------------------------------------------------
-  // Method dispatcher
-  // ---------------------------------------------------------------------------
-  function dispatch(msg, cwd) {
-    const { method, id, params } = msg;
-  
-    // Notifications (no id) need no response
-    if (method === 'notifications/initialized' || method === 'notifications/cancelled') {
-      return;
-    }
-  
-    if (method === 'initialize') {
-      respond(id, {
-        protocolVersion: (params && params.protocolVersion) || '2024-11-05',
-        serverInfo: SERVER_INFO,
-        capabilities: { tools: {} },
-      });
-      return;
-    }
-  
-    if (method === 'tools/list') {
-      respond(id, { tools: TOOLS });
-      return;
-    }
-  
-    if (method === 'tools/call') {
-      const name = params && params.name;
-      const args = (params && params.arguments) || {};
-  
-      let text;
-      try {
-        if (name === 'read_context') text = readContext(args, cwd);
-        else if (name === 'search_signatures') text = searchSignatures(args, cwd);
-        else if (name === 'get_map') text = getMap(args, cwd);
-        else if (name === 'create_checkpoint') text = createCheckpoint(args, cwd);
-        else if (name === 'get_routing') text = getRouting(args, cwd);
-        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_impact') text = getImpact(args, cwd);
-        else if (name === 'get_lines') text = getLines(args, cwd);
-        else {
-          respondError(id, -32601, `Unknown tool: ${name}`);
-          return;
-        }
-      } catch (err) {
-        respondError(id, -32603, `Tool error: ${err.message}`);
+
+  if (method === 'tools/list') {
+    respond(id, { tools: TOOLS });
+    return;
+  }
+
+  if (method === 'tools/call') {
+    const name = params && params.name;
+    const args = (params && params.arguments) || {};
+
+    let text;
+    try {
+      if (name === 'read_context') text = readContext(args, cwd);
+      else if (name === 'search_signatures') text = searchSignatures(args, cwd);
+      else if (name === 'get_map') text = getMap(args, cwd);
+      else if (name === 'create_checkpoint') text = createCheckpoint(args, cwd);
+      else if (name === 'get_routing') text = getRouting(args, cwd);
+      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_impact') text = getImpact(args, cwd);
+      else if (name === 'get_lines') text = getLines(args, cwd);
+      else if (name === 'read_memory') text = readMemory(args, cwd);
+      else {
+        respondError(id, -32601, `Unknown tool: ${name}`);
         return;
       }
-  
-      respond(id, {
-        content: [{ type: 'text', text: String(text) }],
-      });
+    } catch (err) {
+      respondError(id, -32603, `Tool error: ${err.message}`);
       return;
     }
-  
-    // Unknown method
-    if (id !== undefined && id !== null) {
-      respondError(id, -32601, `Method not found: ${method}`);
-    }
-  }
-  
-  // ---------------------------------------------------------------------------
-  // Server entry point
-  // ---------------------------------------------------------------------------
-  function start(cwd) {
-    const rl = readline.createInterface({ input: process.stdin, terminal: false });
-  
-    rl.on('line', (line) => {
-      const trimmed = line.trim();
-      if (!trimmed) return;
-  
-      let msg;
-      try {
-        msg = JSON.parse(trimmed);
-      } catch (_) {
-        // Cannot respond without a valid id — ignore malformed input
-        return;
-      }
-  
-      try {
-        dispatch(msg, cwd);
-      } catch (err) {
-        const id = (msg && msg.id) != null ? msg.id : null;
-        respondError(id, -32603, `Internal error: ${err.message}`);
-      }
-    });
-  
-    rl.on('close', () => {
-      process.exit(0);
+
+    respond(id, {
+      content: [{ type: 'text', text: String(text) }],
     });
+    return;
   }
-  
-  module.exports = { start };
-  
-};
 
+  // Unknown method
+  if (id !== undefined && id !== null) {
+    respondError(id, -32601, `Method not found: ${method}`);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Server entry point
+// ---------------------------------------------------------------------------
+function start(cwd) {
+  const rl = readline.createInterface({ input: process.stdin, terminal: false });
+
+  rl.on('line', (line) => {
+    const trimmed = line.trim();
+    if (!trimmed) return;
+
+    let msg;
+    try {
+      msg = JSON.parse(trimmed);
+    } catch (_) {
+      // Cannot respond without a valid id — ignore malformed input
+      return;
+    }
+
+    try {
+      dispatch(msg, cwd);
+    } catch (err) {
+      const id = (msg && msg.id) != null ? msg.id : null;
+      respondError(id, -32603, `Internal error: ${err.message}`);
+    }
+  });
+
+  rl.on('close', () => {
+    process.exit(0);
+  });
+}
+
+module.exports = { start };
+
+};
 // ── ./src/mcp/tools ──
 __factories["./src/mcp/tools"] = function(module, exports) {
-  
-  /**
-   * MCP tool definitions for SigMap.
-   * Three tools: read_context, search_signatures, get_map.
-   */
-  
-  const TOOLS = [
-    {
-      name: 'read_context',
-      description:
-        'Read extracted code signatures for the project or a specific module path. ' +
-        'Returns the full copilot-instructions.md content (~500–4K tokens) or a ' +
-        'filtered subset when a module path is provided (~50–500 tokens).',
-      inputSchema: {
-        type: 'object',
-        properties: {
-          module: {
-            type: 'string',
-            description:
-              'Optional subdirectory path to scope results (e.g. "src/services"). ' +
-              'Omit to get the full codebase context.',
-          },
+'use strict';
+
+/**
+ * MCP tool definitions for SigMap (11 tools).
+ * read_context, search_signatures, get_map, create_checkpoint, get_routing,
+ * explain_file, list_modules, query_context, get_impact, get_lines, read_memory.
+ */
+
+const TOOLS = [
+  {
+    name: 'read_context',
+    description:
+      'Read extracted code signatures for the project or a specific module path. ' +
+      'Returns the full copilot-instructions.md content (~500–4K tokens) or a ' +
+      'filtered subset when a module path is provided (~50–500 tokens).',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        module: {
+          type: 'string',
+          description:
+            'Optional subdirectory path to scope results (e.g. "src/services"). ' +
+            'Omit to get the full codebase context.',
         },
-        required: [],
       },
+      required: [],
     },
-    {
-      name: 'search_signatures',
-      description:
-        'Search extracted code signatures for a keyword, function name, or class name. ' +
-        'Returns matching signature lines with their file paths.',
-      inputSchema: {
-        type: 'object',
-        properties: {
-          query: {
-            type: 'string',
-            description: 'Keyword to search for in signatures (case-insensitive).',
-          },
+  },
+  {
+    name: 'search_signatures',
+    description:
+      'Search extracted code signatures for a keyword, function name, or class name. ' +
+      'Returns matching signature lines with their file paths.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        query: {
+          type: 'string',
+          description: 'Keyword to search for in signatures (case-insensitive).',
         },
-        required: ['query'],
       },
+      required: ['query'],
     },
-    {
-      name: 'get_map',
-      description:
-        'Read a section from PROJECT_MAP.md — import graph, class hierarchy, or route table. ' +
-        'Requires gen-project-map.js to have been run first.',
-      inputSchema: {
-        type: 'object',
-        properties: {
-          type: {
-            type: 'string',
-            enum: ['imports', 'classes', 'routes'],
-            description: 'Which section to retrieve: imports, classes, or routes.',
-          },
+  },
+  {
+    name: 'get_map',
+    description:
+      'Read a section from PROJECT_MAP.md — import graph, class hierarchy, or route table. ' +
+      'Requires gen-project-map.js to have been run first.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        type: {
+          type: 'string',
+          enum: ['imports', 'classes', 'routes'],
+          description: 'Which section to retrieve: imports, classes, or routes.',
         },
-        required: ['type'],
       },
+      required: ['type'],
     },
-    {
-      name: 'create_checkpoint',
-      description:
-        'Create a session checkpoint summarising current project state. ' +
-        'Returns recent git commits, active branch, token count, and a ' +
-        'compact snapshot of the codebase context — ideal for session handoffs ' +
-        'or periodic saves during long coding sessions.',
-      inputSchema: {
-        type: 'object',
-        properties: {
-          note: {
-            type: 'string',
-            description: 'Optional free-text note to include in the checkpoint (e.g. what you were working on).',
-          },
+  },
+  {
+    name: 'create_checkpoint',
+    description:
+      'Create a session checkpoint summarising current project state. ' +
+      'Returns recent git commits, active branch, token count, and a ' +
+      'compact snapshot of the codebase context — ideal for session handoffs ' +
+      'or periodic saves during long coding sessions.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        note: {
+          type: 'string',
+          description: 'Optional free-text note to include in the checkpoint (e.g. what you were working on).',
         },
-        required: [],
       },
+      required: [],
     },
-    {
-      name: 'get_routing',
-      description:
-        'Get model routing hints for this project — which files belong to which complexity ' +
-        'tier (fast/balanced/powerful) and which AI model to use for each type of task. ' +
-        'Helps reduce API costs by 40–80% by routing simple tasks to cheaper models.',
-      inputSchema: {
-        type: 'object',
-        properties: {},
-        required: [],
-      },
+  },
+  {
+    name: 'get_routing',
+    description:
+      'Get model routing hints for this project — which files belong to which complexity ' +
+      'tier (fast/balanced/powerful) and which AI model to use for each type of task. ' +
+      'Helps reduce API costs by 40–80% by routing simple tasks to cheaper models.',
+    inputSchema: {
+      type: 'object',
+      properties: {},
+      required: [],
     },
-    {
-      name: 'explain_file',
-      description:
-        'Explain a specific file: returns its extracted signatures, direct imports ' +
-        '(files it depends on), and callers (files that import it). ' +
-        'Ideal for understanding a file in isolation without reading raw source. ' +
-        'Requires the context file to have been generated first.',
-      inputSchema: {
-        type: 'object',
-        properties: {
-          path: {
-            type: 'string',
-            description:
-              'Relative path from the project root (e.g. "src/services/auth.ts"). ' +
-              'Use the paths shown in read_context output.',
-          },
+  },
+  {
+    name: 'explain_file',
+    description:
+      'Explain a specific file: returns its extracted signatures, direct imports ' +
+      '(files it depends on), and callers (files that import it). ' +
+      'Ideal for understanding a file in isolation without reading raw source. ' +
+      'Requires the context file to have been generated first.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        path: {
+          type: 'string',
+          description:
+            'Relative path from the project root (e.g. "src/services/auth.ts"). ' +
+            'Use the paths shown in read_context output.',
         },
-        required: ['path'],
       },
+      required: ['path'],
     },
-    {
-      name: 'list_modules',
-      description:
-        'List all top-level modules (srcDirs) present in the context file, ' +
-        'sorted by token count descending. Use this to decide which module to ' +
-        'pass to read_context before querying a specific area of the codebase.',
-      inputSchema: {
-        type: 'object',
-        properties: {},
-        required: [],
-      },
+  },
+  {
+    name: 'list_modules',
+    description:
+      'List all top-level modules (srcDirs) present in the context file, ' +
+      'sorted by token count descending. Use this to decide which module to ' +
+      'pass to read_context before querying a specific area of the codebase.',
+    inputSchema: {
+      type: 'object',
+      properties: {},
+      required: [],
     },
-    {
-      name: 'query_context',
-      description:
-        'Rank and return the most relevant files for a specific task or question. ' +
-        'Uses keyword + symbol + path scoring to surface only the top-K files relevant ' +
-        'to the query — much cheaper than reading all context. ' +
-        'Returns ranked file list with signatures and relevance scores.',
-      inputSchema: {
-        type: 'object',
-        properties: {
-          query: {
-            type: 'string',
-            description:
-              'Natural language task description or keyword(s) to rank files against. ' +
-              'E.g. "add a new language extractor", "fix secret scanning", "auth module".',
-          },
-          topK: {
-            type: 'number',
-            description: 'Maximum number of files to return (default: 10, max: 25).',
-          },
+  },
+  {
+    name: 'query_context',
+    description:
+      'Rank and return the most relevant files for a specific task or question. ' +
+      'Uses keyword + symbol + path scoring to surface only the top-K files relevant ' +
+      'to the query — much cheaper than reading all context. ' +
+      'Returns ranked file list with signatures and relevance scores.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        query: {
+          type: 'string',
+          description:
+            'Natural language task description or keyword(s) to rank files against. ' +
+            'E.g. "add a new language extractor", "fix secret scanning", "auth module".',
+        },
+        topK: {
+          type: 'number',
+          description: 'Maximum number of files to return (default: 10, max: 25).',
         },
-        required: ['query'],
       },
+      required: ['query'],
     },
-    {
-      name: 'get_impact',
-      description:
-        'Show every file that is impacted when a given file changes — direct importers, ' +
-        'transitive importers, affected tests, and affected routes/controllers. ' +
-        'Gives agents instant blast-radius awareness before making a change. ' +
-        'Handles circular dependencies safely (no infinite loops).',
-      inputSchema: {
-        type: 'object',
-        properties: {
-          file: {
-            type: 'string',
-            description:
-              'Relative path from the project root of the file that changed ' +
-              '(e.g. "src/extractors/python.js"). Use forward slashes.',
-          },
-          depth: {
-            type: 'number',
-            description: 'BFS traversal depth limit (default: 3). Use 0 for unlimited.',
-          },
+  },
+  {
+    name: 'get_impact',
+    description:
+      'Show every file that is impacted when a given file changes — direct importers, ' +
+      'transitive importers, affected tests, and affected routes/controllers. ' +
+      'Gives agents instant blast-radius awareness before making a change. ' +
+      'Handles circular dependencies safely (no infinite loops).',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        file: {
+          type: 'string',
+          description:
+            'Relative path from the project root of the file that changed ' +
+            '(e.g. "src/extractors/python.js"). Use forward slashes.',
+        },
+        depth: {
+          type: 'number',
+          description: 'BFS traversal depth limit (default: 3). Use 0 for unlimited.',
         },
-        required: ['file'],
       },
+      required: ['file'],
     },
-    {
-      name: 'get_lines',
-      description:
-        'Fetch an exact line range from a source file on demand — the Surgical Context ' +
-        'workhorse. Signatures carry `path:start-end` anchors; call this to read just those ' +
-        'lines instead of re-opening the whole file. Lines are clamped to the file bounds and ' +
-        'secret-scanned (redacted) before return. Path is sandboxed to the project root.',
-      inputSchema: {
-        type: 'object',
-        properties: {
-          file: {
-            type: 'string',
-            description:
-              'Relative path from the project root (e.g. "src/config/loader.js"). ' +
-              'Use the path shown in a signature anchor. Use forward slashes.',
-          },
-          start: {
-            type: 'number',
-            description: '1-based start line (inclusive). Clamped to the file bounds.',
-          },
-          end: {
-            type: 'number',
-            description: '1-based end line (inclusive). Clamped to the file bounds.',
-          },
+  },
+  {
+    name: 'get_lines',
+    description:
+      'Fetch an exact line range from a source file on demand — the Surgical Context ' +
+      'workhorse. Signatures carry `path:start-end` anchors; call this to read just those ' +
+      'lines instead of re-opening the whole file. Lines are clamped to the file bounds and ' +
+      'secret-scanned (redacted) before return. Path is sandboxed to the project root.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        file: {
+          type: 'string',
+          description:
+            'Relative path from the project root (e.g. "src/config/loader.js"). ' +
+            'Use the path shown in a signature anchor. Use forward slashes.',
+        },
+        start: {
+          type: 'number',
+          description: '1-based start line (inclusive). Clamped to the file bounds.',
+        },
+        end: {
+          type: 'number',
+          description: '1-based end line (inclusive). Clamped to the file bounds.',
         },
-        required: ['file', 'start', 'end'],
       },
+      required: ['file', 'start', 'end'],
     },
-  ];
+  },
+  {
+    name: 'read_memory',
+    description:
+      'Recall the project decision log — recent notes left by humans or agents ' +
+      'across sessions (via `sigmap note`), plus the last ranking-session focus. ' +
+      'Call this at the start of a task to kill cold-start: it answers ' +
+      '"what were we doing and why" without re-reading the whole codebase.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        limit: {
+          type: 'number',
+          description: 'How many of the most recent notes to return (default: 10, max: 50).',
+        },
+      },
+      required: [],
+    },
+  },
+];
 
-  module.exports = { TOOLS };
-  
-};
+module.exports = { TOOLS };
 
+};
 // ── ./src/routing/classifier ──
 __factories["./src/routing/classifier"] = function(module, exports) {
   
@@ -7007,6 +7133,110 @@ __factories["./src/tracking/logger"] = function(module, exports) {
   
 };
 
+// ── ./src/session/notes ──
+__factories["./src/session/notes"] = function(module, exports) {
+'use strict';
+
+/**
+ * Decision-log notes (Memory, v6.15.0).
+ *
+ * A tiny append-only log of human/agent notes that survives across sessions,
+ * so an agent starting cold can recall "what were we doing / why". Stored as
+ * NDJSON under `.context/` to match the project's other state logs
+ * (usage.ndjson, benchmark-history.ndjson). Zero dependencies.
+ *
+ * Consumed by the `read_memory` MCP tool and the `sigmap note` / `sigmap status`
+ * commands. Complements `src/session/memory.js` (ranking session) rather than
+ * duplicating it.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const NOTES_FILE = path.join('.context', 'notes.ndjson');
+const MAX_TEXT = 2000;
+
+function notesPath(cwd) {
+  return path.join(cwd, NOTES_FILE);
+}
+
+function _currentBranch(cwd) {
+  try {
+    return execSync('git rev-parse --abbrev-ref HEAD', {
+      cwd, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim() || null;
+  } catch (_) {
+    return null;
+  }
+}
+
+/**
+ * Append a note. Returns the stored entry.
+ * @param {string} cwd
+ * @param {string} text
+ * @param {object} [opts]
+ * @param {string|null} [opts.branch]  override branch (default: current git branch)
+ * @param {string} [opts.tag]          optional category tag
+ */
+function addNote(cwd, text, opts = {}) {
+  const clean = String(text == null ? '' : text).trim().slice(0, MAX_TEXT);
+  if (!clean) throw new Error('note text is empty');
+  const entry = {
+    ts: new Date().toISOString(),
+    text: clean,
+    branch: opts.branch !== undefined ? opts.branch : _currentBranch(cwd),
+  };
+  if (opts.tag) entry.tag = String(opts.tag).trim().slice(0, 40);
+  const p = notesPath(cwd);
+  fs.mkdirSync(path.dirname(p), { recursive: true });
+  fs.appendFileSync(p, JSON.stringify(entry) + '\n');
+  return entry;
+}
+
+/**
+ * Read notes in chronological order (oldest first).
+ * @param {string} cwd
+ * @param {number} [limit=0]  keep only the most recent N (0 = all)
+ * @returns {object[]}
+ */
+function readNotes(cwd, limit = 0) {
+  let raw;
+  try { raw = fs.readFileSync(notesPath(cwd), 'utf8'); }
+  catch (_) { return []; }
+  const out = [];
+  for (const line of raw.split('\n')) {
+    const t = line.trim();
+    if (!t) continue;
+    try { out.push(JSON.parse(t)); } catch (_) { /* skip corrupt line */ }
+  }
+  if (limit > 0 && out.length > limit) return out.slice(out.length - limit);
+  return out;
+}
+
+/** Format notes as a Markdown list (pass already-ordered notes). */
+function formatNotes(notes) {
+  if (!notes || !notes.length) {
+    return 'No notes recorded yet. Add one with: sigmap note "<text>"';
+  }
+  return notes.map((n) => {
+    const when = String(n.ts || '').replace('T', ' ').slice(0, 16);
+    const br = n.branch ? ` (${n.branch})` : '';
+    const tag = n.tag ? ` #${n.tag}` : '';
+    return `- [${when}${br}]${tag} ${n.text}`;
+  }).join('\n');
+}
+
+/** Delete the notes log. Returns true if a file was removed. */
+function clearNotes(cwd) {
+  try { fs.unlinkSync(notesPath(cwd)); return true; }
+  catch (_) { return false; }
+}
+
+module.exports = { notesPath, addNote, readNotes, formatNotes, clearNotes };
+
+};
+
 // ── ./src/session/memory ──
 __factories["./src/session/memory"] = function(module, exports) {
   'use strict';
@@ -7781,314 +8011,621 @@ __factories["./src/eval/usefulness-scorer"] = function(module, exports) {
 
 // ── ./packages/adapters/copilot (bundled) ──
 __factories["./packages/adapters/copilot"] = function(module, exports) {
-  const path = require('path');
-  const fs = require('fs');
-  const name = 'copilot';
-  const COPILOT_MARKER = '\n\n## Auto-generated signatures\n<!-- Updated by gen-context.js -->\n';
-  function format(context, opts = {}) {
-    if (!context || typeof context !== 'string') return '';
-    const version = (opts && opts.version) || 'unknown';
-    const timestamp = new Date().toISOString();
-    return [
-      `<!-- Generated by SigMap gen-context.js v${version} -->`,
-      `<!-- Updated: ${timestamp} -->`,
-      `<!-- Do not edit below — regenerate with: node gen-context.js -->`,
-      '',
-      '## SigMap commands',
-      '',
-      '| When | Command |',
-      '|------|---------|',
-      '| Before answering a question about code | `sigmap ask "<your question>"` |',
-      '| After changing config or source dirs | `sigmap validate` |',
-      '| To verify an AI answer is grounded | `sigmap judge --response <file>` |',
-      '',
-      '# Code signatures',
-      '',
-      context,
-    ].join('\n');
+'use strict';
+
+/**
+ * Copilot adapter — writes to .github/copilot-instructions.md
+ * GitHub Copilot reads this file automatically in every workspace.
+ *
+ * Contract:
+ *   format(context, opts?) → string
+ *   outputPath(cwd) → string
+ */
+
+const path = require('path');
+const fs = require('fs');
+
+const name = 'copilot';
+const MARKER = '\n\n## Auto-generated signatures\n<!-- Updated by gen-context.js -->\n';
+
+/**
+ * Format context for GitHub Copilot instructions.
+ * @param {string} context - Raw signature context string
+ * @param {object} [opts]
+ * @param {string} [opts.version] - SigMap version string
+ * @returns {string}
+ */
+function format(context, opts = {}) {
+  if (!context || typeof context !== 'string') return '';
+  const version   = opts.version   || 'unknown';
+  const timestamp = new Date().toISOString();
+  const meta = _confidenceMeta(opts);
+  const header = [
+    `<!-- Generated by SigMap gen-context.js v${version} -->`,
+    `<!-- Updated: ${timestamp} -->`,
+    meta,
+    `<!-- Do not edit below — regenerate with: node gen-context.js -->`,
+    '',
+    '# Code signatures',
+    '',
+  ].join('\n');
+  return header + context;
+}
+
+function _confidenceMeta(opts) {
+  const parts = [`version=${opts.version || 'unknown'}`];
+  if (opts.confidence)    parts.push(`confidence=${opts.confidence}`);
+  if (opts.coverage != null) parts.push(`coverage=${opts.coverage}%`);
+  if (opts.dropped  != null) parts.push(`dropped=${opts.dropped}`);
+  if (opts.commit)        parts.push(`commit=${opts.commit}`);
+  return `<!-- sigmap: ${parts.join(' ')} -->`;
+}
+
+/**
+ * Return the output file path for this adapter.
+ * @param {string} cwd - Project root
+ * @returns {string}
+ */
+function outputPath(cwd) {
+  return path.join(cwd, '.github', 'copilot-instructions.md');
+}
+
+/**
+ * Write signatures into copilot-instructions.md using append-under-marker.
+ * If marker exists, content above marker is preserved.
+ * If legacy generated content exists without marker, replace it cleanly.
+ * @param {string} context - Raw signature context string
+ * @param {string} cwd - Project root
+ * @param {object} [opts]
+ */
+function write(context, cwd, opts = {}) {
+  const filePath = outputPath(cwd);
+  let existing = '';
+  if (fs.existsSync(filePath)) {
+    existing = fs.readFileSync(filePath, 'utf8');
   }
-  function outputPath(cwd) { return path.join(cwd, '.github', 'copilot-instructions.md'); }
-  function write(context, cwd, opts = {}) {
-    const filePath = outputPath(cwd);
-    let existing = '';
-    if (fs.existsSync(filePath)) existing = fs.readFileSync(filePath, 'utf8');
-    const formatted = format(context, opts);
-    const markerIdx = existing.indexOf('## Auto-generated signatures');
-    const isLegacyGenerated = existing.includes('<!-- Generated by SigMap gen-context.js') || existing.includes('# Code signatures');
-    const newContent = markerIdx !== -1
-      ? existing.slice(0, markerIdx) + COPILOT_MARKER.trimStart() + formatted
-      : (isLegacyGenerated ? COPILOT_MARKER.trimStart() + formatted : existing + COPILOT_MARKER + formatted);
-    fs.mkdirSync(path.dirname(filePath), { recursive: true });
-    fs.writeFileSync(filePath, newContent, 'utf8');
+
+  const formatted = format(context, opts);
+  const markerIdx = existing.indexOf('## Auto-generated signatures');
+
+  let newContent;
+  if (markerIdx !== -1) {
+    newContent = existing.slice(0, markerIdx) + MARKER.trimStart() + formatted;
+  } else {
+    const isLegacyGenerated = existing.includes('<!-- Generated by SigMap gen-context.js')
+      || existing.includes('# Code signatures');
+    newContent = isLegacyGenerated
+      ? MARKER.trimStart() + formatted
+      : existing + MARKER + formatted;
   }
-  module.exports = { name, format, outputPath, write };
-};
 
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, newContent, 'utf8');
+}
+
+module.exports = { name, format, outputPath, write };
+
+};
 // ── ./packages/adapters/claude (bundled) ──
 __factories["./packages/adapters/claude"] = function(module, exports) {
-  const path = require('path');
-  const fs = require('fs');
-  const name = 'claude';
-  const CLAUDE_MARKER = '\n\n## Auto-generated signatures\n<!-- Updated by gen-context.js -->\n';
-  const CLAUDE_ALLOWLIST_MARKER = '<!-- sigmap-bash-allowlist -->';
-  const CLAUDE_ALLOWLIST_BLOCK = [
-    '## Bash allowlist',
-    '',
-    CLAUDE_ALLOWLIST_MARKER,
-    '',
-    'The following sigmap commands are pre-approved — Claude Code will not prompt for confirmation:',
-    '',
-    '```json',
-    JSON.stringify({
-      permissions: {
-        allow: [
-          'Bash(sigmap ask*)',
-          'Bash(sigmap validate*)',
-          'Bash(sigmap judge*)',
-          'Bash(sigmap weights*)',
-          'Bash(sigmap history*)',
-          'Bash(sigmap --query*)',
-          'Bash(sigmap --diff*)',
-          'Bash(sigmap --health*)',
-          'Bash(sigmap --coverage*)',
-          'Bash(node gen-context.js*)',
-        ],
-      },
-    }, null, 2),
-    '```',
-    '',
-    'Add the `permissions.allow` array above to `.claude/settings.json` to activate.',
+'use strict';
+
+/**
+ * Claude adapter — appends to CLAUDE.md under a marker line.
+ * Never overwrites human-written content above the marker.
+ *
+ * Contract:
+ *   format(context, opts?) → string
+ *   outputPath(cwd) → string
+ *   write(context, cwd, opts?) → void   (handles append logic)
+ */
+
+const path = require('path');
+const fs = require('fs');
+
+const name = 'claude';
+
+const MARKER = '\n\n## Auto-generated signatures\n<!-- Updated by gen-context.js -->\n';
+const ALLOWLIST_MARKER = '<!-- sigmap-bash-allowlist -->';
+
+const ALLOWLIST_BLOCK = [
+  '## Bash allowlist',
+  '',
+  ALLOWLIST_MARKER,
+  '',
+  'The following sigmap commands are pre-approved — Claude Code will not prompt for confirmation:',
+  '',
+  '```json',
+  JSON.stringify({
+    permissions: {
+      allow: [
+        'Bash(sigmap ask*)',
+        'Bash(sigmap validate*)',
+        'Bash(sigmap judge*)',
+        'Bash(sigmap weights*)',
+        'Bash(sigmap history*)',
+        'Bash(sigmap --query*)',
+        'Bash(sigmap --diff*)',
+        'Bash(sigmap --health*)',
+        'Bash(sigmap --coverage*)',
+        'Bash(node gen-context.js*)',
+      ],
+    },
+  }, null, 2),
+  '```',
+  '',
+  'Add the `permissions.allow` array above to `.claude/settings.json` to activate.',
+  '',
+].join('\n');
+
+/**
+ * Format context suited for CLAUDE.md.
+ * @param {string} context - Raw signature context string
+ * @param {object} [opts]
+ * @param {string} [opts.version] - SigMap version string
+ * @returns {string}
+ */
+function format(context, opts = {}) {
+  if (!context || typeof context !== 'string') return '';
+  const version   = opts.version || 'unknown';
+  const timestamp = new Date().toISOString();
+  const meta      = _confidenceMeta(opts);
+  return [
+    `<!-- Generated by SigMap v${version} — ${timestamp} -->`,
+    meta,
     '',
+    context,
   ].join('\n');
-  function format(context, opts = {}) {
-    if (!context || typeof context !== 'string') return '';
-    const version = (opts && opts.version) || 'unknown';
-    const timestamp = new Date().toISOString();
-    return [
-      '## SigMap',
-      '- Before searching for files, run `sigmap ask "<query>"` — ranks by TF-IDF relevance',
-      '- After config changes, run `sigmap validate` to confirm coverage',
-      '- To verify answer groundedness, run `sigmap judge --response <file> --context CLAUDE.md`',
-      '- For PR-scoped context, run `sigmap --diff`',
-      '',
-      `<!-- Generated by SigMap v${version} — ${timestamp} -->`,
-      '',
-      context,
-    ].join('\n');
+}
+
+function _confidenceMeta(opts) {
+  const parts = [`version=${opts.version || 'unknown'}`];
+  if (opts.confidence)    parts.push(`confidence=${opts.confidence}`);
+  if (opts.coverage != null) parts.push(`coverage=${opts.coverage}%`);
+  if (opts.dropped  != null) parts.push(`dropped=${opts.dropped}`);
+  if (opts.commit)        parts.push(`commit=${opts.commit}`);
+  return `<!-- sigmap: ${parts.join(' ')} -->`;
+}
+
+/**
+ * Return the output file path for this adapter.
+ * @param {string} cwd - Project root
+ * @returns {string}
+ */
+function outputPath(cwd) {
+  return path.join(cwd, 'CLAUDE.md');
+}
+
+/**
+ * Write signatures into CLAUDE.md using the append-under-marker strategy.
+ * Human content above the marker is never touched.
+ * @param {string} context - Raw signature context string
+ * @param {string} cwd - Project root
+ * @param {object} [opts]
+ */
+function write(context, cwd, opts = {}) {
+  const filePath = outputPath(cwd);
+  let existing = '';
+  if (fs.existsSync(filePath)) {
+    existing = fs.readFileSync(filePath, 'utf8');
   }
-  function outputPath(cwd) { return path.join(cwd, 'CLAUDE.md'); }
-  function write(context, cwd, opts = {}) {
-    const filePath = outputPath(cwd);
-    let existing = '';
-    if (fs.existsSync(filePath)) existing = fs.readFileSync(filePath, 'utf8');
-    const formatted = format(context, opts);
-    const markerIdx = existing.indexOf('## Auto-generated signatures');
-    let newContent = markerIdx !== -1
-      ? existing.slice(0, markerIdx) + CLAUDE_MARKER.trimStart() + formatted
-      : existing + CLAUDE_MARKER + formatted;
-    if (!newContent.includes(CLAUDE_ALLOWLIST_MARKER)) {
-      const sigPos = newContent.indexOf('## Auto-generated signatures');
-      if (sigPos !== -1) {
-        newContent = newContent.slice(0, sigPos) + CLAUDE_ALLOWLIST_BLOCK + '\n' + newContent.slice(sigPos);
-      } else {
-        newContent = CLAUDE_ALLOWLIST_BLOCK + '\n' + newContent;
-      }
+  const formatted = format(context, opts);
+  const markerIdx = existing.indexOf('## Auto-generated signatures');
+  let newContent;
+  if (markerIdx !== -1) {
+    newContent = existing.slice(0, markerIdx) + MARKER.trimStart() + formatted;
+  } else {
+    newContent = existing + MARKER + formatted;
+  }
+
+  // Inject ## Bash allowlist above the sig marker if not already present
+  if (!newContent.includes(ALLOWLIST_MARKER)) {
+    const sigMarkerPos = newContent.indexOf('## Auto-generated signatures');
+    if (sigMarkerPos !== -1) {
+      newContent = newContent.slice(0, sigMarkerPos) + ALLOWLIST_BLOCK + '\n' + newContent.slice(sigMarkerPos);
+    } else {
+      newContent = ALLOWLIST_BLOCK + '\n' + newContent;
     }
-    fs.writeFileSync(filePath, newContent, 'utf8');
   }
-  module.exports = { name, format, outputPath, write };
-};
 
+  fs.writeFileSync(filePath, newContent, 'utf8');
+}
+
+module.exports = { name, format, outputPath, write };
+
+};
 // ── ./packages/adapters/cursor (bundled) ──
 __factories["./packages/adapters/cursor"] = function(module, exports) {
-  const path = require('path');
-  const name = 'cursor';
-  function format(context, opts = {}) {
-    if (!context || typeof context !== 'string') return '';
-    const version = (opts && opts.version) || 'unknown';
-    const timestamp = new Date().toISOString();
-    return [
-      `# Code signatures — generated by SigMap v${version}`,
-      `# Updated: ${timestamp}`,
-      `# Regenerate: node gen-context.js`,
-      '#',
-      '# SigMap: before answering, run: sigmap ask "<query>" — finds relevant files',
-      '# SigMap: after config changes, run: sigmap validate',
-      '# SigMap: to verify answers, run: sigmap judge --response <file>',
-      '',
-      context,
-    ].join('\n');
-  }
-  function outputPath(cwd) { return path.join(cwd, '.cursorrules'); }
-  module.exports = { name, format, outputPath };
-};
+'use strict';
+
+/**
+ * Cursor adapter — writes to .cursorrules
+ * Cursor reads .cursorrules automatically in every workspace.
+ *
+ * Contract:
+ *   format(context, opts?) → string
+ *   outputPath(cwd) → string
+ */
+
+const path = require('path');
+
+const name = 'cursor';
+
+/**
+ * Format context for Cursor rules file.
+ * @param {string} context - Raw signature context string
+ * @param {object} [opts]
+ * @param {string} [opts.version] - SigMap version string
+ * @returns {string}
+ */
+function format(context, opts = {}) {
+  if (!context || typeof context !== 'string') return '';
+  const version   = opts.version || 'unknown';
+  const timestamp = new Date().toISOString();
+  const meta      = _confidenceMeta(opts);
+  const header = [
+    `# Code signatures — generated by SigMap v${version}`,
+    `# Updated: ${timestamp}`,
+    `# ${meta}`,
+    `# Regenerate: node gen-context.js`,
+    '',
+  ].join('\n');
+  return header + context;
+}
+
+function _confidenceMeta(opts) {
+  const parts = [`version=${opts.version || 'unknown'}`];
+  if (opts.confidence)    parts.push(`confidence=${opts.confidence}`);
+  if (opts.coverage != null) parts.push(`coverage=${opts.coverage}%`);
+  if (opts.dropped  != null) parts.push(`dropped=${opts.dropped}`);
+  if (opts.commit)        parts.push(`commit=${opts.commit}`);
+  return `sigmap: ${parts.join(' ')}`;
+}
+
+/**
+ * Return the output file path for this adapter.
+ * @param {string} cwd - Project root
+ * @returns {string}
+ */
+function outputPath(cwd) {
+  return path.join(cwd, '.cursorrules');
+}
+
+module.exports = { name, format, outputPath };
 
+};
 // ── ./packages/adapters/windsurf (bundled) ──
 __factories["./packages/adapters/windsurf"] = function(module, exports) {
-  const path = require('path');
-  const name = 'windsurf';
-  function format(context, opts = {}) {
-    if (!context || typeof context !== 'string') return '';
-    const version = (opts && opts.version) || 'unknown';
-    const timestamp = new Date().toISOString();
-    return [
-      `# Code signatures — generated by SigMap v${version}`,
-      `# Updated: ${timestamp}`,
-      `# Regenerate: node gen-context.js`,
-      '#',
-      '# SigMap: before answering, run: sigmap ask "<query>" — finds relevant files',
-      '# SigMap: after config changes, run: sigmap validate',
-      '# SigMap: to verify answers, run: sigmap judge --response <file>',
-      '',
-      context,
-    ].join('\n');
-  }
-  function outputPath(cwd) { return path.join(cwd, '.windsurfrules'); }
-  module.exports = { name, format, outputPath };
-};
+'use strict';
 
-// ── ./packages/adapters/openai (bundled) ──
-__factories["./packages/adapters/openai"] = function(module, exports) {
-  const path = require('path');
-  const name = 'openai';
-  function format(context, opts = {}) {
-    if (!context || typeof context !== 'string') return '';
-    const version = (opts && opts.version) || 'unknown';
-    const timestamp = new Date().toISOString();
-    const projectLine = (opts && opts.projectName) ? `Project: ${opts.projectName}\n` : '';
-    return [
-      `You are a coding assistant with full knowledge of this codebase.`,
-      `Below are the code signatures extracted by SigMap v${version} on ${timestamp}.`,
-      projectLine,
-      `Use these signatures to answer questions about the code accurately.`,
-      `When the user asks about a specific file or function, refer to the signatures below.`,
-      `Before answering questions about specific code areas, prefer running \`sigmap ask "<query>"\` to get the most relevant files. After config changes, \`sigmap validate\` confirms coverage.`,
-      ``,
-      `## Code Signatures`,
-      ``,
-      context,
-    ].join('\n');
-  }
-  function outputPath(cwd) { return path.join(cwd, '.github', 'openai-context.md'); }
-  module.exports = { name, format, outputPath };
-};
+/**
+ * Windsurf adapter — writes to .windsurfrules
+ * Windsurf reads .windsurfrules automatically in every workspace.
+ *
+ * Contract:
+ *   format(context, opts?) → string
+ *   outputPath(cwd) → string
+ */
 
-// ── ./packages/adapters/gemini (bundled) ──
-__factories["./packages/adapters/gemini"] = function(module, exports) {
-  const path = require('path');
-  const fs = require('fs');
-  const name = 'gemini';
-  const GEMINI_MARKER = '\n\n## Auto-generated signatures\n<!-- Updated by gen-context.js -->\n';
-  function format(context, opts = {}) {
-    if (!context || typeof context !== 'string') return '';
-    const version = (opts && opts.version) || 'unknown';
-    const timestamp = new Date().toISOString();
-    const projectLine = (opts && opts.projectName) ? `Project: ${opts.projectName}\n` : '';
-    return [
-      `You are a coding assistant with complete knowledge of this codebase.`,
-      `The following code signatures were extracted by SigMap v${version} on ${timestamp}.`,
-      projectLine,
-      `These signatures represent every public function, class, and type in the project.`,
-      `Refer to them when answering questions about code structure, APIs, and implementation.`,
-      `Before answering questions about specific code areas, suggest running \`sigmap ask "<query>"\` to get the most relevant files. After config changes, \`sigmap validate\` confirms coverage.`,
-      ``,
-      `## Code Signatures`,
-      ``,
-      context,
-    ].join('\n');
-  }
-  function outputPath(cwd) { return path.join(cwd, '.github', 'gemini-context.md'); }
-  function write(context, cwd, opts = {}) {
-    const filePath = outputPath(cwd);
-    let existing = '';
-    if (fs.existsSync(filePath)) existing = fs.readFileSync(filePath, 'utf8');
-    const formatted = format(context, opts);
-    const markerIdx = existing.indexOf('## Auto-generated signatures');
-    const isLegacyGenerated = existing.includes('<!-- Generated by SigMap gen-context.js') || existing.includes('## Code Signatures');
-    const newContent = markerIdx !== -1
-      ? existing.slice(0, markerIdx) + GEMINI_MARKER.trimStart() + formatted
-      : (isLegacyGenerated ? GEMINI_MARKER.trimStart() + formatted : existing + GEMINI_MARKER + formatted);
-    fs.mkdirSync(path.dirname(filePath), { recursive: true });
-    fs.writeFileSync(filePath, newContent, 'utf8');
-  }
-  module.exports = { name, format, outputPath, write };
-};
+const path = require('path');
 
-// ── ./packages/adapters/codex (bundled) ──
-__factories["./packages/adapters/codex"] = function(module, exports) {
-  const path = require('path');
-  const fs = require('fs');
-  const name = 'codex';
-  const CODEX_MARKER = '\n\n## Auto-generated signatures\n<!-- Updated by gen-context.js -->\n';
-  const CODEX_TOOLS_MARKER = '<!-- sigmap-tools -->';
-  const CODEX_TOOLS_BLOCK = [
-    '## Tools',
-    '',
-    CODEX_TOOLS_MARKER,
-    '',
-    '```json',
-    JSON.stringify([
-      { name: 'sigmap_ask', description: 'Rank source files by relevance to a natural-language query. Run before exploring the codebase.', command: 'sigmap ask "$QUERY"' },
-      { name: 'sigmap_validate', description: 'Validate SigMap config and measure context coverage. Run after changing config or source dirs.', command: 'sigmap validate' },
-      { name: 'sigmap_judge', description: 'Score an LLM response for groundedness against source context. Use to verify answer quality.', command: 'sigmap judge --response "$RESPONSE" --context "$CONTEXT"' },
-      { name: 'sigmap_query', description: 'Rank all files by relevance using TF-IDF and write a focused mini-context.', command: 'sigmap --query "$QUERY" --context' },
-      { name: 'sigmap_weights', description: 'Show learned file-ranking multipliers accumulated from past sessions.', command: 'sigmap weights' },
-    ], null, 2),
-    '```',
+const name = 'windsurf';
+
+/**
+ * Format context for Windsurf rules file.
+ * @param {string} context - Raw signature context string
+ * @param {object} [opts]
+ * @param {string} [opts.version] - SigMap version string
+ * @returns {string}
+ */
+function format(context, opts = {}) {
+  if (!context || typeof context !== 'string') return '';
+  const version   = opts.version || 'unknown';
+  const timestamp = new Date().toISOString();
+  const meta      = _confidenceMeta(opts);
+  const header = [
+    `# Code signatures — generated by SigMap v${version}`,
+    `# Updated: ${timestamp}`,
+    `# ${meta}`,
+    `# Regenerate: node gen-context.js`,
     '',
   ].join('\n');
-  function format(context, opts = {}) {
-    if (!context || typeof context !== 'string' || !context.trim()) return '';
-    const toolBlock = [
-      '## SigMap commands',
-      '',
-      '| When | Command |',
-      '|------|---------|',
-      '| Before answering a question | `sigmap ask "<your question>"` |',
-      '| After code changes | `sigmap validate` |',
-      '| To query by topic | `sigmap --query "<topic>"` |',
-      '',
-      'Always run `sigmap ask` or `sigmap --query` before searching for files relevant to a task.',
-      '',
-    ].join('\n');
-    return '# Code signatures\n\n' + toolBlock + context;
-  }
-  function outputPath(cwd) { return path.join(cwd, 'AGENTS.md'); }
-  function write(context, cwd, opts = {}) {
-    const filePath = outputPath(cwd);
-    let existing = '';
-    if (fs.existsSync(filePath)) existing = fs.readFileSync(filePath, 'utf8');
-    const formatted = format(context, opts);
-    const markerIdx = existing.indexOf('## Auto-generated signatures');
-    const isLegacyGenerated = existing.includes('<!-- Generated by SigMap gen-context.js') || existing.includes('## Code Signatures') || existing.includes('# Code signatures');
-    let newContent = markerIdx !== -1
-      ? existing.slice(0, markerIdx) + CODEX_MARKER.trimStart() + formatted
-      : (isLegacyGenerated ? CODEX_MARKER.trimStart() + formatted : existing + CODEX_MARKER + formatted);
-    if (!newContent.includes(CODEX_TOOLS_MARKER)) {
-      const sigPos = newContent.indexOf('## Auto-generated signatures');
-      if (sigPos !== -1) {
-        newContent = newContent.slice(0, sigPos) + CODEX_TOOLS_BLOCK + '\n' + newContent.slice(sigPos);
-      } else {
-        newContent = CODEX_TOOLS_BLOCK + '\n' + newContent;
-      }
-    }
-    fs.writeFileSync(filePath, newContent, 'utf8');
-  }
-  module.exports = { name, format, outputPath, write };
+  return header + context;
+}
+
+function _confidenceMeta(opts) {
+  const parts = [`version=${opts.version || 'unknown'}`];
+  if (opts.confidence)    parts.push(`confidence=${opts.confidence}`);
+  if (opts.coverage != null) parts.push(`coverage=${opts.coverage}%`);
+  if (opts.dropped  != null) parts.push(`dropped=${opts.dropped}`);
+  if (opts.commit)        parts.push(`commit=${opts.commit}`);
+  return `sigmap: ${parts.join(' ')}`;
+}
+
+/**
+ * Return the output file path for this adapter.
+ * @param {string} cwd - Project root
+ * @returns {string}
+ */
+function outputPath(cwd) {
+  return path.join(cwd, '.windsurfrules');
+}
+
+module.exports = { name, format, outputPath };
+
 };
+// ── ./packages/adapters/openai (bundled) ──
+__factories["./packages/adapters/openai"] = function(module, exports) {
+'use strict';
 
-// ── ./packages/adapters/index (bundled) ──
-__factories["./packages/adapters/index"] = function(module, exports) {
-  const ADAPTER_NAMES = ['copilot', 'claude', 'cursor', 'windsurf', 'openai', 'gemini', 'codex'];
-  const _adapterCache = {};
-  function getAdapter(name) {
-    if (!name || typeof name !== 'string') return null;
-    const key = name.toLowerCase();
-    if (!ADAPTER_NAMES.includes(key)) return null;
-    if (!_adapterCache[key]) {
-      try { _adapterCache[key] = __require('./packages/adapters/' + key); } catch (_) { return null; }
-    }
-    return _adapterCache[key];
+/**
+ * OpenAI adapter — formats context as an OpenAI system message.
+ * Use the output as the `content` field of a system role message.
+ *
+ * Example usage in code:
+ *   const { format } = require('sigmap/adapters/openai');
+ *   const systemPrompt = format(context);
+ *   // Pass to: openai.chat.completions.create({ messages: [{ role: 'system', content: systemPrompt }] })
+ *
+ * Contract:
+ *   format(context, opts?) → string
+ *   outputPath(cwd) → string
+ */
+
+const path = require('path');
+
+const name = 'openai';
+
+/**
+ * Format context as an OpenAI system prompt.
+ * @param {string} context - Raw signature context string
+ * @param {object} [opts]
+ * @param {string} [opts.version] - SigMap version string
+ * @param {string} [opts.projectName] - Optional project name
+ * @returns {string}
+ */
+function format(context, opts = {}) {
+  if (!context || typeof context !== 'string') return '';
+  const version = opts.version || 'unknown';
+  const timestamp = new Date().toISOString();
+  const projectLine = opts.projectName
+    ? `Project: ${opts.projectName}\n`
+    : '';
+
+  const meta = _confidenceMeta(opts);
+  return [
+    `You are a coding assistant with full knowledge of this codebase.`,
+    `Below are the code signatures extracted by SigMap v${version} on ${timestamp}.`,
+    `<!-- ${meta} -->`,
+    projectLine,
+    `Use these signatures to answer questions about the code accurately.`,
+    `When the user asks about a specific file or function, refer to the signatures below.`,
+    `## Code Signatures`,
+    ``,
+    context,
+  ].join('\n');
+}
+
+/**
+ * Return the output file path for this adapter.
+ * Writes a .openai-context.md file that can be loaded at runtime.
+ * @param {string} cwd - Project root
+ * @returns {string}
+ */
+function outputPath(cwd) {
+  return path.join(cwd, '.github', 'openai-context.md');
+}
+
+function _confidenceMeta(opts) {
+  const parts = [`version=${opts.version || 'unknown'}`];
+  if (opts.confidence)    parts.push(`confidence=${opts.confidence}`);
+  if (opts.coverage != null) parts.push(`coverage=${opts.coverage}%`);
+  if (opts.dropped  != null) parts.push(`dropped=${opts.dropped}`);
+  if (opts.commit)        parts.push(`commit=${opts.commit}`);
+  return `sigmap: ${parts.join(' ')}`;
+}
+
+module.exports = { name, format, outputPath };
+
+};
+// ── ./packages/adapters/gemini (bundled) ──
+__factories["./packages/adapters/gemini"] = function(module, exports) {
+'use strict';
+
+/**
+ * Gemini adapter — formats context as a Gemini system instruction.
+ * Use the output as the `system_instruction` field in a Gemini API request.
+ *
+ * Example usage:
+ *   const { format } = require('sigmap/adapters/gemini');
+ *   const instruction = format(context);
+ *   // Pass to: genAI.getGenerativeModel({ model: 'gemini-pro', systemInstruction: instruction })
+ *
+ * Contract:
+ *   format(context, opts?) → string
+ *   outputPath(cwd) → string
+ */
+
+const path = require('path');
+const fs = require('fs');
+
+const name = 'gemini';
+const MARKER = '\n\n## Auto-generated signatures\n<!-- Updated by gen-context.js -->\n';
+
+/**
+ * Format context as a Gemini system instruction.
+ * @param {string} context - Raw signature context string
+ * @param {object} [opts]
+ * @param {string} [opts.version] - SigMap version string
+ * @param {string} [opts.projectName] - Optional project name
+ * @returns {string}
+ */
+function format(context, opts = {}) {
+  if (!context || typeof context !== 'string') return '';
+  const version = opts.version || 'unknown';
+  const timestamp = new Date().toISOString();
+  const projectLine = opts.projectName
+    ? `Project: ${opts.projectName}\n`
+    : '';
+
+  const meta = _confidenceMeta(opts);
+  return [
+    `You are a coding assistant with complete knowledge of this codebase.`,
+    `The following code signatures were extracted by SigMap v${version} on ${timestamp}.`,
+    `<!-- ${meta} -->`,
+    projectLine,
+    `These signatures represent every public function, class, and type in the project.`,
+    `Refer to them when answering questions about code structure, APIs, and implementation.`,
+    `## Code Signatures`,
+    ``,
+    context,
+  ].join('\n');
+}
+
+/**
+ * Return the output file path for this adapter.
+ * @param {string} cwd - Project root
+ * @returns {string}
+ */
+function outputPath(cwd) {
+  return path.join(cwd, '.github', 'gemini-context.md');
+}
+
+/**
+ * Write signatures into gemini-context.md using append-under-marker.
+ * If marker exists, content above marker is preserved.
+ * If legacy generated content exists without marker, replace it cleanly.
+ * @param {string} context - Raw signature context string
+ * @param {string} cwd - Project root
+ * @param {object} [opts]
+ */
+function write(context, cwd, opts = {}) {
+  const filePath = outputPath(cwd);
+  let existing = '';
+  if (fs.existsSync(filePath)) {
+    existing = fs.readFileSync(filePath, 'utf8');
+  }
+
+  const formatted = format(context, opts);
+  const markerIdx = existing.indexOf('## Auto-generated signatures');
+
+  let newContent;
+  if (markerIdx !== -1) {
+    newContent = existing.slice(0, markerIdx) + MARKER.trimStart() + formatted;
+  } else {
+    const isLegacyGenerated = existing.includes('<!-- Generated by SigMap gen-context.js')
+      || existing.includes('## Code Signatures');
+    newContent = isLegacyGenerated
+      ? MARKER.trimStart() + formatted
+      : existing + MARKER + formatted;
+  }
+
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, newContent, 'utf8');
+}
+
+function _confidenceMeta(opts) {
+  const parts = [`version=${opts.version || 'unknown'}`];
+  if (opts.confidence)    parts.push(`confidence=${opts.confidence}`);
+  if (opts.coverage != null) parts.push(`coverage=${opts.coverage}%`);
+  if (opts.dropped  != null) parts.push(`dropped=${opts.dropped}`);
+  if (opts.commit)        parts.push(`commit=${opts.commit}`);
+  return `sigmap: ${parts.join(' ')}`;
+}
+
+module.exports = { name, format, outputPath, write };
+
+};
+// ── ./packages/adapters/codex (bundled) ──
+__factories["./packages/adapters/codex"] = function(module, exports) {
+'use strict';
+
+/**
+ * Codex adapter — writes OpenAI-style context to AGENTS.md.
+ *
+ * This adapter reuses the same prompt format as the OpenAI adapter,
+ * but targets AGENTS.md so Codex-style agents can read repository guidance.
+ *
+ * Contract:
+ *   format(context, opts?) → string
+ *   outputPath(cwd) → string
+ *   write(context, cwd, opts?) → void
+ */
+
+const path = require('path');
+const fs = require('fs');
+
+const name = 'codex';
+const MARKER = '\n\n## Auto-generated signatures\n<!-- Updated by gen-context.js -->\n';
+
+/**
+ * Format context for AGENTS.md — clean markdown, no LLM preamble.
+ * @param {string} context - Raw signature context string
+ * @param {object} [opts]
+ * @returns {string}
+ */
+function format(context, opts = {}) {
+  if (!context || typeof context !== 'string' || !context.trim()) return '';
+  return `# Code signatures\n\n${context}`;
+}
+
+/**
+ * Return the output file path for this adapter.
+ * @param {string} cwd - Project root
+ * @returns {string}
+ */
+function outputPath(cwd) {
+  return path.join(cwd, 'AGENTS.md');
+}
+
+/**
+ * Write signatures into AGENTS.md using append-under-marker.
+ * If marker exists, content above marker is preserved.
+ * If legacy generated content exists without marker, replace it cleanly.
+ * @param {string} context - Raw signature context string
+ * @param {string} cwd - Project root
+ * @param {object} [opts]
+ */
+function write(context, cwd, opts = {}) {
+  const filePath = outputPath(cwd);
+  let existing = '';
+  if (fs.existsSync(filePath)) {
+    existing = fs.readFileSync(filePath, 'utf8');
+  }
+
+  const formatted = format(context, opts);
+  const markerIdx = existing.indexOf('## Auto-generated signatures');
+
+  let newContent;
+  if (markerIdx !== -1) {
+    newContent = existing.slice(0, markerIdx) + MARKER.trimStart() + formatted;
+  } else {
+    const isLegacyGenerated = existing.includes('<!-- Generated by SigMap gen-context.js')
+      || existing.includes('## Code Signatures')
+      || existing.includes('# Code signatures');
+    newContent = isLegacyGenerated
+      ? MARKER.trimStart() + formatted
+      : existing + MARKER + formatted;
+  }
+
+  fs.writeFileSync(filePath, newContent, 'utf8');
+}
+
+module.exports = { name, format, outputPath, write };
+
+};
+// ── ./packages/adapters/index (bundled) ──
+__factories["./packages/adapters/index"] = function(module, exports) {
+  const ADAPTER_NAMES = ['copilot', 'claude', 'cursor', 'windsurf', 'openai', 'gemini', 'codex'];
+  const _adapterCache = {};
+  function getAdapter(name) {
+    if (!name || typeof name !== 'string') return null;
+    const key = name.toLowerCase();
+    if (!ADAPTER_NAMES.includes(key)) return null;
+    if (!_adapterCache[key]) {
+      try { _adapterCache[key] = __require('./packages/adapters/' + key); } catch (_) { return null; }
+    }
+    return _adapterCache[key];
   }
   function listAdapters() { return ADAPTER_NAMES.slice(); }
   function adapt(context, adapterName, opts = {}) {
@@ -8877,108 +9414,1551 @@ __factories["./src/discovery/r-manifest"] = function(module, exports) {
   }
 };
 
-// ── ./src/workspace/detector ──
-__factories["./src/workspace/detector"] = function(module, exports) {
-  'use strict';
-  const fs   = require('fs');
-  const path = require('path');
-  module.exports = { detectWorkspaces, inferPackage, scopeToPackage };
+// ── ./src/workspace/detector ──
+__factories["./src/workspace/detector"] = function(module, exports) {
+  'use strict';
+  const fs   = require('fs');
+  const path = require('path');
+  module.exports = { detectWorkspaces, inferPackage, scopeToPackage };
+
+  function detectWorkspaces(cwd) {
+    const pkgPath = path.join(cwd, 'package.json');
+    if (!fs.existsSync(pkgPath)) return [];
+
+    let pkg;
+    try {
+      pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+    } catch {
+      return [];
+    }
+
+    const patterns = pkg.workspaces || [];
+    const dirs = [];
+
+    // Handle both flat array and object with packages field (Yarn v2 format)
+    const patternArray = Array.isArray(patterns) ? patterns : (patterns.packages || []);
+
+    for (const p of patternArray) {
+      const base = p.replace(/\/\*\*?$/, '');
+      const resolved = path.join(cwd, base);
+      if (fs.existsSync(resolved)) {
+        try {
+          for (const entry of fs.readdirSync(resolved, { withFileTypes: true })) {
+            if (entry.isDirectory()) dirs.push(path.join(resolved, entry.name));
+          }
+        } catch (_) {}
+      }
+    }
+
+    return dirs;
+  }
+
+  // Infer package from query tokens: "add rate limiting to payments" → "packages/payments"
+  function inferPackage(query, workspaceDirs, cwd) {
+    const tokens = query.toLowerCase().split(/\W+/).filter(t => t.length > 2);
+
+    // Find longest matching package name
+    let bestMatch = null;
+    let bestLen = 0;
+    let bestMatchLen = 0;
+
+    for (const dir of workspaceDirs) {
+      const name = path.basename(dir).toLowerCase();
+      for (const token of tokens) {
+        const matchLen = _getMatchLength(name, token);
+        // Only consider matches; use longest match, and break ties by longest package name
+        if (matchLen > 0 && (matchLen > bestLen || (matchLen === bestLen && name.length > bestMatchLen))) {
+          bestMatch = dir;
+          bestLen = matchLen;
+          bestMatchLen = name.length;
+        }
+      }
+    }
+
+    return bestMatch;
+  }
+
+  function _getMatchLength(name, token) {
+    if (name === token) return 1000 + name.length;  // Exact match is best
+    if (name.startsWith(token) && token.length >= 3) return 100 + token.length;
+    if (token.startsWith(name) && name.length >= 3) return name.length;
+    return 0;
+  }
+
+  // Return boost multiplier for files inside the inferred package
+  function scopeToPackage(filePath, packageDir) {
+    const normalized = filePath.replace(/\\/g, '/');
+    const normalizedPkg = packageDir.replace(/\\/g, '/');
+
+    // Ensure we match the directory boundary, not just a prefix
+    // e.g., packages/payment should not match packages/payment-old
+    if (normalized.startsWith(normalizedPkg)) {
+      const afterPrefix = normalized.slice(normalizedPkg.length);
+      // Check if next char is / or if it's the exact match
+      if (afterPrefix === '' || afterPrefix[0] === '/') {
+        return 0.30;
+      }
+    }
+    return 0;
+  }
+};
+
+/**
+ * SigMap — gen-context.js v1.2.0
+ * Zero-dependency AI context engine.
+ * Runs with: node gen-context.js
+ * No npm install required. Node 18+ built-ins only.
+ */
+
+// ── ./src/format/usage-guidance ──
+__factories["./src/format/usage-guidance"] = function(module, exports) {
+'use strict';
+
+/**
+ * Canonical "how to use SigMap" guidance block (v6.16/v7.0).
+ *
+ * Every adapter emits this one identical block so all generated context files
+ * (CLAUDE.md, AGENTS.md, .github/copilot-instructions.md, GEMINI.md, .cursorrules,
+ * …) carry the same, single usage section — instead of each adapter inventing
+ * its own wording (and codex emitting a redundant second JSON block).
+ */
+
+function usageBlock() {
+  return [
+    '## SigMap commands',
+    '',
+    '| When | Command |',
+    '|------|---------|',
+    '| Before answering a question about code | `sigmap ask "<your question>"` |',
+    '| To rank files by topic | `sigmap --query "<topic>"` |',
+    '| After changing config or source dirs | `sigmap validate` |',
+    '| To verify an AI answer is grounded | `sigmap judge --response <file>` |',
+    '',
+    'Always run `sigmap ask` (or `sigmap --query`) before searching for files relevant to a task.',
+    '',
+  ].join('\n');
+}
+
+module.exports = { usageBlock };
+
+};
+
+// ── ./src/squeeze/classify ──
+__factories["./src/squeeze/classify"] = function(module, exports) {
+'use strict';
+
+/**
+ * Squeeze input classifier (v7.0.0).
+ *
+ * Deterministic, zero-dep detector that labels a pasted blob as a
+ * `stacktrace`, `cilog`, or `json` payload — or `null` (pass through). Pure
+ * regex/heuristics; runs in well under 10ms even on large input.
+ *
+ * Order matters: stack traces are highest value and a CI log often *contains*
+ * a trace, so stacktrace is checked first, then cilog, then json.
+ */
+
+const FRAME_RE = [
+  /^\s*at\s+.+\(.+:\d+:\d+\)\s*$/,          // JS: at fn (file:line:col)
+  /^\s*at\s+.+:\d+:\d+\s*$/,                 // JS: at file:line:col
+  /^\s*at\s+[\w$.<>]+\(.+\.\w+:\d+\)/,       // Java/Kotlin: at pkg.Cls.m(File.java:42)
+  /^\s*File\s+".+",\s+line\s+\d+/,           // Python frame
+  /^\s+\w+.*\([^)]*\.(go|rs):\d+\)/,         // Go/Rust frame with file:line
+  /^\s*#\d+\s+0x[0-9a-f]+/,                  // native/gdb frame
+];
+
+const STACK_HEADER_RE = [
+  /Traceback \(most recent call last\)/,
+  /Exception in thread/,
+  /\bat Object\.<anonymous>\b/,
+  /thread '.*' panicked at/,
+  /^panic:/m,
+  /goroutine \d+ \[/,
+];
+
+function countFrames(lines) {
+  let n = 0;
+  for (const line of lines) {
+    if (FRAME_RE.some((re) => re.test(line))) n++;
+  }
+  return n;
+}
+
+function matchesStackTrace(input, lines) {
+  const frames = countFrames(lines);
+  const header = STACK_HEADER_RE.some((re) => re.test(input));
+  // A single explicit header (Traceback/panic) counts as strong evidence even
+  // with few parsed frames; otherwise require 2+ frame-like lines.
+  if (!header && frames < 2) return { match: false, confidence: 0, frames };
+  // Confidence scales with frame count; a header alone floors it at 0.6.
+  let confidence = Math.min(0.97, 0.15 * frames);
+  if (header) confidence = Math.max(confidence, 0.6 + Math.min(0.3, 0.05 * frames));
+  return { match: true, confidence: Number(confidence.toFixed(2)), frames };
+}
+
+const TS_RE = /(\b\d{1,2}:\d{2}:\d{2}\b)|(\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2})/;
+const PROGRESS_RE = /(\d{1,3}%)|(\bDownloading\b)|(\bnpm (WARN|notice|http)\b)|(##\[(group|endgroup|command)\])|(\[\d+\/\d+\])|(▕|█|━|⠿)|(\bETA\b)|(\r$)/;
+
+function matchesCiLog(input, lines) {
+  if (lines.length < 8) return { match: false, confidence: 0 };
+  let logish = 0;
+  const seen = new Map();
+  let repeats = 0;
+  for (const line of lines) {
+    if (TS_RE.test(line) || PROGRESS_RE.test(line)) logish++;
+    const norm = line.replace(/\d+/g, '#').trim();
+    if (norm) {
+      const c = (seen.get(norm) || 0) + 1;
+      seen.set(norm, c);
+      if (c > 1) repeats++;
+    }
+  }
+  const density = logish / lines.length;
+  const repeatRatio = repeats / lines.length;
+  if (density < 0.4 && repeatRatio < 0.4) return { match: false, confidence: 0 };
+  const confidence = Math.min(0.95, Math.max(density, repeatRatio) + 0.15);
+  return { match: true, confidence: Number(confidence.toFixed(2)) };
+}
+
+function matchesJsonPayload(input) {
+  const trimmed = input.trim();
+  if (/^[[{]/.test(trimmed)) {
+    try {
+      JSON.parse(trimmed);
+      return { match: true, confidence: 0.95 };
+    } catch (_) { /* not strict JSON — fall through to heuristic */ }
+  }
+  const lines = trimmed.split('\n');
+  if (lines.length < 4) return { match: false, confidence: 0 };
+  let kv = 0;
+  for (const line of lines) {
+    if (/^\s*"[^"]+"\s*:\s*.+/.test(line) || /^\s*[}\]],?\s*$/.test(line)) kv++;
+  }
+  const ratio = kv / lines.length;
+  if (ratio < 0.6) return { match: false, confidence: 0 };
+  return { match: true, confidence: Number(Math.min(0.9, ratio).toFixed(2)) };
+}
+
+/**
+ * @param {string} input
+ * @returns {{ category: 'stacktrace'|'cilog'|'json'|null, confidence: number }}
+ */
+function classify(input) {
+  if (typeof input !== 'string' || !input.trim()) return { category: null, confidence: 0 };
+  const lines = input.split('\n');
+
+  const st = matchesStackTrace(input, lines);
+  if (st.match) return { category: 'stacktrace', confidence: st.confidence };
+
+  const ci = matchesCiLog(input, lines);
+  if (ci.match) return { category: 'cilog', confidence: ci.confidence };
+
+  const js = matchesJsonPayload(input);
+  if (js.match) return { category: 'json', confidence: js.confidence };
+
+  return { category: null, confidence: 0 };
+}
+
+module.exports = { classify, countFrames };
+
+};
+
+// ── ./src/squeeze/cilog ──
+__factories["./src/squeeze/cilog"] = function(module, exports) {
+'use strict';
+
+/**
+ * CI / build-log squeeze (v7.0.0).
+ *
+ * Strips timestamps, progress bars, and repeated noise; keeps every error line
+ * plus a small context window around it. Never returns empty — when there are
+ * no errors it falls back to a head/tail summary. Also reused by the stacktrace
+ * squeezer to clean noise surrounding a trace.
+ */
+
+const TS_PREFIX_RE = /^\s*(?:\[?\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}(?:[.,]\d+)?Z?\]?\s*|\[?\d{1,2}:\d{2}:\d{2}(?:[.,]\d+)?\]?\s*)+/;
+const PROGRESS_LINE_RE = /(?:^|\s)(?:\d{1,3}%|Downloading|Receiving objects|Resolving deltas|Compressing objects|npm (?:WARN|notice|http|sill|verb)|##\[(?:group|endgroup|command|section)\]|\[\d+\/\d+\]|ETA[: ]|█|━|▕|⣿)/;
+const ERROR_RE = /\b(?:error|err!|fail(?:ed|ure)?|exception|panic|fatal|traceback|ERR_|E[A-Z]{3,})\b|✗|❌/i;
+
+/** Remove a leading timestamp prefix from a single line. */
+function stripTimestamp(line) {
+  return line.replace(TS_PREFIX_RE, '');
+}
+
+/**
+ * @param {string} input
+ * @param {object} [opts]
+ * @param {number} [opts.context=2]  context lines kept around each error
+ * @returns {{ squeezed: string, kept: string[], stripped: string[] }}
+ */
+function squeezeCiLog(input, opts = {}) {
+  const ctx = opts.context != null ? opts.context : 2;
+  const lines = input.split('\n');
+  const keep = new Set();
+  const errorIdx = [];
+
+  for (let i = 0; i < lines.length; i++) {
+    if (ERROR_RE.test(lines[i])) {
+      errorIdx.push(i);
+      for (let j = Math.max(0, i - ctx); j <= Math.min(lines.length - 1, i + ctx); j++) keep.add(j);
+    }
+  }
+
+  let body;
+  let keptDesc;
+  if (errorIdx.length === 0) {
+    const head = lines.slice(0, 10).map(stripTimestamp);
+    const tail = lines.length > 20 ? lines.slice(-10).map(stripTimestamp) : [];
+    body = head.slice();
+    if (tail.length) body.push(`… (${lines.length - 20} lines omitted) …`, ...tail);
+    keptDesc = ['head/tail summary (no error lines found)'];
+  } else {
+    const sorted = [...keep].sort((a, b) => a - b);
+    body = [];
+    let prev = -2;
+    for (const idx of sorted) {
+      // Drop pure progress/noise lines unless they are themselves errors.
+      const line = stripTimestamp(lines[idx]);
+      if (PROGRESS_LINE_RE.test(line) && !ERROR_RE.test(line)) continue;
+      if (idx > prev + 1) body.push(`… (${idx - prev - 1} lines) …`);
+      body.push(line);
+      prev = idx;
+    }
+    if (body.length === 0) body = errorIdx.map((i) => stripTimestamp(lines[i])); // safety net
+    keptDesc = [`${errorIdx.length} error line(s) + ${ctx}-line context`];
+  }
+
+  return {
+    squeezed: body.join('\n'),
+    kept: keptDesc,
+    stripped: [`${Math.max(0, lines.length - body.length)} timestamp/progress/noise line(s)`],
+  };
+}
+
+module.exports = { squeezeCiLog, stripTimestamp, ERROR_RE };
+
+};
+
+// ── ./src/squeeze/jsonpayload ──
+__factories["./src/squeeze/jsonpayload"] = function(module, exports) {
+'use strict';
+
+/**
+ * JSON-payload squeeze (v7.0.0).
+ *
+ * Collapses repeated array elements, truncates long string values, and
+ * preserves the schema shape at every depth — so an LLM still sees the
+ * structure of an API/GraphQL/validation error without the bulk.
+ */
+
+const MAX_STR = 500;
+const ARRAY_KEEP = 2;
+
+function squeezeValue(v, opts) {
+  const maxStr = opts.maxStr;
+  const keep = opts.arrayKeep;
+  if (Array.isArray(v)) {
+    if (v.length <= keep + 1) return v.map((x) => squeezeValue(x, opts));
+    const head = v.slice(0, keep).map((x) => squeezeValue(x, opts));
+    head.push(`…${v.length - keep} more similar items`);
+    return head;
+  }
+  if (v && typeof v === 'object') {
+    const o = {};
+    for (const k of Object.keys(v)) o[k] = squeezeValue(v[k], opts);
+    return o;
+  }
+  if (typeof v === 'string' && v.length > maxStr) {
+    return v.slice(0, maxStr) + `…(${v.length} chars)`;
+  }
+  return v;
+}
+
+/**
+ * @param {string} input
+ * @param {object} [opts]
+ * @param {number} [opts.maxStr=500]    truncate strings longer than this
+ * @param {number} [opts.arrayKeep=2]   array items kept before collapsing
+ * @returns {{ squeezed, kept, stripped }}
+ */
+function squeezeJsonPayload(input, opts = {}) {
+  let parsed;
+  try { parsed = JSON.parse(input); }
+  catch (_) { return { squeezed: input, kept: ['(not valid JSON — unchanged)'], stripped: [] }; }
+  const cfg = { maxStr: opts.maxStr != null ? opts.maxStr : MAX_STR, arrayKeep: opts.arrayKeep != null ? opts.arrayKeep : ARRAY_KEEP };
+  const squeezed = JSON.stringify(squeezeValue(parsed, cfg), null, 2);
+  return {
+    squeezed,
+    kept: ['schema shape preserved at all depths'],
+    stripped: ['collapsed repeated array items; truncated long string values'],
+  };
+}
+
+module.exports = { squeezeJsonPayload, squeezeValue };
+
+};
+
+// ── ./src/squeeze/stacktrace ──
+__factories["./src/squeeze/stacktrace"] = function(module, exports) {
+'use strict';
+
+/**
+ * Stack-trace squeeze (v7.0.0) — the highest-value squeeze module.
+ *
+ * Dedupes repeated exceptions, strips vendor frames, keeps frames in the user's
+ * own source dirs, and — the differentiator — **enriches the top kept frame**
+ * with its real signature from the SigMap symbol index (`buildSigIndex`).
+ * Generic log summarizers can't do this; SigMap has the repo's symbol map.
+ *
+ * Pure/deterministic. The symbol index is injected via `opts.symbolIndex` so
+ * the module is unit-testable without touching the filesystem.
+ */
+
+const path = require('path');
+
+const VENDOR_RE = /(?:^|[\\/])(?:node_modules|vendor|site-packages|dist|build|\.venv|venv|third_party|external|\.cargo|go\/pkg\/mod)[\\/]/;
+
+/** Parse a frame line across JS/TS, Python, Java/Kotlin, Go, Rust, native. */
+function parseFrame(line) {
+  let m;
+  if ((m = line.match(/^\s*at\s+(.+?)\s+\((.+?):(\d+):(\d+)\)/))) return { fn: m[1], file: m[2], line: +m[3], raw: line };
+  if ((m = line.match(/^\s*at\s+(.+?):(\d+):(\d+)\s*$/))) return { fn: '', file: m[1], line: +m[2], raw: line };
+  if ((m = line.match(/^\s*at\s+([\w$.<>]+)\((.+?):(\d+)\)/))) return { fn: m[1], file: m[2], line: +m[3], raw: line };
+  if ((m = line.match(/^\s*File\s+"(.+?)",\s+line\s+(\d+)(?:,\s+in\s+(.+))?/))) return { fn: (m[3] || '').trim(), file: m[1], line: +m[2], raw: line };
+  if ((m = line.match(/^\s*(.+\.(?:go|rs)):(\d+)/))) return { fn: '', file: m[1], line: +m[2], raw: line };
+  return null;
+}
+
+function isVendor(file) { return VENDOR_RE.test(String(file).replace(/\\/g, '/')); }
+
+function inSrcDirs(file, srcDirs) {
+  const f = String(file).replace(/\\/g, '/');
+  return srcDirs.some((d) => {
+    const dd = String(d).replace(/^\.\//, '').replace(/\/$/, '');
+    return dd && (f === dd || f.startsWith(dd + '/') || f.includes('/' + dd + '/'));
+  });
+}
+
+/** Look up the real signature for a frame in the SigMap symbol index. */
+function enrichFrame(frame, symbolIndex) {
+  if (!symbolIndex || !frame) return null;
+  const want = String(frame.file).replace(/\\/g, '/');
+  const base = path.basename(want);
+  let key = null;
+  for (const k0 of symbolIndex.keys()) {
+    const k = String(k0).replace(/\\/g, '/');
+    if (k === want || want.endsWith('/' + k) || k.endsWith('/' + want)) { key = k0; break; }
+    if (!key && path.basename(k) === base) key = k0;
+  }
+  if (!key) return null;
+  const sigs = symbolIndex.get(key) || [];
+  const wantFn = frame.fn ? frame.fn.split('.').pop() : '';
+  let byLine = null, byName = null;
+  for (const sig of sigs) {
+    const s = String(sig);
+    const mm = s.match(/:(\d+)(?:-(\d+))?\s*$/);
+    if (mm) {
+      const a = +mm[1], b = mm[2] ? +mm[2] : a;
+      if (frame.line >= a && frame.line <= b) byLine = s;
+    }
+    if (wantFn && new RegExp('\\b' + wantFn.replace(/[^\w$]/g, '') + '\\b').test(s)) byName = byName || s;
+  }
+  const sig = byLine || byName;
+  return sig ? { file: key, sig: sig.replace(/\s*:\d+(?:-\d+)?\s*$/, '').trim() } : null;
+}
+
+/**
+ * @param {string} input
+ * @param {object} [opts]
+ * @param {string[]} [opts.srcDirs]      user source dirs (default ['src'])
+ * @param {Map}      [opts.symbolIndex]  SigMap signature index for enrichment
+ * @param {number}   [opts.maxFrames=8]  cap on kept source frames
+ * @returns {{ squeezed, kept, stripped, enriched }}
+ */
+function squeezeStackTrace(input, opts = {}) {
+  const srcDirs = (opts.srcDirs && opts.srcDirs.length) ? opts.srcDirs : ['src'];
+  const maxFrames = opts.maxFrames != null ? opts.maxFrames : 8;
+  const lines = input.split('\n');
+
+  const headerCount = new Map();
+  const headerOrder = [];
+  const frames = [];
+  for (const line of lines) {
+    const f = parseFrame(line);
+    if (f) { frames.push(f); continue; }
+    const t = line.trim();
+    if (!t) continue;
+    if (!headerCount.has(t)) headerOrder.push(t);
+    headerCount.set(t, (headerCount.get(t) || 0) + 1);
+  }
+
+  const seen = new Set();
+  let dupFrames = 0;
+  const nonVendor = [];
+  const sourceFrames = [];
+  let vendorCount = 0;
+  for (const f of frames) {
+    const k = f.file + ':' + f.line;
+    if (seen.has(k)) { dupFrames++; continue; }
+    seen.add(k);
+    if (isVendor(f.file)) { vendorCount++; continue; }
+    nonVendor.push(f);
+    if (inSrcDirs(f.file, srcDirs)) sourceFrames.push(f);
+  }
+
+  // Prefer source frames; never return empty (fall back to top non-vendor, then raw).
+  const shown = sourceFrames.length ? sourceFrames.slice(0, maxFrames)
+    : (nonVendor.length ? nonVendor.slice(0, 3) : frames.slice(0, 3));
+
+  const enrichment = shown.length ? enrichFrame(shown[0], opts.symbolIndex) : null;
+
+  const out = [];
+  for (const h of headerOrder) {
+    const n = headerCount.get(h);
+    out.push(n > 1 ? `${h}   (occurred ×${n})` : h);
+  }
+  for (let i = 0; i < shown.length; i++) {
+    out.push('    ' + shown[i].raw.trim());
+    if (i === 0 && enrichment) out.push(`      ↳ ${enrichment.sig}   [${enrichment.file}]`);
+  }
+
+  return {
+    squeezed: out.join('\n'),
+    kept: [
+      `${headerOrder.length} unique exception(s)`,
+      `top ${shown.length} ${sourceFrames.length ? 'source ' : ''}frame(s)`,
+      ...(enrichment ? [`enriched ${path.basename(shown[0].file)}:${shown[0].line}`] : []),
+    ],
+    stripped: [`${vendorCount} vendor frame(s)`, `${dupFrames} duplicate frame(s)`],
+    enriched: !!enrichment,
+  };
+}
+
+module.exports = { squeezeStackTrace, parseFrame, isVendor, inSrcDirs, enrichFrame };
+
+};
+
+// ── ./src/squeeze/index ──
+__factories["./src/squeeze/index"] = function(module, exports) {
+'use strict';
+
+/**
+ * Squeeze orchestrator (v7.0.0): classify → squeeze → reduction → decision.
+ *
+ * Always-on and silent: callers run `squeeze()` on pasted input, then use
+ * `shouldPrompt()` to decide whether the reduction is worth interrupting for.
+ * Everything is deterministic and offline; the symbol index for stack-trace
+ * enrichment is passed through via `opts.symbolIndex`.
+ */
+
+const { classify } = __require('./src/squeeze/classify');
+const { squeezeStackTrace } = __require('./src/squeeze/stacktrace');
+const { squeezeCiLog } = __require('./src/squeeze/cilog');
+const { squeezeJsonPayload } = __require('./src/squeeze/jsonpayload');
+
+function estimateTokens(s) { return Math.ceil(String(s || '').length / 4); }
+
+/**
+ * @param {string} input
+ * @param {object} [opts]  forwarded to the category squeezer (srcDirs, symbolIndex, …)
+ * @returns {{ category, confidence, original, squeezed, rawTokens, squeezedTokens, reduction, kept, stripped, enriched, applies }}
+ */
+function squeeze(input, opts = {}) {
+  const { category, confidence } = classify(input);
+  const rawTokens = estimateTokens(input);
+  const base = {
+    category, confidence, original: input, squeezed: input,
+    rawTokens, squeezedTokens: rawTokens, reduction: 0,
+    kept: [], stripped: [], enriched: false, applies: false,
+  };
+  if (!category) return base;
+
+  let r;
+  if (category === 'stacktrace') r = squeezeStackTrace(input, opts);
+  else if (category === 'cilog') r = squeezeCiLog(input, opts);
+  else r = squeezeJsonPayload(input, opts);
+
+  const squeezedTokens = estimateTokens(r.squeezed);
+  const reduction = rawTokens > 0 ? (rawTokens - squeezedTokens) / rawTokens : 0;
+  return {
+    category, confidence,
+    original: input, squeezed: r.squeezed,
+    rawTokens, squeezedTokens,
+    reduction: Math.max(0, Number(reduction.toFixed(4))),
+    kept: r.kept || [], stripped: r.stripped || [], enriched: !!r.enriched,
+    applies: squeezedTokens < rawTokens,
+  };
+}
+
+/** True when the reduction clears the threshold (accepts 0–1 or 0–100). */
+function shouldPrompt(reduction, threshold) {
+  const t = threshold > 1 ? threshold / 100 : threshold;
+  return reduction >= t;
+}
+
+/** A compact human summary of what squeeze would do (for the prompt). */
+function formatSummary(result) {
+  const pct = Math.round(result.reduction * 100);
+  const lines = [
+    `Input: ${result.rawTokens.toLocaleString()} tokens`,
+    `Can reduce to ${result.squeezedTokens.toLocaleString()} tokens (${pct}% smaller):`,
+  ];
+  for (const k of result.kept) lines.push(`  ✓ Kept: ${k}`);
+  for (const s of result.stripped) lines.push(`  ✗ Stripped: ${s}`);
+  return lines.join('\n');
+}
+
+module.exports = { squeeze, shouldPrompt, formatSummary, estimateTokens };
+
+};
+
+// ── ./src/nudge ──
+__factories["./src/nudge"] = function(module, exports) {
+'use strict';
+
+/**
+ * Star nudge + usage tracking (v7.0.0).
+ *
+ * Records run counts in `.context/usage.json` and shows a one-time GitHub-star
+ * message after the tool has been genuinely useful (≥10 runs, ≥8 successes).
+ * Shown exactly once per machine — even under concurrent runs (an `wx` lock
+ * file makes the show race-safe). Wired into `ask` (and the `squeeze` path).
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const crypto = require('crypto');
+
+const RUN_THRESHOLD = 10;
+const SUCCESS_THRESHOLD = 8;
+
+function usagePath(cwd) { return path.join(cwd, '.context', 'usage.json'); }
+
+function defaultUsage() {
+  return {
+    totalRuns: 0, successfulRuns: 0, squeezeOffered: 0, squeezeAccepted: 0,
+    starNudgeShown: false, machineId: '', firstRunDate: null, lastRunDate: null,
+  };
+}
+
+function readUsage(cwd) {
+  try { return { ...defaultUsage(), ...JSON.parse(fs.readFileSync(usagePath(cwd), 'utf8')) }; }
+  catch (_) { return defaultUsage(); }
+}
+
+function writeUsageAtomic(cwd, usage) {
+  const p = usagePath(cwd);
+  fs.mkdirSync(path.dirname(p), { recursive: true });
+  const tmp = `${p}.${process.pid}.tmp`;
+  fs.writeFileSync(tmp, JSON.stringify(usage, null, 2));
+  fs.renameSync(tmp, p); // atomic on POSIX
+}
+
+const STAR_MESSAGE = [
+  '─────────────────────────────────────────────────────────',
+  '  SigMap has helped you 10 times now.',
+  '',
+  "  If it's been useful, a GitHub star takes 5 seconds and",
+  '  helps other developers find it:',
+  '  → github.com/manojmallick/sigmap',
+  '',
+  "  (Won't ask again. Press Enter to continue.)",
+  '─────────────────────────────────────────────────────────',
+].join('\n');
+
+function showStarNudge(write) {
+  (write || ((s) => process.stderr.write(s)))('\n' + STAR_MESSAGE + '\n');
+}
+
+/**
+ * Record one run and, when the thresholds are first met, show the star nudge.
+ * @param {string} cwd
+ * @param {boolean} runSuccess
+ * @param {object} [opts]
+ * @param {boolean} [opts.silent]   record only — never print
+ * @param {function} [opts.write]   sink for the message (default stderr)
+ * @param {string} [opts.today]     override date (testing)
+ * @param {object} [opts.bump]      counter deltas to merge (e.g. { squeezeAccepted: 1 })
+ * @returns {{ usage, nudged }}
+ */
+function checkStarNudge(cwd, runSuccess, opts = {}) {
+  const usage = readUsage(cwd);
+  usage.totalRuns += 1;
+  if (runSuccess) usage.successfulRuns += 1;
+  if (opts.bump) for (const k of Object.keys(opts.bump)) usage[k] = (usage[k] || 0) + opts.bump[k];
+
+  const today = opts.today || new Date().toISOString().slice(0, 10);
+  if (!usage.firstRunDate) usage.firstRunDate = today;
+  usage.lastRunDate = today;
+  if (!usage.machineId) {
+    try { usage.machineId = 'sha256-' + crypto.createHash('sha256').update(os.hostname()).digest('hex').slice(0, 16); } catch (_) {}
+  }
+
+  let nudged = false;
+  if (!usage.starNudgeShown && usage.totalRuns >= RUN_THRESHOLD && usage.successfulRuns >= SUCCESS_THRESHOLD) {
+    // Race-safe single-show: only the process that creates the lock prints.
+    let won = false;
+    try { fs.closeSync(fs.openSync(usagePath(cwd) + '.nudge.lock', 'wx')); won = true; }
+    catch (_) { won = false; }
+    if (won && !opts.silent) showStarNudge(opts.write);
+    nudged = won;
+    usage.starNudgeShown = true;
+  }
+
+  writeUsageAtomic(cwd, usage);
+  return { usage, nudged };
+}
+
+module.exports = { checkStarNudge, readUsage, usagePath, showStarNudge, RUN_THRESHOLD, SUCCESS_THRESHOLD };
+
+};
+
+// ── ./src/verify/parsers ──
+__factories["./src/verify/parsers"] = function(module, exports) {
+'use strict';
+
+/**
+ * Parsers for the Hallucination Guard (verify-ai-output).
+ *
+ * Extract the verifiable claims an AI answer makes about a codebase:
+ *   - file paths it references
+ *   - import / require statements it shows
+ *   - function / class symbols it calls
+ *   - fenced code blocks (so callers can scope checks to code vs prose)
+ *
+ * Everything here is deterministic and offline — pure string analysis.
+ */
+
+// Extensions we are confident name a source/code/config file (no slash required).
+const KNOWN_CODE_EXT = new Set([
+  'js', 'jsx', 'mjs', 'cjs', 'ts', 'tsx', 'py', 'pyw', 'rb', 'go', 'rs',
+  'java', 'kt', 'swift', 'c', 'h', 'cpp', 'hpp', 'cs', 'php', 'r',
+  'vue', 'svelte', 'css', 'scss', 'less', 'html', 'json', 'yml', 'yaml',
+  'toml', 'xml', 'sql', 'graphql', 'gql', 'proto', 'tf', 'md', 'sh',
+  'gd', 'gdscript',
+]);
+
+/**
+ * Extract fenced code blocks.
+ * @param {string} text
+ * @returns {{ lang: string, content: string, line: number }[]}
+ */
+function extractCodeBlocks(text) {
+  const blocks = [];
+  const lines = text.split('\n');
+  let inBlock = false;
+  let lang = '';
+  let buf = [];
+  let startLine = 0;
+  for (let i = 0; i < lines.length; i++) {
+    const m = lines[i].match(/^```(\w*)/);
+    if (m) {
+      if (!inBlock) {
+        inBlock = true;
+        lang = m[1] || '';
+        buf = [];
+        startLine = i + 2; // first content line (1-based)
+      } else {
+        blocks.push({ lang, content: buf.join('\n'), line: startLine });
+        inBlock = false;
+      }
+      continue;
+    }
+    if (inBlock) buf.push(lines[i]);
+  }
+  return blocks;
+}
+
+/**
+ * Extract file-path references (deduped, first-seen line kept).
+ * A token counts as a path when it has a `.<letter…>` extension AND
+ * either contains a `/` or carries a known code/config extension.
+ * @param {string} text
+ * @returns {{ path: string, line: number }[]}
+ */
+function extractFilePaths(text) {
+  const lines = text.split('\n');
+  const seen = new Map();
+  const re = /(?:^|[\s`"'(\[<])([A-Za-z0-9_][\w./-]*\.[A-Za-z][A-Za-z0-9]*)/g;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    let m;
+    re.lastIndex = 0;
+    while ((m = re.exec(line)) !== null) {
+      const p = m[1];
+      if (/^https?:/i.test(p)) continue;
+      const ext = (p.split('.').pop() || '').toLowerCase();
+      const hasSlash = p.includes('/');
+      if (!hasSlash && !KNOWN_CODE_EXT.has(ext)) continue;
+      if (!seen.has(p)) seen.set(p, i + 1);
+    }
+  }
+  return [...seen.entries()].map(([p, line]) => ({ path: p, line }));
+}
+
+/**
+ * Extract import / require statements.
+ * @param {string} text
+ * @returns {{ module: string, kind: 'js'|'py', relative: boolean, line: number, raw: string }[]}
+ */
+function extractImports(text) {
+  const lines = text.split('\n');
+  const out = [];
+  const push = (module, kind, line, raw) => {
+    if (!module) return;
+    out.push({ module, kind, relative: /^[./]/.test(module), line, raw: raw.trim() });
+  };
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    let m;
+    // JS/TS: import ... from 'x'  |  export ... from 'x'
+    if ((m = line.match(/\b(?:import|export)\b[^'"]*\bfrom\s*['"]([^'"]+)['"]/))) {
+      push(m[1], 'js', i + 1, line);
+    } else if ((m = line.match(/\bimport\s*['"]([^'"]+)['"]/))) {
+      // side-effect import 'x'
+      push(m[1], 'js', i + 1, line);
+    }
+    // require('x') / dynamic import('x') — may co-occur, scan separately
+    const reqRe = /\b(?:require|import)\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+    let r;
+    while ((r = reqRe.exec(line)) !== null) push(r[1], 'js', i + 1, line);
+
+    // TS: import X = require('mod')
+    if ((m = line.match(/\bimport\s+[A-Za-z_$][\w$]*\s*=\s*require\s*\(\s*['"]([^'"]+)['"]\s*\)/))) {
+      push(m[1], 'js', i + 1, line);
+    }
+
+    // Python: from x import y  |  import x
+    if ((m = line.match(/^\s*from\s+([.\w]+)\s+import\b/))) {
+      push(m[1], 'py', i + 1, line);
+    } else if ((m = line.match(/^\s*import\s+([A-Za-z_][\w.]*)/))) {
+      push(m[1], 'py', i + 1, line);
+    }
+  }
+
+  // Multi-line JS/TS imports, e.g.
+  //   import {
+  //     A as B,
+  //   } from './mod';
+  // The per-line pass above misses these because `from '…'` sits on a later
+  // line. Trigger only when the opening line has no quote and no `from` yet,
+  // then gather forward until the source string appears.
+  for (let i = 0; i < lines.length; i++) {
+    const start = lines[i];
+    if (!/^\s*(?:import|export)\b/.test(start)) continue;
+    if (/['"]/.test(start) || /\bfrom\b/.test(start)) continue; // single-line, already handled
+    let joined = start;
+    for (let j = i + 1; j < Math.min(lines.length, i + 12); j++) {
+      joined += ' ' + lines[j];
+      const fm = joined.match(/\bfrom\s*['"]([^'"]+)['"]/);
+      if (fm) { push(fm[1], 'js', i + 1, start.trim()); break; }
+      if (/['"]/.test(lines[j]) && !/\bfrom\b/.test(joined)) break; // a string that isn't a source — bail
+    }
+  }
+  return out;
+}
+
+/**
+ * Extract npm/pnpm/yarn script invocations (`npm run <name>`).
+ * Only the explicit `run` form is matched, to avoid confusing package-manager
+ * subcommands (`yarn add`, `pnpm install`) with script names.
+ * @param {string} text
+ * @returns {{ name: string, line: number }[]}
+ */
+function extractNpmScripts(text) {
+  const lines = text.split('\n');
+  const out = [];
+  const seen = new Set();
+  const re = /\b(?:npm|pnpm|yarn)\s+run(?:-script)?\s+([A-Za-z0-9:_-]+)/g;
+  for (let i = 0; i < lines.length; i++) {
+    let m;
+    re.lastIndex = 0;
+    while ((m = re.exec(lines[i])) !== null) {
+      const name = m[1];
+      if (seen.has(name)) continue;
+      seen.add(name);
+      out.push({ name, line: i + 1 });
+    }
+  }
+  return out;
+}
+
+/**
+ * Extract function/class symbol references that look like calls.
+ * Restricted to backtick-wrapped calls (`foo(...)`) for high precision.
+ * @param {string} text
+ * @returns {{ name: string, line: number }[]}
+ */
+function extractSymbols(text) {
+  const lines = text.split('\n');
+  const out = [];
+  const seen = new Set();
+  const re = /`([A-Za-z_$][\w$]*)\s*\([^`]*\)`/g;
+  for (let i = 0; i < lines.length; i++) {
+    let m;
+    re.lastIndex = 0;
+    while ((m = re.exec(lines[i])) !== null) {
+      const name = m[1];
+      const key = name + '@' + (i + 1);
+      if (seen.has(key)) continue;
+      seen.add(key);
+      out.push({ name, line: i + 1 });
+    }
+  }
+  return out;
+}
+
+module.exports = {
+  extractCodeBlocks,
+  extractFilePaths,
+  extractImports,
+  extractSymbols,
+  extractNpmScripts,
+};
+
+};
+
+// ── ./src/verify/closest-match ──
+__factories["./src/verify/closest-match"] = function(module, exports) {
+'use strict';
+
+/**
+ * Closest-match suggestions for the Hallucination Guard (v6.15.0).
+ *
+ * Heuristic layer (plan §5 labels this "Medium" confidence): given a name the
+ * detectors flagged as fake, find the nearest *real* candidate by Levenshtein
+ * distance so the report can say "Did you mean `loadConfig()` in
+ * src/config/loader.js:42?". Pure, deterministic, offline — no network, no LLM.
+ *
+ * All inputs are passed in (symbol/file/script candidate lists) so this module
+ * stays unit-testable without touching the filesystem or the SigMap index.
+ */
+
+/**
+ * Levenshtein edit distance with an early-exit ceiling.
+ * Returns `max + 1` as soon as the best achievable distance exceeds `max`,
+ * so callers can cheaply reject far-apart strings.
+ */
+function levenshtein(a, b, max = Infinity) {
+  if (a === b) return 0;
+  const al = a.length;
+  const bl = b.length;
+  if (al === 0) return bl;
+  if (bl === 0) return al;
+  if (Math.abs(al - bl) > max) return max + 1;
+
+  let prev = new Array(bl + 1);
+  let curr = new Array(bl + 1);
+  for (let j = 0; j <= bl; j++) prev[j] = j;
+
+  for (let i = 1; i <= al; i++) {
+    curr[0] = i;
+    let rowMin = curr[0];
+    const ca = a.charCodeAt(i - 1);
+    for (let j = 1; j <= bl; j++) {
+      const cost = ca === b.charCodeAt(j - 1) ? 0 : 1;
+      curr[j] = Math.min(prev[j] + 1, curr[j - 1] + 1, prev[j - 1] + cost);
+      if (curr[j] < rowMin) rowMin = curr[j];
+    }
+    if (rowMin > max) return max + 1;
+    const tmp = prev;
+    prev = curr;
+    curr = tmp;
+  }
+  return prev[bl];
+}
+
+/** Bucket a normalized edit distance into a confidence label (plan §5). */
+function suggestionConfidence(distance, targetLen) {
+  const ratio = distance / Math.max(targetLen, 1);
+  if (distance === 0 || ratio <= 0.2) return 'high';
+  if (ratio <= 0.4) return 'medium';
+  return 'low';
+}
+
+/**
+ * Find the nearest candidate name to `target`.
+ *
+ * @param {string} target
+ * @param {Array<string | { name: string, file?: string, line?: number }>} candidates
+ * @param {object} [opts]
+ * @param {number} [opts.maxRatio=0.5]  reject matches farther than ratio·len edits
+ * @param {number} [opts.minLen=3]      skip very short targets (too noisy)
+ * @returns {{ name, file, line, distance, confidence } | null}
+ */
+function closestMatch(target, candidates, opts = {}) {
+  const maxRatio = opts.maxRatio != null ? opts.maxRatio : 0.5;
+  const minLen = opts.minLen != null ? opts.minLen : 3;
+  if (!target || target.length < minLen) return null;
+  if (!candidates || candidates.length === 0) return null;
+
+  const lower = target.toLowerCase();
+  const cap = Math.max(1, Math.ceil(target.length * maxRatio));
+  let best = null;
+
+  for (const c of candidates) {
+    const name = typeof c === 'string' ? c : c && c.name;
+    if (!name || name === target) continue;
+    if (Math.abs(name.length - target.length) > cap) continue;
+    const d = levenshtein(lower, name.toLowerCase(), cap);
+    if (d > cap) continue;
+    if (!best || d < best.distance ||
+        (d === best.distance && name.length < best.name.length)) {
+      best = {
+        name,
+        file: typeof c === 'object' ? c.file : undefined,
+        line: typeof c === 'object' ? c.line : undefined,
+        distance: d,
+      };
+      if (d === 0) break; // case-only difference — can't beat it
+    }
+  }
+
+  if (!best) return null;
+  best.confidence = suggestionConfidence(best.distance, target.length);
+  return best;
+}
+
+/**
+ * Build `[{ name, file, line }]` symbol candidates from a SigMap signature
+ * index (`Map<file, string[]>` whose entries may carry a `:start-end` anchor).
+ */
+function buildSymbolCandidates(sigIndex) {
+  const out = [];
+  const seen = new Set();
+  if (!sigIndex) return out;
+  for (const [file, sigs] of sigIndex) {
+    for (const sig of sigs) {
+      const s = String(sig);
+      const lineM = s.match(/:(\d+)(?:-\d+)?\s*$/);
+      const line = lineM ? parseInt(lineM[1], 10) : null;
+      const cleaned = s.replace(/\s*:\d+(?:-\d+)?\s*$/, '');
+      const m = cleaned.match(/\b(?:async\s+function|function|class|def|interface|type|enum|const|let|var)\s+([A-Za-z_$][\w$]*)/)
+        || cleaned.match(/([A-Za-z_$][\w$]*)\s*\(/)
+        || cleaned.match(/([A-Za-z_$][\w$]*)/);
+      if (!m) continue;
+      const name = m[1];
+      const key = name + '@' + file;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      out.push({ name, file, line });
+    }
+  }
+  return out;
+}
+
+/** Format a suggestion object into a human one-liner for reports/CLI. */
+function formatSuggestion(match, asCall) {
+  if (!match) return null;
+  const sym = asCall ? `${match.name}()` : match.name;
+  let where = '';
+  if (match.file) {
+    where = match.line ? ` in ${match.file}:${match.line}` : ` in ${match.file}`;
+  }
+  return `Did you mean \`${sym}\`${where}?`;
+}
+
+module.exports = {
+  levenshtein,
+  closestMatch,
+  buildSymbolCandidates,
+  suggestionConfidence,
+  formatSuggestion,
+};
+
+};
+
+// ── ./src/format/verify-report ──
+__factories["./src/format/verify-report"] = function(module, exports) {
+'use strict';
+
+/**
+ * Hallucination Guard report view (Surface A, v6.15.0).
+ *
+ * Turns the `verify-ai-output --json` result into a standalone, self-contained
+ * HTML report — red/amber/green per issue, with closest-match suggestions
+ * inline. The visual language deliberately mirrors the planned PR-comment
+ * styling so a single screenshot is reusable across docs and CI (plan proof #5).
+ *
+ * Zero dependencies, inline CSS/SVG, no external assets. Also exports a compact
+ * Markdown renderer for CI / PR comments that shares the same structure.
+ */
 
-  function detectWorkspaces(cwd) {
-    const pkgPath = path.join(cwd, 'package.json');
-    if (!fs.existsSync(pkgPath)) return [];
+const TYPE_META = {
+  'fake-file': { label: 'Fake file', tone: 'red', icon: '✕' },
+  'fake-test-file': { label: 'Fake test file', tone: 'red', icon: '✕' },
+  'fake-import': { label: 'Fake import', tone: 'red', icon: '✕' },
+  'fake-npm-script': { label: 'Fake npm script', tone: 'red', icon: '✕' },
+  'fake-symbol': { label: 'Fake symbol', tone: 'amber', icon: '!' },
+};
 
-    let pkg;
-    try {
-      pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
-    } catch {
-      return [];
-    }
+function escapeHtml(value) {
+  return String(value == null ? '' : value)
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;');
+}
 
-    const patterns = pkg.workspaces || [];
-    const dirs = [];
+function toneFor(issue) {
+  const meta = TYPE_META[issue.type];
+  if (meta) return meta.tone;
+  return issue.confidence === 'high' ? 'red' : 'amber';
+}
 
-    // Handle both flat array and object with packages field (Yarn v2 format)
-    const patternArray = Array.isArray(patterns) ? patterns : (patterns.packages || []);
+function labelFor(issue) {
+  return (TYPE_META[issue.type] && TYPE_META[issue.type].label) || issue.type;
+}
 
-    for (const p of patternArray) {
-      const base = p.replace(/\/\*\*?$/, '');
-      const resolved = path.join(cwd, base);
-      if (fs.existsSync(resolved)) {
-        try {
-          for (const entry of fs.readdirSync(resolved, { withFileTypes: true })) {
-            if (entry.isDirectory()) dirs.push(path.join(resolved, entry.name));
-          }
-        } catch (_) {}
-      }
-    }
+/**
+ * Render the verify result to a full HTML document.
+ * @param {{ file?: string, issues: object[], summary: object }} result
+ * @param {object} [opts]
+ * @param {string} [opts.title]
+ * @returns {string} HTML
+ */
+function renderReportHtml(result, opts = {}) {
+  const issues = Array.isArray(result.issues) ? result.issues : [];
+  const summary = result.summary || { total: issues.length, byType: {}, clean: issues.length === 0 };
+  const file = result.file || opts.file || 'AI answer';
+  const title = opts.title || 'SigMap — Hallucination Guard report';
+  const clean = summary.clean || issues.length === 0;
+  const byType = summary.byType || {};
+
+  const chips = Object.keys(TYPE_META)
+    .filter((t) => byType[t])
+    .map((t) => `<span class="chip chip-${TYPE_META[t].tone}">${escapeHtml(TYPE_META[t].label)}: ${byType[t]}</span>`)
+    .join('');
+
+  const banner = clean
+    ? `<div class="banner banner-green"><span class="dot"></span> No hallucinations detected — ${escapeHtml(String(summary.symbolsIndexed || 0))} symbols indexed</div>`
+    : `<div class="banner banner-red"><span class="dot"></span> ${issues.length} issue${issues.length === 1 ? '' : 's'} found in <code>${escapeHtml(file)}</code></div>`;
+
+  const rows = issues.map((issue) => {
+    const tone = toneFor(issue);
+    const sugg = issue.suggestion
+      ? `<div class="suggestion">↳ ${escapeHtml(issue.suggestion)} <span class="conf">heuristic</span></div>`
+      : '';
+    return [
+      `<li class="issue issue-${tone}">`,
+      `  <div class="issue-head">`,
+      `    <span class="badge badge-${tone}">${escapeHtml(labelFor(issue))}</span>`,
+      `    <span class="loc">${escapeHtml(issue.location || ('L' + issue.line))}</span>`,
+      `    <span class="conf conf-${escapeHtml(issue.confidence || 'high')}">${escapeHtml(issue.confidence || 'high')} confidence</span>`,
+      `  </div>`,
+      `  <div class="msg">${escapeHtml(issue.message || issue.value)}</div>`,
+      `  ${sugg}`,
+      `</li>`,
+    ].join('\n');
+  }).join('\n');
+
+  const list = clean
+    ? '<p class="empty">Nothing to report — every file, import, symbol, and script in the answer resolves against the repository.</p>'
+    : `<ul class="issues">${rows}</ul>`;
+
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>${escapeHtml(title)}</title>
+<style>
+  :root { color-scheme: light dark; }
+  * { box-sizing: border-box; }
+  body { font: 14px/1.5 -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif; margin: 0; background: #0d1117; color: #e6edf3; }
+  .wrap { max-width: 880px; margin: 0 auto; padding: 32px 20px 64px; }
+  h1 { font-size: 20px; margin: 0 0 4px; }
+  .sub { color: #8b949e; margin: 0 0 20px; font-size: 13px; }
+  code { font-family: ui-monospace, SFMono-Regular, Menlo, monospace; background: #161b22; padding: 1px 5px; border-radius: 4px; font-size: 12.5px; }
+  .banner { display: flex; align-items: center; gap: 8px; padding: 12px 16px; border-radius: 8px; font-weight: 600; margin-bottom: 16px; }
+  .banner-green { background: rgba(46,160,67,.15); border: 1px solid rgba(46,160,67,.4); color: #3fb950; }
+  .banner-red { background: rgba(248,81,73,.12); border: 1px solid rgba(248,81,73,.4); color: #f85149; }
+  .dot { width: 9px; height: 9px; border-radius: 50%; background: currentColor; }
+  .chips { display: flex; flex-wrap: wrap; gap: 6px; margin-bottom: 20px; }
+  .chip { font-size: 12px; padding: 3px 9px; border-radius: 999px; font-weight: 600; }
+  .chip-red { background: rgba(248,81,73,.15); color: #f85149; }
+  .chip-amber { background: rgba(210,153,34,.18); color: #d29922; }
+  ul.issues { list-style: none; margin: 0; padding: 0; display: flex; flex-direction: column; gap: 10px; }
+  .issue { border: 1px solid #30363d; border-left-width: 4px; border-radius: 8px; padding: 12px 14px; background: #0f141a; }
+  .issue-red { border-left-color: #f85149; }
+  .issue-amber { border-left-color: #d29922; }
+  .issue-head { display: flex; align-items: center; gap: 10px; flex-wrap: wrap; }
+  .badge { font-size: 11.5px; font-weight: 700; padding: 2px 8px; border-radius: 5px; text-transform: uppercase; letter-spacing: .03em; }
+  .badge-red { background: rgba(248,81,73,.18); color: #f85149; }
+  .badge-amber { background: rgba(210,153,34,.2); color: #d29922; }
+  .loc { font-family: ui-monospace, monospace; color: #8b949e; font-size: 12px; }
+  .conf { font-size: 11px; color: #8b949e; }
+  .conf-high { color: #f85149; }
+  .conf-medium { color: #d29922; }
+  .msg { margin-top: 7px; font-family: ui-monospace, monospace; font-size: 12.5px; color: #e6edf3; }
+  .suggestion { margin-top: 6px; font-size: 12.5px; color: #3fb950; }
+  .suggestion .conf { margin-left: 6px; }
+  .empty { color: #8b949e; }
+  footer { margin-top: 28px; color: #6e7681; font-size: 12px; }
+  a { color: #58a6ff; }
+</style>
+</head>
+<body>
+<div class="wrap">
+  <h1>Hallucination Guard report</h1>
+  <p class="sub">Deterministic verification of an AI answer against the real repository — <code>sigmap verify-ai-output</code></p>
+  ${banner}
+  ${chips ? `<div class="chips">${chips}</div>` : ''}
+  ${list}
+  <footer>Generated by <a href="https://github.com/manojmallick/sigmap">SigMap</a> · offline, no LLM · suggestions are heuristic (closest-match)</footer>
+</div>
+</body>
+</html>
+`;
+}
 
-    return dirs;
+/** Compact Markdown rendering of the same result (CI / PR comments). */
+function renderReportMarkdown(result) {
+  const issues = Array.isArray(result.issues) ? result.issues : [];
+  const summary = result.summary || {};
+  const file = result.file || 'AI answer';
+  if (summary.clean || issues.length === 0) {
+    return `### ✅ Hallucination Guard — clean\n\nNo fabricated files, imports, symbols, or scripts in \`${file}\`.`;
+  }
+  const lines = [
+    `### ❌ Hallucination Guard — ${issues.length} issue${issues.length === 1 ? '' : 's'} in \`${file}\``,
+    '',
+    '| Type | Location | Detail | Suggestion |',
+    '| --- | --- | --- | --- |',
+  ];
+  for (const i of issues) {
+    const sugg = i.suggestion ? i.suggestion.replace(/\|/g, '\\|') : '—';
+    lines.push(`| ${labelFor(i)} | ${i.location || ('L' + i.line)} | \`${String(i.value).replace(/\|/g, '\\|')}\` | ${sugg} |`);
   }
+  return lines.join('\n');
+}
 
-  // Infer package from query tokens: "add rate limiting to payments" → "packages/payments"
-  function inferPackage(query, workspaceDirs, cwd) {
-    const tokens = query.toLowerCase().split(/\W+/).filter(t => t.length > 2);
+module.exports = { renderReportHtml, renderReportMarkdown, escapeHtml };
 
-    // Find longest matching package name
-    let bestMatch = null;
-    let bestLen = 0;
-    let bestMatchLen = 0;
+};
 
-    for (const dir of workspaceDirs) {
-      const name = path.basename(dir).toLowerCase();
-      for (const token of tokens) {
-        const matchLen = _getMatchLength(name, token);
-        // Only consider matches; use longest match, and break ties by longest package name
-        if (matchLen > 0 && (matchLen > bestLen || (matchLen === bestLen && name.length > bestMatchLen))) {
-          bestMatch = dir;
-          bestLen = matchLen;
-          bestMatchLen = name.length;
-        }
+// ── ./src/verify/hallucination-guard ──
+__factories["./src/verify/hallucination-guard"] = function(module, exports) {
+'use strict';
+
+/**
+ * Hallucination Guard — deterministic core (Reliable MVP, v6.15.0).
+ *
+ * Given the text of an AI answer, flag claims that do not match the repo:
+ *   - fake-file      : a referenced path is not on disk
+ *   - fake-test-file : a referenced *test* path is not on disk (sub-type)
+ *   - fake-import    : a relative import does not resolve; a bare import is
+ *                      absent from package.json deps (builtins allow-listed)
+ *   - fake-symbol    : a called function/class is absent from the symbol index
+ *   - fake-npm-script: `npm run X` where X is not a package.json script
+ *
+ * Each issue carries a `confidence` (detection certainty) and, where a near
+ * match exists, a heuristic `suggestion` ("Did you mean …?"). No network, no
+ * LLM. Reuses SigMap primitives (buildSigIndex) but every external dependency
+ * is injectable via `opts` so the core stays unit-testable.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const parsers = __require('./src/verify/parsers');
+const { closestMatch, buildSymbolCandidates, formatSuggestion } = __require('./src/verify/closest-match');
+
+// A path that looks like a test file (JS/TS spec/test, Python test_/_test, or
+// a tests/__tests__ directory). Used to flag fake-test-file separately.
+const TEST_PATH_RE = /(?:\.(?:test|spec)\.[mc]?[jt]sx?$)|(?:(?:^|\/)__tests__\/)|(?:(?:^|\/)test_[^/]+\.py$)|(?:_test\.py$)|(?:(?:^|\/)tests?\/)/i;
+function isTestPath(p) { return TEST_PATH_RE.test(p); }
+
+const NODE_BUILTINS = new Set([
+  'fs', 'path', 'os', 'util', 'events', 'stream', 'http', 'https', 'crypto',
+  'child_process', 'url', 'querystring', 'assert', 'zlib', 'readline', 'net',
+  'tls', 'dns', 'buffer', 'process', 'vm', 'module', 'console', 'timers',
+  'string_decoder', 'perf_hooks', 'worker_threads', 'cluster', 'dgram', 'v8',
+  'tty', 'repl', 'async_hooks', 'inspector', 'fs/promises', 'path/posix',
+]);
+
+const PY_BUILTINS = new Set([
+  'os', 'sys', 're', 'json', 'math', 'typing', 'collections', 'itertools',
+  'functools', 'datetime', 'pathlib', 'subprocess', 'abc', 'dataclasses',
+  'enum', 'io', 'time', 'random', 'logging', 'argparse', 'unittest', 'asyncio',
+  'copy', 'hashlib', 'threading', 'string', 'csv', 'glob', 'shutil', 'tempfile',
+]);
+
+const LANG_GLOBALS = new Set([
+  // JS
+  'console', 'require', 'module', 'exports', 'process', 'Object', 'Array',
+  'String', 'Number', 'Boolean', 'Math', 'JSON', 'Date', 'Promise', 'Map',
+  'Set', 'WeakMap', 'WeakSet', 'RegExp', 'Error', 'Symbol', 'parseInt',
+  'parseFloat', 'isNaN', 'setTimeout', 'setInterval', 'clearTimeout', 'fetch',
+  'Buffer', 'Function', 'eval', 'encodeURIComponent', 'decodeURIComponent',
+  // Python
+  'print', 'len', 'range', 'str', 'int', 'float', 'dict', 'list', 'tuple',
+  'set', 'bool', 'open', 'enumerate', 'zip', 'map', 'filter', 'sorted',
+  'sum', 'min', 'max', 'abs', 'isinstance', 'super', 'type', 'getattr',
+  'setattr', 'hasattr',
+]);
+
+const REL_EXTS = ['', '.js', '.ts', '.tsx', '.jsx', '.mjs', '.cjs', '.json', '.py', '.r', '.R', '.vue'];
+const REL_INDEX = ['index.js', 'index.ts', 'index.tsx', 'index.jsx', '__init__.py'];
+
+/**
+ * Build the set of known symbol identifiers from the SigMap signature index,
+ * plus `{ name, file, line }` candidates (for closest-match suggestions).
+ */
+function buildSymbolSet(cwd) {
+  const set = new Set();
+  let fileKeys = [];
+  let symbolCandidates = [];
+  try {
+    const { buildSigIndex } = __require('./src/retrieval/ranker');
+    const idx = buildSigIndex(cwd);
+    fileKeys = [...idx.keys()];
+    for (const sigs of idx.values()) {
+      for (const sig of sigs) {
+        const cleaned = String(sig).replace(/\s*:\d+(?:-\d+)?\s*$/, '');
+        const ids = cleaned.match(/[A-Za-z_$][\w$]*/g) || [];
+        for (const id of ids) set.add(id);
       }
     }
+    symbolCandidates = buildSymbolCandidates(idx);
+  } catch (_) {}
+  return { set, fileKeys, symbolCandidates };
+}
 
-    return bestMatch;
+/** Load declared dependency names from package.json. */
+function loadDeps(cwd) {
+  const deps = new Set();
+  let hasPkg = false;
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(cwd, 'package.json'), 'utf8'));
+    hasPkg = true;
+    for (const k of ['dependencies', 'devDependencies', 'peerDependencies', 'optionalDependencies']) {
+      if (pkg[k] && typeof pkg[k] === 'object') {
+        for (const name of Object.keys(pkg[k])) deps.add(name);
+      }
+    }
+  } catch (_) {}
+  return { deps, hasPkg };
+}
+
+/** Load the set of npm script names declared in package.json. */
+function loadScripts(cwd) {
+  const scripts = new Set();
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(cwd, 'package.json'), 'utf8'));
+    if (pkg.scripts && typeof pkg.scripts === 'object') {
+      for (const name of Object.keys(pkg.scripts)) scripts.add(name);
+    }
+  } catch (_) {}
+  return scripts;
+}
+
+/** Default file-existence check: resolve a referenced path against cwd. */
+function defaultFileExists(cwd, ref) {
+  const clean = ref.replace(/^\.\//, '');
+  for (const c of [path.resolve(cwd, clean), path.resolve(cwd, ref)]) {
+    try {
+      if (fs.existsSync(c)) return true;
+    } catch (_) {}
   }
+  return false;
+}
 
-  function _getMatchLength(name, token) {
-    if (name === token) return 1000 + name.length;  // Exact match is best
-    if (name.startsWith(token) && token.length >= 3) return 100 + token.length;
-    if (token.startsWith(name) && name.length >= 3) return name.length;
-    return 0;
+/** Default relative-import resolver: fs candidates + basename match in index. */
+function defaultRelativeResolvable(cwd, mod, fileBasenames) {
+  const base = path.resolve(cwd, mod);
+  for (const e of REL_EXTS) {
+    try {
+      if (fs.existsSync(base + e)) return true;
+    } catch (_) {}
   }
+  for (const idx of REL_INDEX) {
+    try {
+      if (fs.existsSync(path.join(base, idx))) return true;
+    } catch (_) {}
+  }
+  // Fall back to basename match against the indexed file set (the answer's
+  // import is relative to a file we cannot know, so a name match is enough
+  // to avoid false positives).
+  const wantBase = path.basename(mod).replace(/\.[^.]+$/, '').toLowerCase();
+  return fileBasenames.has(wantBase);
+}
 
-  // Return boost multiplier for files inside the inferred package
-  function scopeToPackage(filePath, packageDir) {
-    const normalized = filePath.replace(/\\/g, '/');
-    const normalizedPkg = packageDir.replace(/\\/g, '/');
+/**
+ * Verify an AI answer against the repository.
+ *
+ * Each issue has the shape:
+ *   { type, value, line, location, message, confidence, suggestion }
+ * where `confidence` is the *detection* certainty ('high' for path/dep/script
+ * checks, 'medium' for symbol checks) and `suggestion` is a heuristic
+ * closest-match hint (or null).
+ *
+ * @param {string} answerText
+ * @param {string} cwd
+ * @param {object} [opts]
+ * @param {Set<string>} [opts.symbolSet]      override known symbols
+ * @param {Array}       [opts.symbolCandidates] override { name, file, line } list
+ * @param {Array<string>} [opts.fileCandidates]  override repo file paths (suggestions)
+ * @param {Set<string>} [opts.deps]           override package deps
+ * @param {Set<string>} [opts.scripts]        override package.json script names
+ * @param {boolean}     [opts.hasPkg]         whether a package.json exists
+ * @param {(ref: string) => boolean} [opts.fileExists]          override file check
+ * @param {(mod: string) => boolean} [opts.relativeResolvable]  override rel-import check
+ * @returns {{ issues: object[], summary: object }}
+ */
+function verify(answerText, cwd, opts = {}) {
+  let symbolSet = opts.symbolSet;
+  let fileBasenames = opts.fileBasenames;
+  let symbolCandidates = opts.symbolCandidates || [];
+  let fileCandidates = opts.fileCandidates || [];
+  if (!symbolSet) {
+    const built = buildSymbolSet(cwd);
+    symbolSet = built.set;
+    fileBasenames = new Set(built.fileKeys.map(
+      (k) => path.basename(k).replace(/\.[^.]+$/, '').toLowerCase()
+    ));
+    symbolCandidates = built.symbolCandidates;
+    fileCandidates = built.fileKeys;
+  }
+  if (!fileBasenames) fileBasenames = new Set();
+
+  let deps = opts.deps;
+  let hasPkg = opts.hasPkg;
+  if (!deps) {
+    const loaded = loadDeps(cwd);
+    deps = loaded.deps;
+    if (hasPkg === undefined) hasPkg = loaded.hasPkg;
+  }
+  const scripts = opts.scripts || (hasPkg ? loadScripts(cwd) : new Set());
+
+  const fileExists = opts.fileExists || ((ref) => defaultFileExists(cwd, ref));
+  const relativeResolvable = opts.relativeResolvable
+    || ((mod) => defaultRelativeResolvable(cwd, mod, fileBasenames));
+
+  // Pre-derive basename candidates for file suggestions (compare on basename so
+  // a wrong directory still surfaces the right file).
+  const fileBasenameCandidates = fileCandidates.map((f) => ({ name: path.basename(f), file: f }));
+
+  const issues = [];
+  const dedupe = new Set();
+  const add = (issue) => {
+    const key = `${issue.type}::${issue.value}`;
+    if (dedupe.has(key)) return;
+    dedupe.add(key);
+    if (!('suggestion' in issue)) issue.suggestion = null;
+    issue.location = `L${issue.line}`;
+    issues.push(issue);
+  };
 
-    // Ensure we match the directory boundary, not just a prefix
-    // e.g., packages/payment should not match packages/payment-old
-    if (normalized.startsWith(normalizedPkg)) {
-      const afterPrefix = normalized.slice(normalizedPkg.length);
-      // Check if next char is / or if it's the exact match
-      if (afterPrefix === '' || afterPrefix[0] === '/') {
-        return 0.30;
+  // 1. fake-file / fake-test-file
+  for (const { path: p, line } of parsers.extractFilePaths(answerText)) {
+    if (fileExists(p)) continue;
+    const isTest = isTestPath(p);
+    const match = closestMatch(path.basename(p), fileBasenameCandidates, { minLen: 4 });
+    add({
+      type: isTest ? 'fake-test-file' : 'fake-file',
+      value: p,
+      line,
+      message: `${isTest ? 'Test file' : 'File'} not found on disk: ${p}`,
+      confidence: 'high',
+      suggestion: match ? formatSuggestion(match, false) : null,
+    });
+  }
+
+  // 2. fake-import
+  for (const imp of parsers.extractImports(answerText)) {
+    if (imp.relative) {
+      if (!relativeResolvable(imp.module)) {
+        add({ type: 'fake-import', value: imp.module, line: imp.line, message: `Import does not resolve: ${imp.module}`, confidence: 'high' });
       }
+      continue;
+    }
+    // Bare module — only verifiable for JS when a package.json exists.
+    const top = imp.module.split('/')[0];
+    if (imp.kind === 'js') {
+      if (!hasPkg) continue;
+      if (NODE_BUILTINS.has(imp.module) || NODE_BUILTINS.has(top)) continue;
+      if (top.startsWith('@')) {
+        const scoped = imp.module.split('/').slice(0, 2).join('/');
+        if (deps.has(scoped) || deps.has(imp.module)) continue;
+      } else if (deps.has(top) || deps.has(imp.module)) {
+        continue;
+      }
+      const match = closestMatch(top, [...deps], { minLen: 3 });
+      add({
+        type: 'fake-import',
+        value: imp.module,
+        line: imp.line,
+        message: `Package not in dependencies: ${imp.module}`,
+        confidence: 'high',
+        suggestion: match ? formatSuggestion({ name: match.name }, false) : null,
+      });
+    }
+    // Python bare imports: stdlib is unbounded offline — skip to keep precision.
+  }
+
+  // 3. fake-symbol
+  if (symbolSet.size > 0) {
+    for (const { name, line } of parsers.extractSymbols(answerText)) {
+      if (symbolSet.has(name)) continue;
+      if (LANG_GLOBALS.has(name) || NODE_BUILTINS.has(name) || PY_BUILTINS.has(name)) continue;
+      const match = closestMatch(name, symbolCandidates, { minLen: 4 });
+      add({
+        type: 'fake-symbol',
+        value: name,
+        line,
+        message: `Symbol not found in repo index: ${name}()`,
+        confidence: 'medium',
+        suggestion: match ? formatSuggestion(match, true) : null,
+      });
     }
-    return 0;
   }
-};
 
-/**
- * SigMap — gen-context.js v1.2.0
- * Zero-dependency AI context engine.
- * Runs with: node gen-context.js
- * No npm install required. Node 18+ built-ins only.
- */
+  // 4. fake-npm-script
+  if (hasPkg && scripts.size > 0) {
+    for (const { name, line } of parsers.extractNpmScripts(answerText)) {
+      if (scripts.has(name)) continue;
+      const match = closestMatch(name, [...scripts], { minLen: 2 });
+      add({
+        type: 'fake-npm-script',
+        value: name,
+        line,
+        message: `npm script not in package.json: ${name}`,
+        confidence: 'high',
+        suggestion: match ? formatSuggestion({ name: match.name }, false) : null,
+      });
+    }
+  }
+
+  issues.sort((a, b) => a.line - b.line);
+
+  const byType = {
+    'fake-file': 0, 'fake-test-file': 0, 'fake-import': 0,
+    'fake-symbol': 0, 'fake-npm-script': 0,
+  };
+  for (const i of issues) byType[i.type] = (byType[i.type] || 0) + 1;
+
+  const summary = {
+    total: issues.length,
+    byType,
+    clean: issues.length === 0,
+    symbolsIndexed: symbolSet.size,
+    withSuggestion: issues.filter((i) => i.suggestion).length,
+  };
+
+  return { issues, summary };
+}
+
+module.exports = { verify, buildSymbolSet, loadDeps, loadScripts, isTestPath };
+
+};
 
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
 const { execSync } = require('child_process');
 
-const VERSION = '6.14.0';
+const VERSION = '7.0.0';
 const MARKER = '\n\n## Auto-generated signatures\n<!-- Updated by gen-context.js -->\n';
 
 function requireSourceOrBundled(key) {
@@ -9278,29 +11258,17 @@ function applyTokenBudget(fileEntries, maxTokens) {
   let total = renderedTotal(fileEntries);
   if (total <= budgetForEntries) return fileEntries;
 
-  // v6.12 Surgical Context — progressive disclosure: before dropping whole files,
-  // collapse signature BODIES to their line-anchor pointers (keep `symbol :start-end`).
-  // Only sigs that actually carry an anchor shrink; the agent can re-fetch bodies via
-  // the get_lines MCP tool. This degrades gracefully instead of losing files outright.
-  let working = fileEntries;
-  const collapsed = fileEntries.map((e) => {
-    const slim = (e.sigs || []).map((s) => {
-      const line = toIndexLine(s);
-      return line && /:\d+-\d+/.test(line) ? line : s; // replace only when it yields an anchor
-    });
-    return { ...e, sigs: slim };
-  });
-  const collapsedRendered = renderedTotal(collapsed);
-  if (collapsedRendered < total) {
-    console.warn(`[sigmap] budget: collapsed bodies to anchors, reclaimed ~${total - collapsedRendered} tokens`);
-    working = collapsed;
-    total = collapsedRendered;
-    // Collapsing keeps every file, so the section overhead must fit too — not just sigs.
-    if (total <= budgetForEntries) return working;
-  }
-
-  // Sort by drop priority (drop first = index 0)
-  const withPriority = working.map((e) => {
+  // Over budget — degrade gracefully, best file first:
+  //   1. keep FULL signatures (params + return type) while they fit;
+  //   2. when a file no longer fits with full sigs, collapse just THAT file to
+  //      its line-anchor pointers (still discoverable via buildSigIndex / the
+  //      ranker — it parses the context file, so an anchored file stays findable);
+  //   3. drop a file only when even the anchor form won't fit.
+  // The important, high-priority files therefore keep their real signatures —
+  // the user-visible value — while only low-priority overflow degrades to
+  // anchors instead of vanishing. (Earlier versions collapsed EVERY file to an
+  // anchor the moment you went 1 token over budget, gutting all signatures.)
+  const withPriority = fileEntries.map((e) => {
     let priority = 0;
     let dropReason = 'budget: low recency';
     if (isGeneratedFile(e.filePath)) { priority = 10; dropReason = 'budget: generated file'; }
@@ -9308,41 +11276,59 @@ function applyTokenBudget(fileEntries, maxTokens) {
     else if (isTestFile(e.filePath)) { priority = 8;  dropReason = 'budget: test file'; }
     else if (isConfigFile(e.filePath)) { priority = 6; dropReason = 'budget: config file'; }
     else priority = 4;
-    // v4.0: signal quality = sigs per line-of-code (higher = more informative)
     const loc = e.content ? e.content.split('\n').length : 1;
     const signalQuality = loc > 0 ? (e.sigs ? e.sigs.length : 0) / loc : 0;
     return { ...e, priority, dropReason, signalQuality };
   });
 
-  // Within same priority: sort by mtime ascending (oldest first), then signalQuality ascending (least informative first)
-  withPriority.sort((a, b) => {
-    if (b.priority !== a.priority) return b.priority - a.priority;
-    if ((a.mtime || 0) !== (b.mtime || 0)) return (a.mtime || 0) - (b.mtime || 0);
-    return (a.signalQuality || 0) - (b.signalQuality || 0);
+  // Best-first order: lowest drop-priority, then most-recent, then most-informative.
+  const bestFirst = withPriority.slice().sort((a, b) => {
+    if (a.priority !== b.priority) return a.priority - b.priority;
+    if ((b.mtime || 0) !== (a.mtime || 0)) return (b.mtime || 0) - (a.mtime || 0);
+    return (b.signalQuality || 0) - (a.signalQuality || 0);
   });
 
-  const kept = [];
+  const entryCost = (e) => estimateTokens(e.sigs.join('\n')) + sectionOverhead(e);
+  const collapseEntry = (e) => ({
+    ...e,
+    sigs: (e.sigs || []).map((s) => {
+      const line = toIndexLine(s);
+      return line && /:\d+-\d+/.test(line) ? line : s;
+    }),
+  });
+  // Keep FULL signatures for the best files while they fit (signatures are the
+  // value the user reads). When a file's full form no longer fits, fall back to
+  // its anchor form (still discoverable via the ranker, which parses this file);
+  // drop only when even the anchor won't fit. So the important files keep real
+  // signatures and only the lowest-priority overflow degrades — instead of every
+  // signature being gutted to an anchor the moment you go over budget.
+  const finalByPath = new Map();
   const verboseDropped = [];
-  // Iterate forward: highest drop-priority files (generated=10, mock=9, test=8) are at index 0.
-  // Drop those first until the RENDERED total (sigs + section overhead) fits maxTokens,
-  // then keep everything else.
-  let rendered = renderedTotal(withPriority);
-  for (const entry of withPriority) {
-    if (rendered > budgetForEntries) {
-      rendered -= estimateTokens(entry.sigs.join('\n')) + sectionOverhead(entry);
-      verboseDropped.push({ filePath: entry.filePath, reason: entry.dropReason });
-    } else {
-      kept.push(entry);
+  let collapsedCount = 0;
+  let used = 0;
+  for (const entry of bestFirst) { // best first
+    if (used + entryCost(entry) <= budgetForEntries) {
+      finalByPath.set(entry.filePath, entry); used += entryCost(entry); continue;
+    }
+    const slim = collapseEntry(entry);
+    if (used + entryCost(slim) <= budgetForEntries) {
+      finalByPath.set(entry.filePath, slim); used += entryCost(slim); collapsedCount++; continue;
     }
+    verboseDropped.push({ filePath: entry.filePath, reason: entry.dropReason });
   }
-  if (verboseDropped.length > 0) {
-    console.warn(`[sigmap] budget: dropped ${verboseDropped.length} files to stay under ${maxTokens} tokens`);
-    // Feature 7: --verbose — print per-file drop reason
+  // Restore the original file order for stable output.
+  const kept = withPriority.filter((e) => finalByPath.has(e.filePath)).map((e) => finalByPath.get(e.filePath));
+
+  if (verboseDropped.length > 0 || collapsedCount > 0) {
+    const parts = [];
+    if (verboseDropped.length) parts.push(`dropped ${verboseDropped.length} file(s)`);
+    if (collapsedCount) parts.push(`collapsed ${collapsedCount} low-priority file(s) to anchors`);
+    console.warn(`[sigmap] budget: ${parts.join(', ')} to stay under ${maxTokens} tokens`);
     if (process.argv.includes('--verbose')) {
       for (const { filePath, reason } of verboseDropped) {
         console.warn(`[sigmap] dropped: ${path.relative(process.cwd(), filePath)} — ${reason}`);
       }
-      console.warn(`[sigmap] included: ${kept.length} files, dropped: ${verboseDropped.length}`);
+      console.warn(`[sigmap] included: ${kept.length} files (${collapsedCount} collapsed), dropped: ${verboseDropped.length}`);
     }
   }
   return kept;
@@ -9564,12 +11550,17 @@ function resolveImpactRadius(fileEntries, cwd, config) {
 }
 
 function formatOutput(fileEntries, cwd, routingEnabled, config, extras) {
+  // One canonical usage block for every context file (CLAUDE.md, AGENTS.md,
+  // copilot-instructions.md, …). Lives here — the single source all writers
+  // consume — so adapters don't each invent their own (now-removed) variant.
+  const { usageBlock } = requireSourceOrBundled('./src/format/usage-guidance');
   const lines = [
     '<!-- Generated by SigMap gen-context.js v' + VERSION + ' -->',
     '<!-- DO NOT EDIT below the marker line — run gen-context.js to regenerate -->',
     '',
     '# Code signatures',
     '',
+    usageBlock(),
   ];
 
   // Compact dependency map section (shows import relationships, ~50-100 tokens)
@@ -10737,8 +12728,16 @@ Usage:
   ${cmd} --impact <file>                   Show every file impacted by changing <file>
   ${cmd} --impact <file> --json            Impact as JSON {changed, direct, transitive, tests, routes}
   ${cmd} --impact <file> --depth <n>       BFS depth limit (default 3, 0=unlimited)
-  ${cmd} verify-ai-output <answer.md>      Flag fake files/imports/symbols in an AI answer
-  ${cmd} verify-ai-output <answer.md> --json  Hallucination report as JSON (exits 1 if issues)
+  ${cmd} verify-ai-output <answer.md>      Flag fake files/tests/imports/symbols/npm-scripts in an AI answer
+  ${cmd} verify-ai-output <answer.md> --json    Hallucination report as JSON (exits 1 if issues)
+  ${cmd} verify-ai-output <answer.md> --report  Write a standalone HTML report (red/amber/green)
+  ${cmd} squeeze <file|->                  Minimize a pasted stacktrace/CI-log/JSON blob (--json for stats)
+  ${cmd} ask "<query>" --squeeze           Auto-accept input minimization (no prompt; for scripts/CI)
+  ${cmd} ask "<query>" --no-squeeze        Disable input minimization entirely
+  ${cmd} ask "<query>" --squeeze-threshold N  Min reduction %% to prompt (default 30)
+  ${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
   ${cmd} --init                            Write example config + .contextignore scaffold
   ${cmd} --help                            Show this message
   ${cmd} --version                         Show version
@@ -11124,8 +13123,8 @@ function main() {
     const { loadSession, saveSession, mergeSessionContext } = requireSourceOrBundled('./src/session/memory');
     const { detectWorkspaces, inferPackage, scopeToPackage } = requireSourceOrBundled('./src/workspace/detector');
 
-    const intent = detectIntent(query);
-    const intentWeights = getIntentWeights(intent);
+    let intent = detectIntent(query);
+    let intentWeights = getIntentWeights(intent);
 
     const sigIndex = buildSigIndex(cwd);
     if (sigIndex.size === 0) {
@@ -11133,6 +13132,44 @@ function main() {
       process.exit(1);
     }
 
+    // v7.0.0: Squeeze — classify and minimize pasted stacktrace/CI-log/JSON
+    // input before ranking. Always runs silently; only prompts (interactive
+    // TTY) when the reduction clears the threshold. Never blocks pipes/CI.
+    let squeezeOffered = false;
+    let squeezeAccepted = false;
+    if (!args.includes('--no-squeeze')) {
+      try {
+        const { squeeze: runSqueeze, shouldPrompt, formatSummary } = requireSourceOrBundled('./src/squeeze/index');
+        const sq = runSqueeze(query, { srcDirs: config.srcDirs, symbolIndex: sigIndex });
+        if (sq.applies && sq.reduction > 0) {
+          squeezeOffered = true;
+          const thrIdx = args.indexOf('--squeeze-threshold');
+          const threshold = thrIdx !== -1 ? parseFloat(args[thrIdx + 1]) : 30;
+          const auto = args.includes('--squeeze');
+          const interactive = !!(process.stdin.isTTY && process.stderr.isTTY) && !args.includes('--json');
+          let accept = false;
+          if (auto) {
+            accept = true;
+          } else if (interactive && shouldPrompt(sq.reduction, threshold)) {
+            process.stderr.write('\n' + formatSummary(sq) + '\n\n');
+            process.stderr.write('Proceed with minimized input? [Y/n] ');
+            const buf = Buffer.alloc(8);
+            try {
+              const n = fs.readSync(0, buf, 0, 8, null);
+              const ans = buf.toString('utf8', 0, n).trim().toLowerCase();
+              accept = ans === '' || ans === 'y' || ans === 'yes';
+            } catch (_) { accept = false; }
+          }
+          if (accept) {
+            query = sq.squeezed;
+            intent = detectIntent(query);
+            intentWeights = getIntentWeights(intent);
+            squeezeAccepted = true;
+          }
+        }
+      } catch (_) { /* squeeze is best-effort — never break ask */ }
+    }
+
     let ranked = rank(query, sigIndex, { topK: 5, weights: intentWeights, cwd });
 
     // v6.10: Workspace scoping — infer package from query and apply boost
@@ -11232,6 +13269,15 @@ function main() {
         bar,
       ].join('\n'));
     }
+    // v7.0.0: record the run and show the one-time star nudge (interactive only).
+    try {
+      const { checkStarNudge } = requireSourceOrBundled('./src/nudge');
+      const showNudge = !!process.stderr.isTTY && !args.includes('--json');
+      checkStarNudge(cwd, true, {
+        silent: !showNudge,
+        bump: { squeezeOffered: squeezeOffered ? 1 : 0, squeezeAccepted: squeezeAccepted ? 1 : 0 },
+      });
+    } catch (_) {}
     process.exit(0);
   }
 
@@ -11860,12 +13906,186 @@ function main() {
     process.exit(0);
   }
 
+  // `sigmap note "<text>"` — append to the cross-session decision log.
+  // With no text, lists recent notes (also `note --list [N]`).
+  if (args[0] === 'note') {
+    const jsonOut = args.includes('--json');
+    const { addNote, readNotes, formatNotes } = requireSourceOrBundled('./src/session/notes');
+    const listIdx = args.indexOf('--list');
+    // Build positionals, skipping value-taking flags and their values
+    // (e.g. `--cwd <dir>`, `--list <N>`) so they never leak into the note text.
+    const VALUE_FLAGS = new Set(['--cwd', '--list']);
+    const positional = [];
+    for (let i = 1; i < args.length; i++) {
+      const a = args[i];
+      if (a.startsWith('--')) { if (VALUE_FLAGS.has(a)) i++; continue; }
+      positional.push(a);
+    }
+    const wantsList = listIdx !== -1 || positional.length === 0;
+
+    if (wantsList) {
+      const limArg = listIdx !== -1 ? parseInt(args[listIdx + 1], 10) : parseInt(positional[0], 10);
+      const limit = Number.isFinite(limArg) && limArg > 0 ? limArg : 10;
+      const notes = readNotes(cwd, limit);
+      if (jsonOut) {
+        process.stdout.write(JSON.stringify({ notes }) + '\n');
+      } else {
+        console.log(`[sigmap] ${notes.length} recent note${notes.length === 1 ? '' : 's'}`);
+        console.log(formatNotes(notes.slice().reverse()));
+      }
+      process.exit(0);
+    }
+
+    const text = positional.join(' ');
+    let entry;
+    try {
+      entry = addNote(cwd, text);
+    } catch (err) {
+      console.error(`[sigmap] ${err.message}`);
+      process.exit(1);
+    }
+    if (jsonOut) {
+      process.stdout.write(JSON.stringify({ added: entry }) + '\n');
+    } else {
+      console.log(`[sigmap] noted${entry.branch ? ` (${entry.branch})` : ''}: ${entry.text}`);
+    }
+    process.exit(0);
+  }
+
+  // `sigmap status` — environment / repo state at a glance.
+  if (args[0] === 'status') {
+    const jsonOut = args.includes('--json');
+    const gitOpts = { cwd, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] };
+    const st = { branch: null, dirty: 0, lastIndex: null, indexVersion: null, indexFiles: null, changedSinceIndex: null, notes: 0, lastNote: null };
+
+    try { st.branch = execSync('git rev-parse --abbrev-ref HEAD', gitOpts).trim() || null; } catch (_) {}
+    // Fallback for an unborn branch (fresh repo, no commits yet).
+    if (!st.branch || st.branch === 'HEAD') {
+      try { st.branch = execSync('git symbolic-ref --short HEAD', gitOpts).trim() || st.branch; } catch (_) {}
+    }
+    try {
+      const porcelain = execSync('git status --porcelain', gitOpts).trim();
+      st.dirty = porcelain ? porcelain.split('\n').filter(Boolean).length : 0;
+    } catch (_) {}
+
+    try {
+      const { readLog } = requireSourceOrBundled('./src/tracking/logger');
+      const log = readLog(cwd);
+      if (log.length) {
+        const last = log[log.length - 1];
+        st.lastIndex = last.ts || null;
+        st.indexVersion = last.version || null;
+        st.indexFiles = last.fileCount != null ? last.fileCount : null;
+      }
+    } catch (_) {}
+
+    // Index freshness: count tracked files modified after the last index run.
+    if (st.lastIndex) {
+      try {
+        const since = Date.parse(st.lastIndex);
+        const tracked = execSync('git ls-files', gitOpts).split('\n').filter(Boolean);
+        let changed = 0;
+        for (const f of tracked.slice(0, 5000)) {
+          try { if (fs.statSync(path.join(cwd, f)).mtimeMs > since) changed++; } catch (_) {}
+        }
+        st.changedSinceIndex = changed;
+      } catch (_) {}
+    }
+
+    try {
+      const { readNotes } = requireSourceOrBundled('./src/session/notes');
+      const notes = readNotes(cwd);
+      st.notes = notes.length;
+      if (notes.length) st.lastNote = notes[notes.length - 1];
+    } catch (_) {}
+
+    if (jsonOut) {
+      process.stdout.write(JSON.stringify(st) + '\n');
+      process.exit(0);
+    }
+
+    const fmtAgo = (iso) => {
+      if (!iso) return 'never';
+      const ms = Date.now() - Date.parse(iso);
+      if (!Number.isFinite(ms)) return iso;
+      const m = Math.floor(ms / 60000), h = Math.floor(m / 60), d = Math.floor(h / 24);
+      if (d > 0) return `${d}d ago`;
+      if (h > 0) return `${h}h ago`;
+      if (m > 0) return `${m}m ago`;
+      return 'just now';
+    };
+
+    console.log('[sigmap] status');
+    console.log(`  Branch:        ${st.branch || '(not a git repo)'}`);
+    console.log(`  Working tree:  ${st.dirty === 0 ? 'clean' : `${st.dirty} file${st.dirty === 1 ? '' : 's'} changed`}`);
+    if (st.lastIndex) {
+      let fresh = `${fmtAgo(st.lastIndex)} (v${st.indexVersion || '?'}, ${st.indexFiles != null ? st.indexFiles + ' files' : 'n/a'})`;
+      if (st.changedSinceIndex != null && st.changedSinceIndex > 0) fresh += ` — STALE: ${st.changedSinceIndex} file${st.changedSinceIndex === 1 ? '' : 's'} changed since`;
+      console.log(`  Last index:    ${fresh}`);
+    } else {
+      console.log('  Last index:    never — run: sigmap');
+    }
+    if (st.notes > 0) {
+      console.log(`  Notes:         ${st.notes} (latest: ${st.lastNote.text.slice(0, 60)}${st.lastNote.text.length > 60 ? '…' : ''})`);
+    } else {
+      console.log('  Notes:         none — add with: sigmap note "<text>"');
+    }
+    process.exit(0);
+  }
+
+  // v7.0.0: `sigmap squeeze <file|->` — minimize a pasted stacktrace / CI-log / JSON blob
+  if (args[0] === 'squeeze') {
+    const jsonOut = args.includes('--json');
+    const target = args[1] && !args[1].startsWith('--') ? args[1] : '-';
+    let input = '';
+    try {
+      input = fs.readFileSync(target === '-' ? 0 : path.resolve(cwd, target), 'utf8');
+    } catch (e) {
+      console.error(`[sigmap] cannot read input: ${e.message}`);
+      process.exit(1);
+    }
+
+    const { squeeze: runSqueeze, formatSummary } = requireSourceOrBundled('./src/squeeze/index');
+    let symbolIndex = null;
+    try {
+      const { buildSigIndex } = requireSourceOrBundled('./src/retrieval/ranker');
+      symbolIndex = buildSigIndex(cwd);
+    } catch (_) {}
+    const sq = runSqueeze(input, { srcDirs: config.srcDirs, symbolIndex });
+
+    try {
+      const { checkStarNudge } = requireSourceOrBundled('./src/nudge');
+      checkStarNudge(cwd, true, { silent: !process.stderr.isTTY || jsonOut, bump: { squeezeOffered: sq.applies ? 1 : 0 } });
+    } catch (_) {}
+
+    if (jsonOut) {
+      process.stdout.write(JSON.stringify({
+        category: sq.category, confidence: sq.confidence,
+        rawTokens: sq.rawTokens, squeezedTokens: sq.squeezedTokens,
+        reduction: sq.reduction, enriched: sq.enriched, squeezed: sq.squeezed,
+      }) + '\n');
+      process.exit(0);
+    }
+    if (!sq.category) {
+      process.stderr.write('[sigmap] no squeezable structure detected — input unchanged\n');
+      process.stdout.write(input);
+      process.exit(0);
+    }
+    process.stderr.write(formatSummary(sq) + '\n\n');
+    process.stdout.write(sq.squeezed + '\n');
+    process.exit(0);
+  }
+
   // `sigmap verify-ai-output <answer.md>` — Hallucination Guard (deterministic core)
   if (args[0] === 'verify-ai-output') {
     const target = args[1];
     const jsonOut = args.includes('--json');
+    const reportIdx = args.indexOf('--report');
+    const reportOut = reportIdx !== -1
+      ? (args[reportIdx + 1] && !args[reportIdx + 1].startsWith('--') ? args[reportIdx + 1] : 'sigmap-verify-report.html')
+      : null;
     if (!target || target.startsWith('--')) {
-      console.error('[sigmap] Usage: sigmap verify-ai-output <answer.md> [--json]');
+      console.error('[sigmap] Usage: sigmap verify-ai-output <answer.md> [--json] [--report [out.html]]');
       process.exit(1);
     }
     const absTarget = path.resolve(cwd, target);
@@ -11877,24 +14097,39 @@ function main() {
     const answerText = fs.readFileSync(absTarget, 'utf8');
     const { verify } = requireSourceOrBundled('./src/verify/hallucination-guard');
     const { issues, summary } = verify(answerText, cwd);
+    const rel = path.relative(cwd, absTarget) || target;
+    const result = { file: rel, issues, summary };
+
+    // Optional HTML report (Surface A) — written alongside any other output.
+    if (reportOut) {
+      const { renderReportHtml } = requireSourceOrBundled('./src/format/verify-report');
+      const outAbs = path.resolve(cwd, reportOut);
+      fs.writeFileSync(outAbs, renderReportHtml(result));
+      if (!jsonOut) console.log(`[sigmap] report written: ${path.relative(cwd, outAbs) || reportOut}`);
+    }
 
     if (jsonOut) {
-      process.stdout.write(JSON.stringify({ file: path.relative(cwd, absTarget) || target, issues, summary }) + '\n');
+      process.stdout.write(JSON.stringify(result) + '\n');
       process.exit(summary.total > 0 ? 1 : 0);
     }
 
-    const rel = path.relative(cwd, absTarget) || target;
     if (summary.total === 0) {
       console.log(`[sigmap] ✓ ${rel} — no hallucinations detected (${summary.symbolsIndexed} symbols indexed)`);
       process.exit(0);
     }
 
-    const labels = { 'fake-file': 'Fake file', 'fake-import': 'Fake import', 'fake-symbol': 'Fake symbol' };
+    const labels = {
+      'fake-file': 'Fake file', 'fake-test-file': 'Fake test file',
+      'fake-import': 'Fake import', 'fake-symbol': 'Fake symbol',
+      'fake-npm-script': 'Fake npm script',
+    };
+    const bt = summary.byType;
     console.log(`[sigmap] ✗ ${rel} — ${summary.total} issue${summary.total === 1 ? '' : 's'} found`);
-    console.log(`  fake-file: ${summary.byType['fake-file']}  fake-import: ${summary.byType['fake-import']}  fake-symbol: ${summary.byType['fake-symbol']}`);
+    console.log(`  fake-file: ${bt['fake-file']}  fake-test-file: ${bt['fake-test-file']}  fake-import: ${bt['fake-import']}  fake-symbol: ${bt['fake-symbol']}  fake-npm-script: ${bt['fake-npm-script']}`);
     console.log('');
     for (const issue of issues) {
       console.log(`  L${issue.line}  [${labels[issue.type] || issue.type}]  ${issue.message}`);
+      if (issue.suggestion) console.log(`         ↳ ${issue.suggestion}`);
     }
     process.exit(1);
   }