sigmap 6.5.1 → 6.6.0

package/AGENTS.md

@@ -56,15 +56,11 @@ Use this marker block for all appendable context files:
 | To query by topic | `sigmap --query "<topic>"` |
 
 Always run `sigmap ask` or `sigmap --query` before searching for files relevant to a task.
-## changes (last 5 commits — 6 minutes ago)
+## changes (last 5 commits — 8 minutes ago)
 ```
-src/config/loader.js                          +_legacyDetectAutoSrcDirs  ~detectAutoSrcDirs
-src/discovery/language-detector.js            +detectLanguages  +_walkDepth
-src/discovery/framework-detector.js           +detectFrameworks  +_readDeps  +_readFile  +_existsAnywhere
-src/discovery/source-root-resolver.js         +resolveSourceRoots  +_detectMonorepo  +_enumerateCandidates  +_applySpecialRules
-src/discovery/source-root-scorer.js           +getRecentlyChangedDirs  +scoreCandidate  +_countSourceFiles
-src/discovery/sigmapignore.js                 +loadIgnorePatterns  +matchesIgnorePattern
-src/retrieval/ranker.js                       +_computePenalty  ~scoreFile  ~rank  ~buildSigIndex
+src/plan/planner.js                           +createPlan
+src/retrieval/ranker.js                       +_computePenalty  +_computeHubs  +_isHub  ~scoreFile
+src/session/memory.js                         +sessionPath  +loadSession  +saveSession  +mergeSessionContext
 ```
 
 ## packages
@@ -166,46 +162,25 @@ function _confidenceMeta(opts)
 function outputPath(cwd) → string
 ```
 
-### packages/adapters/codex.js
+### packages/adapters/claude.js
 ```
 module.exports = { name, format, outputPath, write }
 function format(context, opts = {}) → string
+function _confidenceMeta(opts)
 function outputPath(cwd) → string
 function write(context, cwd, opts = {})
 ```
 
-### packages/adapters/claude.js
+### packages/adapters/codex.js
 ```
 module.exports = { name, format, outputPath, write }
 function format(context, opts = {}) → string
-function _confidenceMeta(opts)
 function outputPath(cwd) → string
 function write(context, cwd, opts = {})
 ```
 
 ## src
 
-### src/extractors/javascript.js
-```
-module.exports = { extract }
-function extract(src) → string[]
-function extractBlock(src, startIndex)
-function extractClassMembers(block, returnHints)
-function buildReturnHints(src)
-function normalizeType(type)
-function formatReturnHint(type)
-function normalizeParams(params)
-```
-
-### src/extractors/kotlin.js
-```
-module.exports = { extract }
-function extract(src) → string[]
-function extractBlock(src, startIndex)
-function extractMembers(block)
-function normalizeParams(params)
-```
-
 ### src/extractors/php.js
 ```
 module.exports = { extract }
@@ -483,11 +458,6 @@ function formatAnalysisTable(stats, showSlow) → string
 function formatAnalysisJSON(stats) → object
 ```
 
-### src/config/defaults.js
-```
-module.exports = { DEFAULTS }
-```
-
 ### src/format/dashboard.js
 ```
 module.exports = { generateDashboardHtml, renderHistoryCharts, computeExtractorCoverage, percentile, overBudgetStreak }
@@ -610,6 +580,11 @@ function exportWeights(cwd, outputPath)
 function importWeights(cwd, importPath, replace)
 ```
 
+### src/config/defaults.js
+```
+module.exports = { DEFAULTS }
+```
+
 ### src/config/loader.js
 ```
 module.exports = { loadConfig, loadBaseConfig }
@@ -620,23 +595,6 @@ function loadConfig(cwd) → object
 function deepClone(obj)
 ```
 
-### src/discovery/language-detector.js
-```
-module.exports = { detectLanguages }
-function detectLanguages(cwd)
-function _walkDepth(dir, depth, extCount)
-```
-
-### src/discovery/framework-detector.js
-```
-module.exports = { detectFrameworks }
-function detectFrameworks(cwd)
-function _readDeps(cwd)
-function _readFile(p)
-function _existsAnywhere(cwd, filename, maxDepth)
-function _walkFind(dir, name, depth)
-```
-
 ### src/discovery/source-root-registry.js
 ```
 module.exports = { REGISTRY }
@@ -653,6 +611,13 @@ function _dedupeNested(scored)
 function _computeConfidence(frameworks, languages, scoredCount)
 ```
 
+### src/discovery/language-detector.js
+```
+module.exports = { detectLanguages }
+function detectLanguages(cwd)
+function _walkDepth(dir, depth, extCount)
+```
+
 ### src/discovery/source-root-scorer.js
 ```
 module.exports = { scoreCandidate, getRecentlyChangedDirs, ROOT_ENTRYPOINTS }
@@ -661,6 +626,16 @@ function scoreCandidate(dirName, fullPath, context)
 function _countSourceFiles(dir, depth)
 ```
 
+### src/discovery/framework-detector.js
+```
+module.exports = { detectFrameworks }
+function detectFrameworks(cwd)
+function _readDeps(cwd)
+function _readFile(p)
+function _existsAnywhere(cwd, filename, maxDepth)
+function _walkFind(dir, name, depth)
+```
+
 ### src/discovery/sigmapignore.js
 ```
 module.exports = { loadIgnorePatterns, matchesIgnorePattern }
@@ -668,10 +643,27 @@ function loadIgnorePatterns(cwd)
 function matchesIgnorePattern(dirName, patterns)
 ```
 
+### src/plan/planner.js
+```
+module.exports = { createPlan }
+function createPlan(goal, cwd, config)
+```
+
+### src/mcp/server.js
+```
+module.exports = { start }
+function respond(id, result)
+function respondError(id, code, message)
+function dispatch(msg, cwd)
+function start(cwd)
+```
+
 ### src/retrieval/ranker.js
 ```
-module.exports = { rank, buildSigIndex, scoreFile, formatRankTable, formatRankJSON, DEFAULT_WEIGHTS, detectIntent }
+module.exports = { rank, buildSigIndex, scoreFile, formatRankTable, formatRankJSON, DEFAULT_WEIGHTS, GRAPH_BOOST_AMOUNTS, detectIntent }
 function _computePenalty(filePath)
