sigmap 6.10.0 → 6.10.2

package/AGENTS.md

@@ -56,27 +56,39 @@ 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 — 0 seconds ago)
+## changes (last 5 commits — 3 days ago)
+## deps
 ```
-src/eval/usefulness-scorer.js                 +scoreUsefulness  +computeUsefulnessStats
-src/workspace/detector.js                     +detectWorkspaces  +inferPackage  +_getMatchLength  +scopeToPackage
+src/extractors/python_ast.py ← ast
 ```
 
 ## packages
 
-### packages/cli/index.js
+### packages/core/index.js
 ```
-module.exports = { CLI_ENTRY, run }
-function run(argv, cwd) → void
+module.exports = { extract, rank, buildSigIndex, scan, score, adapt }
+function _resolveExtractor(language)
+function extract(src, language) → string[]
+function rank(query, sigIndex, opts) → { file: string, score: nu
+function buildSigIndex(cwd) → Map<string, string[]>
+function scan(sigs, filePath) → { safe: string[], redacte
+function score(cwd) → { * score: number, * grad
+function adapt(context, adapterName, opts = {}) → string
+## changes (last 5 commits — 1 second ago)
+```
+src/discovery/source-root-resolver.js         ~_applySpecialRules  ~_dedupeNested
+src/map/import-graph.js                       ~analyze
+packages/adapters/index.js                    ~getAdapter
+packages/adapters/willow.js                   +format  +outputPath  +generateAtomId  +fetchWithTimeout
 ```
 
-### packages/adapters/index.js
+## src
+
+### src/discovery/sigmapignore.js
+### packages/cli/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[]
+module.exports = { CLI_ENTRY, run }
+function run(argv, cwd) → void
 ```
 
 ### packages/adapters/llm-full.js
