sigmap 6.10.4 → 6.10.6

package/AGENTS.md

@@ -56,40 +56,18 @@ 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 — 3 days ago)
 ## deps
 ```
 src/extractors/python_ast.py ← ast
 ```
 
-## packages
-
-### 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
-## changes (last 5 commits — 1 second ago)
+## changes (last 5 commits — 11 minutes 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
+src/analysis/diagnostics.js                   +estimateTokens  +formatFileDecision  +computeFileMetrics  +explainInclusion
+src/map/import-graph.js                       +buildReverseGraph  ~extractImports  ~resolveJsPath  ~detectCycles
 ```
 
-## src
-
-### src/discovery/sigmapignore.js
-### packages/cli/index.js
-```
-module.exports = { CLI_ENTRY, run }
-function run(argv, cwd) → void
-```
+## packages
 
 ### packages/adapters/llm-full.js
 ```
@@ -121,168 +99,63 @@ code-fence ---
 
 ### packages/adapters/copilot.js
 ```
-module.exports = { loadIgnorePatterns, matchesIgnorePattern }
-function loadIgnorePatterns(cwd)
-function matchesIgnorePattern(dirName, patterns)
-```
-
-### src/discovery/source-root-registry.js
-```
-module.exports = { REGISTRY }
-```
-
-### src/discovery/source-root-resolver.js
-```
-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)
-```
-
-### src/discovery/source-root-scorer.js
-```
-module.exports = { scoreCandidate, getRecentlyChangedDirs, ROOT_ENTRYPOINTS, JVM_PATH_PATTERN }
-function getRecentlyChangedDirs(cwd)
-function scoreCandidate(dirName, fullPath, context)
-function _countSourceFiles(dir, depth)
-```
-
-### src/eval/runner.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
-```
-
-### src/eval/scorer.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)
-```
-
-### src/extractors/coverage.js
-```
-module.exports = { buildTestIndex, isTested }
-function walkFiles(dir)
-function buildTestIndex(cwd, testDirs)
-function isTested(funcName, testIndex)
-```
-
-### src/extractors/cpp.js
-```
-module.exports = { extract }
-function extract(src) → string[]
-function extractBlock(src, startIndex)
-function extractMembers(block)
-function normalizeParams(params)
-function normalizeType(type)
-```
-
-### src/extractors/csharp.js
-```
-module.exports = { extract }
-function extract(src) → string[]
-function extractBlock(src, startIndex)
-function extractMembers(block)
-function normalizeParams(params)
-function normalizeType(type)
-```
-
-### src/extractors/css.js
-```
-module.exports = { extract }
-function extract(src) → string[]
-```
-
-### src/extractors/dart.js
-```
-module.exports = { extract }
-function extract(src) → string[]
-function extractBlock(src, startIndex)
-function extractMembers(block)
-function normalizeParams(params)
-```
-
-### src/extractors/deps.js
-```
-module.exports = { extractPythonDeps, extractTSDeps, buildReverseDepMap }
-function extractPythonDeps(src) → string[]
-function extractTSDeps(src) → string[]
-function buildReverseDepMap(forwardMap) → Map<string, string[]>
-```
-
-### src/extractors/dockerfile.js
-```
-module.exports = { extract }
-function extract(src) → string[]
+module.exports = { name, format, outputPath, write }
+function format(context, opts = {}) → string
+function _confidenceMeta(opts)
+function outputPath(cwd) → string
+function write(context, cwd, opts = {})
 ```
 
-### src/extractors/generic.js
+### packages/adapters/cursor.js
 ```
-module.exports = { extract }
-function extract(src)
+module.exports = { name, format, outputPath }
+function format(context, opts = {}) → string
+function _confidenceMeta(opts)
+function outputPath(cwd) → string
 ```
 
-### src/extractors/go.js
+### packages/adapters/gemini.js
 ```
-module.exports = { extract }
-function extract(src) → string[]
-function extractBlock(src, startIndex)
-function extractInterfaceMethods(block)
-function normalizeParams(params)
+module.exports = { name, format, outputPath, write }
+function format(context, opts = {}) → string
+function outputPath(cwd) → string
+function write(context, cwd, opts = {})
+function _confidenceMeta(opts)
 ```
 