+function _computeHubs(graph)
+function _isHub(filePath)
 function scoreFile(filePath, sigs, queryTokens, weights) → { score: number, signals:
 function rank(query, sigIndex, opts) → { file: string, score: nu
 function _parseContextFile(contextPath) → Map<string, string[]>
@@ -681,11 +673,12 @@ function formatRankJSON(results, query) → object
 function detectIntent(query)
 ```
 
-### src/mcp/server.js
+### src/session/memory.js
 ```
-module.exports = { start }
-function respond(id, result)
-function respondError(id, code, message)
-function dispatch(msg, cwd)
-function start(cwd)
+module.exports = { loadSession, saveSession, mergeSessionContext, clearSession }
+function sessionPath(cwd)
+function loadSession(cwd)
+function saveSession(cwd, { intent, topFiles, query })
+function mergeSessionContext(scores, session, currentIntent)
+function clearSession(cwd)
 ```

package/CHANGELOG.md

@@ -10,6 +10,27 @@ Format: [Semantic Versioning](https://semver.org/)
 
 ---
 
+## [6.6.0] — 2026-04-27
+
+### Added
+
+- **Session memory** — Carry context across follow-up queries within a coding session. New `src/session/memory.js` module manages session state with 4-hour TTL. Previous session's top-5 files get +0.2 score boost in next query; boost reduced to +0.1 if intent differs (topic-switch guard).
+- **`sigmap ask --followup`** — Reuse previous session's context when making follow-up queries. Session automatically saved after each `ask` command for seamless context carry-forward.
+- **`sigmap plan "<goal>"`** — Analyze change impact and plan modifications. Returns files grouped by confidence (inspect-first vs likely-to-change), impact radius, and affected tests. Supports `--json` output for agent integration.
+
+---
+
+## [6.5.2] — 2026-04-27
+
+### Added
+
+- **2-hop graph boost with decay** — `rank()` now traverses 2 hops in the dependency graph instead of 1. Direct imports (+0.40) and second-order imports (+0.15 with decay) receive score boosts for better context relevance in multi-layer dependency scenarios.
+- **Hub suppression** — shared utility files (detected by >20% fanout threshold or static patterns like `util/`, `helper/`, `common/`) are now excluded from graph boosts to prevent over-boosting generic utilities.
+- **Incremental signature cache (`sigCache`)** — new opt-in `sigCache: true` config key enables mtime-based caching of extracted signatures. Cache is automatically busted on version changes, and unchanged files skip re-extraction for faster subsequent runs.
+- **Cache health statistics** — `--health` output now includes cache stats: entry count and disk size in KB. `--health --json` includes `cacheStats` field with `entries` and `sizeKb` when cache exists.
+
+---
+
 ## [6.5.1] — 2026-04-25
 
 ### Added

package/gen-context.js

@@ -5387,7 +5387,7 @@ __factories["./src/mcp/server"] = function(module, exports) {
   
   const SERVER_INFO = {
     name: 'sigmap',
-  version: '6.5.1',
+  version: '6.6.0',
     description: 'SigMap MCP server — code signatures on demand',
   };
   
@@ -6211,6 +6211,62 @@ __factories["./src/tracking/logger"] = function(module, exports) {
   
 };
 
+// ── ./src/session/memory ──
+__factories["./src/session/memory"] = function(module, exports) {
+  'use strict';
+
+  const fs = require('fs');
+  const path = require('path');
+
+  const SESSION_TTL_MS = 4 * 60 * 60 * 1000;   // 4 hours — one coding session
+
+  function sessionPath(cwd) {
+    return path.join(cwd, '.context', 'session.json');
+  }
+
+  function loadSession(cwd) {
+    const p = sessionPath(cwd);
+    if (!fs.existsSync(p)) return null;
+    try {
+      const raw = JSON.parse(fs.readFileSync(p, 'utf8'));
+      if (Date.now() - raw.ts > SESSION_TTL_MS) return null;  // expired
+      return raw;
+    } catch {
+      return null;
+    }
+  }
+
+  function saveSession(cwd, { intent, topFiles, query }) {
+    const p = sessionPath(cwd);
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    fs.writeFileSync(p, JSON.stringify({
+      ts: Date.now(),
+      intent,
+      topFiles,   // [{ file, score }] — top 5 from last ask
+      lastQuery: query,
+    }));
+  }
+
+  function mergeSessionContext(scores, session, currentIntent) {
+    if (!session) return scores;
+
+    const boostAmount = session.intent === currentIntent ? 0.20 : 0.10;
+    const sessionBoost = new Map(session.topFiles.map(f => [f.file, boostAmount]));
+
+    return scores.map(r => ({
+      ...r,
+      score: r.score + (sessionBoost.get(r.file) || 0),
+    }));
+  }
+
+  function clearSession(cwd) {
+    const p = sessionPath(cwd);
+    if (fs.existsSync(p)) fs.unlinkSync(p);
+  }
+
+  module.exports = { loadSession, saveSession, mergeSessionContext, clearSession };
+};
+
 // ── ./src/retrieval/tokenizer ──
 __factories["./src/retrieval/tokenizer"] = function(module, exports) {
   'use strict';
@@ -7210,6 +7266,521 @@ __factories["./packages/adapters/llm-full"] = function(module, exports) {
   module.exports = { name: 'llm-full', format, outputPath, write };
 };
 
+// ── ./src/discovery/source-root-registry ──
+__factories["./src/discovery/source-root-registry"] = function(module, exports) {
+  'use strict';
+  const REGISTRY = {
+    javascript: {
+      manifestFiles: ['package.json'],
+      frameworks: {
+        nextjs:    { detectionFiles: ['next.config.js','next.config.ts','next.config.mjs'], detectionDeps: ['next'],               srcDirs: ['app','src/app','pages','src/pages','src','components','lib','hooks','utils'], entrypoints: ['app/page.tsx','pages/index.tsx'] },
+        nestjs:    { detectionFiles: ['nest-cli.json'],                                    detectionDeps: ['@nestjs/core'],        srcDirs: ['src'], entrypoints: ['src/main.ts','src/app.module.ts'] },
+        express:   { detectionFiles: [],                                                    detectionDeps: ['express'],             srcDirs: ['src','routes','middleware','controllers','services'], entrypoints: ['src/index.js','server.js','app.js'] },
+        fastify:   { detectionFiles: [],                                                    detectionDeps: ['fastify'],             srcDirs: ['src','routes','plugins'], entrypoints: ['src/index.js'] },
+        react:     { detectionFiles: [],                                                    detectionDeps: ['react'],               srcDirs: ['src','components','hooks','context','pages','app','lib','utils'] },
+        vue:       { detectionFiles: ['vue.config.js','vue.config.ts'],                    detectionDeps: ['vue'],                 srcDirs: ['src','components','composables','pages','views'] },
+        nuxt:      { detectionFiles: ['nuxt.config.js','nuxt.config.ts'],                  detectionDeps: ['nuxt'],                srcDirs: ['pages','components','composables','server','middleware','plugins'] },
+        svelte:    { detectionFiles: ['svelte.config.js'],                                 detectionDeps: ['svelte','@sveltejs/kit'], srcDirs: ['src','src/routes','src/lib'] },
+        angular:   { detectionFiles: ['angular.json'],                                     detectionDeps: ['@angular/core'],       srcDirs: ['src','src/app','projects','apps','libs'] },
+        gatsby:    { detectionFiles: ['gatsby-config.js','gatsby-config.ts'],              detectionDeps: ['gatsby'],              srcDirs: ['src','gatsby'] },
+        vite:      { detectionFiles: ['vite.config.js','vite.config.ts'],                  detectionDeps: ['vite'],                srcDirs: ['src'] },
+        remix:     { detectionFiles: ['remix.config.js'],                                  detectionDeps: ['@remix-run/react'],    srcDirs: ['app'] },
+        trpc:      { detectionFiles: [],                                                    detectionDeps: ['@trpc/server'],        srcDirs: ['src','server','routers'] },
+      },
+      srcDirs:  ['src','lib','index.js','server.js','app.js'],
+      penalties: ['dist','build','.next','.nuxt','coverage','storybook-static'],
+    },
+    typescript: {
+      manifestFiles: ['package.json','tsconfig.json'],
+      frameworks: {
+        nextjs:  { detectionFiles: ['next.config.ts','next.config.mjs'], detectionDeps: ['next'],            srcDirs: ['app','src/app','pages','src','components','lib','hooks','utils'] },
+        nestjs:  { detectionFiles: ['nest-cli.json'],                     detectionDeps: ['@nestjs/core'],   srcDirs: ['src'], entrypoints: ['src/main.ts'] },
+        angular: { detectionFiles: ['angular.json'],                      detectionDeps: ['@angular/core'],  srcDirs: ['src','src/app','projects','apps','libs'] },
+      },
+      srcDirs:  ['src','lib','packages'],
+      penalties: ['dist','build','.next'],
+    },
+    python: {
+      manifestFiles: ['requirements.txt','pyproject.toml','setup.py','Pipfile'],
+      frameworks: {
+        django:  { detectionFiles: ['manage.py'],           detectionDeps: ['Django'],  srcDirs: [],         specialRule: 'django-app-dirs', entrypoints: ['manage.py'] },
+        fastapi: { detectionFiles: [],                       detectionDeps: ['fastapi'], srcDirs: ['app','src','routers','api'], entrypoints: ['main.py','app/main.py'] },
+        flask:   { detectionFiles: ['wsgi.py','app.py'],    detectionDeps: ['Flask'],   srcDirs: ['app','src'], entrypoints: ['app.py','wsgi.py'] },
+        celery:  { detectionFiles: [],                       detectionDeps: ['celery'],  srcDirs: ['tasks','workers','app'] },
+      },
+      srcDirs:  ['.'],
+      penalties: ['venv','.venv','__pycache__','.pytest_cache','htmlcov'],
+    },
+    go: {
+      manifestFiles: ['go.mod'],
+      frameworks: {
+        gin:   { detectionFiles: [], detectionDeps: ['github.com/gin-gonic/gin'],      srcDirs: ['internal','cmd','pkg','api','handler','middleware'] },
+        echo:  { detectionFiles: [], detectionDeps: ['github.com/labstack/echo'],      srcDirs: ['internal','cmd','handler','middleware'] },
+        fiber: { detectionFiles: [], detectionDeps: ['github.com/gofiber/fiber'],      srcDirs: ['internal','cmd','handler','routes'] },
+        grpc:  { detectionFiles: [], detectionDeps: ['google.golang.org/grpc'],        srcDirs: ['internal','proto','server','client'] },
+        chi:   { detectionFiles: [], detectionDeps: ['github.com/go-chi/chi'],         srcDirs: ['internal','cmd','handler'] },
+      },
+      srcDirs:  ['internal','cmd','pkg','api'],
+      penalties: ['vendor'],
+    },
+    rust: {
+      manifestFiles: ['Cargo.toml'],
+      frameworks: {
+        actix: { detectionFiles: [], detectionDeps: ['actix-web'], srcDirs: ['src'] },
+        axum:  { detectionFiles: [], detectionDeps: ['axum'],      srcDirs: ['src'] },
+        tauri: { detectionFiles: ['src-tauri/tauri.conf.json'], detectionDeps: ['tauri'], srcDirs: ['src','src-tauri/src'] },
+      },
+      srcDirs:  ['src'],
+      penalties: ['target'],
+    },
+    java: {
+      manifestFiles: ['pom.xml','build.gradle'],
+      frameworks: {
+        spring:   { detectionFiles: [], detectionDeps: ['spring-boot'], srcDirs: ['src/main/java','src/main/kotlin','src/main/resources'] },
+        quarkus:  { detectionFiles: [], detectionDeps: ['io.quarkus'],  srcDirs: ['src/main/java'] },
+        android:  { detectionFiles: ['AndroidManifest.xml'],            srcDirs: ['app/src/main/java','app/src/main','src'] },
+        micronaut:{ detectionFiles: [], detectionDeps: ['io.micronaut'],srcDirs: ['src/main/java'] },
+      },
+      srcDirs:  ['src/main/java','src'],
+      penalties: ['target','build'],
+    },
+    kotlin: {
+      manifestFiles: ['build.gradle.kts'],
+      frameworks: {
+        spring:  { detectionFiles: [], detectionDeps: ['spring-boot'],    srcDirs: ['src/main/kotlin'] },
+        android: { detectionFiles: ['AndroidManifest.xml'],               srcDirs: ['app/src/main/kotlin','app/src/main/java'] },
+        ktor:    { detectionFiles: [], detectionDeps: ['io.ktor'],         srcDirs: ['src'] },
+        compose: { detectionFiles: [], detectionDeps: ['compose-runtime'], srcDirs: ['app/src/main/kotlin','src'] },
+      },
+      srcDirs:  ['src/main/kotlin','src'],
+      penalties: ['build','.gradle'],
+    },
+    csharp: {
+      manifestFiles: ['.csproj','.sln'],
+      frameworks: {
+        aspnet:  { detectionFiles: ['appsettings.json'], detectionDeps: ['Microsoft.AspNetCore'], srcDirs: ['Controllers','Services','Models','Middleware','Pages'] },
+        blazor:  { detectionFiles: [], detectionDeps: ['Microsoft.AspNetCore.Components'],        srcDirs: ['Components','Pages','Services'] },
+        unity:   { detectionFiles: ['ProjectSettings/ProjectSettings.asset'],                     srcDirs: ['Assets/Scripts','Assets'] },
+        maui:    { detectionFiles: [], detectionDeps: ['Microsoft.Maui'],                          srcDirs: ['src','Pages','ViewModels'] },
+      },
+      srcDirs:  ['src','Controllers','Services','Models'],
+      penalties: ['bin','obj','.vs'],
+    },
+    php: {
+      manifestFiles: ['composer.json'],
+      frameworks: {
+        laravel:   { detectionFiles: ['artisan'],           srcDirs: ['app','routes','config','database','resources','tests'], entrypoints: ['artisan'] },
+        symfony:   { detectionFiles: ['symfony.lock'],      srcDirs: ['src','config','templates'], specialRule: 'symfony-bundle-dirs' },
+        wordpress: { detectionFiles: ['wp-config.php'],     srcDirs: ['wp-content/themes','wp-content/plugins','wp-content/mu-plugins'] },
+        slim:      { detectionFiles: [],                    detectionDeps: ['slim/slim'], srcDirs: ['src','app','routes'] },
+      },
+      srcDirs:  ['src','app'],
+      penalties: ['vendor'],
+    },
+    ruby: {
+      manifestFiles: ['Gemfile'],
+      frameworks: {
+        rails:   { detectionFiles: ['config/routes.rb'],   srcDirs: ['app','lib','config','db','spec','test'], entrypoints: ['config/routes.rb'] },
+        sinatra: { detectionFiles: ['config.ru','app.rb'], srcDirs: ['.','lib'],            entrypoints: ['app.rb','config.ru'] },
+        hanami:  { detectionFiles: [],                     detectionDeps: ['hanami'],       srcDirs: ['apps','lib','slices'] },
+      },
+      srcDirs:  ['app','lib'],
+      penalties: ['vendor','coverage','.bundle'],
+    },
+    swift: {
+      manifestFiles: ['Package.swift'],
+      frameworks: {
+        vapor:   { detectionFiles: [],              detectionDeps: ['vapor/vapor'], srcDirs: ['Sources','App'] },
+        swiftui: { detectionFiles: ['.xcodeproj'],  srcDirs: [],                    specialRule: 'swift-project-dir' },
+        swiftpm: { detectionFiles: ['Package.swift'],srcDirs: ['Sources'] },
+      },
+      srcDirs:  ['Sources','Source'],
+      penalties: ['.build','DerivedData','Pods','Carthage'],
+    },
+    dart: {
+      manifestFiles: ['pubspec.yaml'],
+      frameworks: {
+        flutter:    { detectionFiles: [],                   detectionDeps: ['flutter'],    srcDirs: ['lib','lib/src'], entrypoints: ['lib/main.dart'] },
+        serverpod:  { detectionFiles: [],                   detectionDeps: ['serverpod'],  srcDirs: ['lib','endpoints','models'] },
+        'dart-frog':{ detectionFiles: ['dart_frog.yaml'],   srcDirs: ['routes','lib'] },
+      },
+      srcDirs:  ['lib','lib/src'],
+      penalties: ['.dart_tool','build'],
+    },
+    scala: {
+      manifestFiles: ['build.sbt'],
+      frameworks: {
+        akka:  { detectionFiles: [], detectionDeps: ['akka'], srcDirs: ['src/main/scala','src'] },
+        play:  { detectionFiles: [], detectionDeps: ['play'], srcDirs: ['app','conf'] },
+        spark: { detectionFiles: [], detectionDeps: ['spark'],srcDirs: ['src/main/scala'] },
+        zio:   { detectionFiles: [], detectionDeps: ['zio'],  srcDirs: ['src/main/scala'] },
+      },
+      srcDirs:  ['src/main/scala','src'],
+      penalties: ['target'],
+    },
+  };
+  module.exports = { REGISTRY };
+};
+
+// ── ./src/discovery/sigmapignore ──
+__factories["./src/discovery/sigmapignore"] = function(module, exports) {
+  'use strict';
+  const fs   = require('fs');
+  const path = require('path');
+  function loadIgnorePatterns(cwd) {
+    for (const fname of ['.sigmapignore', '.contextignore']) {
+      const p = path.join(cwd, fname);
+      if (fs.existsSync(p)) {
+        return fs.readFileSync(p, 'utf8')
+          .split('\n')
+          .map(l => l.trim())
+          .filter(l => l && !l.startsWith('#'));
+      }
+    }
+    return [];
+  }
+  function matchesIgnorePattern(dirName, patterns) {
+    for (const pat of patterns) {
+      const clean = pat.replace(/\/$/, '');
+      if (clean === dirName) return true;
+      if (clean.endsWith('/**') && dirName.startsWith(clean.slice(0, -3))) return true;
+      if (clean.endsWith('/*') && dirName.startsWith(clean.slice(0, -2))) return true;
+    }
+    return false;
+  }
+  module.exports = { loadIgnorePatterns, matchesIgnorePattern };
+};
+
+// ── ./src/discovery/language-detector ──
+__factories["./src/discovery/language-detector"] = function(module, exports) {
+  'use strict';
+  const fs   = require('fs');
+  const path = require('path');
+  const { REGISTRY } = __require('./src/discovery/source-root-registry');
+  function detectLanguages(cwd) {
+    const weights = {};
+    for (const [lang, reg] of Object.entries(REGISTRY)) {
+      for (const mf of (reg.manifestFiles || [])) {
+        if (fs.existsSync(path.join(cwd, mf))) {
+          weights[lang] = (weights[lang] || 0) + 3;
+        }
+      }
+    }
+    try {
+      const pkg = JSON.parse(fs.readFileSync(path.join(cwd, 'package.json'), 'utf8'));
+      const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+      if (allDeps.typescript) { weights.typescript = (weights.typescript || 0) + 2; }
+    } catch (_) {}
+    const extCount = {};
+    (function _walkDepth(dir, depth, extCount) {
+      if (depth <= 0) return;
+      let entries;
+      try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch (_) { return; }
+      for (const e of entries) {
+        const SKIP_DIRS = new Set(['node_modules','dist','build','.git','.next','.nuxt','vendor','DerivedData','Pods','target','coverage','__pycache__','.venv','venv','.build','Carthage','storybook-static']);
+        if (SKIP_DIRS.has(e.name)) continue;
+        if (e.isDirectory()) {
+          _walkDepth(path.join(dir, e.name), depth - 1, extCount);
+        } else if (e.isFile()) {
+          const EXT_TO_LANG = {'.js': 'javascript', '.mjs': 'javascript', '.cjs': 'javascript', '.ts': 'typescript', '.tsx': 'typescript', '.jsx': 'javascript', '.py': 'python', '.rb': 'ruby', '.go': 'go', '.rs': 'rust', '.java': 'java', '.kt': 'kotlin', '.cs': 'csharp', '.cpp': 'cpp', '.c': 'cpp', '.h': 'cpp', '.hpp': 'cpp', '.swift': 'swift', '.dart': 'dart', '.scala': 'scala', '.php': 'php'};
+          const ext = path.extname(e.name).toLowerCase();
+          if (EXT_TO_LANG[ext]) extCount[ext] = (extCount[ext] || 0) + 1;
+        }
+      }
+    })(cwd, 3, extCount);
+    const maxCount = Math.max(1, ...Object.values(extCount));
+    const EXT_TO_LANG = {'.js': 'javascript', '.mjs': 'javascript', '.cjs': 'javascript', '.ts': 'typescript', '.tsx': 'typescript', '.jsx': 'javascript', '.py': 'python', '.rb': 'ruby', '.go': 'go', '.rs': 'rust', '.java': 'java', '.kt': 'kotlin', '.cs': 'csharp', '.cpp': 'cpp', '.c': 'cpp', '.h': 'cpp', '.hpp': 'cpp', '.swift': 'swift', '.dart': 'dart', '.scala': 'scala', '.php': 'php'};
+    for (const [ext, count] of Object.entries(extCount)) {
+      const lang = EXT_TO_LANG[ext];
+      if (lang) {
+        weights[lang] = (weights[lang] || 0) + Math.min(5, (count / maxCount) * 5);
+      }
+    }
+    const maxW = Math.max(1, ...Object.values(weights));
+    return Object.entries(weights)
+      .map(([name, w]) => ({ name, weight: Math.round(w / maxW * 100) / 100 }))
+      .sort((a, b) => b.weight - a.weight);
+  }
+  module.exports = { detectLanguages };
+};
+
+// ── ./src/discovery/source-root-scorer ──
+__factories["./src/discovery/source-root-scorer"] = function(module, exports) {
+  'use strict';
+  const fs   = require('fs');
+  const path = require('path');
+  const { execSync } = require('child_process');
+  const CODE_EXTS = new Set(['.js','.mjs','.cjs','.ts','.tsx','.jsx','.py','.rb','.go','.rs','.java','.kt','.cs','.cpp','.c','.h','.swift','.dart','.scala','.php']);
+  const AUTO_SKIP = new Set(['node_modules','dist','build','.git','.next','.nuxt','vendor','DerivedData','Pods','target','coverage','__pycache__','.venv','venv','.build','Carthage','storybook-static','.gradle','bin','obj','.vs']);
+  const PENALTY_DIRS = new Set(['test','tests','spec','__tests__','e2e','docs','doc','docs-vp','examples','example','fixtures','mocks','__mocks__','demo','samples','migrations','benchmarks','scripts']);
+  const ROOT_ENTRYPOINTS = { go: ['main.go'], python: ['app.py','main.py','wsgi.py','asgi.py'], javascript: ['index.js','server.js','app.js'], typescript: ['index.ts','main.ts'], rust: [], php: ['index.php'] };
+  function getRecentlyChangedDirs(cwd) {
+    try {
+      const out = execSync('git log --name-only --format="" HEAD~10 2>/dev/null', { cwd, timeout: 3000 }).toString();
+      return new Set(out.split('\n').filter(Boolean).map(f => f.split('/')[0]));
+    } catch { return new Set(); }
+  }
+  function scoreCandidate(dirName, fullPath, context) {
+    const { frameworks, languages, recentDirs, frameworkSrcDirs, entrypoints, frameworkPenalties } = context;
+    if (AUTO_SKIP.has(dirName)) return -99;
+    if (!fs.existsSync(fullPath)) return -99;
+    let score = 0;
+    if (frameworkSrcDirs.has(dirName)) score += 3.0;
+    const sourceFileCount = (function _countSourceFiles(dir, depth) {
+      if (depth <= 0) return 0;
+      let count = 0;
+      try {
+        for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
+          if (e.isFile() && CODE_EXTS.has(path.extname(e.name).toLowerCase())) count++;
+          else if (e.isDirectory() && depth > 1) count += _countSourceFiles(path.join(dir, e.name), depth - 1);
+        }
+      } catch (_) {}
+      return count;
+    })(fullPath, 2);
+    const density = Math.min(1.0, sourceFileCount / 10);
+    score += density * 2.5;
+    if (sourceFileCount >= 3) score += 2.0;
+    if ((entrypoints || []).some(ep => ep.startsWith(dirName + '/'))) score += 1.5;
+    if (fs.existsSync(path.join(fullPath, 'package.json')) ||
+        fs.existsSync(path.join(fullPath, 'go.mod')) ||
+        fs.existsSync(path.join(fullPath, 'Cargo.toml')) ||
+        fs.existsSync(path.join(fullPath, 'pom.xml'))) {
+      score += 1.0;
+    }
+    if (recentDirs.has(dirName)) score += 2.0;
+    if (PENALTY_DIRS.has(dirName.toLowerCase()) && !frameworkSrcDirs.has(dirName)) score -= 3.0;
+    if ((frameworkPenalties || []).includes(dirName)) score -= 3.0;
+    return Math.round(score * 100) / 100;
+  }
+  module.exports = { scoreCandidate, getRecentlyChangedDirs, ROOT_ENTRYPOINTS };
+};
+
+// ── ./src/discovery/framework-detector ──
+__factories["./src/discovery/framework-detector"] = function(module, exports) {
+  'use strict';
+  const fs   = require('fs');
+  const path = require('path');
+  const { REGISTRY } = __require('./src/discovery/source-root-registry');
+  function detectFrameworks(cwd) {
+    const detected = [];
+    for (const [lang, reg] of Object.entries(REGISTRY)) {
+      if (!reg.frameworks) continue;
+      for (const [name, fw] of Object.entries(reg.frameworks)) {
+        let confidence = 0;
+        for (const f of (fw.detectionFiles || [])) {
+          if ((function _existsAnywhere(cwd, filename, maxDepth) {
+            const parts = filename.split('/');
+            if (parts.length > 1) return fs.existsSync(path.join(cwd, filename));
+            return (function _walkFind(dir, name, depth) {
+              if (depth <= 0) return false;
+              try {
+                const entries = fs.readdirSync(dir, { withFileTypes: true });
+                for (const e of entries) {
+                  if (e.name === name) return true;
+                  if (e.isDirectory() && depth > 1) {
+                    if (_walkFind(path.join(dir, e.name), name, depth - 1)) return true;
+                  }
+                }
+              } catch (_) {}
+              return false;
+            })(cwd, parts[0], maxDepth);
+          })(cwd, f, 3)) { confidence = Math.max(confidence, 0.93); }
+        }
+        if (fw.detectionDeps?.length) {
+          const deps = (function _readDeps(cwd) {
+            try {
+              const pkg = JSON.parse(fs.readFileSync(path.join(cwd, 'package.json'), 'utf8'));
+              return new Set([...Object.keys(pkg.dependencies || {}), ...Object.keys(pkg.devDependencies || {})]);
+            } catch { return new Set(); }
+          })(cwd);
+          for (const dep of fw.detectionDeps) {
+            if (deps.has(dep)) { confidence = Math.max(confidence, 0.90); }
+          }
+        }
+        if (lang === 'go' && fw.detectionDeps?.length) {
+          const goMod = (function _readFile(p) {
+            try { return fs.readFileSync(p, 'utf8'); } catch { return ''; }
+          })(path.join(cwd, 'go.mod'));
+          for (const dep of fw.detectionDeps) {
+            if (goMod.includes(dep)) { confidence = Math.max(confidence, 0.90); }
+          }
+        }
+        if (lang === 'rust' && fw.detectionDeps?.length) {
+          const cargoToml = (function _readFile(p) {
+            try { return fs.readFileSync(p, 'utf8'); } catch { return ''; }
+          })(path.join(cwd, 'Cargo.toml'));
+          for (const dep of fw.detectionDeps) {
+            if (cargoToml.includes(dep)) { confidence = Math.max(confidence, 0.88); }
+          }
+        }
+        if (fw.specialRule === 'django-app-dirs' && fs.existsSync(path.join(cwd, 'manage.py'))) {
+          confidence = Math.max(confidence, 0.95);
+        }
+        if (fw.specialRule === 'swift-project-dir' && (function _existsAnywhere(cwd, filename, maxDepth) {
+          const parts = filename.split('/');
+          if (parts.length > 1) return fs.existsSync(path.join(cwd, filename));
+          return (function _walkFind(dir, name, depth) {
+            if (depth <= 0) return false;
+            try {
+              const entries = fs.readdirSync(dir, { withFileTypes: true });
+              for (const e of entries) {
+                if (e.name === name) return true;
+                if (e.isDirectory() && depth > 1) {
+                  if (_walkFind(path.join(dir, e.name), name, depth - 1)) return true;
+                }
+              }
+            } catch (_) {}
+            return false;
+          })(cwd, parts[0], maxDepth);
+        })(cwd, '.xcodeproj', 2)) {
+          confidence = Math.max(confidence, 0.90);
+        }
+        if (confidence > 0) detected.push({ name, language: lang, confidence });
+      }
+    }
+    return detected.sort((a, b) => b.confidence - a.confidence);
+  }
+  module.exports = { detectFrameworks };
+};
+
+// ── ./src/discovery/source-root-resolver ──
+__factories["./src/discovery/source-root-resolver"] = function(module, exports) {
+  'use strict';
+  const fs   = require('fs');
+  const path = require('path');
+  const { REGISTRY }              = __require('./src/discovery/source-root-registry');
+  const { detectLanguages }       = __require('./src/discovery/language-detector');
+  const { detectFrameworks }      = __require('./src/discovery/framework-detector');
+  const { scoreCandidate, getRecentlyChangedDirs, ROOT_ENTRYPOINTS } = __require('./src/discovery/source-root-scorer');
+  const { loadIgnorePatterns, matchesIgnorePattern } = __require('./src/discovery/sigmapignore');
+  function resolveSourceRoots(cwd, opts = {}) {
+    const ignorePatterns = loadIgnorePatterns(cwd);
+    const languages      = detectLanguages(cwd);
+    const frameworks     = detectFrameworks(cwd);
+    const recentDirs     = getRecentlyChangedDirs(cwd);
+    const isMonorepo     = (function _detectMonorepo(cwd) {
+      const MONOREPO_MARKERS = ['pnpm-workspace.yaml','turbo.json','nx.json','lerna.json'];
+      for (const m of MONOREPO_MARKERS) {
+        if (fs.existsSync(path.join(cwd, m))) return true;
+      }
+      try {
+        const pkg = JSON.parse(fs.readFileSync(path.join(cwd, 'package.json'), 'utf8'));
+        if (pkg.workspaces) return true;
+      } catch (_) {}
+      return false;
+    })(cwd);
+    const primaryLang   = languages[0]?.name;
+    const primaryFw     = frameworks[0];
+    const registry      = primaryLang ? REGISTRY[primaryLang] : null;
+    const fwEntry        = primaryFw && registry?.frameworks?.[primaryFw.name];
+    const frameworkSrcDirs   = new Set(fwEntry?.srcDirs || registry?.srcDirs || []);
+    const entrypoints        = fwEntry?.entrypoints || [];
+    const frameworkPenalties = registry?.penalties || [];
+    const context = { frameworks, languages, recentDirs, frameworkSrcDirs, entrypoints, frameworkPenalties };
+    const candidates = (function _enumerateCandidates(cwd, isMonorepo, ignorePatterns, excludeList) {
+      const candidates = [];
+      const excSet     = new Set(excludeList);
+      try {
+        for (const e of fs.readdirSync(cwd, { withFileTypes: true })) {
+          if (!e.isDirectory()) continue;
+          if (excSet.has(e.name)) continue;
+          if (matchesIgnorePattern(e.name, ignorePatterns)) continue;
+          candidates.push({ name: e.name, full: path.join(cwd, e.name) });
+        }
+      } catch (_) {}
+      if (isMonorepo) {
+        for (const top of ['packages','apps','services','modules']) {
+          const topFull = path.join(cwd, top);
+          if (!fs.existsSync(topFull)) continue;
+          try {
+            for (const pkg of fs.readdirSync(topFull, { withFileTypes: true })) {
+              if (!pkg.isDirectory()) continue;
+              const srcFull = path.join(topFull, pkg.name, 'src');
+              if (fs.existsSync(srcFull)) {
+                candidates.push({ name: `${top}/${pkg.name}/src`, full: srcFull });
+              }
+              candidates.push({ name: `${top}/${pkg.name}`, full: path.join(topFull, pkg.name) });
+            }
+          } catch (_) {}
+        }
+      }
+      const DEEP_PATHS = ['src/main/java','src/main/kotlin','src/main/scala','src-tauri/src','Sources/App','app/src/main/java','app/src/main/kotlin'];
+      for (const dp of DEEP_PATHS) {
+        const full = path.join(cwd, dp);
+        if (fs.existsSync(full)) candidates.push({ name: dp, full });
+      }
+      return candidates;
+    })(cwd, isMonorepo, ignorePatterns, opts.exclude || []);
+    const scored = candidates
+      .map(({ name, full }) => ({
+        dir:   name,
+        full,
+        score: scoreCandidate(name, full, context),
+      }))
+      .filter(c => c.score > 0)
+      .sort((a, b) => b.score - a.score);
+    let roots = (function _applySpecialRules(scored, cwd, primaryFw, fwEntry, frameworks) {
+      let roots = [...scored];
+      if (primaryFw?.name === 'django' || frameworks.some(f => f.name === 'django')) {
+        try {
+          for (const e of fs.readdirSync(cwd, { withFileTypes: true })) {
+            if (!e.isDirectory()) continue;
+            const d = path.join(cwd, e.name);
+            if (fs.existsSync(path.join(d, 'models.py')) || fs.existsSync(path.join(d, 'views.py'))) {
+              if (!roots.find(r => r.dir === e.name)) {
+                roots.push({ dir: e.name, full: d, score: 5.0 });
+              }
+            }
+          }
+        } catch (_) {}
+        roots.sort((a, b) => b.score - a.score);
+      }
+      if (frameworks.some(f => f.name === 'swiftui')) {
+        try {
+          for (const e of fs.readdirSync(cwd, { withFileTypes: true })) {
+            if (!e.isDirectory()) continue;
+            const d = path.join(cwd, e.name);
+            const swiftCount = (fs.readdirSync(d).filter(f => f.endsWith('.swift'))).length;
+            if (swiftCount >= 3 && !roots.find(r => r.dir === e.name)) {
+              roots.push({ dir: e.name, full: d, score: 4.0 });
+            }
+          }
+        } catch (_) {}
+        roots.sort((a, b) => b.score - a.score);
+      }
+      return roots;
+    })(scored, cwd, primaryFw, fwEntry, frameworks);
+    roots = (function _dedupeNested(scored) {
+      const result = [];
+      for (const c of scored) {
+        const isNested = result.some(r => c.dir.startsWith(r.dir + '/'));
+        if (!isNested) result.push(c);
+      }
+      return result;
+    })(roots);
+    const MAX_ROOTS = 6;
+    roots = roots.slice(0, MAX_ROOTS).map(r => r.dir);
+    const confidence = (function _computeConfidence(frameworks, languages, scoredCount) {
+      if (frameworks.length > 0 && frameworks[0].confidence >= 0.90) return 'high';
+      if (languages.length > 0 && scoredCount > 0) return 'medium';
+      return 'low';
+    })(frameworks, languages, scored.length);
+    return {
+      roots,
+      languages,
+      frameworks,
+      confidence,
+      explanation: scored.slice(0, 8).map(c => ({
+        dir:   c.dir,
+        score: c.score,
+        reason: `score: ${c.score}`,
+      })),
+      isMonorepo,
+    };
+  }
+  module.exports = { resolveSourceRoots };
+};
+
 /**
  * SigMap — gen-context.js v1.2.0
  * Zero-dependency AI context engine.
@@ -7222,7 +7793,7 @@ const path = require('path');
 const os = require('os');
 const { execSync } = require('child_process');
 
-const VERSION = '6.5.1';
+const VERSION = '6.6.0';
 const MARKER = '\n\n## Auto-generated signatures\n<!-- Updated by gen-context.js -->\n';
 
 function requireSourceOrBundled(key) {
@@ -8429,6 +9000,13 @@ function runGenerate(cwd, config, reportMode, reportJson = false) {
   const hotCommits = config.hotCommits || 10;
   const recentFiles = config.diffPriority ? getRecentlyCommittedFiles(cwd, hotCommits) : new Set();
 
+  // v6.7: Load signature cache if enabled
+  let cache = null;
+  const { loadCache, saveCache, getChangedFiles, updateCacheEntries } = requireSourceOrBundled('./src/cache/sig-cache');
+  if (config.sigCache) {
+    cache = loadCache(cwd, VERSION);
+  }
+
   let inputTokenTotal = 0;
   let fileEntries = [];
   let testIndex = null;
@@ -8449,7 +9027,23 @@ function runGenerate(cwd, config, reportMode, reportJson = false) {
       continue;
     }
 
-    let sigs = detectAndExtract(filePath, content, config.maxSigsPerFile);
+    // v6.7: Check cache before extracting
+    let sigs = [];
+    if (cache) {
+      const cached = cache.get(filePath);
+      let mtime = 0;
+      try { mtime = fs.statSync(filePath).mtimeMs; } catch (_) {}
+      if (cached && cached.mtime === mtime) {
+        sigs = cached.sigs;
+      } else {
+        sigs = detectAndExtract(filePath, content, config.maxSigsPerFile);
+        if (sigs.length > 0) {
+          cache.set(filePath, { mtime, sigs });
+        }
+      }
+    } else {
+      sigs = detectAndExtract(filePath, content, config.maxSigsPerFile);
+    }
     if (sigs.length === 0) continue;
 
     // Baseline = estimated tokens of original source content for intuitive reduction stats.
@@ -8651,6 +9245,15 @@ function runGenerate(cwd, config, reportMode, reportJson = false) {
     process.stderr.write(lines.join('\n'));
   }
 
+  // v6.7: Save cache if enabled
+  if (config.sigCache && cache) {
+    try {
+      saveCache(cwd, VERSION, cache);
+    } catch (err) {
+      console.warn(`[sigmap] cache save failed: ${err.message}`);
+    }
+  }
+
   return result;
 }
 
@@ -9244,6 +9847,7 @@ function main() {
 
     const { detectIntent, buildSigIndex, rank } = requireSourceOrBundled('./src/retrieval/ranker');
     const { coverageScore } = requireSourceOrBundled('./src/analysis/coverage-score');
+    const { loadSession, saveSession, mergeSessionContext } = requireSourceOrBundled('./src/session/memory');
 
     const intent = detectIntent(query);
     const intentWeights = getIntentWeights(intent);
@@ -9254,7 +9858,21 @@ function main() {
       process.exit(1);
     }
 
-    const ranked = rank(query, sigIndex, { topK: 5, weights: intentWeights, cwd });
+    let ranked = rank(query, sigIndex, { topK: 5, weights: intentWeights, cwd });
+
+    // v6.8: --followup support — carry session context forward
+    const isFollowup = args.includes('--followup');
+    const session = isFollowup ? loadSession(cwd) : null;
+    if (session) {
+      ranked = mergeSessionContext(ranked, session, intent);
+      ranked.sort((a, b) => b.score - a.score);
+      if (!args.includes('--json')) {
+        process.stderr.write(`[sigmap] ♻  followup — carrying context from: "${session.lastQuery.slice(0, 60)}"\n`);
+      }
+    }
+
+    // v6.8: Save session for future --followup calls
+    saveSession(cwd, { intent, topFiles: ranked.slice(0, 5).map(r => ({ file: r.file, score: r.score })), query });
     const miniCtx = buildMiniContext(ranked, cwd);
     const outPath = path.join(cwd, '.context', 'query-context.md');
     fs.mkdirSync(path.dirname(outPath), { recursive: true });
@@ -9400,6 +10018,77 @@ function main() {
     process.exit(0);
   }
 
+  // v6.8: `sigmap plan "<goal>"` — analyze what files need changes and impact radius
+  if (args[0] === 'plan') {
+    const goal = args[1];
+    if (!goal || goal.startsWith('--')) {
+      console.error('[sigmap] Usage: sigmap plan "<goal>"');
+      console.error('  Example: sigmap plan "add rate limiting to the API"');
+      process.exit(1);
+    }
+
+    const { detectIntent, buildSigIndex, rank } = requireSourceOrBundled('./src/retrieval/ranker');
+
+    const intent = detectIntent(goal);
+    const intentWeights = getIntentWeights(intent);
+
+    const sigIndex = buildSigIndex(cwd);
+    if (sigIndex.size === 0) {
+      console.error('[sigmap] no context file found. Run: sigmap (to generate first)');
+      process.exit(1);
+    }
+
+    const ranked = rank(goal, sigIndex, { topK: 15, weights: intentWeights, cwd });
+
+    // Separate into confidence levels
+    const highConf = ranked.filter(r => r.confidence === 'high').slice(0, 5);
+    const medConf = ranked.filter(r => r.confidence === 'medium').slice(0, 5);
+
+    // Compute impact radius (simplified — no graph for now)
+    let impact = null;
+
+    // Identify likely-affected tests (simplified — checks for .test. or .spec. in filename)
+    const testedFiles = highConf.filter(r => /\.(test|spec)\.(js|ts|py)$|_test\.(js|ts|py)$/.test(r.file));
+
+    if (args.includes('--json')) {
+      process.stdout.write(JSON.stringify({
+        goal, intent,
+        inspectFirst: highConf.map(r => r.file),
+        likelyToChange: medConf.map(r => r.file),
+        impactRadius: impact,
+        testsAffected: testedFiles.map(r => r.file),
+      }, null, 2) + '\n');
+    } else {
+      const bar = '─'.repeat(50);
+      console.log(bar);
+      console.log(` sigmap plan  "${goal}"`);
+      console.log(` Intent     : ${intent}`);
+      console.log(bar);
+      console.log('');
+      console.log(' Inspect first (highest relevance):');
+      if (highConf.length === 0) {
+        console.log('   (no files found)');
+      } else {
+        highConf.forEach((r, i) => console.log(`   ${i + 1}. ${path.relative(cwd, r.file)}`));
+      }
+      console.log('');
+      console.log(' Likely to change:');
+      if (medConf.length === 0) {
+        console.log('   (no files found)');
+      } else {
+        medConf.forEach((r, i) => console.log(`   ${i + 1}. ${path.relative(cwd, r.file)}`));
+      }
+      if (testedFiles.length > 0) {
+        console.log('');
+        console.log(' Tests to run after change:');
+        testedFiles.forEach(r => console.log(`   • ${path.relative(cwd, r.file)}`));
+      }
+      console.log('');
+      console.log(bar);
+    }
+    process.exit(0);
+  }
+
   // v5.9: `sigmap bench --submit` — format local benchmark history as a shareable community block
   if (args[0] === 'bench' && args.includes('--submit')) {
     const versionMeta = (() => {
@@ -9954,6 +10643,19 @@ function main() {
       const fakeEntries = allFiles.map(f => ({ filePath: f }));
       coverageResult = coverageScore(cwd, fakeEntries, cfg);
     } catch (_) {}
+    // v6.7: Collect cache stats if enabled
+    let cacheStats = null;
+    try {
+      const cachePath = path.join(cwd, '.sigmap-cache.json');
+      if (fs.existsSync(cachePath)) {
+        const raw = fs.readFileSync(cachePath, 'utf8');
+        const data = JSON.parse(raw);
+        const sizeKb = Math.round(Buffer.byteLength(raw) / 1024);
+        const entries = Object.keys(data.entries || {}).length;
+        const mtime = fs.statSync(cachePath).mtimeMs;
+        cacheStats = { sizeKb, entries, mtimeMs: mtime };
+      }
+    } catch (_) {}
     if (args.includes('--json')) {
       // Feature 3 (VS Code) + Feature 5 (JetBrains): emit tokens + reduction for plugins
       const ctxPath = path.join(cwd, '.github', 'copilot-instructions.md');
@@ -9970,6 +10672,9 @@ function main() {
         payload.coverageTotalFiles = coverageResult.total;
         payload.coverageIncludedFiles = coverageResult.included;
       }
+      if (cacheStats) {
+        payload.cacheStats = cacheStats;
+      }
       process.stdout.write(JSON.stringify(payload) + '\n');
     } else {
       console.log('[sigmap] health:');
@@ -9983,6 +10688,9 @@ function main() {
       if (result.strategyFreshnessDays !== null) {
         console.log(`  cold freshness  : ${result.strategyFreshnessDays} day(s)`);
       }
+      if (cacheStats) {
+        console.log(`  sig-cache       : ${cacheStats.entries} files cached  ${cacheStats.sizeKb}KB on disk`);
+      }
       console.log(`  total runs      : ${result.totalRuns}`);
       console.log(`  over-budget runs: ${result.overBudgetRuns}`);
       console.log(`  p50 token count : ${result.p50TokenCount}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sigmap",
-  "version": "6.5.1",
+  "version": "6.6.0",
   "description": "Zero-dependency AI context engine — 97% token reduction. No npm install. Runs on Node 18+.",
   "main": "gen-context.js",
   "exports": {

package/packages/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sigmap-cli",
-  "version": "6.5.1",
+  "version": "6.6.0",
   "description": "SigMap CLI wrapper — thin adapter for programmatic CLI invocation",
   "main": "index.js",
   "keywords": [

package/packages/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sigmap-core",
-  "version": "6.5.1",
+  "version": "6.6.0",
   "description": "SigMap core library — zero-dependency code signature extraction, retrieval, and security scanning",
   "main": "index.js",
   "keywords": [

package/src/config/defaults.js

@@ -125,6 +125,9 @@ const DEFAULTS = {
   // Directories scanned for tests when testCoverage is enabled
   testDirs: ['tests', 'test', '__tests__', 'spec'],
 
+  // Enable incremental signature cache (v6.7) - only re-extract changed files
+  sigCache: false,
+
   // Add reverse dependency usage hints on file headings (opt-in)
   impactRadius: false,
 

package/src/mcp/server.js

@@ -18,7 +18,7 @@ const { readContext, searchSignatures, getMap, createCheckpoint, getRouting, exp
 
 const SERVER_INFO = {
   name: 'sigmap',
-  version: '6.5.1',
+  version: '6.6.0',
   description: 'SigMap MCP server — code signatures on demand',
 };
 

package/src/plan/planner.js

@@ -0,0 +1,65 @@
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+const { buildFromCwd } = require('../graph/builder');
+const { getImpact } = require('../graph/impact');
+const { buildSigIndex, rank, detectIntent } = require('../retrieval/ranker');
+const { buildTestIndex, isTested } = require('../extractors/coverage');
+
+module.exports = { createPlan };
+
+function createPlan(goal, cwd, config) {
+  // Step 1: Detect intent and rank files for the goal
+  const intent = detectIntent(goal);
+  const sigIndex = buildSigIndex(cwd);
+  if (sigIndex.size === 0) {
+    return { error: 'no context found' };
+  }
+
+  const ranked = rank(goal, sigIndex, { topK: 15, cwd });
+
+  // Step 2: Separate into confidence levels
+  const highConf = ranked.filter(r => r.confidence === 'high').slice(0, 5);
+  const medConf = ranked.filter(r => r.confidence === 'medium').slice(0, 5);
+
+  // Step 3: Compute impact radius for highest-confidence file
+  let impact = null;
+  if (highConf.length > 0) {
+    const entryFile = highConf[0].file;
+    try {
+      const graph = buildFromCwd(cwd);
+      impact = getImpact(entryFile, graph, { maxDepth: 3, cwd });
+    } catch (_) {
+      // Graph build failed, continue without impact
+    }
+  }
+
+  // Step 4: Identify likely-affected tests
+  let testedFiles = [];
+  try {
+    const testIndex = buildTestIndex(cwd, config.testDirs || ['test', 'tests', '__tests__', 'spec']);
+    testedFiles = highConf.filter(r => {
+      const sigs = r.sigs || [];
+      const fnNames = sigs.map(s => {
+        const m = s.match(/(?:function|def|fn)\s+(\w+)/);
+        return m ? m[1] : null;
+      }).filter(Boolean);
+      return fnNames.some(fn => isTested(fn, testIndex));
+    });
+  } catch (_) {
+    // Coverage index failed, continue without test info
+  }
+
+  return {
+    goal,
+    intent,
+    inspectFirst: highConf.map(r => r.file),
+    likelyToChange: medConf.map(r => r.file),
+    impactRadius: impact ? {
+      direct: [...(impact.direct || [])],
+      transitive: [...(impact.transitive || [])],
+    } : null,
+    testsAffected: testedFiles.map(r => r.file),
+  };
+}

package/src/retrieval/ranker.js

@@ -32,6 +32,12 @@ const DEFAULT_WEIGHTS = {
   graphBoost: 0.4,       // additive bonus for 1-hop import neighbors of matching files
 };
 
+// Graph boost amounts for 2-hop traversal with decay (v6.7)
+const GRAPH_BOOST_AMOUNTS = {
+  hop1: 0.40,   // direct import neighbor of a file with score > 0
+  hop2: 0.15,   // 2 hops away (transitive), with decay
+};
+
 // Intent-specific weight adjustments
 const INTENT_WEIGHTS = {
   search:     DEFAULT_WEIGHTS,
@@ -61,6 +67,26 @@ function _computePenalty(filePath) {
   return 1.0;
 }
 
+// Detect hub files: those with fanout > 20% of all files in the graph
+function _computeHubs(graph) {
+  if (!graph || !graph.reverse) return new Set();
+  const fileCount = Math.max(1, graph.reverse.size);
+  const threshold = Math.ceil(fileCount * 0.2);
+  const hubs = new Set();
+  for (const [file, deps] of graph.reverse) {
+    if ((deps && deps.size >= threshold) || (Array.isArray(deps) && deps.length >= threshold)) {
+      hubs.add(file);
+    }
+  }
+  return hubs;
+}
+
+// Common utility paths that should be treated as hubs regardless of fanout
+function _isHub(filePath) {
+  return /\/(utils|helpers|shared|common|constants|types|interfaces|index)\.(ts|tsx|js|jsx)$/.test(filePath)
+      || filePath.endsWith('/index.ts') || filePath.endsWith('/index.js');
+}
+
 /**
  * Score a single file against a query, returning detailed signal breakdown.
  *
@@ -198,26 +224,54 @@ function rank(query, sigIndex, opts) {
     });
   }
 
-  // Graph neighbor boost: for each file with score > 0, add graphBoost to 1-hop forward
-  // neighbors that are also in the index. sigIndex uses relative paths; graph uses absolute.
+  // Graph neighbor boost: 2-hop traversal with decay (v6.7)
+  // Hop 1: add hop1 amount to direct import neighbors (score > 0)
+  // Hop 2: add hop2 amount to neighbors of hop1 files (with decay)
+  // Hub suppression: files with high fanout (>20%) are not boosted
   if (graph && cwd) {
     const path = require('path');
-    // Build a map: relative path → index position in scored array for O(1) lookup
+    // Build maps for relative ↔ absolute path conversion and index lookup
     const relToIdx = new Map();
+    const absToRel = new Map();
     for (let i = 0; i < scored.length; i++) {
       relToIdx.set(scored[i].file, i);
+      const abs = path.resolve(cwd, scored[i].file);
+      absToRel.set(abs, scored[i].file);
     }
+
+    const hubs = _computeHubs(graph);
+    const hop1Files = new Set(); // track which files received hop1 boost
+
+    // Hop 1: direct neighbors of scored files
     for (const entry of scored) {
       if (entry.score <= 0) continue;
-      // Resolve relative path to absolute for graph lookup
       const abs = path.resolve(cwd, entry.file);
       const neighbors = graph.forward.get(abs) || [];
       for (const neighborAbs of neighbors) {
+        if (_isHub(neighborAbs) || hubs.has(neighborAbs)) continue;
         const neighborRel = path.relative(cwd, neighborAbs).replace(/\\/g, '/');
         const idx = relToIdx.get(neighborRel);
         if (idx !== undefined) {
-          scored[idx].score += weights.graphBoost;
-          scored[idx].signals.graphBoost = (scored[idx].signals.graphBoost || 0) + weights.graphBoost;
+          scored[idx].score += GRAPH_BOOST_AMOUNTS.hop1;
+          scored[idx].signals.graphBoost = (scored[idx].signals.graphBoost || 0) + GRAPH_BOOST_AMOUNTS.hop1;
+          hop1Files.add(neighborAbs);
+        }
+      }
+    }
+
+    // Hop 2: neighbors of hop1 files (only if they didn't get a direct score)
+    for (const hop1File of hop1Files) {
+      if (!absToRel.has(hop1File)) continue; // skip files not in index
+      const neighbors = graph.forward.get(hop1File) || [];
+      for (const neighborAbs of neighbors) {
+        if (_isHub(neighborAbs) || hubs.has(neighborAbs)) continue;
+        if (hop1Files.has(neighborAbs)) continue; // skip already hop1-boosted
+        const neighborRel = path.relative(cwd, neighborAbs).replace(/\\/g, '/');
+        const idx = relToIdx.get(neighborRel);
+        if (idx !== undefined && scored[idx].score > 0) {
+          // Only boost files that have some baseline score (not noise)
+          scored[idx].score += GRAPH_BOOST_AMOUNTS.hop2;
+          scored[idx].signals.graphBoost = (scored[idx].signals.graphBoost || 0) + GRAPH_BOOST_AMOUNTS.hop2;
         }
       }
     }
@@ -425,4 +479,4 @@ function detectIntent(query) {
   return 'search';
 }
 
-module.exports = { rank, buildSigIndex, scoreFile, formatRankTable, formatRankJSON, DEFAULT_WEIGHTS, detectIntent };
+module.exports = { rank, buildSigIndex, scoreFile, formatRankTable, formatRankJSON, DEFAULT_WEIGHTS, GRAPH_BOOST_AMOUNTS, detectIntent };

package/src/session/memory.js

@@ -0,0 +1,56 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+module.exports = { loadSession, saveSession, mergeSessionContext, clearSession };
+
+const SESSION_TTL_MS = 4 * 60 * 60 * 1000;   // 4 hours — one coding session
+
+function sessionPath(cwd) {
+  return path.join(cwd, '.context', 'session.json');
+}
+
+function loadSession(cwd) {
+  const p = sessionPath(cwd);
+  if (!fs.existsSync(p)) return null;
+  try {
+    const raw = JSON.parse(fs.readFileSync(p, 'utf8'));
+    if (Date.now() - raw.ts > SESSION_TTL_MS) return null;  // expired
+    return raw;
+  } catch {
+    return null;
+  }
+}
+
+function saveSession(cwd, { intent, topFiles, query }) {
+  const p = sessionPath(cwd);
+  fs.mkdirSync(path.dirname(p), { recursive: true });
+  fs.writeFileSync(p, JSON.stringify({
+    ts: Date.now(),
+    intent,
+    topFiles,   // [{ file, score }] — top 5 from last ask
+    lastQuery: query,
+  }));
+}
+
+// Merge session context as additional ranking signal:
+// any file that appeared in the previous session's top-5 gets a +0.2 boost
+// Reduce to +0.1 if the intent has changed (topic switch guard)
+function mergeSessionContext(scores, session, currentIntent) {
+  if (!session) return scores;
+
+  const boostAmount = session.intent === currentIntent ? 0.20 : 0.10;
+  const sessionBoost = new Map(session.topFiles.map(f => [f.file, boostAmount]));
+
+  return scores.map(r => ({
+    ...r,
+    // Additive boost — cannot reduce a score
+    score: r.score + (sessionBoost.get(r.file) || 0),
+  }));
+}
+
+function clearSession(cwd) {
+  const p = sessionPath(cwd);
+  if (fs.existsSync(p)) fs.unlinkSync(p);
+}