weavatrix 0.3.9 → 0.3.11

package/src/mcp/graph/tools-query.mjs

@@ -6,6 +6,7 @@ import {createPathClassifier, hasPathClass} from '../../path-classification.js'
 
 const QUERY_NON_PRODUCT = Object.freeze(['test', 'e2e', 'generated', 'mock', 'story', 'docs', 'benchmark', 'temp'])
 const LOW_SIGNAL_SYMBOL_RE = /^(?:const(?:ant)?|variable|property|field|enum_member)$/i
+const AMBIGUOUS_FILE_BASENAME_RE = /^(mod|lib|main)\.rs$|^index\.[a-z0-9]+$|^__init__\.py$/
 const querySourceFile = (node) => String(node?.source_file || String(node?.id || '').split('#', 1)[0]).replace(/\\/g, '/').replace(/^\.\//, '').toLowerCase()
 const queryWords = (value) => new Set(String(value || '').replace(/([a-z0-9])([A-Z])/g, '$1 $2').toLowerCase().split(/[^a-z0-9_]+/).filter(Boolean))
 const exactSymbolName = (node) => {
@@ -34,6 +35,23 @@ function resolveExactSeedSymbols(g, requested, limit = 12) {
     return {seeds, missing, ambiguous}
 }
 
+// Edge/hop lines print bare labels without the [id] suffix node lines carry, so repeated or
+// conventionally-generic file basenames (mod.rs, index.ts, __init__.py) become indistinguishable —
+// widen those, scoped to the shown ids, to the last two path segments.
+const makeEdgeLabel = (g, shownIds) => {
+    const counts = new Map()
+    for (const id of shownIds) {
+        const label = labelOf(g, id)
+        counts.set(label, (counts.get(label) || 0) + 1)
+    }
+    return (id) => {
+        const label = labelOf(g, id)
+        const isFile = String(id).includes('/') && !String(id).includes('#')
+        if (isFile && ((counts.get(label) || 0) > 1 || AMBIGUOUS_FILE_BASENAME_RE.test(label))) return String(id).split('/').slice(-2).join('/')
+        return label
+    }
+}
+
 const relationSet = (relationFilter, legacyFilter) => {
     const raw = relationFilter ?? legacyFilter
     const values = Array.isArray(raw) ? raw : (raw == null ? [] : String(raw).split(','))
@@ -89,6 +107,12 @@ export function tQueryGraph(g, {
         const node = g.byId.get(String(id))
         const file = querySourceFile(node)
         if (!file || pinnedFiles.has(file) || include_classified === true) return {ok: true}
+        // Extractor-proven test symbols (Rust #[cfg(test)]) live in production files; suppress them
+        // under the same policy as path-classified tests unless the question asks about tests.
+        if (node?.test_surface === true && !requestedClasses.has('test')) {
+            classifiedSuppressed.add(String(id))
+            return {ok: false, bucket: 'classified'}
+        }
         if (!classificationCache.has(file)) classificationCache.set(file, classifier.explain(file, {content: ''}))
         const info = classificationCache.get(file)
         const classes = QUERY_NON_PRODUCT.filter((name) => hasPathClass(info, name))
@@ -180,7 +204,8 @@ export function tQueryGraph(g, {
         'Nodes:',
     ]
     const nodeLines = shown.map((node) => `  [d${node.distance}] ${labelOf(g, node.id)}  (deg ${node.degree})  [${node.id}]`)
-    const edgeLines = ['', 'Edges:', ...shownEdges.map(([source, relation, target]) => `  ${labelOf(g, source)} --${relation || 'rel'}--> ${labelOf(g, target)}`)]
+    const edgeLabel = makeEdgeLabel(g, shownIds)
+    const edgeLines = ['', 'Edges:', ...shownEdges.map(([source, relation, target]) => `  ${edgeLabel(source)} --${relation || 'rel'}--> ${edgeLabel(target)}`)]
     let text = [...head.filter(Boolean), ...nodeLines, ...edgeLines].join('\n')
     if (text.length > charBudget) text = text.slice(0, charBudget) + `\n... (truncated to ~${token_budget} tokens)`
     return text
@@ -218,6 +243,7 @@ export function tShortestPath(g, {source, target, max_hops = 8} = {}) {
     if (!previous.has(targetId)) return `No path found between "${sourceNode.label ?? sourceId}" and "${targetNode.label ?? targetId}" within ${limit} hops.`
     const path = []
     for (let current = targetId; current != null; current = previous.get(current)) path.unshift(current)
-    const lines = path.map((id, index) => index === 0 ? `  ${labelOf(g, id)}` : `  --${relationTo.get(id) || 'rel'}--> ${labelOf(g, id)}`)
+    const edgeLabel = makeEdgeLabel(g, path)
+    const lines = path.map((id, index) => index === 0 ? `  ${edgeLabel(id)}` : `  --${relationTo.get(id) || 'rel'}--> ${edgeLabel(id)}`)
     return [`Shortest path (${path.length - 1} hops): ${sourceNode.label ?? sourceId} → ${targetNode.label ?? targetId}`, ...lines].join('\n')
 }

package/src/mcp/health/endpoints.mjs

@@ -1,5 +1,6 @@
 import {rawGraph} from '../graph-context.mjs'
 import {analyzeEndpointInventory} from '../../analysis/endpoints.js'
+import {PATH_CLASS_NAMES, createPathClassifier, hasPathClass} from '../../path-classification.js'
 import {toolResult} from '../tool-result.mjs'
 
 export function tListEndpoints(g, args, ctx) {
@@ -16,12 +17,34 @@ export function tListEndpoints(g, args, ctx) {
     const path = args.path ? String(args.path) : null
     if (method) eps = eps.filter((endpoint) => endpoint.method === method)
     if (path) eps = eps.filter((endpoint) => endpoint.path === path || endpoint.path.endsWith(path))
-    if (!eps.length) return 'No HTTP endpoints detected in the indexed code files.'
+    // Production-first: classified endpoints are suppressed by default; a tests-only graph would
+    // suppress everything, so that build mode auto-includes them (same precedent as module_map).
+    const includeClassified = args.include_classified === true || graph.graphBuildMode === 'tests-only'
+    const classifier = createPathClassifier(ctx.repoRoot)
+    const byFile = new Map()
+    const classesOf = (file) => {
+        const key = String(file || '')
+        if (!byFile.has(key)) {
+            const info = classifier.explain(key, {content: ''})
+            byFile.set(key, {classified: info.excluded || hasPathClass(info, ...PATH_CLASS_NAMES), pathClasses: info.classes})
+        }
+        return byFile.get(key)
+    }
+    const production = eps.filter((endpoint) => !classesOf(endpoint.file).classified)
+    const classified = eps.filter((endpoint) => classesOf(endpoint.file).classified)
+    const suppressed = includeClassified ? 0 : classified.length
+    eps = includeClassified ? [...production, ...classified] : production
+    const suppressionNote = suppressed
+        ? `${suppressed} endpoint(s) in classified test/e2e/generated/mock/story/docs/benchmark/temp or explicitly excluded paths were suppressed; pass include_classified:true to inspect them.`
+        : ''
+    if (!eps.length) return suppressed
+        ? `No production HTTP endpoints detected; ${suppressionNote}`
+        : 'No HTTP endpoints detected in the indexed code files.'
     const max = Math.max(1, Math.min(300, Number(args.max_results) || 100))
     const shown = eps.slice(0, max)
     const stats = inventory.stats
     const text = [
-        `${eps.length} endpoint(s) matched${eps.length > shown.length ? `, showing ${shown.length}` : ''}. Inventory: ${stats.declaredRoutes} declaration(s); ${stats.reachableStaticRoutes} statically reachable composed route(s); ${stats.localDeclarations} local/root declaration candidate(s); ${stats.staticMounts} static router mount(s)${stats.truncated ? `; TRUNCATED at ${stats.maxEndpoints}` : ''}.`,
+        `${eps.length} endpoint(s) matched${eps.length > shown.length ? `, showing ${shown.length}` : ''}. Inventory: ${stats.declaredRoutes} declaration(s); ${stats.reachableStaticRoutes} statically reachable composed route(s); ${stats.localDeclarations} local/root declaration candidate(s); ${stats.staticMounts} static router mount(s)${stats.truncated ? `; TRUNCATED at ${stats.maxEndpoints}` : ''}.${suppressed ? ` ${suppressionNote}` : ''}`,
         ...shown.map((e) => {
             const via = e.mountChain?.length
                 ? `\n           declared ${e.declaredPath} in ${e.file}${e.line ? `:${e.line}` : ''}; mount chain ${e.mountChain.map((mount) => `${mount.file}:${mount.line} ${mount.path}`).join(' → ')}`
@@ -29,14 +52,20 @@ export function tListEndpoints(g, args, ctx) {
             const activation = e.conditional
                 ? `; conditional default ${e.defaultActive === false ? 'inactive' : e.defaultActive === true ? 'active' : 'unknown'}`
                 : ''
-            return `  ${e.method.toUpperCase().padEnd(6)} ${e.path}${e.handler ? `  → ${e.handler}` : ''}  (${e.file}${e.line ? `:${e.line}` : ''}; ${e.mountState}/${e.confidence}${activation})${via}`
+            const info = classesOf(e.file)
+            const tag = info.classified ? ` [classified${info.pathClasses.length ? `:${info.pathClasses.join('+')}` : ''}]` : ''
+            return `  ${e.method.toUpperCase().padEnd(6)} ${e.path}${e.handler ? `  → ${e.handler}` : ''}  (${e.file}${e.line ? `:${e.line}` : ''}; ${e.mountState}/${e.confidence}${activation})${tag}${via}`
         }),
     ].join('\n')
     return toolResult(text, {
         filters: {method, path},
         stats,
-        endpoints: shown,
+        pathPolicy: includeClassified ? 'all' : 'production-first',
+        suppressed,
+        endpoints: shown.map((e) => {
+            const info = classesOf(e.file)
+            return info.classified ? {...e, classified: true, pathClasses: info.pathClasses} : e
+        }),
         page: {shown: shown.length, total: eps.length, truncated: eps.length > shown.length || stats.truncated},
     }, {completeness: {status: stats.truncated ? 'PARTIAL' : 'COMPLETE', reason: stats.truncated ? `endpoint cap ${stats.maxEndpoints} reached` : 'all indexed code files scanned'}})
 }
-

package/src/mcp/sync/payload-v2.mjs

@@ -19,6 +19,7 @@ export function sanitizeNode(value) {
     if (community !== undefined && Number.isInteger(community) && community >= 0) out.community = community;
     if (typeof value.exported === 'boolean') out.exported = value.exported;
     if (typeof value.decorated === 'boolean') out.decorated = value.decorated;
+    if (value.test_surface === true) out.test_surface = true;
     setIf(out, 'complexity', sanitizeComplexity(value.complexity));
     return out;
 }

package/src/mcp/tools-company.mjs

@@ -231,6 +231,15 @@ export async function tTraceApiContract(_g, args = {}, ctx = {}) {
                     ...screens,
                 ]
             }),
+            // Mismatch-only endpoints rarely rank into top_n (zero callsites), yet they drive the
+            // *_METHOD_MISMATCH verdicts — always surface them, citing the verdict's own total.
+            ...(analysis.totals.methodMismatches > 0 ? [
+                `  Method mismatches (${verdict.methodMismatches} call(s)):`,
+                ...analysis.endpoints.filter((endpoint) => endpoint.methodMismatches > 0).slice(0, 5).flatMap((endpoint) => [
+                    `    ${endpoint.method} ${endpoint.path} — ${endpoint.methodMismatches} call(s) use a different method`,
+                    ...(endpoint.methodMismatchSites || []).slice(0, 2).map((site) => `      caller ${site.clientRepo}:${site.file}:${site.line} uses ${site.method}`),
+                ]),
+            ] : []),
             ...transportAnalysis.contracts.filter((contract) => contract.callsites.length).slice(0, topN).map((contract) =>
                 `  ${contract.transport.toUpperCase()} ${contract.service ? `${contract.service}.` : contract.operation ? `${contract.operation} ` : ''}${contract.name} (${contract.file}:${contract.line}) [${contract.liveness}] → ${contract.callsites.length} callsite(s), ${contract.affected.files.length} affected file(s)`),
             completeness.complete

package/src/mcp/tools-endpoints.mjs

@@ -29,17 +29,47 @@ function endpointCandidates(inventory, args) {
     return exact.length ? exact : eligible.filter((endpoint) => endpoint.path.endsWith(path))
 }
 
-function handlerCandidates(graph, endpoint) {
+// A handler_file hint narrows the FULL same-named pool before any scoring, so it can rescue a
+// candidate the ranking would otherwise collapse away. An exact repo-relative match beats suffix
+// matches; comparison is case-insensitive (Windows paths and human-typed hints disagree on casing).
+function matchesHandlerHint(file, hint) {
+    if (!hint) return true
+    const lower = file.toLowerCase()
+    return lower === hint || lower.endsWith(`/${hint}`)
+}
+
+function handlerCandidates(graph, endpoint, hint = '') {
     if (!endpoint.handler) return []
     const wanted = endpoint.handler.toLowerCase()
     const qualifier = String(endpoint.handlerRef || '').split('.').slice(-2, -1)[0]?.toLowerCase() || ''
     const routeDir = posix.dirname(endpoint.file)
-    const scored = (graph.nodes || [])
+    // File-level import/re-export bindings at the route file break same-name ties between otherwise
+    // unranked candidates. The bonus deliberately sits BELOW same-directory proximity (+40): a
+    // file-level edge proves coupling, not symbol identity, and must never outrank the conventional
+    // same-package/same-dir handler (Go same-package files have no import edge at all).
+    const importBound = new Set()
+    for (const edge of graph.out.get(endpoint.file) || []) {
+        if (edge.relation !== 'imports' && edge.relation !== 're_exports') continue
+        if (edge.typeOnly === true || edge.barrelProxy === true) continue
+        const targetId = String(edge.id)
+        if (targetId.includes('#')) continue
+        const target = graph.byId.get(targetId)
+        importBound.add(String(target?.source_file || targetId).replace(/\\/g, '/'))
+    }
+    let pool = (graph.nodes || [])
         .filter((node) => String(node.id).includes('#') && node.source_file && symbolName(node).toLowerCase() === wanted)
+    if (hint) {
+        pool = pool.filter((node) => matchesHandlerHint(String(node.source_file).replace(/\\/g, '/').toLowerCase(), hint))
+        const exact = pool.filter((node) => String(node.source_file).replace(/\\/g, '/').toLowerCase() === hint)
+        if (exact.length) pool = exact
+    }
+    const scored = pool
         .map((node) => {
             const file = String(node.source_file).replace(/\\/g, '/')
             let score = 0
+            const importBoundAtRoute = importBound.has(file)
             if (file === endpoint.file) score += 100
+            if (importBoundAtRoute) score += 35
             if (posix.dirname(file) === routeDir) score += 40
             if (file.startsWith(`${routeDir}/`)) score += 15
             if (qualifier) {
@@ -48,16 +78,15 @@ function handlerCandidates(graph, endpoint) {
             }
             const line = symbolLine(node)
             if (file === endpoint.file && line >= endpoint.line && line - endpoint.line <= 250) score += 20
-            return {node, score}
+            return {node, score, importBoundAtRoute}
         })
         .sort((a, b) => b.score - a.score || String(a.node.id).localeCompare(String(b.node.id)))
     if (!scored.length) return []
     const best = scored[0].score
-    return scored.filter((item) => item.score === best).map((item) => item.node)
+    return scored.filter((item) => item.score === best).map(({node, importBoundAtRoute}) => ({node, importBoundAtRoute}))
 }
 
-function traceCalls(graph, start, {maxDepth, maxNodes, includeClassified, repoRoot}) {
-    const classifier = createPathClassifier(repoRoot)
+function traceCalls(graph, start, {maxDepth, maxNodes, includeClassified, classifier}) {
     const allowed = (node) => {
         if (!node?.source_file) return false
         if (includeClassified) return true
@@ -125,12 +154,25 @@ export function tTraceEndpoint(graph, args, ctx) {
         completeness: {status: 'PARTIAL', reason: 'ambiguous endpoint'},
     })
     const endpoint = candidates[0]
-    const handlers = handlerCandidates(graph, endpoint)
+    const classifier = createPathClassifier(ctx.repoRoot)
+    const classify = (file) => {
+        const info = classifier.explain(file, {content: ''})
+        return {classified: info.excluded || NON_PRODUCT.some((name) => hasPathClass(info, name)), pathClasses: info.classes}
+    }
+    const hint = String(args.handler_file || '').trim().replace(/\\/g, '/').replace(/^\.\//, '').toLowerCase()
+    let handlers = handlerCandidates(graph, endpoint, hint)
+        .map((item) => ({...item, ...classify(String(item.node.source_file).replace(/\\/g, '/'))}))
+    // Production-first: a classified twin (tests/mocks/…) never ties with a production candidate,
+    // but an all-classified candidate set is kept rather than emptied.
+    if (args.include_classified !== true && handlers.some((item) => !item.classified)) {
+        handlers = handlers.filter((item) => !item.classified)
+    }
     if (handlers.length !== 1) return toolResult([
-        `Endpoint resolved, but its handler symbol is ${handlers.length ? 'ambiguous' : 'not present in the graph'}:`,
+        `Endpoint resolved, but its handler symbol is ${handlers.length ? 'ambiguous' : `not present in the graph${hint ? ` (no candidate matched handler_file "${hint}")` : ''}`}:`,
         `  ${endpointLine(endpoint)}`,
-        ...handlers.slice(0, 12).map((node) => `  candidate ${node.label || node.id} (${node.source_file}:${symbolLine(node) || '?'}) [${node.id}]`),
-    ].join('\n'), {status: handlers.length ? 'AMBIGUOUS_HANDLER' : 'HANDLER_NOT_FOUND', endpoint, handlers}, {
+        ...handlers.slice(0, 12).map(({node, importBoundAtRoute, pathClasses}) => `  candidate ${node.label || node.id} (${node.source_file}:${symbolLine(node) || '?'}; import-bound at route: ${importBoundAtRoute ? 'yes' : 'no'}${pathClasses.length ? `; classified:${pathClasses.join('+')}` : ''}) [${node.id}]`),
+        ...(handlers.length > 1 ? ['  Next: pass handler_file with the repo-relative path (or an unambiguous path suffix) of the file that declares the intended handler.'] : []),
+    ].join('\n'), {status: handlers.length ? 'AMBIGUOUS_HANDLER' : 'HANDLER_NOT_FOUND', endpoint, handlers: handlers.map(({node, importBoundAtRoute, pathClasses}) => ({...node, importBoundAtRoute, pathClasses}))}, {
         completeness: {status: 'PARTIAL', reason: handlers.length ? 'ambiguous handler symbol' : 'handler symbol not found'},
     })
 
@@ -138,9 +180,9 @@ export function tTraceEndpoint(graph, args, ctx) {
     const maxNodes = Math.max(2, Math.min(40, Number(args.max_nodes) || 20))
     const contextLines = Math.max(0, Math.min(6, Number(args.context_lines) || 2))
     const maxExcerpts = Math.max(0, Math.min(12, Number(args.max_excerpts) || 6))
-    const handler = handlers[0]
+    const handler = handlers[0].node
     const traced = traceCalls(graph, handler, {
-        maxDepth, maxNodes, includeClassified: args.include_classified === true, repoRoot: ctx.repoRoot,
+        maxDepth, maxNodes, includeClassified: args.include_classified === true, classifier,
     })
     const excerpts = traced.edges.slice(0, maxExcerpts).map((edge) => {
         const source = graph.byId.get(edge.from)

package/src/mcp/tools-graph-hubs.mjs

@@ -12,6 +12,7 @@ export function tGodNodes(g, {top_n = 10, include_classified = false} = {}, ctx
     const classificationByFile = new Map()
     const isNonProduct = (node) => {
         if (include_classified === true) return false
+        if (node?.test_surface === true) return true
         const file = sourceFileOf(node)
         if (!file) return false
         if (!classificationByFile.has(file)) classificationByFile.set(file, classifier.explain(file))

package/src/mcp/tools-impact.mjs

@@ -87,10 +87,18 @@ export function tGetDependents(g, args = {}, ctx = {}) {
                     `Semantic precision: EXACT_LSP point query${result.cached ? ' (cache hit)' : ''}; ${count} classified direct reference edge(s).`,
                 )
             }
+            // Never echo COMPLETE here ('COMPLETE; exact absence was not proven' is a contradiction),
+            // but keep NONE/UNAVAILABLE truthful — PARTIAL implies probing actually began.
+            const fallbackState = result.overlay?.state === 'NONE' ? 'NONE'
+                : result.overlay?.state === 'UNAVAILABLE' ? 'UNAVAILABLE' : 'PARTIAL'
             return getDependentsFromGraph(
                 g,
                 args,
-                `Semantic precision: ${result.overlay?.state || 'UNAVAILABLE'}; exact absence was not proven, so graph edges are retained (${result.overlay?.reason || 'incomplete project coverage'}).`,
+                fallbackState === 'NONE'
+                    ? `Semantic precision: NONE; exact references are not available for this language/target, so graph edges are retained (${result.overlay?.reason || 'no eligible JavaScript/TypeScript semantic targets'}).`
+                    : fallbackState === 'UNAVAILABLE'
+                        ? `Semantic precision: UNAVAILABLE; graph evidence retained (${result.overlay?.reason || 'semantic point query unavailable'}).`
+                        : `Semantic precision: PARTIAL; exact absence was not proven, so graph edges are retained (${result.overlay?.reason || 'incomplete project coverage'}).`,
             )
         } catch (error) {
             return getDependentsFromGraph(

package/src/precision/lsp-overlay/build.js

@@ -39,7 +39,9 @@ function coverage(session, verifiedEdges = session.links.length) {
 }
 
 function completedOverlay(session) {
-  const state = session.errors || session.truncated || session.unclassifiedReferences
+  // Coherence guard: COMPLETE must mean every selected target was actually probed.
+  const underQueried = session.queried < session.targets.length
+  const state = session.errors || session.truncated || session.unclassifiedReferences || underQueried
     ? 'PARTIAL' : 'COMPLETE'
   return baseOverlay(session.graph, state, {
     request: session.request,
@@ -67,7 +69,9 @@ function completedOverlay(session) {
     ...(session.errors ? {reason: `${session.errors} semantic request(s) failed or were refused`}
       : session.truncated ? {reason: 'semantic precision stopped at a configured safety limit'}
         : session.unclassifiedReferences
-          ? {reason: 'some exact references could not be classified as runtime or type-only'} : {}),
+          ? {reason: 'some exact references could not be classified as runtime or type-only'}
+          : underQueried
+            ? {reason: 'semantic precision stopped before probing every selected target'} : {}),
   })
 }
 
@@ -185,14 +189,15 @@ export async function buildLspPrecisionOverlay({
   }
   if (graphPath) {
     const cached = readPrecisionOverlay(graphPath, graph)
-    if (cached?.state === 'COMPLETE'
+    // NONE (no eligible targets) is as stable as COMPLETE for an unchanged fingerprint.
+    if ((cached?.state === 'COMPLETE' || cached?.state === 'NONE')
       && precisionOverlayMatches(cached, graph, {request: session.request})
       && cached.semanticInputFingerprint === session.semanticInputs.fingerprint) return cached
   }
   session.eligible = eligibleTargets(graph, session.boundedMax, targetIds)
   session.targets = session.eligible.targets
   if (!session.targets.length) {
-    return persist(session, baseOverlay(graph, 'COMPLETE', {
+    return persist(session, baseOverlay(graph, 'NONE', {
       request: session.request,
       semanticInputFingerprint: session.semanticInputs.fingerprint,
       pluginPolicy: {

package/src/precision/lsp-overlay/contract.js

@@ -1,6 +1,6 @@
 import {typeScriptLspContract} from '../typescript-lsp-provider.js'
 
-export const PRECISION_OVERLAY_V = 4
+export const PRECISION_OVERLAY_V = 5
 export const PRECISION_FILE = 'precision.json'
 export const JS_TS_FILE = /\.(?:[cm]?[jt]sx?)$/i
 export const endpoint = (value) => String(value && typeof value === 'object' ? value.id : value)

package/src/precision/lsp-overlay/target-index.js

@@ -99,10 +99,15 @@ export function eligibleTargets(graph, limit, requestedIds = null) {
   const byId = new Map((graph.nodes || []).map((node) => [String(node.id), node]))
   if (Array.isArray(requestedIds) && requestedIds.length) {
     const ids = [...new Set(requestedIds.map(String))]
-    const targets = ids.map((id) => byId.get(id))
+    const eligible = ids.map((id) => byId.get(id))
       .filter((node) => node?.selection_start && JS_TS_FILE.test(String(node.source_file || '')))
-      .slice(0, limit)
-    return {targets, total: ids.length, orphanIds: new Set()}
+    // total counts only eligible targets so coverage fractions stay honest when ids were dropped.
+    return {
+      targets: eligible.slice(0, limit),
+      total: eligible.length,
+      droppedRequested: ids.length - eligible.length,
+      orphanIds: new Set(),
+    }
   }
   const ranked = new Map()
   const inbound = new Set()

package/src/precision/symbol-query.js

@@ -75,7 +75,8 @@ async function storeEntry(path, entry) {
 }
 
 function cacheable(overlay) {
-    if (overlay?.state === 'COMPLETE') return true
+    // NONE is stable for the fingerprint, but only COMPLETE ever proves absence (see reader below).
+    if (overlay?.state === 'COMPLETE' || overlay?.state === 'NONE') return true
     return overlay?.state === 'PARTIAL'
         && overlay?.reason === 'semantic precision stopped at a configured safety limit'
 }