@@ -107,260 +119,260 @@ code-fence js
 code-fence ---
 ```
 
-### packages/core/index.js
-```
-module.exports = { extract, rank, buildSigIndex, scan, score, adapt }
-function _resolveExtractor(language)
-function extract(src, language) → string[]
-function rank(query, sigIndex, opts) → { file: string, score: nu
-function buildSigIndex(cwd) → Map<string, string[]>
-function scan(sigs, filePath) → { safe: string[], redacte
-function score(cwd) → { * score: number, * grad
-function adapt(context, adapterName, opts = {}) → string
-```
-
 ### packages/adapters/copilot.js
 ```
-module.exports = { name, format, outputPath, write }
-function format(context, opts = {}) → string
-function _confidenceMeta(opts)
-function outputPath(cwd) → string
-function write(context, cwd, opts = {})
+module.exports = { loadIgnorePatterns, matchesIgnorePattern }
+function loadIgnorePatterns(cwd)
+function matchesIgnorePattern(dirName, patterns)
 ```
 
-### packages/adapters/cursor.js
+### src/discovery/source-root-registry.js
 ```
-module.exports = { name, format, outputPath }
-function format(context, opts = {}) → string
-function _confidenceMeta(opts)
-function outputPath(cwd) → string
+module.exports = { REGISTRY }
 ```
 
-### packages/adapters/gemini.js
+### src/discovery/source-root-resolver.js
 ```
-module.exports = { name, format, outputPath, write }
-function format(context, opts = {}) → string
-function outputPath(cwd) → string
-function write(context, cwd, opts = {})
-function _confidenceMeta(opts)
+module.exports = { resolveSourceRoots }
+function resolveSourceRoots(cwd, opts = {})
+function _detectMonorepo(cwd)
+function _enumerateCandidates(cwd, isMonorepo, ignorePatterns, excludeList)
+function _applySpecialRules(scored, cwd, primaryFw, fwEntry, frameworks)
+function _dedupeNested(scored)
+function _computeConfidence(frameworks, languages, scoredCount)
 ```
 
-### packages/adapters/openai.js
+### src/discovery/source-root-scorer.js
 ```
-module.exports = { name, format, outputPath }
-function format(context, opts = {}) → string
-function outputPath(cwd) → string
-function _confidenceMeta(opts)
+module.exports = { scoreCandidate, getRecentlyChangedDirs, ROOT_ENTRYPOINTS, JVM_PATH_PATTERN }
+function getRecentlyChangedDirs(cwd)
+function scoreCandidate(dirName, fullPath, context)
+function _countSourceFiles(dir, depth)
 ```
 
-### packages/adapters/windsurf.js
+### src/eval/runner.js
 ```
-module.exports = { name, format, outputPath }
-function format(context, opts = {}) → string
-function _confidenceMeta(opts)
-function outputPath(cwd) → string
+module.exports = { run, rank, loadTasks, buildSigIndex, formatTable, formatMetrics, tokenize }
+function buildSigIndex(cwd) → Map<string, string[]>
+function tokenize(text) → string[]
+function scoreFile(sigs, queryTokens) → number
+function rank(query, index, topK = 10) → { file: string, score: nu
+function estimateTokens(sigs) → number
+function loadTasks(tasksFile) → Array<{id:string, query:s
+function run(tasksFile, cwd, opts = {}) → { * tasks: Array<{id, que
+function formatTable(taskResults) → string
+function formatMetrics(metrics) → string
 ```
 
-### packages/adapters/claude.js
+### src/eval/scorer.js
 ```
-module.exports = { name, format, outputPath, write }
-function format(context, opts = {}) → string
-function _confidenceMeta(opts)
-function outputPath(cwd) → string
-function write(context, cwd, opts = {})
+module.exports = { hitAtK, reciprocalRank, precisionAtK, aggregate, firstRank }
+function firstRank(ranked, expected) → number
+function normalizePath(p) → string
+function hitAtK(ranked, expected, k = 5) → 0|1
+function reciprocalRank(ranked, expected) → number
+function precisionAtK(ranked, expected, k = 5) → number
+function aggregate(results, k = 5) → { * hitAt5: number, // fr
+function round(x)
 ```
 
-### packages/adapters/codex.js
+### src/extractors/coverage.js
 ```
-module.exports = { name, format, outputPath, write }
-function format(context, opts = {}) → string
-function outputPath(cwd) → string
-function write(context, cwd, opts = {})
+module.exports = { buildTestIndex, isTested }
+function walkFiles(dir)
+function buildTestIndex(cwd, testDirs)
+function isTested(funcName, testIndex)
 ```
 
-## src
-
-### src/extractors/python.js
+### src/extractors/cpp.js
 ```
 module.exports = { extract }
 function extract(src) → string[]
-function extractClassMethods(stripped, startIndex)
-function tryExtractDataclassFields(stripped, classIndex)
-function tryExtractBaseModelFields(stripped, bodyStart)
-function extractClassConstants(stripped, startIndex)
-function extractReturnType(sigLine)
+function extractBlock(src, startIndex)
+function extractMembers(block)
 function normalizeParams(params)
-function extractDocHint(src, fnName, fnSigLine)
+function normalizeType(type)
 ```
 
-### src/extractors/ruby.js
+### src/extractors/csharp.js
 ```
 module.exports = { extract }
 function extract(src) → string[]
+function extractBlock(src, startIndex)
+function extractMembers(block)
 function normalizeParams(params)
-function extractReturnHint(stripped, index)
+function normalizeType(type)
 ```
 
-### src/extractors/rust.js
+### src/extractors/css.js
 ```
 module.exports = { extract }
 function extract(src) → string[]
-function extractBlock(src, startIndex)
-function extractMethods(block)
-function normalizeParams(params)
-function extractReturnType(afterParen)
 ```
 
-### src/extractors/scala.js
+### src/extractors/dart.js
 ```
 module.exports = { extract }
 function extract(src) → string[]
 function extractBlock(src, startIndex)
 function extractMembers(block)
 function normalizeParams(params)
-function normalizeType(type)
 ```
 
-### src/extractors/svelte.js
+### src/extractors/deps.js
 ```
-module.exports = { extract }
-function extract(src) → string[]
-function normalizeParams(params)
-function normalizeType(type)
+module.exports = { extractPythonDeps, extractTSDeps, buildReverseDepMap }
+function extractPythonDeps(src) → string[]
+function extractTSDeps(src) → string[]
+function buildReverseDepMap(forwardMap) → Map<string, string[]>
 ```
 
-### src/extractors/swift.js
+### src/extractors/dockerfile.js
 ```
 module.exports = { extract }
 function extract(src) → string[]
-function extractBlock(src, startIndex)
-function extractMembers(block)
-function normalizeParams(params)
-function extractArrowType(str)
 ```
 
-### src/extractors/todos.js
+### src/extractors/generic.js
 ```
-module.exports = { extractTodos }
-function extractTodos(src) → {line:number, tag:string,
+module.exports = { extract }
+function extract(src)
 ```
 
-### src/extractors/vue.js
+### src/extractors/go.js
 ```
 module.exports = { extract }
 function extract(src) → string[]
+function extractBlock(src, startIndex)
+function extractInterfaceMethods(block)
 function normalizeParams(params)
-function normalizeType(type)
 ```
 
-### src/eval/scorer.js
+### src/extractors/graphql.js
 ```
-module.exports = { hitAtK, reciprocalRank, precisionAtK, aggregate, firstRank }
-function firstRank(ranked, expected) → number
-function normalizePath(p) → string
-function hitAtK(ranked, expected, k = 5) → 0|1
-function reciprocalRank(ranked, expected) → number
-function precisionAtK(ranked, expected, k = 5) → number
-function aggregate(results, k = 5) → { * hitAt5: number, // fr
-function round(x)
+module.exports = { extract }
+function extract(src) → string[]
 ```
 
-### src/eval/runner.js
+### src/extractors/html.js
 ```
-module.exports = { run, rank, loadTasks, buildSigIndex, formatTable, formatMetrics, tokenize }
-function buildSigIndex(cwd) → Map<string, string[]>
-function tokenize(text) → string[]
-function scoreFile(sigs, queryTokens) → number
-function rank(query, index, topK = 10) → { file: string, score: nu
-function estimateTokens(sigs) → number
-function loadTasks(tasksFile) → Array<{id:string, query:s
-function run(tasksFile, cwd, opts = {}) → { * tasks: Array<{id, que
-function formatTable(taskResults) → string
-function formatMetrics(metrics) → string
+module.exports = { extract }
+function extract(src) → string[]
 ```
 
-### src/retrieval/tokenizer.js
+### src/extractors/java.js
 ```
-module.exports = { tokenize, STOP_WORDS }
-function tokenize(text, opts) → string[]
+module.exports = { extract }
+function extract(src) → string[]
+function extractBlock(src, startIndex)
+function extractMembers(block)
+function normalizeParams(params)
+function normalizeType(type)
 ```
 
-### src/graph/builder.js
+### src/extractors/javascript.js
 ```
-module.exports = { build, buildFromCwd, extractFileDeps }
-function resolveJsPath(dir, importStr, fileSet) → string|null
-function extractFileDeps(filePath, content, fileSet) → string[]
-function build(files, cwd) → { forward: Map<string,str
-function buildFromCwd(cwd, opts) → { forward: Map<string,str
+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/graph/impact.js
+### src/extractors/kotlin.js
+### packages/adapters/index.js
 ```
-module.exports = { getImpact, analyzeImpact, formatImpact, formatImpactJSON }
-function bfs(startFile, reverseGraph, maxDepth) → { direct: Set<string>, tr
-function isTestFile(f)
-function isRouteFile(f)
-function getImpact(changedFile, graph, opts) → { * changed: string, * di
-function analyzeImpact(changedFiles, cwd, opts) → { file: string, impact: o
-function formatImpact(result) → string
-function formatImpactJSON(result) → object
+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[]
 ```
 
-### src/mcp/tools.js
+### packages/adapters/willow.js
 ```
-module.exports = { TOOLS }
+module.exports = { name, format, outputPath, write }
+function format(context, opts = {}) → string
+function outputPath(cwd) → string
+function generateAtomId(filepath) → string
+async function fetchWithTimeout(url, opts, timeoutMs) → Promise<Response>
+async function postAtomWithRetry(atom, mcpUrl, timeoutMs, maxRetries) → Promise<boolean>
+async function write(context, cwd, opts = {}) → Promise<void>
 ```
 
-### src/health/scorer.js
+### packages/core/index.js
 ```
-module.exports = { score }
+module.exports = { extract, rank, buildSigIndex, scan, score, adapt }
+function _resolveExtractor(language)
+function extract(src, language) → string[]
+function rank(query, sigIndex, opts) → { file: string, score: nu
+function buildSigIndex(cwd) → Map<string, string[]>
+function scan(sigs, filePath) → { safe: string[], redacte
 function score(cwd) → { * score: number, * grad
+function adapt(context, adapterName, opts = {}) → string
 ```
 
-### src/extractors/coverage.js
+### packages/adapters/willow.js
 ```
-module.exports = { buildTestIndex, isTested }
-function walkFiles(dir)
-function buildTestIndex(cwd, testDirs)
-function isTested(funcName, testIndex)
+module.exports = { name, format, outputPath, write }
+function format(context, opts = {}) → string
+function outputPath(cwd) → string
+function generateAtomId(filepath) → string
+async function fetchWithTimeout(url, opts, timeoutMs) → Promise<Response>
+async function postAtomWithRetry(atom, mcpUrl, timeoutMs, maxRetries) → Promise<boolean>
+async function write(context, cwd, opts = {}) → Promise<void>
 ```
 
-### src/extractors/css.js
+### packages/adapters/index.js
 ```
-module.exports = { extract }
-function extract(src) → string[]
+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[]
 ```
 
-### src/extractors/sql.js
+## src
+
+### src/retrieval/tokenizer.js
 ```
 module.exports = { extract }
 function extract(src) → string[]
-function _cleanName(raw)
-function _normalizeParams(raw)
+function extractBlock(src, startIndex)
+function extractMembers(block)
+function normalizeParams(params)
 ```
 
-### src/extractors/graphql.js
+### src/extractors/markdown.js
 ```
 module.exports = { extract }
 function extract(src) → string[]
 ```
 
-### src/extractors/protobuf.js
+### src/extractors/patterns.js
 ```
 module.exports = { extract }
 function extract(src) → string[]
 ```
 
-### src/extractors/terraform.js
+### src/extractors/php.js
 ```
 module.exports = { extract }
 function extract(src) → string[]
+function extractBlock(src, startIndex)
+function extractMembers(block)
+function normalizeParams(params)
+function normalizeType(type)
 ```
 
-### src/extractors/markdown.js
+### src/extractors/prdiff.js
 ```
-module.exports = { extract }
-function extract(src) → string[]
+module.exports = { diffSignatures, extractName }
+function diffSignatures(baseSigs, currentSigs) → {added:string[], removed:
+function extractName(sig)
 ```
 
 ### src/extractors/properties.js
@@ -369,104 +381,150 @@ module.exports = { extract }
 function extract(src) → string[]
 ```
 
-### src/extractors/toml.js
+### src/extractors/protobuf.js
 ```
 module.exports = { extract }
 function extract(src) → string[]
 ```
 
-### src/extractors/xml.js
+### src/extractors/python.js
 ```
 module.exports = { extract }
 function extract(src) → string[]
+function extractClassMethods(stripped, startIndex)
+function tryExtractDataclassFields(stripped, classIndex)
+function tryExtractBaseModelFields(stripped, bodyStart)
+function extractClassConstants(stripped, startIndex)
+function extractReturnType(sigLine)
+function normalizeParams(params)
+function extractDocHint(src, fnName, fnSigLine)
 ```
 
-### src/extractors/patterns.js
+### src/extractors/python_dataclass.js
 ```
 module.exports = { extract }
 function extract(src) → string[]
 ```
 
-### src/extractors/python_dataclass.js
+### src/extractors/ruby.js
 ```
 module.exports = { extract }
 function extract(src) → string[]
+function normalizeParams(params)
+function extractReturnHint(stripped, index)
 ```
 
-### src/extractors/typescript_react.js
+### src/extractors/rust.js
 ```
 module.exports = { extract }
 function extract(src) → string[]
+function extractBlock(src, startIndex)
+function extractMethods(block)
+function normalizeParams(params)
+function extractReturnType(afterParen)
 ```
 
-### src/extractors/vue_sfc.js
+### src/extractors/scala.js
 ```
 module.exports = { extract }
 function extract(src) → string[]
+function extractBlock(src, startIndex)
+function extractMembers(block)
+function normalizeParams(params)
+function normalizeType(type)
 ```
 
-### src/extractors/generic.js
+### src/extractors/shell.js
 ```
 module.exports = { extract }
-function extract(src)
+function extract(src) → string[]
 ```
 
-### src/format/llm-txt.js
+### src/extractors/sql.js
 ```
-module.exports = { format, outputPath }
-function outputPath(cwd)
-function format(context, cwd, version)
+module.exports = { extract }
+function extract(src) → string[]
+function _cleanName(raw)
+function _normalizeParams(raw)
 ```
 
-### src/format/llms-txt.js
+### src/extractors/svelte.js
 ```
-module.exports = { format, outputPath }
-function outputPath(cwd)
-function getShortCommit(cwd)
-function detectVersion(cwd)
-function format(context, cwd, writtenFiles, sigmapVersion)
+module.exports = { extract }
+function extract(src) → string[]
+function normalizeParams(params)
+function normalizeType(type)
 ```
 
-### src/eval/analyzer.js
+### src/extractors/swift.js
 ```
-module.exports = { analyzeFiles, formatAnalysisTable, formatAnalysisJSON }
-function isDockerfile(name)
-function getExtractorName(filePath)
-function tokenCount(sigs)
-function hasCoverage(filePath, cwd)
-function loadExtractor(name, cwd)
-function analyzeFiles(files, cwd, opts) → object[]
-function formatAnalysisTable(stats, showSlow) → string
-function formatAnalysisJSON(stats) → object
+module.exports = { extract }
+function extract(src) → string[]
+function extractBlock(src, startIndex)
+function extractMembers(block)
+function normalizeParams(params)
+function extractArrowType(str)
+```
+
+### src/extractors/terraform.js
+```
+module.exports = { extract }
+function extract(src) → string[]
+```
+
+### src/extractors/todos.js
+```
+module.exports = { extractTodos }
+function extractTodos(src) → {line:number, tag:string,
+```
+
+### src/extractors/toml.js
+```
+module.exports = { extract }
+function extract(src) → string[]
+```
+
+### src/extractors/typescript.js
+```
+module.exports = { extract }
+function extract(src) → string[]
+function extractBlock(src, startIndex)
+function extractInterfaceMembers(block)
+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 }
+function extract(src) → string[]
+function normalizeParams(params)
+function normalizeType(type)
+```
+
+### src/extractors/vue_sfc.js
+```
+module.exports = { extract }
+function extract(src) → string[]
 ```
 
+### src/extractors/xml.js
 ### src/format/dashboard.js
 ```
-module.exports = { generateDashboardHtml, renderHistoryCharts, computeExtractorCoverage, percentile, overBudgetStreak }
-function toNumber(v)
-function percentile(values, p)
-function overBudgetStreak(entries)
-function loadConfig(cwd)
-function shouldExclude(rel, excludeSet)
-function detectLanguage(filePath)
-function walkFiles(dir, maxDepth, depth, out, excludeSet)
-function computeExtractorCoverage(cwd)
-function readBenchmarkTrend(cwd)
-function lineChartSvg(values, title, ySuffix)
-function barChartSvg(perLanguage)
-function sparkline(values)
-function buildDashboardData(cwd, health)
-function generateDashboardHtml(cwd, health)
-function renderHistoryCharts(cwd, health)
+module.exports = { extract }
+function extract(src) → string[]
 ```
 
-### src/judge/judge-engine.js
+### src/extractors/yaml.js
 ```
-module.exports = { groundedness, judge }
-function tokenize(text)
-function groundedness(response, context)
-function extractContextFiles(context, cwd)
-function judge(response, context, opts = {})
+module.exports = { extract }
+function extract(src) → string[]
 ```
 
 ### src/format/benchmark-report.js
@@ -496,53 +554,83 @@ function generateBenchmarkReportHtml(reports, opts = {})
 function writeBenchmarkReport(cwd, opts = {})
 ```
 
-### src/analysis/coverage-score.js
+### src/format/cache.js
 ```
-module.exports = { coverageScore, CODE_EXTS }
-function coverageScore(cwd, fileEntries, config)
-function _walk(dir, excludeSet, out)
+module.exports = { formatCache, formatCachePayload }
+function formatCache(content) → string
+function formatCachePayload(content, model) → string
 ```
 
-### src/cache/sig-cache.js
+### src/format/dashboard.js
 ```
-module.exports = { loadCache, saveCache, getChangedFiles, updateCacheEntries }
-function cachePath(cwd)
-function loadCache(cwd, currentVersion) → Map<string, { mtime: numb
-function saveCache(cwd, currentVersion, cache)
-function getChangedFiles(files, cache) → { changed: string[], unch
-function updateCacheEntries(cache, extracted)
+module.exports = { generateDashboardHtml, renderHistoryCharts, computeExtractorCoverage, percentile, overBudgetStreak }
+function toNumber(v)
+function percentile(values, p)
+function overBudgetStreak(entries)
+function loadConfig(cwd)
+function shouldExclude(rel, excludeSet)
+function detectLanguage(filePath)
+function walkFiles(dir, maxDepth, depth, out, excludeSet)
+function computeExtractorCoverage(cwd)
+function readBenchmarkTrend(cwd)
+function lineChartSvg(values, title, ySuffix)
+function barChartSvg(perLanguage)
+function sparkline(values)
+function buildDashboardData(cwd, health)
+function generateDashboardHtml(cwd, health)
+function renderHistoryCharts(cwd, health)
 ```
 
-### src/mcp/handlers.js
+### src/format/llm-txt.js
 ```
-module.exports = { readContext, searchSignatures, getMap, createCheckpoint, getRouting, explainFile, listModules, queryContext, getImpact }
-function readContext(args, cwd)
-function searchSignatures(args, cwd)
-function getMap(args, cwd)
-function createCheckpoint(args, cwd)
-function getRouting(args, cwd)
-function explainFile(args, cwd)
-function listModules(args, cwd)
-function queryContext(args, cwd)
-function getImpact(args, cwd)
+module.exports = { format, outputPath }
+function outputPath(cwd)
+function format(context, cwd, version)
 ```
 
-### src/tracking/logger.js
+### src/format/llms-txt.js
 ```
-module.exports = { logRun, readLog, summarize }
-function logRun(entry, cwd)
-function readLog(cwd) → object[]
-function summarize(entries) → object
+module.exports = { format, outputPath }
+function outputPath(cwd)
+function getShortCommit(cwd)
+function detectVersion(cwd)
+function format(context, cwd, writtenFiles, sigmapVersion)
 ```
 
-### src/extractors/typescript.js
+### src/graph/builder.js
 ```
-module.exports = { extract }
-function extract(src) → string[]
-function extractBlock(src, startIndex)
-function extractInterfaceMembers(block)
-function extractClassMembers(block)
-function normalizeParams(params)
+module.exports = { build, buildFromCwd, extractFileDeps }
+function resolveJsPath(dir, importStr, fileSet) → string|null
+function extractFileDeps(filePath, content, fileSet) → string[]
+function build(files, cwd) → { forward: Map<string,str
+function buildFromCwd(cwd, opts) → { forward: Map<string,str
+```
+
+### src/graph/impact.js
+```
+module.exports = { getImpact, analyzeImpact, formatImpact, formatImpactJSON }
+function bfs(startFile, reverseGraph, maxDepth) → { direct: Set<string>, tr
+function isTestFile(f)
+function isRouteFile(f)
+function getImpact(changedFile, graph, opts) → { * changed: string, * di
+function analyzeImpact(changedFiles, cwd, opts) → { file: string, impact: o
+function formatImpact(result) → string
+function formatImpactJSON(result) → object
+```
+
+### src/health/scorer.js
+```
+module.exports = { score }
+function score(cwd) → { * score: number, * grad
+```
+
+### src/judge/judge-engine.js
+```
+module.exports = { groundedness, judge }
+function tokenize(text)
+function groundedness(response, context)
+function extractContextFiles(context, cwd)
+function judge(response, context, opts = {})
 ```
 
 ### src/learning/weights.js
@@ -562,43 +650,52 @@ function exportWeights(cwd, outputPath)
 function importWeights(cwd, importPath, replace)
 ```
 
-### src/config/loader.js
+### src/map/class-hierarchy.js
 ```
-module.exports = { loadConfig, loadBaseConfig }
-function loadBaseConfig(extendsVal, cwd)
-function detectAutoSrcDirs(cwd, excludeList) → string[]
-function _legacyDetectAutoSrcDirs(cwd, excludeList) → string[]
-function loadConfig(cwd) → object
-function deepClone(obj)
+module.exports = { analyze }
+function analyze(files, cwd)
 ```
 
-### src/discovery/framework-detector.js
+### src/map/import-graph.js
 ```
-module.exports = { detectFrameworks }
-function detectFrameworks(cwd)
-function _readDeps(cwd)
-function _readFile(p)
-function _existsAnywhere(cwd, filename, maxDepth)
-function _walkFind(dir, name, depth)
+module.exports = { analyze }
+function extractImports(filePath, content, fileSet)
+function resolveJsPath(dir, importStr, fileSet)
+function detectCycles(graph)
+function analyze(files, cwd)
 ```
 
-### src/discovery/language-detector.js
+### src/map/route-table.js
 ```
-module.exports = { detectLanguages }
-function detectLanguages(cwd)
-function _walkDepth(dir, depth, extCount)
+module.exports = { analyze }
+function shouldSkipFile(rel)
+function analyze(files, cwd)
 ```
 
+### src/mcp/handlers.js
 ### src/discovery/sigmapignore.js
 ```
-module.exports = { loadIgnorePatterns, matchesIgnorePattern }
-function loadIgnorePatterns(cwd)
-function matchesIgnorePattern(dirName, patterns)
+module.exports = { readContext, searchSignatures, getMap, createCheckpoint, getRouting, explainFile, listModules, queryContext, getImpact }
+function readContext(args, cwd)
+function searchSignatures(args, cwd)
+function getMap(args, cwd)
+function createCheckpoint(args, cwd)
+function getRouting(args, cwd)
+function explainFile(args, cwd)
+function listModules(args, cwd)
+function queryContext(args, cwd)
+function getImpact(args, cwd)
 ```
 
-### src/discovery/source-root-registry.js
+### src/mcp/tools.js
 ```
-module.exports = { REGISTRY }
+module.exports = { TOOLS }
+```
+
+### src/plan/planner.js
+```
+module.exports = { createPlan }
+function createPlan(goal, cwd, config)
 ```
 
 ### src/retrieval/ranker.js
@@ -616,10 +713,34 @@ function formatRankJSON(results, query) → object
 function detectIntent(query)
 ```
 
-### src/plan/planner.js
+### src/retrieval/tokenizer.js
 ```
-module.exports = { createPlan }
-function createPlan(goal, cwd, config)
+module.exports = { tokenize, STOP_WORDS }
+function tokenize(text, opts) → string[]
+```
+
+### src/routing/classifier.js
+```
+module.exports = { classify, classifyAll }
+function classify(filePath, sigs) → 'fast'|'balanced'|'powerf
+function classifyAll(fileEntries, cwd) → { fast: string[], balance
+```
+
+### src/routing/hints.js
+```
+module.exports = { TIERS, formatRoutingSection }
+function formatRoutingSection(groups) → string
+```
+
+### src/security/patterns.js
+```
+module.exports = { PATTERNS }
+```
+
+### src/security/scanner.js
+```
+module.exports = { scan }
+function scan(signatures, filePath) → { safe: string[], redacte
 ```
 
 ### src/session/memory.js
@@ -632,17 +753,124 @@ function mergeSessionContext(scores, session, currentIntent)
 function clearSession(cwd)
 ```
 
-### src/config/defaults.js
+### src/tracking/logger.js
 ```
-module.exports = { DEFAULTS }
+module.exports = { logRun, readLog, summarize }
+function logRun(entry, cwd)
+function readLog(cwd) → object[]
+function summarize(entries) → object
 ```
 
-### src/discovery/source-root-scorer.js
+### src/eval/analyzer.js
 ```
-module.exports = { scoreCandidate, getRecentlyChangedDirs, ROOT_ENTRYPOINTS, JVM_PATH_PATTERN }
-function getRecentlyChangedDirs(cwd)
-function scoreCandidate(dirName, fullPath, context)
-function _countSourceFiles(dir, depth)
+module.exports = { analyzeFiles, formatAnalysisTable, formatAnalysisJSON }
+function isDockerfile(name)
+function getExtractorName(filePath)
+function tokenCount(sigs)
+function hasCoverage(filePath, cwd)
+function loadExtractor(name, cwd)
+function analyzeFiles(files, cwd, opts) → object[]
+function formatAnalysisTable(stats, showSlow) → string
+function formatAnalysisJSON(stats) → object
+```
+
+### src/discovery/language-detector.js
+### src/eval/usefulness-scorer.js
+```
+module.exports = { scoreUsefulness, computeUsefulnessStats }
+function scoreUsefulness(taskResult, rankingScore)
+function computeUsefulnessStats(taskResults)
+```
+
+### src/workspace/detector.js
+```
+module.exports = { detectWorkspaces, inferPackage, scopeToPackage }
+function detectWorkspaces(cwd)
+function inferPackage(query, workspaceDirs, cwd)
+function _getMatchLength(name, token)
+function scopeToPackage(filePath, packageDir)
+```
+
+### src/discovery/language-detector.js
+```
+module.exports = { detectLanguages }
+function detectLanguages(cwd)
+function _walkDepth(dir, depth, extCount)
+```
+
+### src/discovery/source-root-registry.js
+```
+module.exports = { REGISTRY }
+### src/discovery/language-detector.js
+```
+module.exports = { detectLanguages }
+function detectLanguages(cwd)
+function _walkDepth(dir, depth, extCount)
+```
+
+### src/extractors/gdscript.js
+```
+module.exports = { extract }
+function extract(src) → string[]
+function extractInnerMembers(stripped, startIndex)
+function normalizeParams(params)
+### src/discovery/source-root-registry.js
+```
+module.exports = { REGISTRY }
+```
+
+### src/eval/analyzer.js
+```
+module.exports = { analyzeFiles, formatAnalysisTable, formatAnalysisJSON }
+function isDockerfile(name)
+function getExtractorName(filePath)
+function tokenCount(sigs)
+function hasCoverage(filePath, cwd)
+function loadExtractor(name, cwd)
+function analyzeFiles(files, cwd, opts) → object[]
+function formatAnalysisTable(stats, showSlow) → string
+function formatAnalysisJSON(stats) → object
+```
+
+### src/extractors/python.js
+```
+module.exports = { extract, tryNativeExtract }
+function tryNativeExtract(filePath) → string[]|null
+function extract(src, filePath) → string[]
+function extractClassMethods(stripped, startIndex)
+function tryExtractDataclassFields(stripped, classIndex)
+function tryExtractBaseModelFields(stripped, bodyStart)
+function extractClassConstants(stripped, startIndex)
+function extractReturnType(sigLine)
+function normalizeParams(params)
+function extractDocHint(src, fnName, fnSigLine)
+```
+
+### src/extractors/python_ast.py
+```
+def annotation_to_str(node)  # Convert an AST annotation node to a string representation
+def format_args(args_node)  # Format a function arguments node into a compact signature st
+def get_decorator_names(node)  # Return a list of decorator name strings for a function/class
+def is_dataclass(node)
+def is_basemodel(bases)  # Check if class bases include BaseModel or BaseSettings
+def is_optional_annotation(annotation)  # Check if an annotation represents an Optional type
+def get_docstring_hint(node)  # Extract first sentence of docstring, if present
+def extract_dataclass_fields(class_node)  # Return a collapsed fields string for a @dataclass class
+def extract_basemodel_fields(class_node)  # Return a compact {required*, optional
+def extract_class_constants(class_node)  # Yield ALL_CAPS constant assignments from class body
+def extract_method_sig(func_node)  # Format a method signature string (already indented by caller
+def extract_function_sig(func_node, src_lines)  # Format a top-level function signature string
+def extract_fastapi_routes(tree, src_lines)  # Extract FastAPI route signatures from top-level decorated fu
+def extract(filepath)
+def main()
+```
+
+### src/extractors/r.js
+```
+module.exports = { extract }
+function extract(src) → string[]
+function readBalancedParens(src, openIdx, cap = 4096)
+function normalizeParams(raw)
 ```
 
 ### src/discovery/source-root-resolver.js
@@ -656,11 +884,13 @@ function _dedupeNested(scored)
 function _computeConfidence(frameworks, languages, scoredCount)
 ```
 
-### src/eval/usefulness-scorer.js
+### src/map/import-graph.js
 ```
-module.exports = { scoreUsefulness, computeUsefulnessStats }
-function scoreUsefulness(taskResult, rankingScore)
-function computeUsefulnessStats(taskResults)
+module.exports = { analyze, extractImports }
+function extractImports(filePath, content, fileSet)
+function resolveJsPath(dir, importStr, fileSet)
+function detectCycles(graph)
+function analyze(files, cwd)
 ```
 
 ### src/mcp/server.js
@@ -671,12 +901,3 @@ function respondError(id, code, message)
 function dispatch(msg, cwd)
 function start(cwd)
 ```
-
-### src/workspace/detector.js
-```
-module.exports = { detectWorkspaces, inferPackage, scopeToPackage }
-function detectWorkspaces(cwd)
-function inferPackage(query, workspaceDirs, cwd)
-function _getMatchLength(name, token)
-function scopeToPackage(filePath, packageDir)
-```