-### src/extractors/graphql.js
+### packages/adapters/openai.js
 ```
-module.exports = { extract }
-function extract(src) → string[]
+module.exports = { name, format, outputPath }
+function format(context, opts = {}) → string
+function outputPath(cwd) → string
+function _confidenceMeta(opts)
 ```
 
-### src/extractors/html.js
+### packages/adapters/windsurf.js
 ```
-module.exports = { extract }
-function extract(src) → string[]
+module.exports = { name, format, outputPath }
+function format(context, opts = {}) → string
+function _confidenceMeta(opts)
+function outputPath(cwd) → string
 ```
 
-### src/extractors/java.js
+### packages/adapters/claude.js
 ```
-module.exports = { extract }
-function extract(src) → string[]
-function extractBlock(src, startIndex)
-function extractMembers(block)
-function normalizeParams(params)
-function normalizeType(type)
+module.exports = { name, format, outputPath, write }
+function format(context, opts = {}) → string
+function _confidenceMeta(opts)
+function outputPath(cwd) → string
+function write(context, cwd, opts = {})
 ```
 
-### src/extractors/javascript.js
+### packages/adapters/codex.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)
+module.exports = { name, format, outputPath, write }
+function format(context, opts = {}) → string
+function outputPath(cwd) → string
+function write(context, cwd, opts = {})
 ```
 
-### src/extractors/kotlin.js
 ### packages/adapters/index.js
 ```
 module.exports = { getAdapter, listAdapters, adapt, outputsToAdapters }
