sigmap 3.5.0 → 3.6.0

package/AGENTS.md

@@ -12,46 +12,19 @@ Use this marker block for all appendable context files:
 ## Auto-generated signatures
 <!-- Updated by gen-context.js -->
 You are a coding assistant with full knowledge of this codebase.
-Below are the code signatures extracted by SigMap v3.4.0 on 2026-04-14T21:21:26.681Z.
+Below are the code signatures extracted by SigMap v3.5.1 on 2026-04-14T23:05:11.451Z.
 
 Use these signatures to answer questions about the code accurately.
 
 ## Code Signatures
 
-<!-- Generated by SigMap gen-context.js v3.4.0 -->
+<!-- Generated by SigMap gen-context.js v3.5.1 -->
 <!-- DO NOT EDIT below the marker line — run gen-context.js to regenerate -->
 
 # Code signatures
 
-## changes (last 5 commits — 11 minutes ago)
-```
-src/config/loader.js                          ~detectAutoSrcDirs
-src/eval/analyzer.js                          ~isDockerfile
-src/extractors/markdown.js                    +extract
-src/extractors/properties.js                  +extract
-src/extractors/toml.js                        +extract
-src/extractors/xml.js                         +attributes  +extract
-```
-
 ## packages
 
-### packages/adapters/codex.js
-```
-module.exports = { name, format, outputPath, write }
-function format(context, opts = {}) → string
-function outputPath(cwd) → string
-function write(context, cwd, opts = {})
-```
-
-### packages/adapters/index.js
-```
-module.exports = { getAdapter, listAdapters, adapt, outputsToAdapters }
-function getAdapter(name) → { name: string, format: F
-function listAdapters() → string[]
-function adapt(context, adapterName, opts = {}) → string
-function outputsToAdapters(outputs) → string[]
-```
-
 ### packages/core/index.js
 ```
 module.exports = { extract, rank, buildSigIndex, scan, score, adapt }
@@ -72,6 +45,14 @@ function outputPath(cwd) → string
 function write(context, cwd, opts = {})
 ```
 
+### packages/adapters/codex.js
+```
+module.exports = { name, format, outputPath, write }
+function format(context, opts = {}) → string
+function outputPath(cwd) → string
+function write(context, cwd, opts = {})
+```
+
 ### packages/adapters/copilot.js
 ```
 module.exports = { name, format, outputPath, write }
@@ -95,6 +76,23 @@ function outputPath(cwd) → string
 function write(context, cwd, opts = {})
 ```
 
+### packages/adapters/index.js
+```
+module.exports = { getAdapter, listAdapters, adapt, outputsToAdapters }
+function getAdapter(name) → { name: string, format: F
+function listAdapters() → string[]
+function adapt(context, adapterName, opts = {}) → string
+function outputsToAdapters(outputs) → string[]
+```
+
+### packages/adapters/llm-full.js
+```
+module.exports = { name: 'llm-full', format, outputPath, write }
+function outputPath(cwd)
+function format(context, opts)
+function write(context, cwd, opts)
+```
+
 ### packages/adapters/openai.js
 ```
 module.exports = { name, format, outputPath }
@@ -163,13 +161,13 @@ function formatAnalysisTable(stats, showSlow) → string
 function formatAnalysisJSON(stats) → object
 ```
 
-### src/extractors/graphql.js
+### src/extractors/markdown.js
 ```
 module.exports = { extract }
 function extract(src) → string[]
 ```
 
-### src/extractors/markdown.js
+### src/extractors/patterns.js
 ```
 module.exports = { extract }
 function extract(src) → string[]
@@ -181,27 +179,25 @@ module.exports = { extract }
 function extract(src) → string[]
 ```
 
-### src/extractors/protobuf.js
+### src/extractors/python_dataclass.js
 ```
 module.exports = { extract }
 function extract(src) → string[]
 ```
 
-### src/extractors/sql.js
+### src/extractors/toml.js
 ```
 module.exports = { extract }
 function extract(src) → string[]
-function _cleanName(raw)
-function _normalizeParams(raw)
 ```
 
-### src/extractors/terraform.js
+### src/extractors/typescript_react.js
 ```
 module.exports = { extract }
 function extract(src) → string[]
 ```
 
-### src/extractors/toml.js
+### src/extractors/vue_sfc.js
 ```
 module.exports = { extract }
 function extract(src) → string[]
@@ -305,6 +301,12 @@ module.exports = { extract }
 function extract(src) → string[]
 ```
 
+### src/extractors/generic.js
+```
+module.exports = { extract }
+function extract(src)
+```
+
 ### src/extractors/go.js
 ```
 module.exports = { extract }
@@ -314,6 +316,12 @@ function extractInterfaceMethods(block)
 function normalizeParams(params)
 ```
 
+### src/extractors/graphql.js
+```
+module.exports = { extract }
+function extract(src) → string[]
+```
+
 ### src/extractors/html.js
 ```
 module.exports = { extract }
@@ -368,6 +376,12 @@ function diffSignatures(baseSigs, currentSigs) → {added:string[], removed:
 function extractName(sig)
 ```
 
