sigmap 1.5.0

package/gen-context.js

@@ -0,0 +1,4316 @@
+#!/usr/bin/env node
+'use strict';
+// SigMap — standalone bundle (generated by scripts/bundle.js)
+// Copy this single file to any project: node gen-context.js --setup
+// No src/ directory required. Node.js 18+ only. Zero npm dependencies.
+
+const __factories = {};
+const __cache = {};
+function __require(key) {
+  if (Object.prototype.hasOwnProperty.call(__cache, key)) {
+    return __cache[key].exports;
+  }
+  if (!Object.prototype.hasOwnProperty.call(__factories, key)) {
+    throw new Error('[sigmap] bundled module not found: ' + key);
+  }
+  const module = { exports: {} };
+  __cache[key] = module;
+  __factories[key](module, module.exports);
+  return module.exports;
+}
+
+
+// ── ./src/config/defaults ──
+__factories["./src/config/defaults"] = function(module, exports) {
+  
+  /**
+   * Default configuration values for SigMap.
+   * All keys documented here. Override via gen-context.config.json.
+   */
+  const DEFAULTS = {
+    // Primary output file (used when outputs includes 'copilot')
+    output: '.github/copilot-instructions.md',
+  
+    // Output targets: 'copilot' | 'claude' | 'cursor' | 'windsurf'
+    outputs: ['copilot'],
+  
+    // Directories to scan (relative to project root)
+    srcDirs: ['src', 'app', 'lib', 'packages', 'services', 'api'],
+  
+    // Directory/file names to exclude entirely
+    exclude: [
+      'node_modules', '.git', 'dist', 'build', 'out',
+      '__pycache__', '.next', 'coverage', 'target', 'vendor',
+      '.context',
+    ],
+  
+    // Maximum directory depth to recurse
+    maxDepth: 6,
+  
+    // Maximum signatures extracted per file
+    maxSigsPerFile: 25,
+  
+    // Maximum tokens in final output before budget enforcement kicks in
+    maxTokens: 6000,
+  
+    // Scan signatures for secrets and redact matches
+    secretScan: true,
+  
+    // Auto-detect monorepo packages and write per-package output files
+    monorepo: false,
+  
+    // Sort recently git-committed files higher in output
+    diffPriority: true,
+  
+    // Debounce delay (ms) between file-system events and regeneration in watch mode
+    watchDebounce: 300,
+  
+    // Append model routing hints section to the context output
+    // Routes files to fast/balanced/powerful model tiers based on complexity
+    routing: false,
+  
+    // Output format: 'default' (markdown only) | 'cache' (also write Anthropic prompt-cache JSON)
+    format: 'default',
+  
+    // Append run metrics to .context/usage.ndjson after each generate
+    tracking: false,
+  
+    // MCP server configuration
+    mcp: {
+      autoRegister: true,
+    },
+
+    // Context strategy controls how the output is split and injected.
+    //
+    // 'full'        — single file, all signatures (default, works everywhere)
+    //
+    // 'per-module'  — one output file per top-level srcDir, e.g.
+    //                 .github/context-server.md, .github/context-web.md
+    //                 Best when IDEs can choose which file to inject per workspace.
+    //                 Zero context lost — all files are still covered.
+    //                 ~70% token reduction per question.
+    //
+    // 'hot-cold'    — two files:
+    //                 hot: .github/copilot-instructions.md  (recently changed files only)
+    //                 cold: .github/context-cold.md         (all other files, MCP on-demand)
+    //                 Best when MCP is available (Claude Code, Cursor).
+    //                 ~90% token reduction but cold-file context requires MCP to retrieve.
+    strategy: 'full',
+
+    // For 'hot-cold' strategy: how many recent git commits count as "hot"
+    hotCommits: 10,
+  };
+  
+  module.exports = { DEFAULTS };
+  
+};
+
+// ── ./src/config/loader ──
+__factories["./src/config/loader"] = function(module, exports) {
+  
+  const fs = require('fs');
+  const path = require('path');
+  const { DEFAULTS } = __require('./src/config/defaults');
+  
+  // Keys that are valid in gen-context.config.json
+  const KNOWN_KEYS = new Set(Object.keys(DEFAULTS));
+  
+  /**
+   * Load and merge configuration for a given working directory.
+   *
+   * @param {string} cwd - Project root directory
+   * @returns {object} Merged config (DEFAULTS + user overrides)
+   */
+  function loadConfig(cwd) {
+    const configPath = path.join(cwd, 'gen-context.config.json');
+    if (!fs.existsSync(configPath)) {
+      return deepClone(DEFAULTS);
+    }
+  
+    let userConfig;
+    try {
+      const raw = fs.readFileSync(configPath, 'utf8');
+      userConfig = JSON.parse(raw);
+    } catch (err) {
+      console.warn(`[sigmap] config parse error in ${configPath}: ${err.message}`);
+      return deepClone(DEFAULTS);
+    }
+  
+    // Warn on unknown keys (helps catch typos)
+    for (const key of Object.keys(userConfig)) {
+      if (key.startsWith('_')) continue; // allow _comment etc.
+      if (!KNOWN_KEYS.has(key)) {
+        console.warn(`[sigmap] unknown config key: "${key}" (ignored)`);
+      }
+    }
+  
+    // Deep merge: top-level known keys from user override defaults
+    // For object values (e.g. mcp), merge one level deep
+    const merged = deepClone(DEFAULTS);
+    for (const key of Object.keys(userConfig)) {
+      if (key.startsWith('_')) continue;
+      if (!KNOWN_KEYS.has(key)) continue; // skip unknown keys
+      const val = userConfig[key];
+      if (val !== null && typeof val === 'object' && !Array.isArray(val) &&
+          typeof merged[key] === 'object' && !Array.isArray(merged[key])) {
+        merged[key] = Object.assign({}, merged[key], val);
+      } else {
+        merged[key] = val;
+      }
+    }
+    return merged;
+  }
+  
+  function deepClone(obj) {
+    return JSON.parse(JSON.stringify(obj));
+  }
+  
+  module.exports = { loadConfig };
+  
+};
+
+// ── ./src/extractors/cpp ──
+__factories["./src/extractors/cpp"] = function(module, exports) {
+  
+  /**
+   * Extract signatures from C/C++ source code.
+   * @param {string} src - Raw file content
+   * @returns {string[]} Array of signature strings
+   */
+  function extract(src) {
+    if (!src || typeof src !== 'string') return [];
+    const sigs = [];
+  
+    const stripped = src
+      .replace(/\/\/.*$/gm, '')
+      .replace(/\/\*[\s\S]*?\*\//g, '');
+  
+    // Classes and structs
+    const classRe = /^(?:class|struct)\s+(\w+)(?:\s*:\s*(?:public|protected|private)\s+[\w:]+)?\s*\{/gm;
+    for (const m of stripped.matchAll(classRe)) {
+      const kind = m[0].trimStart().startsWith('class') ? 'class' : 'struct';
+      sigs.push(`${kind} ${m[1]}`);
+      const block = extractBlock(stripped, m.index + m[0].length);
+      for (const meth of extractMembers(block)) sigs.push(`  ${meth}`);
+    }
+  
+    // Top-level function declarations/definitions (not inside a class)
+    for (const m of stripped.matchAll(/^(?!class|struct|if|for|while|switch)[\w:*&<> ]+\s+(\w+)\s*\(([^)]*)\)\s*(?:const\s*)?\{/gm)) {
+      if (m[1].startsWith('_')) continue;
+      sigs.push(`${m[1]}(${normalizeParams(m[2])})`);
+    }
+  
+    return sigs.slice(0, 25);
+  }
+  
+  function extractBlock(src, startIndex) {
+    let depth = 1, i = startIndex;
+    const end = Math.min(src.length, startIndex + 4000);
+    while (i < end && depth > 0) {
+      if (src[i] === '{') depth++;
+      else if (src[i] === '}') depth--;
+      i++;
+    }
+    return src.slice(startIndex, i - 1);
+  }
+  
+  function extractMembers(block) {
+    const members = [];
+    const methodRe = /^\s+(?:virtual\s+|static\s+|inline\s+)?(?!private:|protected:|public:)[\w:*&<> ]+\s+(\w+)\s*\(([^)]*)\)\s*(?:const\s*)?(?:override\s*)?(?:=\s*0\s*)?;/gm;
+    for (const m of block.matchAll(methodRe)) {
+      if (m[1].startsWith('_')) continue;
+      members.push(`${m[1]}(${normalizeParams(m[2])})`);
+    }
+    return members.slice(0, 8);
+  }
+  
+  function normalizeParams(params) {
+    if (!params) return '';
+    return params.trim().replace(/\s+/g, ' ');
+  }
+  
+  module.exports = { extract };
+  
+};
+
+// ── ./src/extractors/csharp ──
+__factories["./src/extractors/csharp"] = function(module, exports) {
+  
+  /**
+   * Extract signatures from C# source code.
+   * @param {string} src - Raw file content
+   * @returns {string[]} Array of signature strings
+   */
+  function extract(src) {
+    if (!src || typeof src !== 'string') return [];
+    const sigs = [];
+  
+    const stripped = src
+      .replace(/\/\/.*$/gm, '')
+      .replace(/\/\*[\s\S]*?\*\//g, '');
+  
+    // Classes and interfaces
+    const typeRe = /^\s*(?:public\s+|internal\s+|protected\s+)?(?:abstract\s+|sealed\s+|static\s+)?(class|interface|enum|record|struct)\s+(\w+)(?:<[^{]*>)?(?:\s*:\s*[\w<>, .]+)?\s*\{/gm;
+    for (const m of stripped.matchAll(typeRe)) {
+      sigs.push(`${m[1]} ${m[2]}`);
+      const block = extractBlock(stripped, m.index + m[0].length);
+      for (const meth of extractMembers(block)) sigs.push(`  ${meth}`);
+    }
+  
+    return sigs.slice(0, 25);
+  }
+  
+  function extractBlock(src, startIndex) {
+    let depth = 1, i = startIndex;
+    const end = Math.min(src.length, startIndex + 5000);
+    while (i < end && depth > 0) {
+      if (src[i] === '{') depth++;
+      else if (src[i] === '}') depth--;
+      i++;
+    }
+    return src.slice(startIndex, i - 1);
+  }
+  
+  function extractMembers(block) {
+    const members = [];
+    const methodRe = /^\s+(?:public|internal|protected)\s+(?:static\s+|virtual\s+|override\s+|async\s+)*(?:[\w<>\[\]?]+\s+)+(\w+)\s*\(([^)]*)\)/gm;
+    for (const m of block.matchAll(methodRe)) {
+      const sig = m[0].trim().split('{')[0].trim();
+      members.push(sig);
+    }
+    return members.slice(0, 8);
+  }
+  
+  module.exports = { extract };
+  
+};
+
+// ── ./src/extractors/css ──
+__factories["./src/extractors/css"] = function(module, exports) {
+  
+  /**
+   * Extract signatures from CSS/SCSS/SASS/Less source code.
+   * @param {string} src - Raw file content
+   * @returns {string[]} Array of signature strings
+   */
+  function extract(src) {
+    if (!src || typeof src !== 'string') return [];
+    const sigs = [];
+  
+    const stripped = src
+      .replace(/\/\/.*$/gm, '')
+      .replace(/\/\*[\s\S]*?\*\//g, '');
+  
+    // CSS custom properties (variables)
+    const rootMatch = stripped.match(/:root\s*\{([^}]*)\}/);
+    if (rootMatch) {
+      for (const m of rootMatch[1].matchAll(/(--[\w-]+)\s*:/g)) {
+        sigs.push(`var ${m[1]}`);
+      }
+    }
+  
+    // SCSS/Less variables
+    for (const m of stripped.matchAll(/^(\$[\w-]+)\s*:/gm)) {
+      sigs.push(`$var ${m[1]}`);
+    }
+  
+    // SCSS mixins
+    for (const m of stripped.matchAll(/^@mixin\s+([\w-]+)(?:\s*\(([^)]*)\))?/gm)) {
+      const params = m[2] ? `(${m[2].trim()})` : '';
+      sigs.push(`@mixin ${m[1]}${params}`);
+    }
+  
+    // SCSS functions
+    for (const m of stripped.matchAll(/^@function\s+([\w-]+)\s*\(([^)]*)\)/gm)) {
+      sigs.push(`@function ${m[1]}(${m[2].trim()})`);
+    }
+  
+    // Key class names (top-level)
+    const classNames = new Set();
+    for (const m of stripped.matchAll(/^\.([\w-]+)(?=[^{]*\{)/gm)) {
+      classNames.add(m[1]);
+      if (classNames.size >= 10) break;
+    }
+    for (const name of classNames) sigs.push(`.${name}`);
+  
+    return sigs.slice(0, 25);
+  }
+  
+  module.exports = { extract };
+  
+};
+
+// ── ./src/extractors/dart ──
+__factories["./src/extractors/dart"] = function(module, exports) {
+  
+  /**
+   * Extract signatures from Dart source code.
+   * @param {string} src - Raw file content
+   * @returns {string[]} Array of signature strings
+   */
+  function extract(src) {
+    if (!src || typeof src !== 'string') return [];
+    const sigs = [];
+  
+    const stripped = src
+      .replace(/\/\/.*$/gm, '')
+      .replace(/\/\*[\s\S]*?\*\//g, '');
+  
+    // Classes and abstract classes
+    for (const m of stripped.matchAll(/^(?:abstract\s+)?class\s+(\w+)(?:<[^{]*>)?(?:\s+extends\s+[\w<>, ]+)?(?:\s+(?:implements|with|on)\s+[\w<>, ]+)?\s*\{/gm)) {
+      const abs = m[0].trimStart().startsWith('abstract') ? 'abstract ' : '';
+      sigs.push(`${abs}class ${m[1]}`);
+      const block = extractBlock(stripped, m.index + m[0].length);
+      for (const meth of extractMembers(block)) sigs.push(`  ${meth}`);
+    }
+  
+    // Top-level functions
+    for (const m of stripped.matchAll(/^(?:Future|void|[\w<>?]+)\s+(\w+)\s*\(([^)]*)\)/gm)) {
+      if (m[1].startsWith('_')) continue;
+      sigs.push(`${m[1]}(${normalizeParams(m[2])})`);
+    }
+  
+    return sigs.slice(0, 25);
+  }
+  
+  function extractBlock(src, startIndex) {
+    let depth = 1, i = startIndex;
+    const end = Math.min(src.length, startIndex + 4000);
+    while (i < end && depth > 0) {
+      if (src[i] === '{') depth++;
+      else if (src[i] === '}') depth--;
+      i++;
+    }
+    return src.slice(startIndex, i - 1);
+  }
+  
+  function extractMembers(block) {
+    const members = [];
+    for (const m of block.matchAll(/^\s+(?:@override\s+)?(?:Future|void|[\w<>?]+)\s+(\w+)\s*\(([^)]*)\)/gm)) {
+      if (m[1].startsWith('_')) continue;
+      members.push(`${m[1]}(${normalizeParams(m[2])})`);
+    }
+    return members.slice(0, 8);
+  }
+  
+  function normalizeParams(params) {
+    if (!params) return '';
+    return params.trim().replace(/\{[^}]*\}/g, '').replace(/\s+/g, ' ').trim();
+  }
+  
+  module.exports = { extract };
+  
+};
+
+// ── ./src/extractors/dockerfile ──
+__factories["./src/extractors/dockerfile"] = function(module, exports) {
+  
+  /**
+   * Extract signatures from Dockerfiles.
+   * @param {string} src - Raw file content
+   * @returns {string[]} Array of signature strings
+   */
+  function extract(src) {
+    if (!src || typeof src !== 'string') return [];
+    const sigs = [];
+  
+    const lines = src.split('\n').filter((l) => l.trim() && !l.trimStart().startsWith('#'));
+  
+    // FROM stages
+    for (const line of lines) {
+      const m = line.match(/^FROM\s+([^\s]+)(?:\s+AS\s+(\w+))?/i);
+      if (m) sigs.push(`FROM ${m[1]}${m[2] ? ` AS ${m[2]}` : ''}`);
+    }
+  
+    // EXPOSE ports
+    const exposePorts = [];
+    for (const line of lines) {
+      const m = line.match(/^EXPOSE\s+([\d\s/]+)/i);
+      if (m) exposePorts.push(...m[1].trim().split(/\s+/));
+    }
+    if (exposePorts.length > 0) sigs.push(`EXPOSE ${exposePorts.join(' ')}`);
+  
+    // ENTRYPOINT and CMD
+    for (const line of lines) {
+      if (/^ENTRYPOINT\s+/i.test(line)) sigs.push(line.trim());
+      if (/^CMD\s+/i.test(line)) sigs.push(line.trim());
+    }
+  
+    // ENV variables
+    for (const line of lines) {
+      const m = line.match(/^ENV\s+([\w]+)/i);
+      if (m) sigs.push(`ENV ${m[1]}`);
+    }
+  
+    // ARG variables
+    for (const line of lines) {
+      const m = line.match(/^ARG\s+([\w]+)/i);
+      if (m) sigs.push(`ARG ${m[1]}`);
+    }
+  
+    return sigs.slice(0, 25);
+  }
+  
+  module.exports = { extract };
+  
+};
+
+// ── ./src/extractors/go ──
+__factories["./src/extractors/go"] = function(module, exports) {
+  
+  /**
+   * Extract signatures from Go source code.
+   * @param {string} src - Raw file content
+   * @returns {string[]} Array of signature strings
+   */
+  function extract(src) {
+    if (!src || typeof src !== 'string') return [];
+    const sigs = [];
+  
+    const stripped = src
+      .replace(/\/\/.*$/gm, '')
+      .replace(/\/\*[\s\S]*?\*\//g, '');
+  
+    // Structs
+    for (const m of stripped.matchAll(/^type\s+(\w+)\s+struct\s*\{/gm)) {
+      sigs.push(`type ${m[1]} struct`);
+    }
+  
+    // Interfaces
+    for (const m of stripped.matchAll(/^type\s+(\w+)\s+interface\s*\{/gm)) {
+      sigs.push(`type ${m[1]} interface`);
+      const block = extractBlock(stripped, m.index + m[0].length);
+      for (const method of extractInterfaceMethods(block)) sigs.push(`  ${method}`);
+    }
+  
+    // Functions and methods
+    for (const m of stripped.matchAll(/^func\s+(?:\((\w+)\s+[\w*]+\)\s+)?(\w+)\s*\(([^)]*)\)(?:\s*[\w*()\[\],\s]+)?\s*\{/gm)) {
+      const receiver = m[1] ? `(${m[1]}) ` : '';
+      sigs.push(`func ${receiver}${m[2]}(${normalizeParams(m[3])})`);
+    }
+  
+    return sigs.slice(0, 25);
+  }
+  
+  function extractBlock(src, startIndex) {
+    let depth = 1, i = startIndex;
+    const end = Math.min(src.length, startIndex + 2000);
+    while (i < end && depth > 0) {
+      if (src[i] === '{') depth++;
+      else if (src[i] === '}') depth--;
+      i++;
+    }
+    return src.slice(startIndex, i - 1);
+  }
+  
+  function extractInterfaceMethods(block) {
+    const methods = [];
+    for (const m of block.matchAll(/^\s+(\w+)\s*\(([^)]*)\)/gm)) {
+      methods.push(`${m[1]}(${normalizeParams(m[2])})`);
+    }
+    return methods.slice(0, 8);
+  }
+  
+  function normalizeParams(params) {
+    if (!params) return '';
+    return params.trim().replace(/\s+/g, ' ');
+  }
+  
+  module.exports = { extract };
+  
+};
+
+// ── ./src/extractors/html ──
+__factories["./src/extractors/html"] = function(module, exports) {
+  
+  /**
+   * Extract signatures from HTML files.
+   * Focuses on id/class attributes, forms, and script tags.
+   * @param {string} src - Raw file content
+   * @returns {string[]} Array of signature strings
+   */
+  function extract(src) {
+    if (!src || typeof src !== 'string') return [];
+    const sigs = [];
+  
+    // Page title
+    const titleMatch = src.match(/<title[^>]*>([\s\S]*?)<\/title>/i);
+    if (titleMatch) sigs.push(`title: ${titleMatch[1].trim()}`);
+  
+    // Forms with id/action
+    for (const m of src.matchAll(/<form\s+([^>]*)>/gi)) {
+      const attrs = m[1];
+      const id = attrs.match(/id=["']?(\w+)/i);
+      const action = attrs.match(/action=["']?([^"'\s>]+)/i);
+      if (id) sigs.push(`form#${id[1]}${action ? ` action="${action[1]}"` : ''}`);
+    }
+  
+    // Elements with id
+    for (const m of src.matchAll(/<(\w+)\s+[^>]*id=["'](\w+)["'][^>]*>/gi)) {
+      if (['html', 'head', 'body', 'script', 'style', 'link', 'meta'].includes(m[1].toLowerCase())) continue;
+      sigs.push(`${m[1]}#${m[2]}`);
+    }
+  
+    // Data attributes (data-component, data-controller etc)
+    for (const m of src.matchAll(/data-(?:component|controller|view|page)=["'](\w[\w-]*)/gi)) {
+      sigs.push(`data-${m[0].match(/data-(\w[\w-]*)/i)[1]}: ${m[1]}`);
+    }
+  
+    return sigs.slice(0, 25);
+  }
+  
+  module.exports = { extract };
+  
+};
+
+// ── ./src/extractors/java ──
+__factories["./src/extractors/java"] = function(module, exports) {
+  
+  /**
+   * Extract signatures from Java source code.
+   * @param {string} src - Raw file content
+   * @returns {string[]} Array of signature strings
+   */
+  function extract(src) {
+    if (!src || typeof src !== 'string') return [];
+    const sigs = [];
+  
+    const stripped = src
+      .replace(/\/\/.*$/gm, '')
+      .replace(/\/\*[\s\S]*?\*\//g, '');
+  
+    // Classes and interfaces
+    const typeRegex = /^(?:public\s+|protected\s+)?(?:abstract\s+|final\s+)?(class|interface|enum)\s+(\w+)(?:\s+extends\s+[\w<>, .]+)?(?:\s+implements\s+[\w<>, .]+)?\s*\{/gm;
+    for (const m of stripped.matchAll(typeRegex)) {
+      sigs.push(`${m[1]} ${m[2]}`);
+      const block = extractBlock(stripped, m.index + m[0].length);
+      for (const meth of extractMembers(block)) sigs.push(`  ${meth}`);
+    }
+  
+    return sigs.slice(0, 25);
+  }
+  
+  function extractBlock(src, startIndex) {
+    let depth = 1;
+    let i = startIndex;
+    const end = Math.min(src.length, startIndex + 5000);
+    while (i < end && depth > 0) {
+      if (src[i] === '{') depth++;
+      else if (src[i] === '}') depth--;
+      i++;
+    }
+    return src.slice(startIndex, i - 1);
+  }
+  
+  function extractMembers(block) {
+    const members = [];
+    const methodRe = /^\s+(?:public|protected)\s+(?:static\s+)?(?:final\s+)?(?:[\w<>\[\]]+\s+)+(\w+)\s*\(([^)]*)\)/gm;
+    for (const m of block.matchAll(methodRe)) {
+      const sig = m[0].trim().split('{')[0].trim();
+      members.push(sig);
+    }
+    return members.slice(0, 8);
+  }
+  
+  module.exports = { extract };
+  
+};
+
+// ── ./src/extractors/javascript ──
+__factories["./src/extractors/javascript"] = function(module, exports) {
+  
+  /**
+   * Extract signatures from JavaScript source code.
+   * @param {string} src - Raw file content
+   * @returns {string[]} Array of signature strings
+   */
+  function extract(src) {
+    if (!src || typeof src !== 'string') return [];
+    const sigs = [];
+  
+    const stripped = src
+      .replace(/\/\/.*$/gm, '')
+      .replace(/\/\*[\s\S]*?\*\//g, '');
+  
+    // Classes
+    const classRegex = /^(export\s+(?:default\s+)?)?class\s+(\w+)(?:\s+extends\s+[\w.]+)?\s*\{/gm;
+    for (const m of stripped.matchAll(classRegex)) {
+      const prefix = m[1] ? m[1].trim() + ' ' : '';
+      sigs.push(`${prefix}class ${m[2]}`);
+      const block = extractBlock(stripped, m.index + m[0].length);
+      for (const meth of extractClassMembers(block)) sigs.push(`  ${meth}`);
+    }
+  
+    // Exported named functions
+    for (const m of stripped.matchAll(/^export\s+(?:async\s+)?function\s+(\w+)\s*\(([^)]*)\)/gm)) {
+      const asyncKw = /export\s+async/.test(m[0]) ? 'async ' : '';
+      sigs.push(`export ${asyncKw}function ${m[1]}(${normalizeParams(m[2])})`);
+    }
+  
+    // Exported arrow functions
+    for (const m of stripped.matchAll(/^export\s+const\s+(\w+)\s*=\s*(?:async\s+)?\(([^)]*)\)\s*=>/gm)) {
+      const asyncKw = m[0].includes('async') ? 'async ' : '';
+      sigs.push(`export const ${m[1]} = ${asyncKw}(${normalizeParams(m[2])}) =>`);
+    }
+  
+    // module.exports = { ... }
+    const moduleExports = stripped.match(/^module\.exports\s*=\s*\{([^}]+)\}/m);
+    if (moduleExports) {
+      const names = moduleExports[1].split(',').map((s) => s.trim()).filter(Boolean);
+      if (names.length > 0) sigs.push(`module.exports = { ${names.join(', ')} }`);
+    }
+  
+    // Top-level named functions (non-exported)
+    for (const m of stripped.matchAll(/^(?:async\s+)?function\s+(\w+)\s*\(([^)]*)\)/gm)) {
+      const asyncKw = m[0].startsWith('async') ? 'async ' : '';
+      sigs.push(`${asyncKw}function ${m[1]}(${normalizeParams(m[2])})`);
+    }
+  
+    return sigs.slice(0, 25);
+  }
+  
+  function extractBlock(src, startIndex) {
+    let depth = 1;
+    let i = startIndex;
+    const end = Math.min(src.length, startIndex + 4000);
+    while (i < end && depth > 0) {
+      if (src[i] === '{') depth++;
+      else if (src[i] === '}') depth--;
+      i++;
+    }
+    return src.slice(startIndex, i - 1);
+  }
+  
+  function extractClassMembers(block) {
+    const members = [];
+    for (const m of block.matchAll(/^\s+(?:static\s+|async\s+|get\s+|set\s+)*(\w+)\s*\(([^)]*)\)\s*\{/gm)) {
+      if (/^_/.test(m[1])) continue;
+      if (m[1] === 'constructor') { members.push(`constructor(${normalizeParams(m[2])})`); continue; }
+      const isAsync = m[0].includes('async ') ? 'async ' : '';
+      const isStatic = m[0].includes('static ') ? 'static ' : '';
+      members.push(`${isStatic}${isAsync}${m[1]}(${normalizeParams(m[2])})`);
+    }
+    return members.slice(0, 8);
+  }
+  
+  function normalizeParams(params) {
+    if (!params) return '';
+    return params.trim().replace(/\s+/g, ' ');
+  }
+  
+  module.exports = { extract };
+  
+};
+
+// ── ./src/extractors/kotlin ──
+__factories["./src/extractors/kotlin"] = function(module, exports) {
+  
+  /**
+   * Extract signatures from Kotlin source code.
+   * @param {string} src - Raw file content
+   * @returns {string[]} Array of signature strings
+   */
+  function extract(src) {
+    if (!src || typeof src !== 'string') return [];
+    const sigs = [];
+  
+    const stripped = src
+      .replace(/\/\/.*$/gm, '')
+      .replace(/\/\*[\s\S]*?\*\//g, '');
+  
+    // Classes, objects, interfaces
+    for (const m of stripped.matchAll(/^(?:public\s+|internal\s+)?(?:data\s+|sealed\s+|abstract\s+|open\s+)?(class|object|interface)\s+(\w+)(?:[^{]*)\{/gm)) {
+      sigs.push(`${m[1]} ${m[2]}`);
+      const block = extractBlock(stripped, m.index + m[0].length);
+      for (const meth of extractMembers(block)) sigs.push(`  ${meth}`);
+    }
+  
+    // Top-level functions
+    for (const m of stripped.matchAll(/^(?:public\s+|internal\s+)?(?:suspend\s+)?fun\s+(\w+)\s*(?:<[^(]*>)?\s*\(([^)]*)\)/gm)) {
+      const suspend = m[0].includes('suspend') ? 'suspend ' : '';
+      sigs.push(`${suspend}fun ${m[1]}(${normalizeParams(m[2])})`);
+    }
+  
+    return sigs.slice(0, 25);
+  }
+  
+  function extractBlock(src, startIndex) {
+    let depth = 1, i = startIndex;
+    const end = Math.min(src.length, startIndex + 4000);
+    while (i < end && depth > 0) {
+      if (src[i] === '{') depth++;
+      else if (src[i] === '}') depth--;
+      i++;
+    }
+    return src.slice(startIndex, i - 1);
+  }
+  
+  function extractMembers(block) {
+    const members = [];
+    for (const m of block.matchAll(/^\s+(?:public\s+|internal\s+|override\s+)?(?:suspend\s+)?fun\s+(\w+)\s*(?:<[^(]*>)?\s*\(([^)]*)\)/gm)) {
+      if (m[1].startsWith('_')) continue;
+      const suspend = m[0].includes('suspend') ? 'suspend ' : '';
+      members.push(`${suspend}fun ${m[1]}(${normalizeParams(m[2])})`);
+    }
+    return members.slice(0, 8);
+  }
+  
+  function normalizeParams(params) {
+    if (!params) return '';
+    return params.trim()
+      .split(',')
+      .map((p) => p.trim().split(':')[0].trim())
+      .filter(Boolean)
+      .join(', ');
+  }
+  
+  module.exports = { extract };
+  
+};
+
+// ── ./src/extractors/php ──
+__factories["./src/extractors/php"] = function(module, exports) {
+  
+  /**
+   * Extract signatures from PHP source code.
+   * @param {string} src - Raw file content
+   * @returns {string[]} Array of signature strings
+   */
+  function extract(src) {
+    if (!src || typeof src !== 'string') return [];
+    const sigs = [];
+  
+    const stripped = src
+      .replace(/\/\/.*$/gm, '')
+      .replace(/#.*$/gm, '')
+      .replace(/\/\*[\s\S]*?\*\//g, '');
+  
+    // Classes and interfaces
+    const typeRe = /^(?:abstract\s+)?(?:class|interface|trait)\s+(\w+)(?:\s+extends\s+\w+)?(?:\s+implements\s+[\w, ]+)?\s*\{/gm;
+    for (const m of stripped.matchAll(typeRe)) {
+      const kind = m[0].trimStart().startsWith('interface') ? 'interface' :
+        m[0].trimStart().startsWith('trait') ? 'trait' : 'class';
+      sigs.push(`${kind} ${m[1]}`);
+      const block = extractBlock(stripped, m.index + m[0].length);
+      for (const meth of extractMembers(block)) sigs.push(`  ${meth}`);
+    }
+  
+    // Top-level functions
+    for (const m of stripped.matchAll(/^function\s+(\w+)\s*\(([^)]*)\)/gm)) {
+      sigs.push(`function ${m[1]}(${normalizeParams(m[2])})`);
+    }
+  
+    return sigs.slice(0, 25);
+  }
+  
+  function extractBlock(src, startIndex) {
+    let depth = 1, i = startIndex;
+    const end = Math.min(src.length, startIndex + 4000);
+    while (i < end && depth > 0) {
+      if (src[i] === '{') depth++;
+      else if (src[i] === '}') depth--;
+      i++;
+    }
+    return src.slice(startIndex, i - 1);
+  }
+  
+  function extractMembers(block) {
+    const members = [];
+    const methodRe = /^\s+(?:public|protected)\s+(?:static\s+)?function\s+(\w+)\s*\(([^)]*)\)/gm;
+    for (const m of block.matchAll(methodRe)) {
+      if (m[1].startsWith('_')) continue;
+      const isStatic = m[0].includes('static ') ? 'static ' : '';
+      members.push(`${isStatic}function ${m[1]}(${normalizeParams(m[2])})`);
+    }
+    return members.slice(0, 8);
+  }
+  
+  function normalizeParams(params) {
+    if (!params) return '';
+    return params.trim().replace(/\s+/g, ' ');
+  }
+  
+  module.exports = { extract };
+  
+};
+
+// ── ./src/extractors/python ──
+__factories["./src/extractors/python"] = function(module, exports) {
+  
+  /**
+   * Extract signatures from Python source code.
+   * @param {string} src - Raw file content
+   * @returns {string[]} Array of signature strings
+   */
+  function extract(src) {
+    if (!src || typeof src !== 'string') return [];
+    const sigs = [];
+  
+    // Strip comments and docstrings (simple approach)
+    const stripped = src
+      .replace(/#.*$/gm, '')
+      .replace(/"""[\s\S]*?"""/g, '')
+      .replace(/'''[\s\S]*?'''/g, '');
+  
+    // Classes
+    for (const m of stripped.matchAll(/^class\s+(\w+)(?:\s*\(([^)]*)\))?\s*:/gm)) {
+      const base = m[2] ? `(${m[2].trim()})` : '';
+      sigs.push(`class ${m[1]}${base}`);
+      // Get class body methods
+      const bodyStart = m.index + m[0].length;
+      const methods = extractClassMethods(stripped, bodyStart);
+      for (const meth of methods) sigs.push(`  ${meth}`);
+    }
+  
+    // Top-level functions
+    for (const m of stripped.matchAll(/^(?:async\s+)?def\s+(\w+)\s*\(([^)]*)\)/gm)) {
+      if (/^_/.test(m[1])) continue; // skip private
+      const asyncKw = m[0].trimStart().startsWith('async') ? 'async ' : '';
+      const params = normalizeParams(m[2]);
+      sigs.push(`${asyncKw}def ${m[1]}(${params})`);
+    }
+  
+    return sigs.slice(0, 25);
+  }
+  
+  function extractClassMethods(src, startIndex) {
+    const methods = [];
+    // Extract indented block
+    const lines = src.slice(startIndex).split('\n');
+    for (const line of lines) {
+      if (line.trim() === '') continue;
+      // End of class body: line with no leading indent that is not blank
+      const indent = line.match(/^(\s+)/);
+      if (!indent) break;
+      const m = line.match(/^\s+(?:async\s+)?def\s+(\w+)\s*\(([^)]*)\)/);
+      if (m) {
+        if (m[1].startsWith('__') && m[1] !== '__init__') continue;
+        if (m[1].startsWith('_') && !m[1].startsWith('__')) continue;
+        const asyncKw = line.trimStart().startsWith('async') ? 'async ' : '';
+        const params = normalizeParams(m[2]).replace(/^self,?\s*/, '');
+        methods.push(`${asyncKw}def ${m[1]}(${params})`);
+      }
+    }
+    return methods.slice(0, 8);
+  }
+  
+  function normalizeParams(params) {
+    if (!params) return '';
+    return params.trim()
+      .split(',')
+      .map((p) => p.trim().split(':')[0].split('=')[0].trim())
+      .filter(Boolean)
+      .join(', ');
+  }
+  
+  module.exports = { extract };
+  
+};
+
+// ── ./src/extractors/ruby ──
+__factories["./src/extractors/ruby"] = function(module, exports) {
+  
+  /**
+   * Extract signatures from Ruby source code.
+   * @param {string} src - Raw file content
+   * @returns {string[]} Array of signature strings
+   */
+  function extract(src) {
+    if (!src || typeof src !== 'string') return [];
+    const sigs = [];
+  
+    const stripped = src.replace(/#.*$/gm, '');
+  
+    // Modules and classes
+    for (const m of stripped.matchAll(/^(?:module|class)\s+([\w:]+)(?:\s*<\s*[\w:]+)?\s*$/gm)) {
+      const kind = m[0].trimStart().startsWith('module') ? 'module' : 'class';
+      sigs.push(`${kind} ${m[1]}`);
+    }
+  
+    // Public methods (not private/protected)
+    for (const m of stripped.matchAll(/^\s+def\s+(?:self\.)?(\w+)(?:\s*\(([^)]*)\))?/gm)) {
+      if (m[1].startsWith('_')) continue;
+      const params = m[2] ? `(${normalizeParams(m[2])})` : '';
+      const selfPrefix = m[0].includes('self.') ? 'self.' : '';
+      sigs.push(`  def ${selfPrefix}${m[1]}${params}`);
+    }
+  
+    // Top-level def
+    for (const m of stripped.matchAll(/^def\s+(\w+)(?:\s*\(([^)]*)\))?/gm)) {
+      if (m[1].startsWith('_')) continue;
+      const params = m[2] ? `(${normalizeParams(m[2])})` : '';
+      sigs.push(`def ${m[1]}${params}`);
+    }
+  
+    return sigs.slice(0, 25);
+  }
+  
+  function normalizeParams(params) {
+    if (!params) return '';
+    return params.trim().replace(/\s+/g, ' ');
+  }
+  
+  module.exports = { extract };
+  
+};
+
+// ── ./src/extractors/rust ──
+__factories["./src/extractors/rust"] = function(module, exports) {
+  
+  /**
+   * Extract signatures from Rust source code.
+   * @param {string} src - Raw file content
+   * @returns {string[]} Array of signature strings
+   */
+  function extract(src) {
+    if (!src || typeof src !== 'string') return [];
+    const sigs = [];
+  
+    const stripped = src
+      .replace(/\/\/.*$/gm, '')
+      .replace(/\/\*[\s\S]*?\*\//g, '');
+  
+    // Structs
+    for (const m of stripped.matchAll(/^pub\s+struct\s+(\w+)(?:<[^{]*>)?/gm)) {
+      sigs.push(`pub struct ${m[1]}`);
+    }
+  
+    // Enums
+    for (const m of stripped.matchAll(/^pub\s+enum\s+(\w+)(?:<[^{]*>)?/gm)) {
+      sigs.push(`pub enum ${m[1]}`);
+    }
+  
+    // Traits
+    for (const m of stripped.matchAll(/^pub\s+trait\s+(\w+)(?:<[^{]*>)?/gm)) {
+      sigs.push(`pub trait ${m[1]}`);
+    }
+  
+    // impl blocks
+    for (const m of stripped.matchAll(/^impl(?:<[^>]*>)?\s+(?:[\w:]+\s+for\s+)?(\w+)(?:<[^{]*>)?\s*\{/gm)) {
+      sigs.push(`impl ${m[1]}`);
+      const block = extractBlock(stripped, m.index + m[0].length);
+      for (const fn of extractMethods(block)) sigs.push(`  ${fn}`);
+    }
+  
+    // Top-level pub fns
+    for (const m of stripped.matchAll(/^pub(?:\s+async)?\s+fn\s+(\w+)(?:<[^(]*>)?\s*\(([^)]*)\)/gm)) {
+      const asyncKw = m[0].includes('async') ? 'async ' : '';
+      sigs.push(`pub ${asyncKw}fn ${m[1]}(${normalizeParams(m[2])})`);
+    }
+  
+    return sigs.slice(0, 25);
+  }
+  
+  function extractBlock(src, startIndex) {
+    let depth = 1, i = startIndex;
+    const end = Math.min(src.length, startIndex + 5000);
+    while (i < end && depth > 0) {
+      if (src[i] === '{') depth++;
+      else if (src[i] === '}') depth--;
+      i++;
+    }
+    return src.slice(startIndex, i - 1);
+  }
+  
+  function extractMethods(block) {
+    const methods = [];
+    for (const m of block.matchAll(/^\s+pub(?:\s+async)?\s+fn\s+(\w+)(?:<[^(]*>)?\s*\(([^)]*)\)/gm)) {
+      const asyncKw = m[0].includes('async') ? 'async ' : '';
+      methods.push(`pub ${asyncKw}fn ${m[1]}(${normalizeParams(m[2])})`);
+    }
+    return methods.slice(0, 8);
+  }
+  
+  function normalizeParams(params) {
+    if (!params) return '';
+    return params.trim().replace(/\s+/g, ' ');
+  }
+  
+  module.exports = { extract };
+  
+};
+
+// ── ./src/extractors/scala ──
+__factories["./src/extractors/scala"] = function(module, exports) {
+  
+  /**
+   * Extract signatures from Scala source code.
+   * @param {string} src - Raw file content
+   * @returns {string[]} Array of signature strings
+   */
+  function extract(src) {
+    if (!src || typeof src !== 'string') return [];
+    const sigs = [];
+  
+    const stripped = src
+      .replace(/\/\/.*$/gm, '')
+      .replace(/\/\*[\s\S]*?\*\//g, '');
+  
+    // Classes, traits, objects
+    const typeRe = /^(?:case\s+)?(?:class|trait|object)\s+(\w+)(?:\[[\w, ]+\])?(?:[^{]*)\{/gm;
+    for (const m of stripped.matchAll(typeRe)) {
+      const kind = m[0].trimStart().startsWith('case class') ? 'case class' :
+        m[0].trimStart().startsWith('trait') ? 'trait' :
+        m[0].trimStart().startsWith('object') ? 'object' : 'class';
+      sigs.push(`${kind} ${m[1]}`);
+      const block = extractBlock(stripped, m.index + m[0].length);
+      for (const fn of extractMembers(block)) sigs.push(`  ${fn}`);
+    }
+  
+    // Top-level defs
+    for (const m of stripped.matchAll(/^def\s+(\w+)(?:\[[\w, ]+\])?\s*(?:\(([^)]*)\))?/gm)) {
+      if (m[1].startsWith('_')) continue;
+      const params = m[2] ? `(${normalizeParams(m[2])})` : '';
+      sigs.push(`def ${m[1]}${params}`);
+    }
+  
+    return sigs.slice(0, 25);
+  }
+  
+  function extractBlock(src, startIndex) {
+    let depth = 1, i = startIndex;
+    const end = Math.min(src.length, startIndex + 4000);
+    while (i < end && depth > 0) {
+      if (src[i] === '{') depth++;
+      else if (src[i] === '}') depth--;
+      i++;
+    }
+    return src.slice(startIndex, i - 1);
+  }
+  
+  function extractMembers(block) {
+    const members = [];
+    for (const m of block.matchAll(/^\s+def\s+(\w+)(?:\[[\w, ]+\])?\s*(?:\(([^)]*)\))?/gm)) {
+      if (m[1].startsWith('_')) continue;
+      const params = m[2] ? `(${normalizeParams(m[2])})` : '';
+      members.push(`def ${m[1]}${params}`);
+    }
+    return members.slice(0, 8);
+  }
+  
+  function normalizeParams(params) {
+    if (!params) return '';
+    return params.trim()
+      .split(',')
+      .map((p) => p.trim().split(':')[0].trim())
+      .filter(Boolean)
+      .join(', ');
+  }
+  
+  module.exports = { extract };
+  
+};
+
+// ── ./src/extractors/shell ──
+__factories["./src/extractors/shell"] = function(module, exports) {
+  
+  /**
+   * Extract signatures from shell scripts (bash, zsh, fish).
+   * @param {string} src - Raw file content
+   * @returns {string[]} Array of signature strings
+   */
+  function extract(src) {
+    if (!src || typeof src !== 'string') return [];
+    const sigs = [];
+  
+    const stripped = src.replace(/#.*$/gm, '');
+  
+    // Function definitions (bash: name() { and function name {)
+    for (const m of stripped.matchAll(/^(?:function\s+)?([\w:-]+)\s*\(\s*\)\s*\{/gm)) {
+      if (m[1].startsWith('_')) continue;
+      sigs.push(`function ${m[1]}()`);
+    }
+  
+    // Main entry point patterns
+    if (/^\s*main\s*\(/m.test(src) || /^\s*main\s+"?\$@/m.test(src)) {
+      sigs.push('main "$@"');
+    }
+  
+    // Exported variables
+    for (const m of stripped.matchAll(/^export\s+([\w]+)=/gm)) {
+      sigs.push(`export ${m[1]}`);
+    }
+  
+    // Script description (first non-comment line after shebang)
+    const lines = src.split('\n');
+    for (const line of lines.slice(0, 5)) {
+      if (line.startsWith('#!')) continue;
+      if (line.startsWith('#')) {
+        const desc = line.replace(/^#+\s*/, '').trim();
+        if (desc) { sigs.unshift(`# ${desc}`); break; }
+      }
+    }
+  
+    return sigs.slice(0, 25);
+  }
+  
+  module.exports = { extract };
+  
+};
+
+// ── ./src/extractors/svelte ──
+__factories["./src/extractors/svelte"] = function(module, exports) {
+  
+  /**
+   * Extract signatures from Svelte components.
+   * @param {string} src - Raw file content
+   * @returns {string[]} Array of signature strings
+   */
+  function extract(src) {
+    if (!src || typeof src !== 'string') return [];
+    const sigs = [];
+  
+    // Extract <script> block
+    const scriptMatch = src.match(/<script(?:\s[^>]*)?>(?:\s*)([\s\S]*?)<\/script>/i);
+    if (!scriptMatch) return sigs;
+  
+    const script = scriptMatch[1]
+      .replace(/\/\/.*$/gm, '')
+      .replace(/\/\*[\s\S]*?\*\//g, '');
+  
+    // Exported props (writable)
+    for (const m of script.matchAll(/^\s+export\s+let\s+(\w+)(?:\s*=\s*[^;]+)?;/gm)) {
+      sigs.push(`export let ${m[1]}`);
+    }
+  
+    // Exported functions
+    for (const m of script.matchAll(/^export\s+(?:async\s+)?function\s+(\w+)\s*\(([^)]*)\)/gm)) {
+      const asyncKw = m[0].includes('async') ? 'async ' : '';
+      sigs.push(`export ${asyncKw}function ${m[1]}(${normalizeParams(m[2])})`);
+    }
+  
+    // Top-level functions
+    for (const m of script.matchAll(/^(?:async\s+)?function\s+(\w+)\s*\(([^)]*)\)/gm)) {
+      if (m[1].startsWith('_')) continue;
+      const asyncKw = m[0].startsWith('async') ? 'async ' : '';
+      sigs.push(`${asyncKw}function ${m[1]}(${normalizeParams(m[2])})`);
+    }
+  
+    // Reactive declarations $:
+    for (const m of script.matchAll(/^\s+\$:\s+(\w+)\s*=/gm)) {
+      sigs.push(`$: ${m[1]}`);
+    }
+  
+    return sigs.slice(0, 25);
+  }
+  
+  function normalizeParams(params) {
+    if (!params) return '';
+    return params.trim().replace(/\s+/g, ' ');
+  }
+  
+  module.exports = { extract };
+  
+};
+
+// ── ./src/extractors/swift ──
+__factories["./src/extractors/swift"] = function(module, exports) {
+  
+  /**
+   * Extract signatures from Swift source code.
+   * @param {string} src - Raw file content
+   * @returns {string[]} Array of signature strings
+   */
+  function extract(src) {
+    if (!src || typeof src !== 'string') return [];
+    const sigs = [];
+  
+    const stripped = src
+      .replace(/\/\/.*$/gm, '')
+      .replace(/\/\*[\s\S]*?\*\//g, '');
+  
+    // Classes, structs, protocols, enums
+    const typeRe = /^(?:public\s+|internal\s+|open\s+)?(?:final\s+)?(class|struct|protocol|enum|actor)\s+(\w+)(?:<[^{]*>)?(?:\s*:\s*[\w, <>.]+)?\s*\{/gm;
+    for (const m of stripped.matchAll(typeRe)) {
+      sigs.push(`${m[1]} ${m[2]}`);
+      const block = extractBlock(stripped, m.index + m[0].length);
+      for (const fn of extractMembers(block)) sigs.push(`  ${fn}`);
+    }
+  
+    // Top-level public functions
+    for (const m of stripped.matchAll(/^(?:public\s+|internal\s+)?(?:static\s+)?(?:async\s+)?func\s+(\w+)(?:<[^(]*>)?\s*\(([^)]*)\)/gm)) {
+      const asyncKw = m[0].includes('async') ? 'async ' : '';
+      sigs.push(`${asyncKw}func ${m[1]}(${normalizeParams(m[2])})`);
+    }
+  
+    return sigs.slice(0, 25);
+  }
+  
+  function extractBlock(src, startIndex) {
+    let depth = 1, i = startIndex;
+    const end = Math.min(src.length, startIndex + 4000);
+    while (i < end && depth > 0) {
+      if (src[i] === '{') depth++;
+      else if (src[i] === '}') depth--;
+      i++;
+    }
+    return src.slice(startIndex, i - 1);
+  }
+  
+  function extractMembers(block) {
+    const members = [];
+    for (const m of block.matchAll(/^\s+(?:public\s+|internal\s+|open\s+)?(?:static\s+|class\s+)?(?:mutating\s+)?(?:async\s+)?func\s+(\w+)(?:<[^(]*>)?\s*\(([^)]*)\)/gm)) {
+      if (m[1].startsWith('_')) continue;
+      const asyncKw = m[0].includes('async') ? 'async ' : '';
+      members.push(`${asyncKw}func ${m[1]}(${normalizeParams(m[2])})`);
+    }
+    return members.slice(0, 8);
+  }
+  
+  function normalizeParams(params) {
+    if (!params) return '';
+    return params.trim()
+      .split(',')
+      .map((p) => p.trim().split(':')[0].trim())
+      .filter(Boolean)
+      .join(', ');
+  }
+  
+  module.exports = { extract };
+  
+};
+
+// ── ./src/extractors/typescript ──
+__factories["./src/extractors/typescript"] = function(module, exports) {
+  
+  /**
+   * Extract signatures from TypeScript source code.
+   * @param {string} src - Raw file content
+   * @returns {string[]} Array of signature strings
+   */
+  function extract(src) {
+    if (!src || typeof src !== 'string') return [];
+    const sigs = [];
+  
+    // Strip single-line comments
+    const stripped = src
+      .replace(/\/\/.*$/gm, '')
+      .replace(/\/\*[\s\S]*?\*\//g, '');
+  
+    // Exported interfaces
+    for (const m of stripped.matchAll(/^export\s+interface\s+(\w+)(?:<[^{]*>)?\s*(?:extends\s+[^{]+)?\{/gm)) {
+      sigs.push(`export interface ${m[1]}`);
+      // Collect members
+      const start = m.index + m[0].length;
+      const block = extractBlock(stripped, start);
+      const members = extractInterfaceMembers(block);
+      for (const mem of members) sigs.push(`  ${mem}`);
+    }
+  
+    // Exported type aliases
+    for (const m of stripped.matchAll(/^export\s+type\s+(\w+)(?:<[^=]*>)?\s*=/gm)) {
+      sigs.push(`export type ${m[1]}`);
+    }
+  
+    // Exported enums
+    for (const m of stripped.matchAll(/^export\s+(?:const\s+)?enum\s+(\w+)\s*\{/gm)) {
+      sigs.push(`export enum ${m[1]}`);
+    }
+  
+    // Classes (exported and internal)
+    const classRegex = /^(export\s+)?(abstract\s+)?class\s+(\w+)(?:<[^{]*>)?(?:\s+extends\s+[\w<>, .]+)?(?:\s+implements\s+[\w<> ,]+)?\s*\{/gm;
+    for (const m of stripped.matchAll(classRegex)) {
+      const prefix = m[1] ? 'export ' : '';
+      const abs = m[2] ? 'abstract ' : '';
+      sigs.push(`${prefix}${abs}class ${m[3]}`);
+      const start = m.index + m[0].length;
+      const block = extractBlock(stripped, start);
+      const methods = extractClassMembers(block);
+      for (const meth of methods) sigs.push(`  ${meth}`);
+    }
+  
+    // Exported top-level functions (not methods)
+    for (const m of stripped.matchAll(/^export\s+(?:async\s+)?function\s+(\w+)\s*(?:<[^(]*>)?\s*\(([^)]*)\)(?:\s*:\s*[^{]+)?\s*\{/gm)) {
+      const asyncKw = /export\s+async/.test(m[0]) ? 'async ' : '';
+      const params = normalizeParams(m[2]);
+      sigs.push(`export ${asyncKw}function ${m[1]}(${params})`);
+    }
+  
+    // Exported arrow functions / const functions
+    for (const m of stripped.matchAll(/^export\s+const\s+(\w+)\s*(?::\s*[^=]+)?\s*=\s*(?:async\s+)?\(([^)]*)\)\s*(?::\s*[^=>{]+)?\s*=>/gm)) {
+      const asyncKw = /=\s*async\s+/.test(m[0]) ? 'async ' : '';
+      const params = normalizeParams(m[2]);
+      sigs.push(`export const ${m[1]} = ${asyncKw}(${params}) =>`);
+    }
+  
+    return sigs.slice(0, 25);
+  }
+  
+  function extractBlock(src, startIndex) {
+    let depth = 1;
+    let i = startIndex;
+    const end = Math.min(src.length, startIndex + 4000);
+    while (i < end && depth > 0) {
+      if (src[i] === '{') depth++;
+      else if (src[i] === '}') depth--;
+      i++;
+    }
+    return src.slice(startIndex, i - 1);
+  }
+  
+  function extractInterfaceMembers(block) {
+    const members = [];
+    for (const m of block.matchAll(/^\s+(readonly\s+)?(\w+)\??:\s*[^;]+;/gm)) {
+      const readonly = m[1] ? 'readonly ' : '';
+      members.push(`${readonly}${m[2]}`);
+    }
+    for (const m of block.matchAll(/^\s+(\w+)\s*(?:<[^(]*>)?\s*\(([^)]*)\)\s*:/gm)) {
+      members.push(`${m[1]}(${normalizeParams(m[2])})`);
+    }
+    return members.slice(0, 8);
+  }
+  
+  function extractClassMembers(block) {
+    const members = [];
+    // Public methods (skip private/protected/_ prefixed)
+    const methodRe = /^\s+(?:public\s+|static\s+|async\s+|override\s+)*(\w+)\s*(?:<[^(]*>)?\s*\(([^)]*)\)(?:\s*:\s*[^{;]+)?\s*\{/gm;
+    for (const m of block.matchAll(methodRe)) {
+      if (/^(private|protected|_)/.test(m[1])) continue;
+      if (m[1] === 'constructor') { members.push(`constructor(${normalizeParams(m[2])})`); continue; }
+      const isAsync = m[0].includes('async ') ? 'async ' : '';
+      const isStatic = m[0].includes('static ') ? 'static ' : '';
+      members.push(`${isStatic}${isAsync}${m[1]}(${normalizeParams(m[2])})`);
+    }
+    return members.slice(0, 8);
+  }
+  
+  function normalizeParams(params) {
+    if (!params) return '';
+    return params.trim().replace(/\s+/g, ' ').replace(/:[^,)]+/g, '').trim();
+  }
+  
+  module.exports = { extract };
+  
+};
+
+// ── ./src/extractors/vue ──
+__factories["./src/extractors/vue"] = function(module, exports) {
+  
+  /**
+   * Extract signatures from Vue single-file components.
+   * @param {string} src - Raw file content
+   * @returns {string[]} Array of signature strings
+   */
+  function extract(src) {
+    if (!src || typeof src !== 'string') return [];
+    const sigs = [];
+  
+    // Extract component name from filename hint if present or defineComponent
+    const nameMatch = src.match(/name\s*:\s*['"](\w+)['"]/);
+    if (nameMatch) sigs.push(`component ${nameMatch[1]}`);
+  
+    // Extract <script> block
+    const scriptMatch = src.match(/<script(?:\s[^>]*)?>(?:\s*)([\s\S]*?)<\/script>/i);
+    if (!scriptMatch) return sigs;
+  
+    const script = scriptMatch[1]
+      .replace(/\/\/.*$/gm, '')
+      .replace(/\/\*[\s\S]*?\*\//g, '');
+  
+    // Props
+    const propsMatch = script.match(/props\s*:\s*(\{[\s\S]*?\})/);
+    if (propsMatch) {
+      const propNames = [];
+      for (const m of propsMatch[1].matchAll(/^\s+(\w+)\s*:/gm)) {
+        propNames.push(m[1]);
+      }
+      if (propNames.length > 0) sigs.push(`props: [${propNames.join(', ')}]`);
+    }
+  
+    // Methods in options API
+    const methodsMatch = script.match(/methods\s*:\s*\{([\s\S]*?)\},?\s*(?:computed|watch|mounted|created|data|\})/);
+    if (methodsMatch) {
+      for (const m of methodsMatch[1].matchAll(/^\s+(?:async\s+)?(\w+)\s*\(([^)]*)\)/gm)) {
+        if (m[1].startsWith('_')) continue;
+        const asyncKw = m[0].includes('async') ? 'async ' : '';
+        sigs.push(`  ${asyncKw}${m[1]}(${normalizeParams(m[2])})`);
+      }
+    }
+  
+    // defineProps (Composition API)
+    const definePropsMatch = script.match(/defineProps(?:<[^>]*>)?\s*\(\s*(\{[\s\S]*?\})\s*\)/);
+    if (definePropsMatch) {
+      const propNames = [];
+      for (const m of definePropsMatch[1].matchAll(/^\s+(\w+)\s*:/gm)) {
+        propNames.push(m[1]);
+      }
+      if (propNames.length > 0) sigs.push(`defineProps: [${propNames.join(', ')}]`);
+    }
+  
+    // Emits
+    const emitsMatch = script.match(/(?:defineEmits|emits)\s*(?::\s*|\(\s*)(\[[\s\S]*?\])/);
+    if (emitsMatch) sigs.push(`emits: ${emitsMatch[1].replace(/\s+/g, ' ')}`);
+  
+    return sigs.slice(0, 25);
+  }
+  
+  function normalizeParams(params) {
+    if (!params) return '';
+    return params.trim().replace(/\s+/g, ' ');
+  }
+  
+  module.exports = { extract };
+  
+};
+
+// ── ./src/extractors/yaml ──
+__factories["./src/extractors/yaml"] = function(module, exports) {
+  
+  /**
+   * Extract signatures from YAML configuration files.
+   * @param {string} src - Raw file content
+   * @returns {string[]} Array of signature strings
+   */
+  function extract(src) {
+    if (!src || typeof src !== 'string') return [];
+    const sigs = [];
+  
+    const lines = src.split('\n');
+  
+    // Top-level keys (no leading whitespace)
+    const topKeys = [];
+    for (const line of lines) {
+      if (/^#/.test(line)) continue;
+      const m = line.match(/^([\w-]+)\s*:/);
+      if (m) topKeys.push(m[1]);
+    }
+    if (topKeys.length > 0) sigs.push(`keys: [${topKeys.slice(0, 12).join(', ')}]`);
+  
+    // GitHub Actions: jobs
+    let inJobs = false;
+    for (const line of lines) {
+      if (/^jobs\s*:/.test(line)) { inJobs = true; continue; }
+      if (inJobs && /^[a-z]/.test(line) && !line.startsWith('jobs')) inJobs = false;
+      if (inJobs) {
+        const m = line.match(/^  ([\w-]+)\s*:/);
+        if (m) sigs.push(`job: ${m[1]}`);
+      }
+    }
+  
+    // Docker Compose: services
+    let inServices = false;
+    for (const line of lines) {
+      if (/^services\s*:/.test(line)) { inServices = true; continue; }
+      if (inServices && /^[a-z]/.test(line) && !line.startsWith('services')) inServices = false;
+      if (inServices) {
+        const m = line.match(/^  ([\w-]+)\s*:/);
+        if (m) sigs.push(`service: ${m[1]}`);
+      }
+    }
+  
+    // OpenAPI paths
+    let inPaths = false;
+    for (const line of lines) {
+      if (/^paths\s*:/.test(line)) { inPaths = true; continue; }
+      if (inPaths && /^[a-z]/.test(line) && !line.startsWith('paths')) inPaths = false;
+      if (inPaths) {
+        const m = line.match(/^  (\/[\w/{}-]*)\s*:/);
+        if (m) sigs.push(`path: ${m[1]}`);
+      }
+    }
+  
+    return sigs.slice(0, 25);
+  }
+  
+  module.exports = { extract };
+  
+};
+
+// ── ./src/format/cache ──
+__factories["./src/format/cache"] = function(module, exports) {
+  
+  /**
+   * Format context output for Anthropic prompt cache API.
+   *
+   * Usage:
+   *   const { formatCache } = require('./src/format/cache');
+   *   const json = formatCache(markdownContent);
+   *   // json is a ready-to-use Anthropic system block with cache_control
+   *
+   * Writes: .github/copilot-instructions.cache.json
+   */
+  
+  /**
+   * Wrap markdown context in an Anthropic cache-control system block.
+   * @param {string} content - Markdown content from formatOutput()
+   * @returns {string} - JSON string: a single Anthropic system content block
+   */
+  function formatCache(content) {
+    if (!content || typeof content !== 'string') content = '';
+    const block = {
+      type: 'text',
+      text: content,
+      cache_control: { type: 'ephemeral' },
+    };
+    return JSON.stringify(block, null, 2);
+  }
+  
+  /**
+   * Wrap markdown context in a full Anthropic messages API payload.
+   * Includes the system array with cache_control so it can be copy-pasted
+   * directly into an API call.
+   * @param {string} content - Markdown content from formatOutput()
+   * @param {string} [model] - Anthropic model ID (default: claude-opus-4-5)
+   * @returns {string} - JSON string: { model, system: [...] }
+   */
+  function formatCachePayload(content, model) {
+    if (!content || typeof content !== 'string') content = '';
+    const payload = {
+      model: model || 'claude-opus-4-5',
+      system: [
+        {
+          type: 'text',
+          text: content,
+          cache_control: { type: 'ephemeral' },
+        },
+      ],
+      messages: [],
+    };
+    return JSON.stringify(payload, null, 2);
+  }
+  
+  module.exports = { formatCache, formatCachePayload };
+  
+};
+
+// ── ./src/health/scorer ──
+__factories["./src/health/scorer"] = function(module, exports) {
+  
+  /**
+   * SigMap health scorer.
+   *
+   * Computes a composite 0-100 health score for the current project by combining:
+   *   1. Days since context file was last regenerated  (staleness penalty ≤ 30 pts)
+   *   2. Average token reduction percentage             (low-reduction penalty 20 pts)
+   *   3. Over-budget run rate                           (budget penalty 20 pts)
+   *
+   * Strategy-aware: thresholds adjust based on the active strategy so that
+   * hot-cold (90% reduction intentional) is not penalized as 'low reduction'.
+   *
+   * Grade scale:  A ≥ 90  |  B ≥ 75  |  C ≥ 60  |  D < 60
+   *
+   * Never throws — returns graceful result with nulls for unavailable metrics.
+   *
+   * @param {string} cwd - Working directory (root of the project)
+   * @returns {{
+   *   score: number,
+   *   grade: 'A'|'B'|'C'|'D',
+   *   strategy: string,
+   *   tokenReductionPct: number|null,
+   *   daysSinceRegen: number|null,
+   *   strategyFreshnessDays: number|null,
+   *   totalRuns: number,
+   *   overBudgetRuns: number,
+   * }}
+   */
+  function score(cwd) {
+    const fs = require('fs');
+    const path = require('path');
+  
+    let tokenReductionPct = null;
+    let daysSinceRegen = null;
+    let strategyFreshnessDays = null;
+    let overBudgetRuns = 0;
+    let totalRuns = 0;
+  
+    // ── Detect active strategy ──────────────────────────────────────────────
+    let strategy = 'full';
+    try {
+      const cfgPath = path.join(cwd, 'gen-context.config.json');
+      if (fs.existsSync(cfgPath)) {
+        const cfg = JSON.parse(fs.readFileSync(cfgPath, 'utf8'));
+        strategy = cfg.strategy || 'full';
+      }
+    } catch (_) {}
+  
+    // ── Read usage log via tracking logger ──────────────────────────────────
+    try {
+      const { readLog, summarize } = __require('./src/tracking/logger');
+      const entries = readLog(cwd);
+      const s = summarize(entries);
+      // Only set tokenReductionPct when there is actual history; a brand-new/
+      // untracked project should not be penalised for "0% reduction".
+      if (s.totalRuns > 0) tokenReductionPct = s.avgReductionPct;
+      overBudgetRuns = s.overBudgetRuns;
+      totalRuns = s.totalRuns;
+    } catch (_) {
+      // No usage log yet — proceed with nulls
+    }
+  
+    // ── Days since primary context file was last regenerated ─────────────────
+    try {
+      const ctxFile = path.join(cwd, '.github', 'copilot-instructions.md');
+      if (fs.existsSync(ctxFile)) {
+        const mtime = fs.statSync(ctxFile).mtimeMs;
+        daysSinceRegen = parseFloat(((Date.now() - mtime) / (1000 * 60 * 60 * 24)).toFixed(1));
+      }
+    } catch (_) {}
+  
+    // ── Strategy freshness: context-cold.md age (hot-cold only) ─────────────
+    if (strategy === 'hot-cold') {
+      try {
+        const coldFile = path.join(cwd, '.github', 'context-cold.md');
+        if (fs.existsSync(coldFile)) {
+          const mtime = fs.statSync(coldFile).mtimeMs;
+          strategyFreshnessDays = parseFloat(((Date.now() - mtime) / (1000 * 60 * 60 * 24)).toFixed(1));
+        }
+      } catch (_) {}
+    }
+  
+    // ── Compute composite score ───────────────────────────────────────────────
+    let points = 100;
+  
+    // Staleness penalty: -4 pts per day over the 7-day freshness window (max -30)
+    if (daysSinceRegen !== null && daysSinceRegen > 7) {
+      points -= Math.min(30, Math.floor((daysSinceRegen - 7) * 4));
+    }
+  
+    // Low-reduction penalty — threshold depends on strategy:
+    // - hot-cold: primary output tiny by design; use cold freshness instead
+    // - per-module: per-file budgets; global < 60% is expected, no penalty
+    // - full: standard 60% threshold
+    const reductionThreshold = (strategy === 'full') ? 60 : 0;
+    if (tokenReductionPct !== null && tokenReductionPct < reductionThreshold) {
+      points -= 20;
+    }
+  
+    // hot-cold strategy freshness penalty: context-cold.md older than 1 day (-10 pts)
+    if (strategy === 'hot-cold' && strategyFreshnessDays !== null && strategyFreshnessDays > 1) {
+      points -= Math.min(10, Math.floor(strategyFreshnessDays - 1) * 3);
+    }
+  
+    // Over-budget penalty: more than 20% of runs exceeded the token budget (-20)
+    if (overBudgetRuns > 0 && totalRuns > 0) {
+      const overBudgetRate = (overBudgetRuns / totalRuns) * 100;
+      if (overBudgetRate > 20) points -= 20;
+    }
+  
+    points = Math.max(0, Math.min(100, Math.round(points)));
+  
+    let grade;
+    if (points >= 90) grade = 'A';
+    else if (points >= 75) grade = 'B';
+    else if (points >= 60) grade = 'C';
+    else grade = 'D';
+  
+    return { score: points, grade, strategy, tokenReductionPct, daysSinceRegen, strategyFreshnessDays, totalRuns, overBudgetRuns };
+  }
+  
+  module.exports = { score };
+  
+};
+
+// ── ./src/map/class-hierarchy ──
+__factories["./src/map/class-hierarchy"] = function(module, exports) {
+  
+  /**
+   * Class hierarchy analyzer.
+   * Extracts class declarations with extends/implements across
+   * TypeScript, JavaScript, Python, Java, Kotlin, C# files.
+   *
+   * @param {string[]} files — absolute file paths to analyze
+   * @param {string}   cwd   — project root for relative path display
+   * @returns {string} formatted section content (empty string if nothing found)
+   */
+  
+  const fs = require('fs');
+  const path = require('path');
+  
+  function analyze(files, cwd) {
+    const entries = [];
+  
+    for (const filePath of files) {
+      const ext = path.extname(filePath).toLowerCase();
+      const rel = path.relative(cwd, filePath).replace(/\\/g, '/');
+      let content;
+      try { content = fs.readFileSync(filePath, 'utf8'); } catch (_) { continue; }
+  
+      // TS / JS
+      if (['.ts', '.tsx', '.js', '.jsx'].includes(ext)) {
+        const re = /^\s*(?:export\s+)?(?:abstract\s+)?class\s+(\w+)(?:\s+extends\s+([\w<>.]+?))?(?:\s+implements\s+([\w<>.,\s]+?))?\s*\{/gm;
+        let m;
+        while ((m = re.exec(content)) !== null) {
+          const parent = m[2] ? m[2].split('<')[0].trim() : null;
+          const ifaces = m[3]
+            ? m[3].split(',').map((s) => s.split('<')[0].trim()).filter(Boolean)
+            : [];
+          entries.push({ name: m[1], parent, interfaces: ifaces, file: rel });
+        }
+      }
+  
+      // Python
+      if (['.py', '.pyw'].includes(ext)) {
+        const re = /^\s*class\s+(\w+)\s*\(([^)]*)\)\s*:/gm;
+        let m;
+        while ((m = re.exec(content)) !== null) {
+          const parents = m[2]
+            .split(',')
+            .map((s) => s.trim())
+            .filter((s) => s && s !== 'object');
+          entries.push({
+            name: m[1],
+            parent: parents[0] || null,
+            interfaces: parents.slice(1),
+            file: rel,
+          });
+        }
+      }
+  
+      // Java
+      if (ext === '.java') {
+        const re = /^\s*(?:(?:public|protected|private|static|abstract|final)\s+)*class\s+(\w+)(?:\s+extends\s+(\w+))?(?:\s+implements\s+([\w,\s<>]+?))?\s*\{/gm;
+        let m;
+        while ((m = re.exec(content)) !== null) {
+          const ifaces = m[3]
+            ? m[3].split(',').map((s) => s.split('<')[0].trim()).filter(Boolean)
+            : [];
+          entries.push({ name: m[1], parent: m[2] || null, interfaces: ifaces, file: rel });
+        }
+      }
+  
+      // Kotlin
+      if (['.kt', '.kts'].includes(ext)) {
+        const re = /^\s*(?:(?:data|sealed|abstract|open|inner)\s+)?class\s+(\w+)(?:\s*[^:\r\n]*)?\s*:\s*([\w<>(),.\s]+?)(?:\s*\{|$)/gm;
+        let m;
+        while ((m = re.exec(content)) !== null) {
+          const parents = m[2]
+            .split(',')
+            .map((s) => s.replace(/\(.*?\)/, '').split('<')[0].trim())
+            .filter(Boolean);
+          entries.push({
+            name: m[1],
+            parent: parents[0] || null,
+            interfaces: parents.slice(1),
+            file: rel,
+          });
+        }
+      }
+  
+      // C#
+      if (ext === '.cs') {
+        const re = /^\s*(?:(?:public|internal|protected|private|static|abstract|sealed|partial)\s+)*class\s+(\w+)(?:\s*:\s*([\w<>.,\s]+?))?\s*\{/gm;
+        let m;
+        while ((m = re.exec(content)) !== null) {
+          const parents = m[2]
+            ? m[2].split(',').map((s) => s.split('<')[0].trim()).filter(Boolean)
+            : [];
+          entries.push({
+            name: m[1],
+            parent: parents[0] || null,
+            interfaces: parents.slice(1),
+            file: rel,
+          });
+        }
+      }
+    }
+  
+    if (entries.length === 0) return '';
+  
+    return entries
+      .map((e) => {
+        let line = e.name;
+        if (e.parent) line += ` extends ${e.parent}`;
+        if (e.interfaces.length > 0) line += ` implements ${e.interfaces.join(', ')}`;
+        line += ` (${e.file})`;
+        return line;
+      })
+      .join('\n');
+  }
+  
+  module.exports = { analyze };
+  
+};
+
+// ── ./src/map/import-graph ──
+__factories["./src/map/import-graph"] = function(module, exports) {
+  
+  /**
+   * Import graph analyzer.
+   * Extracts relative import relationships from JS/TS/Python files
+   * and detects circular dependencies.
+   *
+   * @param {string[]} files — absolute file paths to analyze
+   * @param {string}   cwd   — project root for relative path display
+   * @returns {string} formatted section content (empty string if nothing found)
+   */
+  
+  const fs = require('fs');
+  const path = require('path');
+  
+  const JS_EXTS = new Set(['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs']);
+  const PY_EXTS = new Set(['.py', '.pyw']);
+  
+  // ---------------------------------------------------------------------------
+  // Import extraction per language
+  // ---------------------------------------------------------------------------
+  function extractImports(filePath, content, fileSet) {
+    const ext = path.extname(filePath).toLowerCase();
+    const dir = path.dirname(filePath);
+    const found = [];
+  
+    if (JS_EXTS.has(ext)) {
+      // ES: import ... from './foo'  or  import './side-effect'
+      const re1 = /(?:^|[\r\n])\s*import\s+(?:[^'";\r\n]*?\s+from\s+)?['"](\.[^'"]+)['"]/g;
+      let m;
+      while ((m = re1.exec(content)) !== null) {
+        const resolved = resolveJsPath(dir, m[1], fileSet);
+        if (resolved) found.push(resolved);
+      }
+      // CommonJS: require('./foo')
+      const re2 = /\brequire\s*\(\s*['"](\.[^'"]+)['"]\s*\)/g;
+      while ((m = re2.exec(content)) !== null) {
+        const resolved = resolveJsPath(dir, m[1], fileSet);
+        if (resolved) found.push(resolved);
+      }
+    }
+  
+    if (PY_EXTS.has(ext)) {
+      // from .module import ...  /  from ..pkg import ...
+      const re = /^[ \t]*from\s+(\.+[\w.]*)\s+import/gm;
+      let m;
+      while ((m = re.exec(content)) !== null) {
+        const dotCount = (m[1].match(/^\.+/) || [''])[0].length;
+        const modPart = m[1].slice(dotCount).replace(/\./g, '/');
+        let base = dir;
+        for (let i = 1; i < dotCount; i++) base = path.dirname(base);
+        const candidate = modPart ? path.join(base, modPart + '.py') : null;
+        if (candidate && fileSet.has(candidate)) found.push(candidate);
+      }
+    }
+  
+    return [...new Set(found)];
+  }
+  
+  function resolveJsPath(dir, importStr, fileSet) {
+    const base = path.resolve(dir, importStr);
+    const candidates = [
+      base,
+      base + '.ts', base + '.tsx',
+      base + '.js', base + '.jsx',
+      base + '/index.ts', base + '/index.js',
+    ];
+    for (const c of candidates) {
+      if (fileSet.has(c)) return c;
+    }
+    return null;
+  }
+  
+  // ---------------------------------------------------------------------------
+  // Cycle detection (DFS with path tracking)
+  // ---------------------------------------------------------------------------
+  function detectCycles(graph) {
+    const cycles = [];
+    const visited = new Set();
+    const onStack = new Set();
+    const stackArr = [];
+  
+    function dfs(node) {
+      if (onStack.has(node)) {
+        const start = stackArr.indexOf(node);
+        if (start !== -1) cycles.push([...stackArr.slice(start), node]);
+        return;
+      }
+      if (visited.has(node)) return;
+  
+      onStack.add(node);
+      stackArr.push(node);
+      for (const dep of (graph.get(node) || [])) dfs(dep);
+      stackArr.pop();
+      onStack.delete(node);
+      visited.add(node);
+    }
+  
+    for (const node of graph.keys()) {
+      if (!visited.has(node)) dfs(node);
+    }
+    return cycles;
+  }
+  
+  // ---------------------------------------------------------------------------
+  // Public API
+  // ---------------------------------------------------------------------------
+  function analyze(files, cwd) {
+    const fileSet = new Set(files.map((f) => path.resolve(f)));
+    const graph = new Map();
+  
+    for (const filePath of files) {
+      let content;
+      try { content = fs.readFileSync(filePath, 'utf8'); } catch (_) { continue; }
+      const deps = extractImports(path.resolve(filePath), content, fileSet);
+      if (deps.length > 0) graph.set(path.resolve(filePath), deps);
+    }
+  
+    if (graph.size === 0) return '';
+  
+    const cycles = detectCycles(graph);
+    const cycleNodeSet = new Set(cycles.flatMap((c) => c));
+  
+    const lines = [];
+    const sorted = [...graph.entries()].sort((a, b) => a[0].localeCompare(b[0]));
+  
+    for (const [fp, deps] of sorted) {
+      const rel = path.relative(cwd, fp).replace(/\\/g, '/');
+      const depList = deps.map((d) => {
+        const drel = path.relative(cwd, d).replace(/\\/g, '/');
+        return cycleNodeSet.has(d) ? `${drel} ⚠` : drel;
+      });
+      lines.push(`${rel} → ${depList.join(', ')}`);
+    }
+  
+    if (cycles.length > 0) {
+      lines.push('');
+      lines.push('Circular dependencies detected:');
+      for (const cycle of cycles) {
+        const relPath = cycle.map((n) => path.relative(cwd, n).replace(/\\/g, '/')).join(' → ');
+        lines.push(`  ⚠ ${relPath}`);
+      }
+    }
+  
+    return lines.join('\n');
+  }
+  
+  module.exports = { analyze };
+  
+};
+
+// ── ./src/map/route-table ──
+__factories["./src/map/route-table"] = function(module, exports) {
+  
+  /**
+   * HTTP route table extractor.
+   * Detects routes in Express, Fastify, NestJS, Flask, FastAPI, Gin, Spring.
+   *
+   * @param {string[]} files — absolute file paths to analyze
+   * @param {string}   cwd   — project root for relative path display
+   * @returns {string} formatted markdown table (empty string if no routes found)
+   */
+  
+  const fs = require('fs');
+  const path = require('path');
+  
+  const JS_EXTS = new Set(['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs']);
+  const PY_EXTS = new Set(['.py', '.pyw']);
+  
+  function analyze(files, cwd) {
+    const routes = [];
+  
+    for (const filePath of files) {
+      const ext = path.extname(filePath).toLowerCase();
+      const rel = path.relative(cwd, filePath).replace(/\\/g, '/');
+      let content;
+      try { content = fs.readFileSync(filePath, 'utf8'); } catch (_) { continue; }
+  
+      // -----------------------------------------------------------------------
+      // Express / Fastify / Koa (JS/TS)
+      // -----------------------------------------------------------------------
+      if (JS_EXTS.has(ext)) {
+        // app.get('/path', ...) / router.post('/path') / fastify.put('/path')
+        const re1 = /\b(?:app|router|fastify|server|koa|instance)\.(get|post|put|patch|delete|head|options|all)\s*\(\s*['"`]([^'"`]+)['"`]/gi;
+        let m;
+        while ((m = re1.exec(content)) !== null) {
+          routes.push({ method: m[1].toUpperCase(), path: m[2], file: rel });
+        }
+  
+        // NestJS decorators: @Get('/path') @Post('/path')
+        const re2 = /@(Get|Post|Put|Patch|Delete|Head|Options|All)\s*\(\s*['"`]([^'"`]+)['"`]\s*\)/g;
+        while ((m = re2.exec(content)) !== null) {
+          routes.push({ method: m[1].toUpperCase(), path: m[2], file: rel });
+        }
+  
+        // NestJS: @Get() with no path
+        const re3 = /@(Get|Post|Put|Patch|Delete)\s*\(\s*\)/g;
+        while ((m = re3.exec(content)) !== null) {
+          routes.push({ method: m[1].toUpperCase(), path: '/', file: rel });
+        }
+      }
+  
+      // -----------------------------------------------------------------------
+      // Flask / FastAPI (Python)
+      // -----------------------------------------------------------------------
+      if (PY_EXTS.has(ext)) {
+        // @app.route('/path', methods=['GET', 'POST'])
+        const re1 = /@[\w.]+\.route\s*\(\s*['"]([^'"]+)['"]([\s\S]{0,150}?)\)/g;
+        let m;
+        while ((m = re1.exec(content)) !== null) {
+          const routePath = m[1];
+          const methodsMatch = m[2].match(/methods\s*=\s*\[([^\]]+)\]/);
+          if (methodsMatch) {
+            const methods = methodsMatch[1].match(/['"]([A-Z]+)['"]/g) || [];
+            for (const meth of methods) {
+              routes.push({ method: meth.replace(/['"]/g, ''), path: routePath, file: rel });
+            }
+          } else {
+            routes.push({ method: 'GET', path: routePath, file: rel });
+          }
+        }
+  
+        // @app.get('/path')  @router.post('/path')  FastAPI style
+        const re2 = /@[\w.]+\.(get|post|put|patch|delete|head|options)\s*\(\s*['"]([^'"]+)['"]/g;
+        while ((m = re2.exec(content)) !== null) {
+          routes.push({ method: m[1].toUpperCase(), path: m[2], file: rel });
+        }
+      }
+  
+      // -----------------------------------------------------------------------
+      // Go — Gin / Echo / chi / net/http
+      // -----------------------------------------------------------------------
+      if (ext === '.go') {
+        // r.GET("/path", handler)
+        const re1 = /\b\w+\.(GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS)\s*\(\s*["']([^"']+)["']/g;
+        let m;
+        while ((m = re1.exec(content)) !== null) {
+          routes.push({ method: m[1], path: m[2], file: rel });
+        }
+        // http.HandleFunc("/path", handler)
+        const re2 = /http\.HandleFunc\s*\(\s*["']([^"']+)["']/g;
+        while ((m = re2.exec(content)) !== null) {
+          routes.push({ method: 'ANY', path: m[1], file: rel });
+        }
+      }
+  
+      // -----------------------------------------------------------------------
+      // Spring (Java)
+      // -----------------------------------------------------------------------
+      if (ext === '.java') {
+        // @GetMapping("/path") @PostMapping @RequestMapping
+        const re1 = /@(Get|Post|Put|Patch|Delete|Request)Mapping\s*\(\s*(?:value\s*=\s*)?["']([^"']+)["']/g;
+        let m;
+        while ((m = re1.exec(content)) !== null) {
+          const method = m[1] === 'Request' ? 'ANY' : m[1].toUpperCase();
+          routes.push({ method, path: m[2], file: rel });
+        }
+      }
+    }
+  
+    if (routes.length === 0) return '';
+  
+    const lines = [
+      '| Method | Path | File |',
+      '|--------|------|------|',
+    ];
+    for (const r of routes) {
+      lines.push(`| ${r.method} | ${r.path} | ${r.file} |`);
+    }
+    return lines.join('\n');
+  }
+  
+  module.exports = { analyze };
+  
+};
+
+// ── ./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 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');
+    const query = args.query.toLowerCase();
+    const lines = content.split('\n');
+  
+    const result = [];
+    let currentFile = '';
+    let fileHeaderAdded = false;
+  
+    for (const line of lines) {
+      if (line.startsWith('### ')) {
+        currentFile = line.slice(4).trim();
+        fileHeaderAdded = false;
+        continue;
+      }
+      // Skip markdown fences and top-level headers
+      if (line.startsWith('```') || line.startsWith('## ') || line.startsWith('# ') || line.startsWith('<!--')) {
+        continue;
+      }
+      if (line.toLowerCase().includes(query)) {
+        if (currentFile && !fileHeaderAdded) {
+          if (result.length > 0) result.push('');
+          result.push(`### ${currentFile}`);
+          fileHeaderAdded = true;
+        }
+        result.push(line);
+      }
+    }
+  
+    if (result.length === 0) return `No signatures found matching: ${args.query}`;
+    return result.join('\n');
+  }
+  
+  /**
+   * 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`;
+    }
+  
+    // 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);
+  }
+  
+  /**
+   * 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_');
+    }
+    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('');
+      }
+    }
+  
+    lines.push('---');
+    lines.push('_Generated by SigMap `create_checkpoint`_');
+  
+    return lines.join('\n');
+  }
+  
+  /**
+   * 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}_`;
+    }
+  }
+  
+  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');
+  }
+  
+  function listModules(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');
+    const ctxLines = content.split('\n');
+    const groups = {};
+    let currentGroup = null;
+    let blockBuf = [];
+  
+    function flushBlock() {
+      if (currentGroup === null || blockBuf.length === 0) return;
+      if (!groups[currentGroup]) groups[currentGroup] = { fileCount: 0, tokenCount: 0 };
+      groups[currentGroup].fileCount++;
+      groups[currentGroup].tokenCount += Math.ceil(blockBuf.join('\n').length / 4);
+      blockBuf = [];
+    }
+  
+    for (const line of ctxLines) {
+      if (line.startsWith('### ')) {
+        flushBlock();
+        const rel = line.slice(4).trim().replace(/\\/g, '/');
+        const parts = rel.split('/');
+        currentGroup = parts.length > 1 ? parts[0] : '.';
+      } else if (currentGroup !== null) {
+        blockBuf.push(line);
+      }
+    }
+    flushBlock();
+  
+    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');
+  }
+  
+  module.exports = { readContext, searchSignatures, getMap, createCheckpoint, getRouting, explainFile, listModules };
+};
+
+// ── ./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        → 3 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 } = __require('./src/mcp/handlers');
+  
+  const SERVER_INFO = {
+    name: 'sigmap',
+    version: '1.4.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;
+    }
+  
+    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 {
+          respondError(id, -32601, `Unknown tool: ${name}`);
+          return;
+        }
+      } catch (err) {
+        respondError(id, -32603, `Tool error: ${err.message}`);
+        return;
+      }
+  
+      respond(id, {
+        content: [{ type: 'text', text: String(text) }],
+      });
+      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);
+    });
+  }
+  
+  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.',
+          },
+        },
+        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).',
+          },
+        },
+        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.',
+          },
+        },
+        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).',
+          },
+        },
+        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.',
+          },
+        },
+        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: [],
+      },
+    },
+  ];
+  
+  module.exports = { TOOLS };
+  
+};
+
+// ── ./src/routing/classifier ──
+__factories["./src/routing/classifier"] = function(module, exports) {
+  
+  /**
+   * Classify files by complexity tier for model routing hints.
+   *
+   * Tiers:
+   *   'fast'     — simple files: config, markup, templates, trivial utilities
+   *   'balanced' — standard application code: moderate functions and classes
+   *   'powerful' — complex files: large classes, many exports, security-critical paths
+   *
+   * @param {string} filePath - absolute path to the file
+   * @param {string[]} sigs   - extracted signatures for the file
+   * @returns {'fast'|'balanced'|'powerful'}
+   */
+  function classify(filePath, sigs) {
+    const lower = filePath.toLowerCase();
+    const sigCount = sigs.length;
+  
+    // ── Fast tier heuristics ────────────────────────────────────────────────
+    // Configuration, markup, templates, and trivial utilities are small tasks
+    if (
+      lower.endsWith('.json') ||
+      lower.endsWith('.yml') ||
+      lower.endsWith('.yaml') ||
+      lower.endsWith('.toml') ||
+      lower.endsWith('.env') ||
+      lower.endsWith('.html') ||
+      lower.endsWith('.htm') ||
+      lower.endsWith('.css') ||
+      lower.endsWith('.scss') ||
+      lower.endsWith('.sass') ||
+      lower.endsWith('.less') ||
+      /dockerfile/i.test(lower) ||
+      lower.endsWith('.sh') ||
+      lower.endsWith('.bash') ||
+      lower.endsWith('.zsh') ||
+      lower.endsWith('.fish')
+    ) {
+      return 'fast';
+    }
+  
+    // Config-like directories
+    if (
+      lower.includes('/config/') ||
+      lower.includes('/configs/') ||
+      lower.includes('/fixtures/') ||
+      lower.includes('/migrations/') ||
+      lower.includes('/seeds/')
+    ) {
+      return sigCount > 4 ? 'balanced' : 'fast';
+    }
+  
+    // Test files — usually standard complexity
+    if (/\.(test|spec)\.[a-z]+$/.test(lower) || /_test\.[a-z]+$/.test(lower)) {
+      return 'balanced';
+    }
+  
+    // ── Powerful tier heuristics — high-signal keywords in the path ─────────
+    if (
+      lower.includes('/security/') ||
+      lower.includes('/auth/') ||
+      lower.includes('/crypto/') ||
+      lower.includes('/core/') ||
+      lower.includes('/engine/') ||
+      lower.includes('/compiler/') ||
+      lower.includes('/parser/') ||
+      lower.includes('/scheduler/') ||
+      lower.includes('/orchestrat')
+    ) {
+      return 'powerful';
+    }
+  
+    // Many exports → complex file
+    if (sigCount >= 12) return 'powerful';
+  
+    // Large number of class-level methods (indented 2-space sigs)
+    const methodCount = sigs.filter((s) => s.startsWith('  ')).length;
+    if (methodCount >= 8) return 'powerful';
+  
+    // ── Balanced covers everything else ────────────────────────────────────
+    if (sigCount <= 2) return 'fast';
+    return 'balanced';
+  }
+  
+  /**
+   * Classify all file entries and group them by tier.
+   *
+   * @param {Array<{filePath: string, sigs: string[]}>} fileEntries
+   * @returns {{ fast: string[], balanced: string[], powerful: string[] }}
+   *   Each array contains relative paths (relative to cwd).
+   */
+  function classifyAll(fileEntries, cwd) {
+    const path = require('path');
+    const result = { fast: [], balanced: [], powerful: [] };
+    for (const { filePath, sigs } of fileEntries) {
+      const tier = classify(filePath, sigs);
+      result[tier].push(path.relative(cwd, filePath));
+    }
+    return result;
+  }
+  
+  module.exports = { classify, classifyAll };
+  
+};
+
+// ── ./src/routing/hints ──
+__factories["./src/routing/hints"] = function(module, exports) {
+  
+  /**
+   * Model routing hint definitions for SigMap.
+   *
+   * Maps complexity tiers to:
+   *   - example model names (vendor-agnostic labels used as hints)
+   *   - task types that belong to each tier
+   *   - estimated per-1K-token API cost (USD, illustrative — update as needed)
+   *
+   * These are embedded in the generated context file when `routing: true`
+   * so that AI agents and developers know which model tier to invoke.
+   */
+  
+  const TIERS = {
+    fast: {
+      label: 'Fast (low-cost)',
+      examples: 'claude-haiku-4-5, gpt-5-1-codex-mini, gemini-3-flash',
+      tasks: [
+        'Autocomplete and inline suggestions',
+        'Edit config or markup files',
+        'Fix typos and rename symbols',
+        'Format, lint, and trivial style changes',
+        'Explain a short utility function',
+        'Generate simple shell scripts or Dockerfiles',
+      ],
+      costHint: '~$0.0008 / 1K tokens',
+    },
+  
+    balanced: {
+      label: 'Balanced (mid-tier)',
+      examples: 'claude-sonnet-4-6, gpt-5-2, gemini-3-1-pro',
+      tasks: [
+        'Write unit or integration tests',
+        'Implement a well-scoped feature function',
+        'Debug a runtime error with stack trace',
+        'Refactor a module (< 200 lines)',
+        'Generate a PR description',
+        'Explain a multi-function module',
+      ],
+      costHint: '~$0.003 / 1K tokens',
+    },
+  
+    powerful: {
+      label: 'Powerful (high-cost)',
+      examples: 'claude-opus-4-6, gpt-5-4, gemini-2-5-pro',
+      tasks: [
+        'Cross-cutting architecture decisions',
+        'Multi-file refactor spanning 5+ files',
+        'Security audit (OWASP Top 10)',
+        'Complex debugging across async boundaries',
+        'Migration plan for a library/framework upgrade',
+        'Designing a new module from requirements',
+      ],
+      costHint: '~$0.015 / 1K tokens',
+    },
+  };
+  
+  /**
+   * Format the routing section as markdown to append to the context file.
+   *
+   * @param {{ fast: string[], balanced: string[], powerful: string[] }} groups
+   *   Relative file paths grouped by tier (from classifier.classifyAll).
+   * @returns {string} Markdown block to embed in the context output.
+   */
+  function formatRoutingSection(groups) {
+    const lines = [
+      '',
+      '---',
+      '',
+      '## Model routing hints',
+      '<!-- Generated by SigMap routing module — update gen-context.config.json to disable -->',
+      '',
+      'Select the model tier based on the task complexity and the files involved.',
+      '',
+    ];
+  
+    for (const [tier, info] of Object.entries(TIERS)) {
+      const files = groups[tier] || [];
+      lines.push(`### ${info.label}`);
+      lines.push(`**Examples:** ${info.examples}  `);
+      lines.push(`**Cost:** ${info.costHint}`);
+      lines.push('');
+      lines.push('**Use for tasks like:**');
+      for (const task of info.tasks) lines.push(`- ${task}`);
+      lines.push('');
+      if (files.length > 0) {
+        lines.push('**Files in this tier:**');
+        for (const f of files.slice(0, 15)) lines.push(`- \`${f}\``);
+        if (files.length > 15) lines.push(`- … and ${files.length - 15} more`);
+      } else {
+        lines.push('**Files in this tier:** _(none detected)_');
+      }
+      lines.push('');
+    }
+  
+    lines.push('> **Tip:** Run `node gen-context.js --routing` to regenerate routing hints.');
+    lines.push('> See `docs/MODEL_ROUTING.md` for full routing guide and cost optimisation tips.');
+  
+    return lines.join('\n');
+  }
+  
+  module.exports = { TIERS, formatRoutingSection };
+  
+};
+
+// ── ./src/security/patterns ──
+__factories["./src/security/patterns"] = function(module, exports) {
+  
+  /**
+   * Secret detection patterns for SigMap scanner.
+   * Each pattern has a name and a regex tested against signature strings.
+   */
+  const PATTERNS = [
+    {
+      name: 'AWS Access Key',
+      regex: /AKIA[0-9A-Z]{16}/,
+    },
+    {
+      name: 'AWS Secret Key',
+      // 40-char base64-like string following common AWS secret key assignment patterns
+      regex: /(?:aws_secret|secret_access_key|SecretAccessKey)\s*[:=]\s*['"]?[0-9a-zA-Z/+]{40}/i,
+    },
+    {
+      name: 'GCP API Key',
+      regex: /AIza[0-9A-Za-z\-_]{35}/,
+    },
+    {
+      name: 'GitHub Token',
+      regex: /gh[pousr]_[A-Za-z0-9_]{36,}/,
+    },
+    {
+      name: 'JWT Token',
+      regex: /eyJ[A-Za-z0-9\-_]+\.[A-Za-z0-9\-_]+\.[A-Za-z0-9\-_]+/,
+    },
+    {
+      name: 'DB Connection String',
+      regex: /(mongodb|postgres|postgresql|mysql|redis):\/\/[^:]+:[^@]+@/i,
+    },
+    {
+      name: 'SSH Private Key',
+      regex: /-----BEGIN (RSA |EC |OPENSSH |DSA )?PRIVATE KEY-----/,
+    },
+    {
+      name: 'Stripe Key',
+      regex: /sk_(live|test)_[0-9a-zA-Z]{24,}/,
+    },
+    {
+      name: 'Twilio Key',
+      regex: /SK[0-9a-fA-F]{32}/,
+    },
+    {
+      name: 'Generic Secret',
+      regex: /(secret|password|passwd|api_key|apikey|auth_token|access_token)\s*[:=]\s*['"][^'"]{8,}['"]/i,
+    },
+  ];
+  
+  module.exports = { PATTERNS };
+  
+};
+
+// ── ./src/security/scanner ──
+__factories["./src/security/scanner"] = function(module, exports) {
+  
+  const { PATTERNS } = __require('./src/security/patterns');
+  
+  /**
+   * Scan an array of signature strings for secrets.
+   *
+   * @param {string[]} signatures - Array of extracted signature strings
+   * @param {string} filePath - Source file path (used in redaction message)
+   * @returns {{ safe: string[], redacted: boolean }}
+   *   safe      — signatures with any secret-containing entries replaced
+   *   redacted  — true if at least one signature was redacted
+   */
+  function scan(signatures, filePath) {
+    if (!Array.isArray(signatures)) return { safe: [], redacted: false };
+  
+    try {
+      let redacted = false;
+      const safe = signatures.map((sig) => {
+        if (typeof sig !== 'string') return sig;
+        for (const pattern of PATTERNS) {
+          if (pattern.regex.test(sig)) {
+            redacted = true;
+            return `[REDACTED — ${pattern.name} detected in ${filePath}]`;
+          }
+        }
+        return sig;
+      });
+      return { safe, redacted };
+    } catch (_) {
+      // Never throw — return original signatures on any error
+      return { safe: signatures, redacted: false };
+    }
+  }
+  
+  module.exports = { scan };
+  
+};
+
+// ── ./src/tracking/logger ──
+__factories["./src/tracking/logger"] = function(module, exports) {
+  
+  /**
+   * SigMap usage logger (v0.9)
+   *
+   * Writes an append-only newline-delimited JSON (NDJSON) log at
+   *   .context/usage.ndjson
+   *
+   * Each line is one JSON object describing a gen-context run.
+   * Zero npm dependencies — pure Node.js fs.
+   *
+   * Enabled by:
+   *   config.tracking: true   (gen-context.config.json)
+   *   --track CLI flag
+   */
+  
+  const fs = require('fs');
+  const path = require('path');
+  
+  const LOG_FILE = path.join('.context', 'usage.ndjson');
+  
+  /**
+   * Append one run entry to the usage log.
+   * @param {object} entry - Run metrics from runGenerate()
+   * @param {string} cwd   - Project root (absolute path)
+   */
+  function logRun(entry, cwd) {
+    try {
+      const logPath = path.join(cwd, LOG_FILE);
+      const dir = path.dirname(logPath);
+      if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  
+      const record = {
+        ts: new Date().toISOString(),
+        version: entry.version || '0.9.0',
+        fileCount: entry.fileCount || 0,
+        droppedCount: entry.droppedCount || 0,
+        rawTokens: entry.rawTokens || 0,
+        finalTokens: entry.finalTokens || 0,
+        reductionPct: entry.rawTokens > 0
+          ? parseFloat((100 - (entry.finalTokens / entry.rawTokens) * 100).toFixed(1))
+          : 0,
+        overBudget: entry.overBudget || false,
+        budgetLimit: entry.budgetLimit || 6000,
+      };
+  
+      fs.appendFileSync(logPath, JSON.stringify(record) + '\n', 'utf8');
+    } catch (err) {
+      // Never crash the main process — tracking is optional
+      process.stderr.write(`[sigmap] tracking: could not write log: ${err.message}\n`);
+    }
+  }
+  
+  /**
+   * Read and parse all usage log entries.
+   * @param {string} cwd - Project root (absolute path)
+   * @returns {object[]} Array of parsed log records (oldest first)
+   */
+  function readLog(cwd) {
+    try {
+      const logPath = path.join(cwd, LOG_FILE);
+      if (!fs.existsSync(logPath)) return [];
+      const raw = fs.readFileSync(logPath, 'utf8');
+      return raw
+        .split('\n')
+        .filter(Boolean)
+        .map((line) => {
+          try { return JSON.parse(line); } catch (_) { return null; }
+        })
+        .filter(Boolean);
+    } catch (_) {
+      return [];
+    }
+  }
+  
+  /**
+   * Compute summary statistics from an array of log records.
+   * @param {object[]} entries
+   * @returns {object} Summary stats
+   */
+  function summarize(entries) {
+    if (!entries || entries.length === 0) {
+      return {
+        totalRuns: 0,
+        avgReductionPct: 0,
+        avgFinalTokens: 0,
+        avgRawTokens: 0,
+        minFinalTokens: 0,
+        maxFinalTokens: 0,
+        firstRun: null,
+        lastRun: null,
+        overBudgetRuns: 0,
+      };
+    }
+  
+    const reductions = entries.map((e) => e.reductionPct || 0);
+    const finals = entries.map((e) => e.finalTokens || 0);
+    const raws = entries.map((e) => e.rawTokens || 0);
+  
+    const avg = (arr) => arr.reduce((a, b) => a + b, 0) / arr.length;
+  
+    return {
+      totalRuns: entries.length,
+      avgReductionPct: parseFloat(avg(reductions).toFixed(1)),
+      avgFinalTokens: Math.round(avg(finals)),
+      avgRawTokens: Math.round(avg(raws)),
+      minFinalTokens: Math.min(...finals),
+      maxFinalTokens: Math.max(...finals),
+      firstRun: entries[0].ts || null,
+      lastRun: entries[entries.length - 1].ts || null,
+      overBudgetRuns: entries.filter((e) => e.overBudget).length,
+    };
+  }
+  
+  module.exports = { logRun, readLog, summarize };
+  
+};
+
+
+/**
+ * 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.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { execSync } = require('child_process');
+
+const VERSION = '1.4.0';
+const MARKER = '\n\n## Auto-generated signatures\n<!-- Updated by gen-context.js -->\n';
+
+// ---------------------------------------------------------------------------
+// Config — delegate to src/config/loader.js
+// ---------------------------------------------------------------------------
+const { loadConfig } = __require('./src/config/loader');
+const { DEFAULTS } = __require('./src/config/defaults');
+
+// ---------------------------------------------------------------------------
+// Language → extractor mapping (by file extension)
+// ---------------------------------------------------------------------------
+const EXT_MAP = {
+  '.ts': 'typescript', '.tsx': 'typescript',
+  '.js': 'javascript', '.jsx': 'javascript', '.mjs': 'javascript', '.cjs': 'javascript',
+  '.py': 'python', '.pyw': 'python',
+  '.java': 'java',
+  '.kt': 'kotlin', '.kts': 'kotlin',
+  '.go': 'go',
+  '.rs': 'rust',
+  '.cs': 'csharp',
+  '.cpp': 'cpp', '.c': 'cpp', '.h': 'cpp', '.hpp': 'cpp', '.cc': 'cpp',
+  '.rb': 'ruby', '.rake': 'ruby',
+  '.php': 'php',
+  '.swift': 'swift',
+  '.dart': 'dart',
+  '.scala': 'scala', '.sc': 'scala',
+  '.vue': 'vue',
+  '.svelte': 'svelte',
+  '.html': 'html', '.htm': 'html',
+  '.css': 'css', '.scss': 'css', '.sass': 'css', '.less': 'css',
+  '.yml': 'yaml', '.yaml': 'yaml',
+  '.sh': 'shell', '.bash': 'shell', '.zsh': 'shell', '.fish': 'shell',
+};
+
+// Dockerfile handled separately (no extension)
+function isDockerfile(filename) {
+  return filename === 'Dockerfile' || filename.startsWith('Dockerfile.');
+}
+
+// ---------------------------------------------------------------------------
+// .contextignore parser (gitignore-style subset)
+// ---------------------------------------------------------------------------
+function loadIgnorePatterns(cwd) {
+  const patterns = [];
+  for (const name of ['.contextignore', '.repomixignore']) {
+    const p = path.join(cwd, name);
+    if (fs.existsSync(p)) {
+      const lines = fs.readFileSync(p, 'utf8').split('\n');
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed && !trimmed.startsWith('#')) patterns.push(trimmed);
+      }
+    }
+  }
+  return patterns;
+}
+
+function matchesIgnore(relPath, patterns) {
+  for (const pat of patterns) {
+    const normalized = pat.replace(/\\/g, '/');
+    // Simple glob: support * and ** and trailing /
+    const regexStr = normalized
+      .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+      .replace(/\*\*/g, '___DOUBLE___')
+      .replace(/\*/g, '[^/]*')
+      .replace(/___DOUBLE___/g, '.*');
+    const regex = new RegExp(`(^|/)${regexStr}($|/)`);
+    if (regex.test(relPath)) return true;
+  }
+  return false;
+}
+
+// ---------------------------------------------------------------------------
+// File walker
+// ---------------------------------------------------------------------------
+function walkDir(dir, exclude, maxDepth, depth = 0) {
+  if (depth > maxDepth) return [];
+  let results = [];
+  let entries;
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch (_) {
+    return [];
+  }
+  for (const entry of entries) {
+    if (exclude.includes(entry.name)) continue;
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      results = results.concat(walkDir(full, exclude, maxDepth, depth + 1));
+    } else if (entry.isFile()) {
+      results.push(full);
+    }
+  }
+  return results;
+}
+
+function buildFileList(cwd, config) {
+  const files = [];
+  for (const srcDir of config.srcDirs) {
+    const abs = path.join(cwd, srcDir);
+    if (!fs.existsSync(abs)) continue;
+    const found = walkDir(abs, config.exclude, config.maxDepth);
+    files.push(...found);
+  }
+  // Deduplicate
+  return [...new Set(files)];
+}
+
+// ---------------------------------------------------------------------------
+// Extractor loader (lazy, cached)
+// ---------------------------------------------------------------------------
+const _extractorCache = {};
+function getExtractor(name) {
+  if (_extractorCache[name]) return _extractorCache[name];
+  try {
+    const mod = __require(`./src/extractors/${name}`);
+    _extractorCache[name] = mod;
+    return mod;
+  } catch (err) {
+    console.warn(`[sigmap] failed to load extractor ${name}: ${err.message}`);
+    return null;
+  }
+}
+
+function detectAndExtract(filePath, content, maxSigsPerFile) {
+  const base = path.basename(filePath);
+  const ext = path.extname(base).toLowerCase();
+  let extractorName = EXT_MAP[ext] || null;
+  if (!extractorName && isDockerfile(base)) extractorName = 'dockerfile';
+  if (!extractorName) return [];
+
+  const extractor = getExtractor(extractorName);
+  if (!extractor) return [];
+
+  try {
+    const sigs = extractor.extract(content);
+    return Array.isArray(sigs) ? sigs.slice(0, maxSigsPerFile) : [];
+  } catch (err) {
+    console.warn(`[sigmap] extractor failed for ${filePath}: ${err.message}`);
+    return [];
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Token budget enforcement
+// ---------------------------------------------------------------------------
+function estimateTokens(str) {
+  return Math.ceil(str.length / 4);
+}
+
+function isTestFile(filePath) {
+  return /\.(test|spec)\.[a-z]+$/.test(filePath) || /_test\.[a-z]+$/.test(filePath);
+}
+
+function isConfigFile(filePath) {
+  return /\.(config|conf)\.[a-z]+$/.test(filePath) ||
+    path.extname(filePath) === '.json';
+}
+
+function isGeneratedFile(filePath) {
+  return /(\.generated\.|\.pb\.|_pb\.)/.test(filePath);
+}
+
+function applyTokenBudget(fileEntries, maxTokens) {
+  // fileEntries: [{ filePath, sigs, mtime }]
+  // Reserve ~10% for formatting overhead (section headers, code fences, top-level header)
+  const effectiveBudget = Math.floor(maxTokens * 0.90);
+  let total = fileEntries.reduce((s, e) => s + estimateTokens(e.sigs.join('\n')), 0);
+  if (total <= effectiveBudget) return fileEntries;
+
+  // Sort by drop priority (drop first = index 0)
+  const withPriority = fileEntries.map((e) => {
+    let priority = 0;
+    if (isGeneratedFile(e.filePath)) priority = 10;
+    else if (isTestFile(e.filePath)) priority = 8;
+    else if (isConfigFile(e.filePath)) priority = 6;
+    else priority = 4;
+    return { ...e, priority };
+  });
+
+  // Within same priority, sort by mtime ascending (oldest first = drop first)
+  withPriority.sort((a, b) => {
+    if (b.priority !== a.priority) return b.priority - a.priority;
+    return (a.mtime || 0) - (b.mtime || 0);
+  });
+
+  const kept = [];
+  let dropped = 0;
+  for (let i = withPriority.length - 1; i >= 0; i--) {
+    const entry = withPriority[i];
+    const entryTokens = estimateTokens(entry.sigs.join('\n'));
+    if (total <= effectiveBudget) {
+      kept.unshift(entry);
+    } else {
+      total -= entryTokens;
+      dropped++;
+    }
+  }
+  if (dropped > 0) {
+    console.warn(`[sigmap] budget: dropped ${dropped} files to stay under ${maxTokens} tokens`);
+  }
+  return kept;
+}
+
+// ---------------------------------------------------------------------------
+// Recently committed files (git, optional)
+// ---------------------------------------------------------------------------
+function getRecentlyCommittedFiles(cwd, count) {
+  const n = count || 10;
+  try {
+    const out = execSync(`git log --name-only --format="" -n ${n}`, {
+      cwd, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    return new Set(out.split('\n').map((f) => f.trim()).filter(Boolean).map((f) => path.resolve(cwd, f)));
+  } catch (_) {
+    return new Set();
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Diff mode: files changed in working tree or staging area
+// ---------------------------------------------------------------------------
+function getDiffFiles(cwd, stagedOnly) {
+  try {
+    const cmd = stagedOnly ? 'git diff --cached --name-only' : 'git diff HEAD --name-only';
+    const out = execSync(cmd, { cwd, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] });
+    return new Set(
+      out.split('\n').map((f) => f.trim()).filter(Boolean).map((f) => path.resolve(cwd, f))
+    );
+  } catch (_) {
+    return new Set();
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Output formatter
+// ---------------------------------------------------------------------------
+function formatOutput(fileEntries, cwd, routingEnabled) {
+  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',
+    '',
+  ];
+
+  // Group by top-level src dir
+  const groups = {};
+  for (const entry of fileEntries) {
+    const rel = path.relative(cwd, entry.filePath);
+    const parts = rel.split(path.sep);
+    const group = parts.length > 1 ? parts[0] : '.';
+    if (!groups[group]) groups[group] = [];
+    groups[group].push({ rel, sigs: entry.sigs });
+  }
+
+  for (const [group, entries] of Object.entries(groups).sort()) {
+    lines.push(`## ${group}`);
+    lines.push('');
+    for (const { rel, sigs } of entries) {
+      if (sigs.length === 0) continue;
+      lines.push(`### ${rel}`);
+      lines.push('```');
+      lines.push(...sigs);
+      lines.push('```');
+      lines.push('');
+    }
+  }
+
+  if (routingEnabled) {
+    try {
+      const { classifyAll } = __require('./src/routing/classifier');
+      const { formatRoutingSection } = __require('./src/routing/hints');
+      const groups = classifyAll(fileEntries, cwd);
+      lines.push(formatRoutingSection(groups));
+    } catch (err) {
+      console.warn(`[sigmap] routing hints skipped: ${err.message}`);
+    }
+  }
+
+  return lines.join('\n');
+}
+
+// ---------------------------------------------------------------------------
+// Output writers
+// ---------------------------------------------------------------------------
+function ensureDir(filePath) {
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+}
+
+// ---------------------------------------------------------------------------
+// Cache output writer (v0.8)
+// ---------------------------------------------------------------------------
+function writeCacheOutput(content, cwd) {
+  try {
+    const { formatCache } = __require('./src/format/cache');
+    const cachePath = path.join(cwd, '.github', 'copilot-instructions.cache.json');
+    ensureDir(cachePath);
+    fs.writeFileSync(cachePath, formatCache(content), 'utf8');
+    console.warn(`[sigmap] cache: wrote ${path.relative(cwd, cachePath)}`);
+  } catch (err) {
+    console.warn(`[sigmap] cache: failed to write cache output: ${err.message}`);
+  }
+}
+
+function writeOutputs(content, targets, cwd) {
+  const targetMap = {
+    copilot: path.join(cwd, '.github', 'copilot-instructions.md'),
+    cursor: path.join(cwd, '.cursorrules'),
+    windsurf: path.join(cwd, '.windsurfrules'),
+  };
+
+  for (const target of targets) {
+    if (target === 'claude') {
+      writeClaude(content, cwd);
+      continue;
+    }
+    const outPath = targetMap[target];
+    if (!outPath) {
+      console.warn(`[sigmap] unknown output target: ${target}`);
+      continue;
+    }
+    ensureDir(outPath);
+    fs.writeFileSync(outPath, content, 'utf8');
+    console.warn(`[sigmap] wrote ${path.relative(cwd, outPath)}`);
+  }
+}
+
+function writeClaude(content, cwd) {
+  const claudePath = path.join(cwd, 'CLAUDE.md');
+  let existing = '';
+  if (fs.existsSync(claudePath)) {
+    existing = fs.readFileSync(claudePath, 'utf8');
+  }
+  const markerIdx = existing.indexOf('## Auto-generated signatures');
+  let newContent;
+  if (markerIdx !== -1) {
+    newContent = existing.slice(0, markerIdx) + MARKER.trimStart() + content;
+  } else {
+    newContent = existing + MARKER + content;
+  }
+  fs.writeFileSync(claudePath, newContent, 'utf8');
+  console.warn(`[sigmap] wrote CLAUDE.md (appended signatures)`);
+}
+
+// ---------------------------------------------------------------------------
+// Report
+// ---------------------------------------------------------------------------
+function printReport(inputTokens, finalTokens, fileCount, droppedCount, asJson, budgetLimit) {
+  const reduction = inputTokens > 0 ? (100 - (finalTokens / inputTokens) * 100).toFixed(1) : 0;
+  const overBudget = finalTokens > (budgetLimit || 6000);
+  if (asJson) {
+    process.stdout.write(JSON.stringify({
+      version: VERSION,
+      timestamp: new Date().toISOString(),
+      rawTokens: inputTokens,
+      inputTokens,
+      finalTokens,
+      fileCount,
+      droppedCount,
+      reductionPct: parseFloat(reduction),
+      overBudget,
+      budgetLimit: budgetLimit || 6000,
+    }) + '\n');
+    // Exit 1 in CI if over budget — lets pipelines fail fast
+    if (overBudget) process.exitCode = 1;
+  } else {
+    console.log(`[sigmap] report:`);
+    console.log(`  version         : ${VERSION}`);
+    console.log(`  files processed : ${fileCount}`);
+    console.log(`  files dropped   : ${droppedCount}`);
+    console.log(`  input tokens    : ~${inputTokens}`);
+    console.log(`  output tokens   : ~${finalTokens}`);
+    console.log(`  budget limit    : ${budgetLimit || 6000}`);
+    console.log(`  reduction       : ${reduction}%`);
+    if (overBudget) console.warn(`[sigmap] WARNING: output (${finalTokens} tokens) exceeds budget (${budgetLimit || 6000})`);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Watch mode
+// ---------------------------------------------------------------------------
+function watchMode(cwd, config) {
+  console.warn('[sigmap] watching for changes (Ctrl+C to stop)…');
+  let debounce = null;
+  for (const srcDir of config.srcDirs) {
+    const abs = path.join(cwd, srcDir);
+    if (!fs.existsSync(abs)) continue;
+    fs.watch(abs, { recursive: true }, () => {
+      if (debounce) clearTimeout(debounce);
+      debounce = setTimeout(() => {
+        console.warn('[sigmap] change detected, regenerating…');
+        runGenerate(cwd, config, false);
+      }, config.watchDebounce || 300);
+    });
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Git hook installer
+// ---------------------------------------------------------------------------
+function installHook(cwd, scriptPath) {
+  const hookDir = path.join(cwd, '.git', 'hooks');
+  if (!fs.existsSync(hookDir)) {
+    console.warn('[sigmap] .git/hooks not found — skipping hook install');
+    return;
+  }
+  const hookPath = path.join(hookDir, 'post-commit');
+  const resolvedScript = path.resolve(scriptPath);
+  const hookLine = `\nnode ${JSON.stringify(resolvedScript)} --generate 2>/dev/null || true\n`;
+
+  if (fs.existsSync(hookPath)) {
+    const existing = fs.readFileSync(hookPath, 'utf8');
+    const existingHookLines = existing.split('\n').filter((line) => line.includes('gen-context.js'));
+    if (existing.includes(hookLine.trim()) && existingHookLines.length === 1) {
+      console.warn('[sigmap] post-commit hook already installed');
+      return;
+    }
+    if (existing.includes('gen-context.js')) {
+      const updated = existing
+        .split('\n')
+        .filter((line) => !line.includes('gen-context.js'))
+        .join('\n')
+        .replace(/\n+$/g, '\n');
+      fs.writeFileSync(hookPath, updated.replace(/\n?$/g, '') + hookLine);
+      console.warn('[sigmap] updated post-commit hook');
+      return;
+    }
+    fs.appendFileSync(hookPath, hookLine);
+  } else {
+    fs.writeFileSync(hookPath, `#!/bin/sh${hookLine}`);
+    fs.chmodSync(hookPath, '755');
+  }
+  console.warn('[sigmap] installed post-commit hook');
+}
+
+// ---------------------------------------------------------------------------
+// Example config writer
+// ---------------------------------------------------------------------------
+function writeInitConfig(cwd) {
+  const dest = path.join(cwd, 'gen-context.config.json');
+  if (fs.existsSync(dest)) {
+    console.warn('[sigmap] gen-context.config.json already exists — skipping');
+  } else {
+    const example = path.join(__dirname, 'gen-context.config.json.example');
+    if (fs.existsSync(example)) {
+      fs.copyFileSync(example, dest);
+    } else {
+      fs.writeFileSync(dest, JSON.stringify(DEFAULTS, null, 2) + '\n');
+    }
+    console.warn('[sigmap] wrote gen-context.config.json');
+  }
+
+  // Also scaffold .contextignore if it does not already exist
+  const ignoreDest = path.join(cwd, '.contextignore');
+  if (fs.existsSync(ignoreDest)) {
+    console.warn('[sigmap] .contextignore already exists — skipping');
+  } else {
+    const ignoreContent = [
+      '# SigMap ignore file — gitignore syntax',
+      '# Files and directories listed here are excluded from signature extraction.',
+      '# This file is union-merged with .repomixignore if present.',
+      '',
+      'node_modules/',
+      'dist/',
+      'build/',
+      'out/',
+      '.next/',
+      'coverage/',
+      'target/',
+      'vendor/',
+      '*.generated.*',
+      '*.pb.*',
+      '*_pb.*',
+      '*.min.js',
+      '*.min.css',
+    ].join('\n') + '\n';
+    fs.writeFileSync(ignoreDest, ignoreContent);
+    console.warn('[sigmap] wrote .contextignore');
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Core generate pipeline
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+// Strategy: per-module — one output file per top-level srcDir
+// ---------------------------------------------------------------------------
+function runPerModuleStrategy(cwd, config, fileEntries, inputTokenTotal) {
+  // Group entries by their top-level srcDir
+  const modules = {};
+  for (const entry of fileEntries) {
+    const rel = path.relative(cwd, entry.filePath);
+    const topDir = rel.split(path.sep)[0];
+    if (!modules[topDir]) modules[topDir] = [];
+    modules[topDir].push(entry);
+  }
+
+  const moduleNames = Object.keys(modules).sort();
+  console.warn(`[sigmap] per-module: ${moduleNames.length} modules — ${moduleNames.join(', ')}`);
+
+  // Thin overview → primary output (always-on, tiny)
+  const overviewLines = [
+    '<!-- Generated by SigMap gen-context.js v' + VERSION + ' — per-module overview -->',
+    '<!-- Load the full module context file for detailed signatures -->',
+    '',
+    '# Codebase overview',
+    '',
+    '| Module | Full context file |',
+    '|--------|-------------------|',
+  ];
+
+  let totalOut = 0;
+  for (const mod of moduleNames) {
+    const outName = `context-${mod}.md`;
+    const outPath = path.join(cwd, '.github', outName);
+    const modEntries = modules[mod];
+
+    // Per-module budget: proportional share of maxTokens
+    const modBudget = Math.max(1000, Math.floor(config.maxTokens / moduleNames.length));
+    const budgeted = applyTokenBudget(modEntries, modBudget);
+
+    const content = formatOutput(budgeted, cwd, false);
+    ensureDir(outPath);
+    fs.writeFileSync(outPath, content, 'utf8');
+    const modTokens = estimateTokens(content);
+    totalOut += modTokens;
+    console.warn(`[sigmap] per-module: wrote .github/${outName} (~${modTokens} tokens, ${budgeted.length} files)`);
+
+    overviewLines.push(`| \`${mod}\` | \`.github/${outName}\` |`);
+  }
+
+  overviewLines.push('');
+  overviewLines.push('> Inject the relevant module file into your IDE context window.');
+  overviewLines.push('> For cross-module questions load both files.');
+  const overviewContent = overviewLines.join('\n') + '\n';
+  const primaryTargets = (config.outputs || ['copilot']).filter((t) => t !== 'claude');
+  writeOutputs(overviewContent, primaryTargets, cwd);
+
+  const overviewTokens = estimateTokens(overviewContent);
+  console.warn(`[sigmap] per-module: overview ~${overviewTokens} tokens (always-on), modules total ~${totalOut} tokens (on-demand)`);
+  return { inputTokenTotal, finalTokens: overviewTokens, fileCount: fileEntries.length, droppedCount: 0 };
+}
+
+// ---------------------------------------------------------------------------
+// Strategy: hot/cold — hot injected always, cold available via MCP only
+// ---------------------------------------------------------------------------
+function runHotColdStrategy(cwd, config, fileEntries, recentFiles, inputTokenTotal) {
+  const hotEntries = fileEntries.filter((e) => recentFiles.has(e.filePath));
+  const coldEntries = fileEntries.filter((e) => !recentFiles.has(e.filePath));
+
+  // Hot → primary output (auto-injected by IDE)
+  const hotContent = hotEntries.length > 0
+    ? formatOutput(hotEntries, cwd, false)
+    : '<!-- Generated by SigMap — no recently changed files -->\n';
+  const primaryTargets = (config.outputs || ['copilot']).filter((t) => t !== 'claude');
+  writeOutputs(hotContent, primaryTargets, cwd);
+  const hotTokens = estimateTokens(hotContent);
+
+  // Cold → .github/context-cold.md (MCP reads this on demand)
+  const coldPath = path.join(cwd, '.github', 'context-cold.md');
+  const coldHeader = [
+    '<!-- Generated by SigMap gen-context.js v' + VERSION + ' — cold context (MCP only) -->',
+    '<!-- NOT auto-injected. Retrieve via MCP: read_context({ module: "..." }) -->',
+    '',
+  ].join('\n');
+  const coldContent = coldHeader + formatOutput(coldEntries, cwd, false);
+  ensureDir(coldPath);
+  fs.writeFileSync(coldPath, coldContent, 'utf8');
+  const coldTokens = estimateTokens(coldContent);
+
+  console.warn('[sigmap] hot-cold:');
+  console.warn(`  hot  (auto-injected) : ${hotEntries.length} files ~${hotTokens} tokens → primary output`);
+  console.warn(`  cold (MCP on-demand) : ${coldEntries.length} files ~${coldTokens} tokens → .github/context-cold.md`);
+  if (coldEntries.length > 0) {
+    console.warn('  retrieve cold: read_context({ module: "<dir>" }) via MCP');
+  }
+
+  return { inputTokenTotal, finalTokens: hotTokens, fileCount: fileEntries.length, droppedCount: 0 };
+}
+
+// ---------------------------------------------------------------------------
+// Diff-mode pipeline — context for changed files only
+// ---------------------------------------------------------------------------
+function runDiff(cwd, config, stagedOnly) {
+  const diffFiles = getDiffFiles(cwd, stagedOnly);
+
+  if (diffFiles.size === 0) {
+    const scope = stagedOnly ? 'staged' : 'working tree';
+    console.warn(`[sigmap] --diff: no changed files found in ${scope} — running full generate`);
+    runGenerate(cwd, config, false);
+    return;
+  }
+
+  const ignorePatterns = loadIgnorePatterns(cwd);
+  let allFiles = buildFileList(cwd, config);
+  allFiles = allFiles.filter((f) => {
+    const rel = path.relative(cwd, f).replace(/\\/g, '/');
+    return !matchesIgnore(rel, ignorePatterns);
+  });
+
+  // Restrict to diff files, keeping only those already in srcDirs
+  const diffFiltered = allFiles.filter((f) => diffFiles.has(f));
+
+  if (diffFiltered.length === 0) {
+    console.warn('[sigmap] --diff: changed files are outside tracked srcDirs — running full generate');
+    runGenerate(cwd, config, false);
+    return;
+  }
+
+  let inputTokenTotal = 0;
+  let fileEntries = [];
+
+  for (const filePath of diffFiltered) {
+    let content = '';
+    try {
+      content = fs.readFileSync(filePath, 'utf8');
+    } catch (_) {
+      continue;
+    }
+
+    let sigs = detectAndExtract(filePath, content, config.maxSigsPerFile);
+    if (sigs.length === 0) continue;
+
+    inputTokenTotal += estimateTokens(content);
+
+    if (config.secretScan) {
+      const { scan } = __require('./src/security/scanner');
+      const result = scan(sigs, filePath);
+      if (result.redacted) {
+        console.warn(`[sigmap] secrets redacted in ${path.relative(cwd, filePath)}`);
+      }
+      sigs = result.safe;
+    }
+
+    fileEntries.push({ filePath, sigs, mtime: Date.now() });
+  }
+
+  if (fileEntries.length === 0) {
+    console.warn('[sigmap] --diff: no extractable signatures in changed files — running full generate');
+    runGenerate(cwd, config, false);
+    return;
+  }
+
+  const routingEnabled = !!(config.routing || process.argv.includes('--routing'));
+  const content = formatOutput(fileEntries, cwd, routingEnabled);
+  const finalTokens = estimateTokens(content);
+  writeOutputs(content, config.outputs, cwd);
+
+  const scope = stagedOnly ? 'staged' : 'diff';
+  console.warn(`[sigmap] ${scope} files: ${fileEntries.length}, diff tokens: ~${finalTokens}`);
+
+  if (process.argv.includes('--report')) {
+    // Also show what the full run would cost for comparison
+    const fullResult = runGenerate(cwd, config, true);
+    console.log(`[sigmap] diff report:`);
+    console.log(`  mode            : ${scope}`);
+    console.log(`  diff files      : ${fileEntries.length}`);
+    console.log(`  diff tokens     : ~${finalTokens}`);
+    console.log(`  full tokens     : ~${fullResult.finalTokens}`);
+    console.log(`  savings         : ~${fullResult.finalTokens - finalTokens} tokens`);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Core generate pipeline
+// ---------------------------------------------------------------------------
+function runGenerate(cwd, config, reportMode, reportJson = false) {
+  const ignorePatterns = loadIgnorePatterns(cwd);
+  let allFiles = buildFileList(cwd, config);
+
+  // Apply .contextignore
+  allFiles = allFiles.filter((f) => {
+    const rel = path.relative(cwd, f).replace(/\\/g, '/');
+    return !matchesIgnore(rel, ignorePatterns);
+  });
+
+  // Gather mtime and git-committed info
+  const hotCommits = config.hotCommits || 10;
+  const recentFiles = config.diffPriority ? getRecentlyCommittedFiles(cwd, hotCommits) : new Set();
+
+  let inputTokenTotal = 0;
+  let fileEntries = [];
+
+  for (const filePath of allFiles) {
+    let content = '';
+    try {
+      content = fs.readFileSync(filePath, 'utf8');
+    } catch (_) {
+      continue;
+    }
+
+    let sigs = detectAndExtract(filePath, content, config.maxSigsPerFile);
+    if (sigs.length === 0) continue;
+
+    // Baseline = estimated tokens of original source content for intuitive reduction stats.
+    inputTokenTotal += estimateTokens(content);
+
+    if (config.secretScan) {
+      const { scan } = __require('./src/security/scanner');
+      const result = scan(sigs, filePath);
+      if (result.redacted) {
+        console.warn(`[sigmap] secrets redacted in ${path.relative(cwd, filePath)}`);
+      }
+      sigs = result.safe;
+    }
+
+    let mtime = 0;
+    try {
+      mtime = fs.statSync(filePath).mtimeMs;
+    } catch (_) {}
+
+    // Boost recently committed files (give them max mtime so they aren't dropped first)
+    if (recentFiles.has(filePath)) mtime = Date.now();
+
+    fileEntries.push({ filePath, sigs, mtime });
+  }
+
+  const strategy = config.strategy || 'full';
+  const beforeCount = fileEntries.length;
+
+  // Sort for output ordering: recently committed files appear first
+  if (config.diffPriority && recentFiles.size > 0) {
+    fileEntries.sort((a, b) => {
+      const aRecent = recentFiles.has(a.filePath) ? 0 : 1;
+      const bRecent = recentFiles.has(b.filePath) ? 0 : 1;
+      return aRecent - bRecent;
+    });
+  }
+
+  let result;
+  if (!reportMode) {
+    if (strategy === 'per-module') {
+      result = runPerModuleStrategy(cwd, config, fileEntries, inputTokenTotal);
+    } else if (strategy === 'hot-cold') {
+      result = runHotColdStrategy(cwd, config, fileEntries, recentFiles, inputTokenTotal);
+    } else {
+      // 'full' — original behaviour
+      fileEntries = applyTokenBudget(fileEntries, config.maxTokens);
+      const droppedCount = beforeCount - fileEntries.length;
+      const routingEnabled = !!(config.routing || process.argv.includes('--routing'));
+      const content = formatOutput(fileEntries, cwd, routingEnabled);
+      const finalTokens = estimateTokens(content);
+      const formatIdx = process.argv.indexOf('--format');
+      const formatValue = formatIdx >= 0 ? process.argv[formatIdx + 1] : (config.format || 'default');
+      writeOutputs(content, config.outputs, cwd);
+      if (formatValue === 'cache') writeCacheOutput(content, cwd);
+      result = { inputTokenTotal, finalTokens, fileCount: beforeCount, droppedCount };
+    }
+  } else {
+    // report mode: always run full pipeline for accurate stats
+    const budgeted = applyTokenBudget([...fileEntries], config.maxTokens);
+    const droppedCount = beforeCount - budgeted.length;
+    const content = formatOutput(budgeted, cwd, false);
+    const finalTokens = estimateTokens(content);
+    result = { inputTokenTotal, finalTokens, fileCount: beforeCount, droppedCount };
+  }
+
+  if (reportMode || process.argv.includes('--report')) {
+    printReport(result.inputTokenTotal, result.finalTokens, result.fileCount, result.droppedCount, reportJson, config.maxTokens);
+  }
+
+  // Usage tracking (v0.9) — optional append-only NDJSON log
+  const trackingEnabled = !!(config.tracking || process.argv.includes('--track'));
+  if (trackingEnabled && !reportMode) {
+    try {
+      const { logRun } = __require('./src/tracking/logger');
+      logRun({
+        version: VERSION,
+        fileCount: result.fileCount,
+        droppedCount: result.droppedCount,
+        rawTokens: result.inputTokenTotal,
+        finalTokens: result.finalTokens,
+        overBudget: result.finalTokens > config.maxTokens,
+        budgetLimit: config.maxTokens,
+      }, cwd);
+    } catch (err) {
+      console.warn(`[sigmap] tracking: ${err.message}`);
+    }
+  }
+
+  return result;
+}
+
+// ---------------------------------------------------------------------------
+// Monorepo support
+// ---------------------------------------------------------------------------
+const MONO_ROOTS  = ['packages', 'apps', 'services', 'libs'];
+const PKG_MANIFESTS = ['package.json', 'pyproject.toml', 'Cargo.toml', 'go.mod', 'build.gradle', 'pom.xml'];
+
+function detectMonorepoPackages(cwd) {
+  const packages = [];
+  for (const monoDir of MONO_ROOTS) {
+    const abs = path.join(cwd, monoDir);
+    if (!fs.existsSync(abs)) continue;
+    let entries;
+    try { entries = fs.readdirSync(abs, { withFileTypes: true }); } catch (_) { continue; }
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const pkgPath = path.join(abs, entry.name);
+      for (const manifest of PKG_MANIFESTS) {
+        if (fs.existsSync(path.join(pkgPath, manifest))) {
+          packages.push(pkgPath);
+          break;
+        }
+      }
+    }
+  }
+  return packages;
+}
+
+function runMonorepo(cwd, config) {
+  const packages = detectMonorepoPackages(cwd);
+  if (packages.length === 0) {
+    console.warn('[sigmap] no monorepo packages found — checked packages/, apps/, services/, libs/');
+    return;
+  }
+  console.warn(`[sigmap] monorepo: found ${packages.length} packages`);
+
+  for (const pkgPath of packages) {
+    const pkgName = path.relative(cwd, pkgPath);
+    console.warn(`[sigmap] monorepo: processing ${pkgName}`);
+    // Per-package config: scan src/ and package root, write CLAUDE.md per package
+    const pkgConfig = {
+      ...config,
+      srcDirs: ['src', 'lib', 'app', '.'],
+      outputs: ['claude'],
+    };
+    try {
+      runGenerate(pkgPath, pkgConfig, false);
+    } catch (err) {
+      console.warn(`[sigmap] monorepo: failed for ${pkgName}: ${err.message}`);
+    }
+  }
+  console.warn(`[sigmap] monorepo: wrote CLAUDE.md for ${packages.length} packages`);
+}
+
+// ---------------------------------------------------------------------------
+// CLI entry point
+// ---------------------------------------------------------------------------
+/**
+ * Classify a task description and return the recommended model tier.
+ *
+ * Rules (ordered):
+ *  1. Match any 'powerful' keyword → 'powerful'
+ *  2. Match any 'fast' keyword     → 'fast'
+ *  3. Default                      → 'balanced'
+ *
+ * @param {string} description - Natural-language task description
+ * @returns {{ tier: string, label: string, models: string, costHint: string }}
+ */
+function suggestTool(description) {
+  const lower = description.toLowerCase();
+  const { TIERS } = __require('./src/routing/hints');
+
+  const powerfulKeywords = [
+    'architecture', 'cross-cutting', 'multi-file', 'security audit', 'owasp',
+    'migration plan', 'framework upgrade', 'complex debug', 'async boundar',
+    'multi-service', 'distributed system', 'performance audit', 'new module from',
+    'redesign', 'from requirements',
+  ];
+  const fastKeywords = [
+    'typo', 'rename symbol', 'format', 'lint', 'style change', 'trivial',
+    'quick fix', 'inline suggest', 'autocomplete', 'config file',
+    'dockerfile', 'shell script', '.yaml', '.yml', '.json', '.css',
+    'html template', 'markup',
+  ];
+
+  let tier = 'balanced';
+  if (powerfulKeywords.some((kw) => lower.includes(kw))) tier = 'powerful';
+  else if (fastKeywords.some((kw) => lower.includes(kw))) tier = 'fast';
+
+  const info = TIERS[tier];
+  return { tier, label: info.label, models: info.examples, costHint: info.costHint };
+}
+
+function resolveProjectRoot(startDir) {
+  try {
+    const gitRoot = execSync('git rev-parse --show-toplevel', {
+      cwd: startDir,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+    }).trim();
+    if (gitRoot) return gitRoot;
+  } catch (_) {}
+  return startDir;
+}
+
+function printHelp() {
+  console.log(`
+SigMap — gen-context.js v${VERSION}
+Zero-dependency AI context engine
+
+Usage:
+  node gen-context.js                                   Generate context once and exit
+  node gen-context.js --monorepo                        Generate per-package context (monorepo)
+  node gen-context.js --routing                         Include model routing hints in output
+  node gen-context.js --format cache                    Also write Anthropic prompt-cache JSON
+  node gen-context.js --track                           Append run metrics to .context/usage.ndjson
+  node gen-context.js --watch                           Generate + watch for file changes
+  node gen-context.js --setup                           Generate + install git hook + watch
+  node gen-context.js --mcp                             Start MCP server on stdio
+  node gen-context.js --report                          Token reduction stats to stdout
+  node gen-context.js --report --json                   Token report as JSON (for CI; exits 1 if over budget)
+  node gen-context.js --report --history                Print usage log summary from .context/usage.ndjson
+  node gen-context.js --suggest-tool "<task>"           Recommend model tier for a task description
+  node gen-context.js --suggest-tool "<task>" --json    Machine-readable tier recommendation
+  node gen-context.js --health                          Print composite health score
+  node gen-context.js --health --json                   Machine-readable health score
+  node gen-context.js --diff                            Generate context for git-changed files only
+  node gen-context.js --diff --staged                   Generate context for staged files only
+  node gen-context.js --init                            Write example config + .contextignore scaffold
+  node gen-context.js --help                            Show this message
+  node gen-context.js --version                         Show version
+
+Strategies (set via config "strategy" key):
+  "full"        Single file, all signatures. Works everywhere. (default)
+  "per-module"  One .github/context-<module>.md per srcDir + thin overview.
+                ~70% fewer tokens per question. No MCP needed.
+  "hot-cold"    Hot (recently changed) auto-injected; cold in .github/context-cold.md
+                ~90% fewer tokens. Best with MCP (Claude Code, Cursor).
+                Set "hotCommits": N to control how many commits count as hot (default 10).
+
+Config: gen-context.config.json
+Ignore: .contextignore, .repomixignore
+Output: .github/copilot-instructions.md (default)
+`);
+}
+
+// ---------------------------------------------------------------------------
+// MCP auto-registration
+// ---------------------------------------------------------------------------
+function registerMcp(cwd, scriptPath) {
+  const serverEntry = {
+    command: 'node',
+    args: [path.resolve(scriptPath), '--mcp'],
+  };
+
+  const targets = [
+    path.join(cwd, '.claude', 'settings.json'),
+    path.join(cwd, '.cursor', 'mcp.json'),
+  ];
+
+  for (const settingsPath of targets) {
+    if (!fs.existsSync(settingsPath)) continue;
+    try {
+      const raw = fs.readFileSync(settingsPath, 'utf8');
+      const settings = JSON.parse(raw);
+      if (!settings.mcpServers) settings.mcpServers = {};
+      if (settings.mcpServers['sigmap']) continue; // already registered
+      settings.mcpServers['sigmap'] = serverEntry;
+      fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n');
+      console.warn(`[sigmap] registered MCP server in ${path.relative(cwd, settingsPath)}`);
+    } catch (err) {
+      console.warn(`[sigmap] could not update ${path.relative(cwd, settingsPath)}: ${err.message}`);
+    }
+  }
+
+  // Always print the manual snippet so users can configure other tools
+  console.warn('[sigmap] MCP server config snippet:');
+  console.warn(JSON.stringify({ mcpServers: { 'sigmap': serverEntry } }, null, 2));
+}
+
+function main() {
+  const args = process.argv.slice(2);
+  const invokedFrom = process.cwd();
+  const cwd = resolveProjectRoot(invokedFrom);
+  const scriptPath = process.argv[1] || path.join(invokedFrom, 'gen-context.js');
+
+  if (cwd !== invokedFrom) {
+    console.warn(`[sigmap] using project root: ${cwd}`);
+  }
+
+  if (args.includes('--help') || args.includes('-h')) {
+    printHelp();
+    process.exit(0);
+  }
+
+  if (args.includes('--version') || args.includes('-v')) {
+    console.log(VERSION);
+    process.exit(0);
+  }
+
+  // MCP server — start before loading config (reads files on demand)
+  if (args.includes('--mcp')) {
+    const { start } = __require('./src/mcp/server');
+    start(cwd);
+    return; // keep process alive — server drives lifecycle via stdin
+  }
+
+  const config = loadConfig(cwd);
+
+  if (args.includes('--init')) {
+    writeInitConfig(cwd);
+    process.exit(0);
+  }
+
+  if (args.includes('--health')) {
+    const { score } = __require('./src/health/scorer');
+    const result = score(cwd);
+    if (args.includes('--json')) {
+      process.stdout.write(JSON.stringify(result) + '\n');
+    } else {
+      console.log('[sigmap] health:');
+      console.log(`  score           : ${result.score}/100 (grade ${result.grade})`);
+      console.log(`  strategy        : ${result.strategy}`);
+      console.log(`  token reduction : ${result.tokenReductionPct !== null ? result.tokenReductionPct + '%' : 'no history'}`);
+      console.log(`  days since regen: ${result.daysSinceRegen !== null ? result.daysSinceRegen : 'context file not found'}`);
+      if (result.strategyFreshnessDays !== null) {
+        console.log(`  cold freshness  : ${result.strategyFreshnessDays} day(s)`);
+      }
+      console.log(`  total runs      : ${result.totalRuns}`);
+      console.log(`  over-budget runs: ${result.overBudgetRuns}`);
+    }
+    process.exit(0);
+  }
+
+  if (args.includes('--suggest-tool')) {
+    const idx = args.indexOf('--suggest-tool');
+    const taskDesc = (args[idx + 1] || '').trim();
+    if (!taskDesc || taskDesc.startsWith('--')) {
+      console.error('[sigmap] --suggest-tool requires a task description');
+      console.error('  Example: node gen-context.js --suggest-tool "refactor the auth module"');
+      process.exit(1);
+    }
+    const result = suggestTool(taskDesc);
+    if (args.includes('--json')) {
+      process.stdout.write(JSON.stringify(result) + '\n');
+    } else {
+      console.log('[sigmap] suggest-tool:');
+      console.log(`  tier   : ${result.tier}`);
+      console.log(`  label  : ${result.label}`);
+      console.log(`  models : ${result.models}`);
+      console.log(`  cost   : ${result.costHint}`);
+    }
+    process.exit(0);
+  }
+
+  if (args.includes('--report')) {
+    if (args.includes('--history')) {
+      try {
+        const { readLog, summarize } = __require('./src/tracking/logger');
+        const entries = readLog(cwd);
+        const summary = summarize(entries);
+        if (args.includes('--json')) {
+          process.stdout.write(JSON.stringify(summary) + '\n');
+        } else {
+          console.log('[sigmap] usage history:');
+          console.log(`  total runs      : ${summary.totalRuns}`);
+          console.log(`  avg reduction   : ${summary.avgReductionPct}%`);
+          console.log(`  avg tokens out  : ~${summary.avgFinalTokens}`);
+          console.log(`  over-budget runs: ${summary.overBudgetRuns}`);
+          if (summary.firstRun) console.log(`  first run       : ${summary.firstRun}`);
+          if (summary.lastRun)  console.log(`  last run        : ${summary.lastRun}`);
+        }
+      } catch (err) {
+        console.warn(`[sigmap] tracking: ${err.message}`);
+      }
+      process.exit(0);
+    }
+    runGenerate(cwd, config, true, args.includes('--json'));
+    process.exit(0);
+  }
+
+  if (args.includes('--monorepo') || config.monorepo) {
+    runMonorepo(cwd, config);
+    process.exit(0);
+  }
+
+  if (args.includes('--setup')) {
+    runGenerate(cwd, config, false);
+    installHook(cwd, scriptPath);
+    registerMcp(cwd, scriptPath);
+    watchMode(cwd, config);
+    return; // keep process alive for watch
+  }
+
+  if (args.includes('--watch')) {
+    runGenerate(cwd, config, false);
+    watchMode(cwd, config);
+    return; // keep process alive
+  }
+
+  if (args.includes('--diff')) {
+    runDiff(cwd, config, args.includes('--staged'));
+    process.exit(0);
+  }
+
+  // Default: generate once
+  runGenerate(cwd, config, false);
+}
+
+main();