@@ -315,216 +188,156 @@ function score(cwd) → { * score: number, * grad
 function adapt(context, adapterName, opts = {}) → string
 ```
 
-### packages/adapters/willow.js
-```
-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>
-```
-
-### 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[]
-```
-
 ## src
 
-### src/retrieval/tokenizer.js
-```
-module.exports = { extract }
-function extract(src) → string[]
-function extractBlock(src, startIndex)
-function extractMembers(block)
-function normalizeParams(params)
-```
-
-### src/extractors/markdown.js
-```
-module.exports = { extract }
-function extract(src) → string[]
-```
-
-### src/extractors/patterns.js
-```
-module.exports = { extract }
-function extract(src) → string[]
-```
-
-### src/extractors/php.js
+### src/mcp/tools.js
 ```
-module.exports = { extract }
-function extract(src) → string[]
-function extractBlock(src, startIndex)
-function extractMembers(block)
-function normalizeParams(params)
-function normalizeType(type)
+module.exports = { TOOLS }
 ```
 
-### src/extractors/prdiff.js
+### src/health/scorer.js
 ```
-module.exports = { diffSignatures, extractName }
-function diffSignatures(baseSigs, currentSigs) → {added:string[], removed:
-function extractName(sig)
+module.exports = { score }
+function score(cwd) → { * score: number, * grad
 ```
 
-### src/extractors/properties.js
+### src/extractors/coverage.js
 ```
-module.exports = { extract }
-function extract(src) → string[]
+module.exports = { buildTestIndex, isTested }
+function walkFiles(dir)
+function buildTestIndex(cwd, testDirs)
+function isTested(funcName, testIndex)
 ```
 
-### src/extractors/protobuf.js
+### src/extractors/css.js
 ```
 module.exports = { extract }
 function extract(src) → string[]
 ```
 
-### src/extractors/python.js
+### src/extractors/sql.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)
+function _cleanName(raw)
+function _normalizeParams(raw)
 ```
 
-### src/extractors/python_dataclass.js
+### src/extractors/graphql.js
 ```
 module.exports = { extract }
 function extract(src) → string[]
 ```
 
-### src/extractors/ruby.js
+### src/extractors/protobuf.js
 ```
 module.exports = { extract }
 function extract(src) → string[]
-function normalizeParams(params)
-function extractReturnHint(stripped, index)
 ```
 
-### src/extractors/rust.js
+### src/extractors/terraform.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/markdown.js
 ```
 module.exports = { extract }
 function extract(src) → string[]
-function extractBlock(src, startIndex)
-function extractMembers(block)
-function normalizeParams(params)
-function normalizeType(type)
 ```
 
-### src/extractors/shell.js
+### src/extractors/properties.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/svelte.js
+### src/extractors/xml.js
 ```
 module.exports = { extract }
 function extract(src) → string[]
-function normalizeParams(params)
-function normalizeType(type)
 ```
 
-### src/extractors/swift.js
+### src/extractors/patterns.js
 ```
 module.exports = { extract }
 function extract(src) → string[]
-function extractBlock(src, startIndex)
-function extractMembers(block)
-function normalizeParams(params)
-function extractArrowType(str)
 ```
 
-### src/extractors/terraform.js
+### src/extractors/python_dataclass.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
+### src/extractors/typescript_react.js
 ```
 module.exports = { extract }
 function extract(src) → string[]
 ```
 
-### src/extractors/typescript.js
+### src/extractors/vue_sfc.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
+### src/extractors/generic.js
 ```
 module.exports = { extract }
-function extract(src) → string[]
+function extract(src)
 ```
 
-### src/extractors/vue.js
+### src/format/llm-txt.js
 ```
-module.exports = { extract }
-function extract(src) → string[]
-function normalizeParams(params)
-function normalizeType(type)
+module.exports = { format, outputPath }
+function outputPath(cwd)
+function format(context, cwd, version)
 ```
 
-### src/extractors/vue_sfc.js
+### src/format/llms-txt.js
 ```
-module.exports = { extract }
-function extract(src) → string[]
+module.exports = { format, outputPath }
+function outputPath(cwd)
+function getShortCommit(cwd)
+function detectVersion(cwd)
+function format(context, cwd, writtenFiles, sigmapVersion)
 ```
 
-### src/extractors/xml.js
 ### src/format/dashboard.js
 ```
-module.exports = { extract }
-function extract(src) → string[]
+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/extractors/yaml.js
+### src/judge/judge-engine.js
 ```
-module.exports = { extract }
-function extract(src) → string[]
+module.exports = { groundedness, judge }
+function tokenize(text)
+function groundedness(response, context)
+function extractContextFiles(context, cwd)
+function judge(response, context, opts = {})
 ```
 
 ### src/format/benchmark-report.js
@@ -554,83 +367,53 @@ function generateBenchmarkReportHtml(reports, opts = {})
 function writeBenchmarkReport(cwd, opts = {})
 ```
 
-### src/format/cache.js
-```
-module.exports = { formatCache, formatCachePayload }
-function formatCache(content) → string
-function formatCachePayload(content, model) → string
-```
-
-### 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)
-```
-
-### src/format/llm-txt.js
-```
-module.exports = { format, outputPath }
-function outputPath(cwd)
-function format(context, cwd, version)
-```
-
-### src/format/llms-txt.js
+### src/analysis/coverage-score.js
 ```
-module.exports = { format, outputPath }
-function outputPath(cwd)
-function getShortCommit(cwd)
-function detectVersion(cwd)
-function format(context, cwd, writtenFiles, sigmapVersion)
+module.exports = { coverageScore, CODE_EXTS }
+function coverageScore(cwd, fileEntries, config)
+function _walk(dir, excludeSet, out)
 ```
 
-### src/graph/builder.js
+### src/cache/sig-cache.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 = { 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)
 ```
 
-### src/graph/impact.js
+### src/mcp/handlers.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 = { 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/health/scorer.js
+### src/tracking/logger.js
 ```
-module.exports = { score }
-function score(cwd) → { * score: number, * grad
+module.exports = { logRun, readLog, summarize }
+function logRun(entry, cwd)
+function readLog(cwd) → object[]
+function summarize(entries) → object
 ```
 
-### src/judge/judge-engine.js
+### src/extractors/typescript.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[]
+function extractBlock(src, startIndex)
+function extractInterfaceMembers(block)
+function extractClassMembers(block)
+function normalizeParams(params)
 ```
 
 ### src/learning/weights.js
@@ -650,52 +433,31 @@ function exportWeights(cwd, outputPath)
 function importWeights(cwd, importPath, replace)
 ```
 
-### src/map/class-hierarchy.js
-```
-module.exports = { analyze }
-function analyze(files, cwd)
-```
-
-### src/map/import-graph.js
+### src/config/loader.js
 ```
-module.exports = { analyze }
-function extractImports(filePath, content, fileSet)
-function resolveJsPath(dir, importStr, fileSet)
-function detectCycles(graph)
-function analyze(files, cwd)
+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)
 ```
 
-### src/map/route-table.js
+### src/discovery/framework-detector.js
 ```
-module.exports = { analyze }
-function shouldSkipFile(rel)
-function analyze(files, cwd)
+module.exports = { detectFrameworks }
+function detectFrameworks(cwd)
+function _readDeps(cwd)
+function _readFile(p)
+function _existsAnywhere(cwd, filename, maxDepth)
+function _walkFind(dir, name, depth)
 ```
 
-### src/mcp/handlers.js
 ### src/discovery/sigmapignore.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)
-```
-
-### src/mcp/tools.js
-```
-module.exports = { TOOLS }
-```
-
-### src/plan/planner.js
-```
-module.exports = { createPlan }
-function createPlan(goal, cwd, config)
+module.exports = { loadIgnorePatterns, matchesIgnorePattern }
+function loadIgnorePatterns(cwd)
+function matchesIgnorePattern(dirName, patterns)
 ```
 
 ### src/retrieval/ranker.js
@@ -713,34 +475,10 @@ function formatRankJSON(results, query) → object
 function detectIntent(query)
 ```
 
-### src/retrieval/tokenizer.js
-```
-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
+### src/plan/planner.js
 ```
-module.exports = { scan }
-function scan(signatures, filePath) → { safe: string[], redacte
+module.exports = { createPlan }
+function createPlan(goal, cwd, config)
 ```
 
 ### src/session/memory.js
@@ -753,28 +491,19 @@ function mergeSessionContext(scores, session, currentIntent)
 function clearSession(cwd)
 ```
 
-### src/tracking/logger.js
+### src/config/defaults.js
 ```
-module.exports = { logRun, readLog, summarize }
-function logRun(entry, cwd)
-function readLog(cwd) → object[]
-function summarize(entries) → object
+module.exports = { DEFAULTS }
 ```
 
-### src/eval/analyzer.js
+### src/discovery/source-root-scorer.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 = { scoreCandidate, getRecentlyChangedDirs, ROOT_ENTRYPOINTS, JVM_PATH_PATTERN }
+function getRecentlyChangedDirs(cwd)
+function scoreCandidate(dirName, fullPath, context)
+function _countSourceFiles(dir, depth)
 ```
 
-### src/discovery/language-detector.js
 ### src/eval/usefulness-scorer.js
 ```
 module.exports = { scoreUsefulness, computeUsefulnessStats }
@@ -791,45 +520,9 @@ 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
@@ -884,12 +577,51 @@ function _dedupeNested(scored)
 function _computeConfidence(frameworks, languages, scoredCount)
 ```
 
+### src/extractors/gdscript.js
+```
+module.exports = { extract }
+function extract(src) → string[]
+function extractInnerMembers(stripped, startIndex)
+function normalizeParams(params)
+```
+
+### src/discovery/language-detector.js
+```
+module.exports = { detectLanguages }
+function detectLanguages(cwd)
+function _walkDepth(dir, depth, extCount)
+```
+
+### 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/analysis/diagnostics.js
+```
+module.exports = { formatFileDecision, computeFileMetrics, explainInclusion, explainExclusion, estimateTokens }
+function estimateTokens(text)
+function formatFileDecision(entry, decision, reason, score = null)
+function computeFileMetrics(entry)
+function explainInclusion(fileEntries, budgetLimit)
+function explainExclusion(dropped, reason)
+```
+
 ### src/map/import-graph.js
 ```
-module.exports = { analyze, extractImports }
+module.exports = { analyze, extractImports, buildReverseGraph, resolveJsPath, detectCycles }
 function extractImports(filePath, content, fileSet)
 function resolveJsPath(dir, importStr, fileSet)
 function detectCycles(graph)
+function buildReverseGraph(graph)
 function analyze(files, cwd)
 ```
 

package/CHANGELOG.md

@@ -10,6 +10,14 @@ Format: [Semantic Versioning](https://semver.org/)
 
 ---
 
+## [6.10.5] — 2026-05-11
+
+### Added
+
+- **Branching strategy tests** — Added regression tests verifying the develop-first branching workflow to ensure all PRs target develop before release merges to main.
+
+---
+
 ## [6.10.4] — 2026-05-11
 
 ### Fixed

package/gen-context.js

@@ -5607,7 +5607,7 @@ __factories["./src/mcp/server"] = function(module, exports) {
   
   const SERVER_INFO = {
     name: 'sigmap',
-  version: '6.10.4',
+  version: '6.10.6',
     description: 'SigMap MCP server — code signatures on demand',
   };
   
@@ -8234,7 +8234,7 @@ const path = require('path');
 const os = require('os');
 const { execSync } = require('child_process');
 
-const VERSION = '6.10.4';
+const VERSION = '6.10.6';
 const MARKER = '\n\n## Auto-generated signatures\n<!-- Updated by gen-context.js -->\n';
 
 function requireSourceOrBundled(key) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sigmap",
-  "version": "6.10.4",
+  "version": "6.10.6",
   "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.10.4",
+  "version": "6.10.6",
   "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.10.4",
+  "version": "6.10.6",
   "description": "SigMap core library — zero-dependency code signature extraction, retrieval, and security scanning",
   "main": "index.js",
   "keywords": [

package/src/analysis/diagnostics.js

@@ -0,0 +1,86 @@
+'use strict';
+
+/**
+ * Diagnostic utilities for understanding file inclusion/exclusion decisions.
+ *
+ * Provides detailed per-file diagnostics showing:
+ * - Why files are included or excluded
+ * - Ranking scores and signals
+ * - Budget constraints and priorities
+ */
+
+const path = require('path');
+
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+
+function formatFileDecision(entry, decision, reason, score = null) {
+  const rel = path.relative(process.cwd(), entry.filePath);
+  const tokens = estimateTokens(entry.sigs.join('\n'));
+  let line = `${decision === 'included' ? '✓' : '✗'} ${rel}`;
+  line += ` [${tokens} tokens]`;
+  if (score !== null) line += ` [score: ${score.toFixed(2)}]`;
+  if (reason) line += ` — ${reason}`;
+  return line;
+}
+
+function computeFileMetrics(entry) {
+  const loc = entry.content ? entry.content.split('\n').length : 1;
+  const sigCount = entry.sigs ? entry.sigs.length : 0;
+  const signalQuality = loc > 0 ? sigCount / loc : 0;
+  const tokens = estimateTokens(entry.sigs.join('\n'));
+
+  return {
+    lineOfCode: loc,
+    sigCount: sigCount,
+    signalQuality: signalQuality.toFixed(3),
+    tokens: tokens,
+    relevance: (sigCount / Math.max(loc, 1)).toFixed(3),
+  };
+}
+
+function explainInclusion(fileEntries, budgetLimit) {
+  const lines = [];
+
+  lines.push('## File Inclusion Diagnostics\n');
+  lines.push(`Budget: ${budgetLimit} tokens`);
+  lines.push(`Files: ${fileEntries.length} scanned\n`);
+
+  let totalTokens = 0;
+  const withMetrics = fileEntries.map((e) => {
+    const metrics = computeFileMetrics(e);
+    totalTokens += metrics.tokens;
+    return { entry: e, metrics };
+  });
+
+  lines.push(`Total token requirement: ${totalTokens} tokens`);
+  lines.push(`Budget headroom: ${budgetLimit * 0.9} tokens (90% of ${budgetLimit})\n`);
+
+  if (totalTokens > budgetLimit * 0.9) {
+    lines.push('⚠ Over budget — files will be dropped\n');
+    lines.push('### Per-file metrics:');
+    for (const { entry, metrics } of withMetrics) {
+      const rel = path.relative(process.cwd(), entry.filePath);
+      lines.push(`- ${rel}`);
+      lines.push(`  - Size: ${metrics.tokens} tokens, ${metrics.lineOfCode} lines`);
+      lines.push(`  - Sigs: ${metrics.sigCount}, quality: ${metrics.signalQuality}`);
+    }
+  } else {
+    lines.push('✓ All files fit within budget\n');
+  }
+
+  return lines.join('\n');
+}
+
+function explainExclusion(dropped, reason) {
+  return `Excluded ${dropped.length} files: ${reason}`;
+}
+
+module.exports = {
+  formatFileDecision,
+  computeFileMetrics,
+  explainInclusion,
+  explainExclusion,
+  estimateTokens,
+};

package/src/map/import-graph.js

@@ -41,10 +41,10 @@ function extractImports(filePath, content, fileSet) {
   }
 
   if (PY_EXTS.has(ext)) {
-    // from .module import ...  /  from ..pkg import ...
-    const re = /^[ \t]*from\s+(\.+[\w.]*)\s+import/gm;
+    // Relative imports: from .module import ...  /  from ..pkg import ...
+    const reRel = /^[ \t]*from\s+(\.+[\w.]*)\s+import/gm;
     let m;
-    while ((m = re.exec(content)) !== null) {
+    while ((m = reRel.exec(content)) !== null) {
       const dotCount = (m[1].match(/^\.+/) || [''])[0].length;
       const modPart = m[1].slice(dotCount).replace(/\./g, '/');
       let base = dir;
@@ -52,6 +52,24 @@ function extractImports(filePath, content, fileSet) {
       const candidate = modPart ? path.join(base, modPart + '.py') : null;
       if (candidate && fileSet.has(candidate)) found.push(candidate);
     }
+
+    // Absolute imports: from package.module import ... (infer from project structure)
+    const reAbs = /^[ \t]*from\s+([\w.]+)\s+import/gm;
+    while ((m = reAbs.exec(content)) !== null) {
+      const modulePath = m[1].replace(/\./g, '/');
+      const candidates = [
+        path.join(dir, modulePath + '.py'),
+        path.join(dir, modulePath, '__init__.py'),
+        path.resolve(dir, '..', modulePath + '.py'),
+        path.resolve(dir, '..', modulePath, '__init__.py'),
+      ];
+      for (const c of candidates) {
+        if (fileSet.has(c)) {
+          found.push(c);
+          break;
+        }
+      }
+    }
   }
 
   return [...new Set(found)];
@@ -62,12 +80,17 @@ function resolveJsPath(dir, importStr, fileSet) {
   const candidates = [
     base,
     base + '.ts', base + '.tsx',
-    base + '.js', base + '.jsx',
-    base + '/index.ts', base + '/index.js',
+    base + '.js', base + '.jsx', base + '.mjs', base + '.cjs',
+    base + '/index.ts', base + '/index.tsx',
+    base + '/index.js', base + '/index.jsx', base + '/index.mjs',
   ];
   for (const c of candidates) {
     if (fileSet.has(c)) return c;
   }
+
+  // Fallback: check if base itself is already a valid file (handles .ts/.js already in path)
+  if (fileSet.has(base)) return base;
+
   return null;
 }
 
@@ -102,6 +125,20 @@ function detectCycles(graph) {
   return cycles;
 }
 
+// ---------------------------------------------------------------------------
+// Build reverse graph (for caller detection)
+// ---------------------------------------------------------------------------
+function buildReverseGraph(graph) {
+  const reverse = new Map();
+  for (const [file, deps] of graph.entries()) {
+    for (const dep of deps) {
+      if (!reverse.has(dep)) reverse.set(dep, []);
+      reverse.get(dep).push(file);
+    }
+  }
+  return reverse;
+}
+
 // ---------------------------------------------------------------------------
 // Public API
 // ---------------------------------------------------------------------------
@@ -145,4 +182,4 @@ function analyze(files, cwd) {
   return lines.join('\n');
 }
 
-module.exports = { analyze, extractImports };
+module.exports = { analyze, extractImports, buildReverseGraph, resolveJsPath, detectCycles };

package/src/mcp/server.js

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