+### src/extractors/protobuf.js
+```
+module.exports = { extract }
+function extract(src) → string[]
+```
+
 ### src/extractors/python.js
 ```
 module.exports = { extract }
@@ -381,12 +395,6 @@ function normalizeParams(params)
 function extractDocHint(src, fnName, fnSigLine)
 ```
 
-### src/extractors/python_dataclass.js
-```
-module.exports = { extract }
-function extract(src) → string[]
-```
-
 ### src/extractors/ruby.js
 ```
 module.exports = { extract }
@@ -421,6 +429,14 @@ module.exports = { extract }
 function extract(src) → string[]
 ```
 
+### src/extractors/sql.js
+```
+module.exports = { extract }
+function extract(src) → string[]
+function _cleanName(raw)
+function _normalizeParams(raw)
+```
+
 ### src/extractors/svelte.js
 ```
 module.exports = { extract }
@@ -439,6 +455,12 @@ function normalizeParams(params)
 function extractArrowType(str)
 ```
 
+### src/extractors/terraform.js
+```
+module.exports = { extract }
+function extract(src) → string[]
+```
+
 ### src/extractors/todos.js
 ```
 module.exports = { extractTodos }
@@ -455,12 +477,6 @@ function extractClassMembers(block)
 function normalizeParams(params)
 ```
 
-### src/extractors/typescript_react.js
-```
-module.exports = { extract }
-function extract(src) → string[]
-```
-
 ### src/extractors/vue.js
 ```
 module.exports = { extract }
@@ -469,12 +485,6 @@ function normalizeParams(params)
 function normalizeType(type)
 ```
 
-### src/extractors/vue_sfc.js
-```
-module.exports = { extract }
-function extract(src) → string[]
-```
-
 ### src/extractors/yaml.js
 ```
 module.exports = { extract }
@@ -508,6 +518,22 @@ function generateDashboardHtml(cwd, health)
 function renderHistoryCharts(cwd, health)
 ```
 
+### src/format/llm-txt.js
+```
+module.exports = { format, outputPath }
+function outputPath(cwd)
+function format(context, cwd, version)
+```
+
+### src/format/llms-txt.js
+```
+module.exports = { format, outputPath }
+function outputPath(cwd)
+function getShortCommit(cwd)
+function detectVersion(cwd)
+function format(context, cwd, writtenFiles, sigmapVersion)
+```
+
 ### src/graph/builder.js
 ```
 module.exports = { build, buildFromCwd, extractFileDeps }

package/README.md

@@ -1,6 +1,6 @@
 <div align="center">
 
-<img src="docs-vp/.vitepress/public/logo.svg" alt="SigMap logo" width="64" height="84" />
+<img src="assets/logo.png" alt="SigMap logo" width="80" height="80" />
 
 <h1>⚡ SigMap</h1>
 
@@ -50,15 +50,15 @@ npx sigmap   # 10 seconds. zero config. your AI never reads the wrong file again
 
 <div align="center">
 <img src="docs/comparison-chart.svg" alt="SigMap benchmark — before vs after across 3 RAG quality metrics" width="700" />
-<br/><sub><a href="https://manojmallick.github.io/sigmap/guide/task-benchmark.html">80 tasks · 16 real repos · no LLM API · <strong>full methodology →</strong></a></sub>
+<br/><sub><a href="https://manojmallick.github.io/sigmap/guide/task-benchmark.html">90 tasks · 18 real repos · no LLM API · <strong>full methodology →</strong></a></sub>
 </div>
 
 | | Without SigMap | With SigMap |
 |---|:---:|:---:|
 | Task success | 10% | **59%** |
-| Prompts per task | 2.84 | **1.54** |
+| Prompts per task | 2.84 | **1.78** |
 | Tokens per session | ~80,000 | **~2,000** |
-| Right file found | 13.7% | **87.5%** |
+| Right file found | 13.6% | **84.4%** |
 | Hallucination risk | 92% | **0%** |
 
 </details>
@@ -126,24 +126,26 @@ Reproduced with `node scripts/run-benchmark.mjs` on public repos:
 
 | Repo | Language | Raw tokens | After SigMap | Reduction |
 |------|----------|------------|--------------|-----------|
-| express | JavaScript | 15.5K | 201 | **98.7%** |
-| flask | Python | 84.8K | 3.4K | **96.0%** |
-| gin | Go | 172.8K | 5.7K | **96.7%** |
-| spring-petclinic | Java | 77.0K | 634 | **99.2%** |
+| express | JavaScript | 70.6K | 911 | **98.7%** |
+| flask | Python | 147.9K | 6.7K | **95.4%** |
+| gin | Go | 216.4K | 6.0K | **97.2%** |
+| spring-petclinic | Java | 97.9K | 3.4K | **96.5%** |
 | rails | Ruby | 1.5M | 7.1K | **99.5%** |
-| axios | TypeScript | 31.7K | 1.5K | **95.2%** |
-| rust-analyzer | Rust | 3.5M | 5.9K | **99.8%** |
+| axios | TypeScript | 105.7K | 6.1K | **94.3%** |
+| rust-analyzer | Rust | 3.5M | 6.3K | **99.8%** |
 | abseil-cpp | C++ | 2.3M | 6.3K | **99.7%** |
-| serilog | C# | 113.7K | 5.8K | **94.9%** |
-| riverpod | Dart | 682.7K | 6.5K | **99.0%** |
+| serilog | C# | 195.5K | 6.9K | **96.4%** |
+| riverpod | Dart | 747.2K | 6.5K | **99.1%** |
 | okhttp | Kotlin | 31.3K | 1.4K | **95.5%** |
 | laravel | PHP | 1.7M | 7.2K | **99.6%** |
 | akka | Scala | 790.5K | 7.1K | **99.1%** |
-| vapor | Swift | 171.2K | 6.4K | **96.3%** |
-| vue-core | Vue | 404.2K | 8.8K | **97.8%** |
+| vapor | Swift | 171.4K | 6.4K | **96.2%** |
+| vue-core | Vue | 414.4K | 8.6K | **97.9%** |
 | svelte | Svelte | 438.2K | 8.0K | **98.2%** |
+| fastify | JavaScript | 54.4K | 2.6K | **95.3%** |
+| fastapi | Python | 178.4K | 5.2K | **97.1%** |
 
-**Average: 99.3% reduction across 16 languages.** See [`benchmarks/reports/token-reduction.md`](benchmarks/reports/token-reduction.md) or reproduce with `node scripts/run-benchmark.mjs`.
+**Average: 97.5% reduction across 18 repos (16 languages).** See [`benchmarks/reports/token-reduction.md`](benchmarks/reports/token-reduction.md) or reproduce with `node scripts/run-benchmark.mjs`.
 
 ---
 
@@ -454,6 +456,10 @@ Activates on startup (`onStartupFinished`) — loads within 3 s, never blocks ed
 
 The official SigMap JetBrains plugin brings the same features to IntelliJ-based IDEs. Install it from the JetBrains Marketplace and it works identically to the VS Code extension.
 
+<div align="center">
+<img src="assets/intelij.gif" alt="SigMap JetBrains plugin — status bar health grade, regenerate action, and context auto-refresh in IntelliJ IDEA" width="700" />
+</div>
+
 | Feature | Detail |
 |---|---|
 | **Status bar widget** | Shows health grade (`A`-`F`) + time since last regen; updates every 60 s |

package/gen-context.js

@@ -5881,6 +5881,153 @@ __factories["./packages/adapters/index"] = function(module, exports) {
   module.exports = { getAdapter, listAdapters, adapt, outputsToAdapters };
 };
 
+// ── ./src/extractors/generic ──
+__factories["./src/extractors/generic"] = function(module, exports) {
+  'use strict';
+  const PATTERNS = [
+    /^(?:pub\s+)?(?:async\s+)?function\s+\w+\s*\(/,
+    /^(?:pub\s+)?(?:async\s+)?fn\s+\w+[\s(<]/,
+    /^def\s+\w+[\s(|:]/,
+    /^(?:pub\s+)?func\s+\w+\s*\(/,
+    /^(?:let|let\s+rec)\s+\w+\s*[=(]/,
+    /^class\s+\w+/,
+    /^(?:proc|sub|method)\s+\w+\s*\(/,
+  ];
+  function extract(src) {
+    if (!src || typeof src !== 'string') return [];
+    const results = [];
+    for (const raw of src.split('\n')) {
+      const line = raw.trim();
+      if (!line || /^[#\-]/.test(line) || /^\/\//.test(line) || line.includes('\0')) continue;
+      for (const pat of PATTERNS) {
+        if (pat.test(line)) { results.push(line.slice(0, 120)); break; }
+      }
+      if (results.length >= 15) break;
+    }
+    return results;
+  }
+  module.exports = { extract };
+};
+
+// ── ./src/format/llm-txt ──
+__factories["./src/format/llm-txt"] = function(module, exports) {
+  'use strict';
+  const path = require('path');
+  function outputPath(cwd) { return path.join(cwd, 'llm.txt'); }
+  function format(context, cwd, version) {
+    const name  = context.projectName || path.basename(cwd);
+    const langs = [...new Set((context.fileEntries || []).map(f => f.language).filter(Boolean))];
+    const mods  = context.srcDirs || [];
+    return [
+      `# Project: ${name}`,
+      `Languages: ${langs.join(', ') || 'unknown'}`,
+      `Root: ${mods[0] || 'src/'}`,
+      '',
+      '## Modules',
+      ...mods.map(m => `- ${m}/`),
+      '',
+      '## Key flows',
+      '- <!-- describe your main user flows here -->',
+      '',
+      '## Rules',
+      '- <!-- describe your team conventions here -->',
+      '',
+      `Generated: ${new Date().toISOString()} | SigMap v${version}`,
+    ].join('\n');
+  }
+  module.exports = { format, outputPath };
+};
+
+// ── ./src/format/llms-txt ──
+__factories["./src/format/llms-txt"] = function(module, exports) {
+  'use strict';
+  const path = require('path');
+  const fs   = require('fs');
+  const { execSync } = require('child_process');
+  function outputPath(cwd) { return path.join(cwd, 'llms.txt'); }
+  function getShortCommit(cwd) {
+    try { return execSync('git rev-parse --short HEAD', { cwd, timeout: 2000 }).toString().trim(); }
+    catch (_) { return ''; }
+  }
+  function detectVersion(cwd) {
+    try {
+      const pkg = path.join(cwd, 'package.json');
+      if (fs.existsSync(pkg)) return JSON.parse(fs.readFileSync(pkg, 'utf8')).version || '';
+    } catch (_) {}
+    return '';
+  }
+  function format(context, cwd, writtenFiles, sigmapVersion) {
+    writtenFiles  = writtenFiles  || [];
+    sigmapVersion = sigmapVersion || '';
+    const name   = context.projectName || path.basename(cwd);
+    const ver    = detectVersion(cwd);
+    const commit = getShortCommit(cwd);
+    const langs  = [...new Set((context.fileEntries || []).map(f => f.language).filter(Boolean))];
+    const lines = [
+      '# SigMap Context Index',
+      `> Generated by SigMap v${sigmapVersion} — zero-dependency AI context engine`,
+      '',
+      '## Project',
+      `- Name: ${name}`,
+    ];
+    if (ver)          lines.push(`- Version: ${ver}`);
+    if (langs.length) lines.push(`- Language: ${langs.join(', ')}`);
+    if (commit)       lines.push(`- Commit: ${commit}`);
+    if (writtenFiles.length) {
+      lines.push('', '## Context Files');
+      for (const f of writtenFiles) {
+        const rel   = path.relative(cwd, f.path);
+        const extra = f.tokens ? `: ${f.tokens} tokens` : '';
+        lines.push(`- [${f.label || rel}](${rel})${extra}`);
+      }
+    }
+    const mods = context.srcDirs || [];
+    if (mods.length) {
+      lines.push('', '## Source Modules');
+      for (const m of mods) lines.push(`- [${m}/](${m}/)`);
+    }
+    const top5 = (context.fileEntries || [])
+      .sort((a, b) => (b.sigs || []).length - (a.sigs || []).length)
+      .slice(0, 5);
+    if (top5.length) {
+      lines.push('', '## Key Files');
+      for (const f of top5) {
+        const rel     = path.relative(cwd, f.filePath);
+        const preview = (f.sigs || []).slice(0, 3).join(', ');
+        lines.push(`- ${rel}: ${preview}`);
+      }
+    }
+    return lines.join('\n');
+  }
+  module.exports = { format, outputPath };
+};
+
+// ── ./packages/adapters/llm-full ──
+__factories["./packages/adapters/llm-full"] = function(module, exports) {
+  'use strict';
+  const path = require('path');
+  const fs   = require('fs');
+  function outputPath(cwd) { return path.join(cwd, 'llm-full.txt'); }
+  function format(context, opts) {
+    opts = opts || {};
+    const lines = [
+      `# ${context.projectName || 'Project'} — SigMap Context`,
+      `Generated: ${new Date().toISOString()} | SigMap v${opts.version || ''}`,
+      '',
+    ];
+    for (const entry of (context.fileEntries || [])) {
+      const rel = path.relative(opts.cwd || '', entry.filePath);
+      lines.push(`## ${rel}`, '```', ...(entry.sigs || []), '```', '');
+    }
+    return lines.join('\n');
+  }
+  function write(context, cwd, opts) {
+    opts = opts || {};
+    fs.writeFileSync(outputPath(cwd), format(context, { ...opts, cwd }));
+  }
+  module.exports = { name: 'llm-full', format, outputPath, write };
+};
+
 /**
  * SigMap — gen-context.js v1.2.0
  * Zero-dependency AI context engine.
@@ -5893,7 +6040,7 @@ const path = require('path');
 const os = require('os');
 const { execSync } = require('child_process');
 
-const VERSION = '3.5.0';
+const VERSION = '3.6.0';
 const MARKER = '\n\n## Auto-generated signatures\n<!-- Updated by gen-context.js -->\n';
 
 function requireSourceOrBundled(key) {
@@ -6042,7 +6189,8 @@ function detectAndExtract(filePath, content, maxSigsPerFile) {
   const ext = path.extname(base).toLowerCase();
   let extractorName = EXT_MAP[ext] || null;
   if (!extractorName && isDockerfile(base)) extractorName = 'dockerfile';
-  if (!extractorName) return [];
+  // Feature 7: generic fallback — catches Nix, Elixir, Gleam, Zig, Go templates, etc.
+  if (!extractorName) extractorName = 'generic';
 
   const extractor = getExtractor(extractorName);
   if (!extractor) return [];
@@ -6122,12 +6270,13 @@ function applyTokenBudget(fileEntries, maxTokens) {
   // Sort by drop priority (drop first = index 0)
   const withPriority = fileEntries.map((e) => {
     let priority = 0;
-    if (isGeneratedFile(e.filePath)) priority = 10;
-    else if (isMockFile(e.filePath)) priority = 9;
-    else if (isTestFile(e.filePath)) priority = 8;
-    else if (isConfigFile(e.filePath)) priority = 6;
+    let dropReason = 'budget: low recency';
+    if (isGeneratedFile(e.filePath)) { priority = 10; dropReason = 'budget: generated file'; }
+    else if (isMockFile(e.filePath)) { priority = 9;  dropReason = 'budget: mock file'; }
+    else if (isTestFile(e.filePath)) { priority = 8;  dropReason = 'budget: test file'; }
+    else if (isConfigFile(e.filePath)) { priority = 6; dropReason = 'budget: config file'; }
     else priority = 4;
-    return { ...e, priority };
+    return { ...e, priority, dropReason };
   });
 
   // Within same priority, sort by mtime ascending (oldest first = drop first)
@@ -6137,20 +6286,27 @@ function applyTokenBudget(fileEntries, maxTokens) {
   });
 
   const kept = [];
-  let dropped = 0;
+  const verboseDropped = [];
   // Iterate forward: highest drop-priority files (generated=10, mock=9, test=8) are at index 0
   // Drop those first until we're under budget, then keep everything else
   for (const entry of withPriority) {
     const entryTokens = estimateTokens(entry.sigs.join('\n'));
     if (total > effectiveBudget) {
       total -= entryTokens;
-      dropped++;
+      verboseDropped.push({ filePath: entry.filePath, reason: entry.dropReason });
     } else {
       kept.push(entry);
     }
   }
-  if (dropped > 0) {
-    console.warn(`[sigmap] budget: dropped ${dropped} files to stay under ${maxTokens} tokens`);
+  if (verboseDropped.length > 0) {
+    console.warn(`[sigmap] budget: dropped ${verboseDropped.length} files to stay under ${maxTokens} tokens`);
+    // Feature 7: --verbose — print per-file drop reason
+    if (process.argv.includes('--verbose')) {
+      for (const { filePath, reason } of verboseDropped) {
+        console.warn(`[sigmap] dropped: ${path.relative(process.cwd(), filePath)} — ${reason}`);
+      }
+      console.warn(`[sigmap] included: ${kept.length} files, dropped: ${verboseDropped.length}`);
+    }
   }
   return kept;
 }
@@ -6980,7 +7136,37 @@ function runGenerate(cwd, config, reportMode, reportJson = false) {
       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, config);
+      // Feature 2: --mode write matrix
+      const activeMode = process.argv.indexOf('--mode') >= 0
+        ? process.argv[process.argv.indexOf('--mode') + 1]
+        : (config.mode || 'default');
+      if (activeMode === 'fast') {
+        const llmTxtMod = requireSourceOrBundled('./src/format/llm-txt');
+        const syncContext = { projectName: path.basename(cwd), fileEntries, srcDirs: config.srcDirs || [] };
+        fs.writeFileSync(llmTxtMod.outputPath(cwd), llmTxtMod.format(syncContext, cwd, VERSION));
+        console.warn(`[sigmap] --mode fast → llm.txt`);
+      } else if (activeMode === 'full') {
+        const llmFullMod = requireSourceOrBundled('./packages/adapters/llm-full');
+        const syncContext = { projectName: path.basename(cwd), fileEntries, srcDirs: config.srcDirs || [] };
+        llmFullMod.write(syncContext, cwd, { version: VERSION });
+        console.warn(`[sigmap] --mode full → llm-full.txt`);
+      } else if (activeMode === 'both') {
+        const llmTxtMod  = requireSourceOrBundled('./src/format/llm-txt');
+        const llmFullMod = requireSourceOrBundled('./packages/adapters/llm-full');
+        const llmsMod    = requireSourceOrBundled('./src/format/llms-txt');
+        const syncContext = { projectName: path.basename(cwd), fileEntries, srcDirs: config.srcDirs || [] };
+        fs.writeFileSync(llmTxtMod.outputPath(cwd),  llmTxtMod.format(syncContext, cwd, VERSION));
+        llmFullMod.write(syncContext, cwd, { version: VERSION });
+        writeOutputs(content, config.outputs, cwd, config);
+        const llmsContent = llmsMod.format(syncContext, cwd, [
+          { path: llmTxtMod.outputPath(cwd),  label: 'llm.txt' },
+          { path: llmFullMod.outputPath(cwd), label: 'llm-full.txt' },
+        ], VERSION);
+        fs.writeFileSync(llmsMod.outputPath(cwd), llmsContent);
+        console.warn(`[sigmap] --mode both → copilot-instructions.md + llm.txt + llm-full.txt + llms.txt`);
+      } else {
+        writeOutputs(content, config.outputs, cwd, config);
+      }
       if (formatValue === 'cache') writeCacheOutput(content, cwd);
       result = { inputTokenTotal, finalTokens, fileCount: beforeCount, droppedCount };
     }
@@ -7016,6 +7202,29 @@ function runGenerate(cwd, config, reportMode, reportJson = false) {
     }
   }
 
+  // Feature 8: post-run summary — 6-line stdout after every normal run
+  if (!reportMode
+    && !process.argv.includes('--json')
+    && !process.argv.includes('--report')
+    && !process.argv.includes('--quiet')) {
+    const bar  = '\u2500'.repeat(43);
+    const syms = fileEntries.reduce((n, f) => n + (f.sigs ? f.sigs.length : 0), 0);
+    const pct  = result.inputTokenTotal > 0
+      ? Math.round((1 - result.finalTokens / result.inputTokenTotal) * 100)
+      : 0;
+    process.stderr.write([
+      bar,
+      ` SigMap v${VERSION}`,
+      ` Files scanned  : ${result.fileCount}`,
+      ` Symbols found  : ${syms.toLocaleString()}`,
+      ` Token reduction: ${pct}%  (${result.inputTokenTotal.toLocaleString()} \u2192 ${result.finalTokens.toLocaleString()})`,
+      ` Output         : .github/copilot-instructions.md`,
+      bar,
+      ` Try: "explain the architecture" \u00b7 "find the auth module"`,
+      bar, '',
+    ].join('\n'));
+  }
+
   return result;
 }
 
@@ -7327,6 +7536,12 @@ function registerMcp(cwd, scriptPath) {
 
 function main() {
   const args = process.argv.slice(2);
+
+  // Feature 1: `sigmap run` alias — strip positional 'run' so existing logic handles it
+  if (args[0] === 'run' && !args[0].startsWith('--')) {
+    args.shift();
+  }
+
   const invokedFrom = process.cwd();
   const cwd = resolveProjectRoot(invokedFrom);
   const scriptPath = process.argv[1] || path.join(invokedFrom, 'gen-context.js');
@@ -7354,6 +7569,154 @@ function main() {
 
   const config = loadConfig(cwd);
 
+  // Feature 2: `--mode fast|full|both`
+  const modeIdx = args.indexOf('--mode');
+  const mode = modeIdx !== -1
+    ? args[modeIdx + 1]
+    : (config.mode || 'default');
+  const VALID_MODES = ['default', 'fast', 'full', 'both'];
+  if (mode && !VALID_MODES.includes(mode)) {
+    console.error(`[sigmap] unknown --mode "${mode}". Valid: ${VALID_MODES.join(', ')}`);
+    process.exit(1);
+  }
+
+  // Feature 6: `sigmap sync` — write all outputs + llms.txt + print compact diff
+  if (args[0] === 'sync') {
+    try {
+      // Generate copilot-instructions.md first (existing output)
+      runGenerate(cwd, config, false);
+      const llmTxt = requireSourceOrBundled('./src/format/llm-txt');
+      const llmsGen = requireSourceOrBundled('./src/format/llms-txt');
+      const llmFullMod = requireSourceOrBundled('./packages/adapters/llm-full');
+
+      // Gather file entries for llm.txt / llm-full.txt
+      const ignorePatterns = loadIgnorePatterns(cwd);
+      let syncFiles = buildFileList(cwd, config).filter((f) => {
+        const rel = path.relative(cwd, f).replace(/\\/g, '/');
+        return !matchesIgnore(rel, ignorePatterns);
+      });
+      const syncEntries = [];
+      for (const fp of syncFiles) {
+        let content = '';
+        try { content = fs.readFileSync(fp, 'utf8'); } catch (_) { continue; }
+        const sigs = detectAndExtract(fp, content, config.maxSigsPerFile || 25);
+        if (sigs.length === 0) continue;
+        syncEntries.push({ filePath: fp, sigs, language: null });
+      }
+      const syncContext = {
+        projectName: path.basename(cwd),
+        fileEntries: syncEntries,
+        srcDirs: config.srcDirs || [],
+      };
+
+      const llmTxtPath   = llmTxt.outputPath(cwd);
+      const llmFullPath  = llmFullMod.outputPath(cwd);
+      const llmsTxtPath  = llmsGen.outputPath(cwd);
+
+      fs.writeFileSync(llmTxtPath,  llmTxt.format(syncContext, cwd, VERSION));
+      llmFullMod.write(syncContext, cwd, { version: VERSION });
+
+      const prev  = fs.existsSync(llmsTxtPath) ? fs.readFileSync(llmsTxtPath, 'utf8') : '';
+      const next  = llmsGen.format(syncContext, cwd, [
+        { path: llmTxtPath,  label: 'llm.txt' },
+        { path: llmFullPath, label: 'llm-full.txt' },
+      ], VERSION);
+      const changed = prev !== next ? 'updated' : 'no change';
+      fs.writeFileSync(llmsTxtPath, next);
+
+      console.log('[sigmap] sync complete');
+      console.log(`  .github/copilot-instructions.md  updated`);
+      console.log(`  llm.txt                          updated`);
+      console.log(`  llm-full.txt                     updated`);
+      console.log(`  llms.txt                         ${changed}`);
+    } catch (err) {
+      console.error(`[sigmap] sync error: ${err.message}`);
+      process.exit(1);
+    }
+    process.exit(0);
+  }
+
+  // Feature 1: `sigmap explain <file>` — why a file is included or excluded
+  if (args[0] === 'explain' || args.includes('--explain')) {
+    const target = args[0] === 'explain'
+      ? args[1]
+      : args[args.indexOf('--explain') + 1];
+
+    if (!target || target.startsWith('--')) {
+      console.error('[sigmap] Usage: sigmap explain <file>');
+      process.exit(1);
+    }
+
+    const absPath = path.resolve(cwd, target);
+    const rel     = path.relative(cwd, absPath);
+    const jsonOut = args.includes('--json');
+
+    // 1. Check .contextignore
+    const ignorePatterns = loadIgnorePatterns(cwd);
+    const ignored = matchesIgnore(rel.replace(/\\/g, '/'), ignorePatterns);
+    if (ignored) {
+      if (jsonOut) {
+        process.stdout.write(JSON.stringify({ status: 'excluded', reason: '.contextignore', fix: `remove the pattern or add '!${rel}' as an exception` }) + '\n');
+      } else {
+        console.log(`[sigmap] ${rel} — EXCLUDED`);
+        console.log(`  Reason: matched .contextignore`);
+        console.log(`  Fix:    remove the pattern or add '!${rel}' as an exception`);
+      }
+      process.exit(0);
+    }
+
+    // 2. Check srcDirs membership
+    const inSrcDirs = (config.srcDirs || []).some(d => absPath.startsWith(path.resolve(cwd, d)));
+    if (!inSrcDirs) {
+      if (jsonOut) {
+        process.stdout.write(JSON.stringify({ status: 'excluded', reason: 'not in srcDirs', srcDirs: config.srcDirs, fix: 'add the containing directory to srcDirs in gen-context.config.json' }) + '\n');
+      } else {
+        console.log(`[sigmap] ${rel} — EXCLUDED`);
+        console.log(`  Reason: not under any srcDir (${(config.srcDirs || []).join(', ')})`);
+        console.log(`  Fix:    add the containing directory to srcDirs in gen-context.config.json`);
+      }
+      process.exit(0);
+    }
+
+    // 3. Detect extractor and extract sigs
+    const base    = path.basename(absPath);
+    const ext     = path.extname(base).toLowerCase();
+    let extractorName = EXT_MAP[ext] || null;
+    if (!extractorName && isDockerfile(base)) extractorName = 'dockerfile';
+    if (!extractorName) extractorName = 'generic';
+
+    let sigs = [];
+    if (fs.existsSync(absPath)) {
+      try {
+        const content = fs.readFileSync(absPath, 'utf8');
+        const extractor = getExtractor(extractorName);
+        if (extractor) sigs = extractor.extract(content).slice(0, config.maxSigsPerFile || 25);
+      } catch (_) {}
+    }
+
+    if (!sigs.length) {
+      if (jsonOut) {
+        process.stdout.write(JSON.stringify({ status: 'excluded', reason: 'no signatures', extractor: extractorName, fix: 'check that the file contains function/class definitions' }) + '\n');
+      } else {
+        console.log(`[sigmap] ${rel} — EXCLUDED`);
+        console.log(`  Reason: no extractable signatures (extractor: ${extractorName})`);
+        console.log(`  Fix:    check that the file contains function/class definitions`);
+      }
+      process.exit(0);
+    }
+
+    // 4. Included
+    if (jsonOut) {
+      process.stdout.write(JSON.stringify({ status: 'included', extractor: extractorName, signatures: sigs.length, preview: sigs.slice(0, 3), sigs }) + '\n');
+    } else {
+      console.log(`[sigmap] ${rel} — INCLUDED`);
+      console.log(`  Extractor : ${extractorName}`);
+      console.log(`  Signatures: ${sigs.length}`);
+      console.log(`  Preview   : ${sigs.slice(0, 3).join(' · ')}`);
+    }
+    process.exit(0);
+  }
+
   if (args.includes('--init')) {
     writeInitConfig(cwd);
     process.exit(0);
@@ -7363,7 +7726,14 @@ function main() {
     const { score } = __require('./src/health/scorer');
     const result = score(cwd);
     if (args.includes('--json')) {
-      process.stdout.write(JSON.stringify(result) + '\n');
+      // Feature 3 (VS Code) + Feature 5 (JetBrains): emit tokens + reduction for plugins
+      const ctxPath = path.join(cwd, '.github', 'copilot-instructions.md');
+      let tokens = 0;
+      let reduction = result.tokenReductionPct || 0;
+      if (fs.existsSync(ctxPath)) {
+        try { tokens = estimateTokens(fs.readFileSync(ctxPath, 'utf8')); } catch (_) {}
+      }
+      process.stdout.write(JSON.stringify({ ...result, tokens, reduction }) + '\n');
     } else {
       console.log('[sigmap] health:');
       console.log(`  score           : ${result.score}/100 (grade ${result.grade})`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sigmap",
-  "version": "3.5.0",
+  "version": "3.6.0",
   "description": "Zero-dependency AI context engine — 97% token reduction. No npm install. Runs on Node 18+.",
   "main": "gen-context.js",
   "exports": {
@@ -24,6 +24,7 @@
     "init": "node gen-context.js --init",
     "report": "node gen-context.js --report",
     "audit:strategies": "node scripts/run-strategy-audit.mjs",
+    "benchmark:matrix": "node scripts/run-benchmark-matrix.mjs --save --skip-clone",
     "health": "node gen-context.js --health",
     "map": "node gen-project-map.js",
     "mcp": "node gen-context.js --mcp",

package/packages/adapters/llm-full.js

@@ -0,0 +1,25 @@
+'use strict';
+const path = require('path');
+const fs   = require('fs');
+module.exports = { name: 'llm-full', format, outputPath, write };
+
+function outputPath(cwd) { return path.join(cwd, 'llm-full.txt'); }
+
+function format(context, opts) {
+  opts = opts || {};
+  const lines = [
+    `# ${context.projectName || 'Project'} — SigMap Context`,
+    `Generated: ${new Date().toISOString()} | SigMap v${opts.version || ''}`,
+    '',
+  ];
+  for (const entry of (context.fileEntries || [])) {
+    const rel = path.relative(opts.cwd || '', entry.filePath);
+    lines.push(`## ${rel}`, '```', ...(entry.sigs || []), '```', '');
+  }
+  return lines.join('\n');
+}
+
+function write(context, cwd, opts) {
+  opts = opts || {};
+  fs.writeFileSync(outputPath(cwd), format(context, { ...opts, cwd }));
+}

package/src/extractors/generic.js

@@ -0,0 +1,26 @@
+'use strict';
+module.exports = { extract };
+
+const PATTERNS = [
+  /^(?:pub\s+)?(?:async\s+)?function\s+\w+\s*\(/,
+  /^(?:pub\s+)?(?:async\s+)?fn\s+\w+[\s(<]/,
+  /^def\s+\w+[\s(|:]/,
+  /^(?:pub\s+)?func\s+\w+\s*\(/,
+  /^(?:let|let\s+rec)\s+\w+\s*[=(]/,
+  /^class\s+\w+/,
+  /^(?:proc|sub|method)\s+\w+\s*\(/,
+];
+
+function extract(src) {
+  if (!src || typeof src !== 'string') return [];
+  const results = [];
+  for (const raw of src.split('\n')) {
+    const line = raw.trim();
+    if (!line || /^[#\-]/.test(line) || /^\/\//.test(line) || line.includes('\0')) continue;
+    for (const pat of PATTERNS) {
+      if (pat.test(line)) { results.push(line.slice(0, 120)); break; }
+    }
+    if (results.length >= 15) break;
+  }
+  return results;
+}

package/src/format/llm-txt.js

@@ -0,0 +1,28 @@
+'use strict';
+const path = require('path');
+module.exports = { format, outputPath };
+
+function outputPath(cwd) { return path.join(cwd, 'llm.txt'); }
+
+function format(context, cwd, version) {
+  const name  = context.projectName || path.basename(cwd);
+  const langs = [...new Set((context.fileEntries || []).map(f => f.language).filter(Boolean))];
+  const mods  = context.srcDirs || [];
+
+  return [
+    `# Project: ${name}`,
+    `Languages: ${langs.join(', ') || 'unknown'}`,
+    `Root: ${mods[0] || 'src/'}`,
+    '',
+    '## Modules',
+    ...mods.map(m => `- ${m}/`),
+    '',
+    '## Key flows',
+    '- <!-- describe your main user flows here -->',
+    '',
+    '## Rules',
+    '- <!-- describe your team conventions here -->',
+    '',
+    `Generated: ${new Date().toISOString()} | SigMap v${version}`,
+  ].join('\n');
+}

package/src/format/llms-txt.js

@@ -0,0 +1,70 @@
+'use strict';
+const path = require('path');
+const fs   = require('fs');
+const { execSync } = require('child_process');
+module.exports = { format, outputPath };
+
+function outputPath(cwd) { return path.join(cwd, 'llms.txt'); }
+
+function getShortCommit(cwd) {
+  try { return execSync('git rev-parse --short HEAD', { cwd, timeout: 2000 }).toString().trim(); }
+  catch (_) { return ''; }
+}
+
+function detectVersion(cwd) {
+  try {
+    const pkg = path.join(cwd, 'package.json');
+    if (fs.existsSync(pkg)) return JSON.parse(fs.readFileSync(pkg, 'utf8')).version || '';
+  } catch (_) {}
+  return '';
+}
+
+function format(context, cwd, writtenFiles, sigmapVersion) {
+  writtenFiles  = writtenFiles  || [];
+  sigmapVersion = sigmapVersion || '';
+
+  const name   = context.projectName || path.basename(cwd);
+  const ver    = detectVersion(cwd);
+  const commit = getShortCommit(cwd);
+  const langs  = [...new Set((context.fileEntries || []).map(f => f.language).filter(Boolean))];
+
+  const lines = [
+    '# SigMap Context Index',
+    `> Generated by SigMap v${sigmapVersion} — zero-dependency AI context engine`,
+    '',
+    '## Project',
+    `- Name: ${name}`,
+  ];
+  if (ver)          lines.push(`- Version: ${ver}`);
+  if (langs.length) lines.push(`- Language: ${langs.join(', ')}`);
+  if (commit)       lines.push(`- Commit: ${commit}`);
+
+  if (writtenFiles.length) {
+    lines.push('', '## Context Files');
+    for (const f of writtenFiles) {
+      const rel   = path.relative(cwd, f.path);
+      const extra = f.tokens ? `: ${f.tokens} tokens` : '';
+      lines.push(`- [${f.label || rel}](${rel})${extra}`);
+    }
+  }
+
+  const mods = context.srcDirs || [];
+  if (mods.length) {
+    lines.push('', '## Source Modules');
+    for (const m of mods) lines.push(`- [${m}/](${m}/)`);
+  }
+
+  const top5 = (context.fileEntries || [])
+    .sort((a, b) => (b.sigs || []).length - (a.sigs || []).length)
+    .slice(0, 5);
+  if (top5.length) {
+    lines.push('', '## Key Files');
+    for (const f of top5) {
+      const rel     = path.relative(cwd, f.filePath);
+      const preview = (f.sigs || []).slice(0, 3).join(', ');
+      lines.push(`- ${rel}: ${preview}`);
+    }
+  }
+
+  return lines.join('\n');
+}