ucn 5.5.3 → 5.6.0

package/core/reporting.js

@@ -11,6 +11,7 @@ const fs = require('fs');
 const { codeUnitCompare, CALLABLE_SYMBOL_KINDS } = require('./shared');
 const path = require('path');
 const { isTestFile } = require('./discovery');
+const { paramFact } = require('./registry');
 const { summarizeCommandTrust } = require('./trust-matrix');
 const { projectComputedDispatch } = require('./ast-analysis');
 const { langTraits } = require('../languages');
@@ -123,8 +124,37 @@ function getStats(index, options = {}) {
         // positive integer, 0 (show nothing), or undefined (default 10).
         const top = options.top === 0
             ? 0
-            : ((options.top != null && Number(options.top) > 0) ? Number(options.top) : 10);
+            : ((options.top != null && Number(options.top) > 0) ? Number(options.top) : paramFact('top', 'hot'));
         const FUNCTION_TYPES = CALLABLE_SYMBOL_KINDS;
+        const maxRefine = Number.isInteger(options.maxRefine) && options.maxRefine > 0
+            ? options.maxRefine : Infinity;
+        // Refinement work is bounded by call records, not wall time, so the
+        // answer is the same on every run and machine (fix #382). One
+        // refinement scans the call records of its name in the countable
+        // files; `workBudget` caps their sum. Exact answers on real projects
+        // stay far below it; a very large repository (kubernetes: ~68M
+        // records under its candidate ceilings) stops and says so.
+        const workBudget = Number.isFinite(options.workBudget) && options.workBudget > 0
+            ? options.workBudget : STATS_HOT_WORK_BUDGET;
+
+        // The ranking is a function of the index and of these options, so an
+        // answer already computed for this index state is the answer
+        // (core/hot-summary.js). Nothing below runs for it.
+        const hotSummary = require('./hot-summary');
+        const summaryKey = hotSummary.keyOf({
+            top, productionCallsOnly: options.productionCallsOnly, maxRefine, workBudget,
+            file: options.file, in: options.in,
+            exclude: Array.isArray(options.exclude)
+                ? options.exclude
+                : (options.exclude
+                    ? String(options.exclude).split(',').map(s => s.trim()).filter(Boolean)
+                    : []),
+        });
+        const keptSummary = hotSummary.get(index, summaryKey);
+        if (keptSummary) {
+            stats.hot = keptSummary;
+            return stats;
+        }
 
         // Ensure the calls cache is fully populated before counting.
         // First-time stats --hot may need to parse files to extract calls;
@@ -374,16 +404,6 @@ function getStats(index, options = {}) {
                 }
             }
         }
-        const maxRefine = Number.isInteger(options.maxRefine) && options.maxRefine > 0
-            ? options.maxRefine : Infinity;
-        // Refinement work is bounded by call records, not wall time, so the
-        // answer is the same on every run and machine (fix #382). One
-        // refinement scans the call records of its name in the countable
-        // files; `workBudget` caps their sum. Exact answers on real projects
-        // stay far below it; a very large repository (kubernetes: ~68M
-        // records under its candidate ceilings) stops and says so.
-        const workBudget = Number.isFinite(options.workBudget) && options.workBudget > 0
-            ? options.workBudget : STATS_HOT_WORK_BUDGET;
         const workOf = candidate => recordsByName.get(candidate.name) || 0;
         // Ceilings in descending order: the early stop fires as soon as no
         // unseen ceiling can reach the current Nth count, so exactly the
@@ -510,7 +530,7 @@ function getStats(index, options = {}) {
             (a.startLine || 0) - (b.startLine || 0)
         );
 
-        stats.hot = {
+        stats.hot = hotSummary.put(index, summaryKey, {
             top,
             total: refined === candidates.length ? hotList.length : candidates.length,
             totalKind: refined === candidates.length ? 'confirmed' : 'raw-call-candidates',
@@ -523,7 +543,7 @@ function getStats(index, options = {}) {
             note: refined === candidates.length
                 ? 'Counts are confirmed caller-engine edges pinned to each displayed definition; unverified dispatch is excluded.'
                 : `Displayed counts are exact confirmed caller-engine edges; ${candidates.length} raw candidates were bounded and ${refined} required exact refinement.`,
-        };
+        });
     }
 
     return stats;
@@ -747,11 +767,6 @@ function doctor(index, options = {}) {
         skippedSources: { count: 0, fileCount: 0, files: [], reasons: {} },
     };
 
-    // Reflection/eval signals come from the shared text-blind-spot counter
-    // (core/shared.js) — the SAME routine detectCompleteness uses for the about
-    // footer, so the two never drift (field-report #2). Occurrence counts.
-    const { hasTextBlindspots, countTextBlindspots } = lazySharedModule();
-
     const computedDispatch = projectComputedDispatch(index);
     for (const [filePath, fe] of index.files) {
         fileCounts.total++;
@@ -781,14 +796,12 @@ function doctor(index, options = {}) {
         if (fe.parseError) recordBlind(blindSpots.parseFailures, 1);
         if (fe.parseRecovery) recordBlind(blindSpots.parseRecoveries, 1);
 
-        // Read file once for eval/reflection signals (shared counter).
-        if (hasTextBlindspots(lang)) {
-            try {
-                const bs = countTextBlindspots(fs.readFileSync(filePath, 'utf-8'), lang);
-                recordBlind(blindSpots.evalCalls, bs.eval);
-                recordBlind(blindSpots.reflection, bs.reflection);
-            } catch (e) { /* ignore read errors */ }
-        }
+        // Code execution and reflection: call sites of each language's
+        // vocabulary (langTraits().reflectionApi), counted in the file's
+        // tree when it was indexed. The completeness footer reads the same
+        // two numbers, so the two never drift, and no file is read here.
+        recordBlind(blindSpots.evalCalls, fe.evalUses || 0);
+        recordBlind(blindSpots.reflection, fe.reflectionUses || 0);
     }
 
     // Files that failed before a fileEntry could be created are absent from
@@ -825,16 +838,30 @@ function doctor(index, options = {}) {
     }
     fileCounts.unsupported = blindSpots.unsupportedSources.fileCount;
 
-    for (const issue of index.discoveryIssues || []) {
-        const rel = issue.relativePath || '.';
-        if (!matchInFilter(rel)) continue;
+    // Source that is not indexed, from the one model every claim uses
+    // (core/source-universe.js): files searched as text only (a bundle, an
+    // excluded path, an oversized file; unsupported languages are counted
+    // above) and paths nothing can be read from. `unsearchable` is the part
+    // no name can be cleared against.
+    const sourceUniverse = require('./source-universe').universe(index);
+    let unsearchablePaths = 0;
+    const noteSkipped = (rel, reason) => {
+        if (!matchInFilter(rel)) return false;
         const skipped = blindSpots.skippedSources;
         skipped.count++;
         skipped.fileCount++;
-        skipped.reasons[issue.reason || 'unknown'] =
-            (skipped.reasons[issue.reason || 'unknown'] || 0) + 1;
+        skipped.reasons[reason] = (skipped.reasons[reason] || 0) + 1;
         if (skipped.files.length < BLINDSPOT_FILE_CAP) skipped.files.push(rel);
+        return true;
+    };
+    for (const entry of sourceUniverse.textOnly) {
+        if (entry.reason === 'unsupported-language') continue;
+        noteSkipped(entry.relativePath, entry.reason);
+    }
+    for (const entry of sourceUniverse.opaque) {
+        if (noteSkipped(entry.relativePath, entry.reason || 'unknown')) unsearchablePaths++;
     }
+    blindSpots.skippedSources.unsearchable = unsearchablePaths;
     fileCounts.skipped = blindSpots.skippedSources.fileCount;
 
     // C/C++ token-pasting macro invocations whose expansion cannot be
@@ -910,7 +937,7 @@ function doctor(index, options = {}) {
     if (blindSpots.skippedSources.count > 0) {
         const reasons = Object.entries(blindSpots.skippedSources.reasons)
             .map(([reason, count]) => `${reason} ${count}`).join(', ');
-        blindSignals.push(`${blindSpots.skippedSources.count} source discovery gap(s): ${reasons}`);
+        blindSignals.push(`${blindSpots.skippedSources.count} source path(s) not indexed: ${reasons}`);
     }
 
     // Trust is task-specific. A healthy index can be excellent for navigation
@@ -932,8 +959,10 @@ function doctor(index, options = {}) {
                 ? `${blindSpots.parseRecoveries.count} file(s) required parser recovery; indexed results may be partial`
                 : cache.fresh === false ? 'index cache is stale'
                     : index.truncated ? `file discovery stopped at maxFiles=${index.truncated.maxFiles}`
+                        : unsearchablePaths > 0
+                            ? `${unsearchablePaths} path(s) could not be searched; no caller account is complete until they can`
                         : blindSpots.skippedSources.count > 0
-                            ? `${blindSpots.skippedSources.count} source path(s) were not indexed; inspect discovery reasons`
+                            ? `${blindSpots.skippedSources.count} source file(s) are searched as text only; a name that occurs in them is listed, not analyzed`
                         : unsupportedCount > 0
                             ? `${fileCounts.scanned} supported file(s) indexed; ${unsupportedCount} unsupported source file(s) require grep/ripgrep`
                             : 'fresh index; no parse failures';
@@ -965,8 +994,11 @@ function doctor(index, options = {}) {
         : 'no known runtime blind spots detected; alias/dynamic completeness is not compiler-verified locally';
 
     const navigationLevel = indexLevel;
+    // A path nothing can be read from leaves every caller account
+    // incomplete, which is what blocks `check`: the two must agree.
     const hardIndexRisk = blindSpots.parseFailures.count > 0 ||
-        blindSpots.parseRecoveries.count > 0 || cache.fresh === false || !!index.truncated;
+        blindSpots.parseRecoveries.count > 0 || cache.fresh === false || !!index.truncated ||
+        unsearchablePaths > 0;
     const refactorLevel = indexLevel === 'UNKNOWN' ? 'UNKNOWN'
         : indexLevel === 'UNSUPPORTED' ? 'UNSUPPORTED'
             : hardIndexRisk ? 'LOW'
@@ -1005,6 +1037,9 @@ function doctor(index, options = {}) {
         symbols: totalSymbols,
         languages: langs,
         blindSpots,
+        // What completeness claims range over: text-only, unsearchable and
+        // declared-outside paths, stated here once.
+        scope: require('./source-universe').scopeSummary(index),
         evidenceProfile,
         cache,
         commandTrust: summarizeCommandTrust(),

package/core/review-items.js

@@ -0,0 +1,75 @@
+/**
+ * core/review-items.js - How much is there to look at?
+ *
+ * Unverified caller candidates are not all the same amount of work. A site
+ * the engine could not bind is one thing to check. A dispatch family (an
+ * interface call that may reach any implementation, a template the
+ * compiler instantiates) is ONE boundary with a known reason, however many
+ * sites it lists. A reader reviews the boundary, not each site.
+ *
+ * One counter, shared by the pre-commit check, the caller formatter and
+ * the oracle evaluation, so the three cannot disagree about the burden.
+ */
+
+'use strict';
+
+/**
+ * Why a caller candidate is unverified, as one of three classes:
+ * 'runtime-dispatch' (the implementation is selected at runtime through a
+ * named boundary), 'compile-time-dispatch' (the compiler selects it),
+ * 'actionable-ambiguity' (something a reader can settle). The class the
+ * engine recorded wins; a possible-dispatch site with a named boundary is
+ * runtime dispatch.
+ */
+function uncertaintyClassOf(site) {
+    return site.uncertaintyClass ||
+        (site.reason === 'possible-dispatch' && site.dispatchVia ? 'runtime-dispatch' : 'actionable-ambiguity');
+}
+
+/** Unverified entries by class: { actionable, runtime, compileTime }. */
+function partitionUnverified(unverified) {
+    const parts = { actionable: [], runtime: [], compileTime: [] };
+    for (const site of Array.isArray(unverified) ? unverified : []) {
+        const kind = uncertaintyClassOf(site);
+        if (kind === 'runtime-dispatch') parts.runtime.push(site);
+        else if (kind === 'compile-time-dispatch') parts.compileTime.push(site);
+        else parts.actionable.push(site);
+    }
+    return parts;
+}
+
+/** Key of the family a runtime-dispatch site belongs to. */
+function runtimeFamilyKey(site) {
+    return `${site.dispatchVia || ''}\0${site.dispatchCandidates ?? ''}\0` +
+        `${site.externalContract ? 'external' : 'project'}`;
+}
+
+/** Key of the family a compile-time-dispatch site belongs to. */
+function compileTimeFamilyKey(site) {
+    return `${site.dispatchFamily || ''}\0${site.dispatchCandidates ?? ''}`;
+}
+
+/**
+ * @param {object[]} unverified - unverified caller entries
+ * @returns {{actionable, runtimeDispatchSites, runtimeDispatchGroups,
+ *   compileTimeDispatchSites, compileTimeDispatchGroups, items}}
+ *   `items` = actionable sites + one per dispatch family.
+ */
+function reviewItemsOf(unverified) {
+    const { actionable: open, runtime, compileTime } = partitionUnverified(unverified);
+    const actionable = open.length;
+    const runtimeDispatchGroups = new Set(runtime.map(runtimeFamilyKey)).size;
+    const compileTimeDispatchGroups = new Set(compileTime.map(compileTimeFamilyKey)).size;
+    return {
+        actionable,
+        runtimeDispatchSites: runtime.length,
+        runtimeDispatchGroups,
+        compileTimeDispatchSites: compileTime.length,
+        compileTimeDispatchGroups,
+        items: actionable + runtimeDispatchGroups + compileTimeDispatchGroups,
+    };
+}
+
+module.exports = {
+    reviewItemsOf, uncertaintyClassOf, partitionUnverified, runtimeFamilyKey, compileTimeFamilyKey,
+};

package/core/search.js

@@ -17,6 +17,8 @@ const { isAccessorDefinition, findAccessorReferences } = require('./accessors');
 const isSafeRegex = require('safe-regex2');
 const { RE2JS } = require('re2js');
 const { UcnError } = require('./errors');
+const { paramValues } = require('./registry');
+const { createTestModel, addTestCaseRows, linkFiles } = require('./test-units');
 
 // Keep the established search-input contract for the canonical catastrophic
 // nested-single-atom family even though the RE2-compatible engine could run it
@@ -36,11 +38,8 @@ function buildGlobMatcher(pattern, caseSensitive) {
     return (name) => regex.test(name);
 }
 
-const STRUCTURAL_TYPES = new Set([
-    'function', 'class', 'call', 'method', 'type', 'constructor',
-    'state', 'field', 'constant', 'macro', 'variable',
-    'interface', 'enum', 'struct', 'trait', 'record', 'namespace',
-]);
+// The kinds a structural search takes: the parameter table's set.
+const STRUCTURAL_TYPES = new Set(paramValues('type', 'search'));
 
 /**
  * Substring match. Case-insensitive by default.
@@ -1313,6 +1312,10 @@ function tests(index, nameOrFile, options = {}) {
     index._beginOp();
     try {
     const results = [];
+    const model = createTestModel(index);
+    // Files where a title that names the term is a link (the term on a test
+    // line is the project's symbol, not the file's own helper).
+    const titled = new Set();
 
     // Check if it's a file path
     const isFilePath = nameOrFile.includes('/') || nameOrFile.includes('\\') ||
@@ -1358,6 +1361,23 @@ function tests(index, nameOrFile, options = {}) {
         }
     }
 
+    // A file's name does not decide what a test executes: the body of a
+    // test a class inherits stands where its base class is, and a runner
+    // takes tests from files of any name. A call site the caller engine
+    // finds in such a file is a test's where the test model says a test
+    // executes that line (core/test-units.js): the file joins the test
+    // files, test code within those lines.
+    const testInfoByPath = new Map(testFiles.map(info => [info.path, info]));
+    const testInfoOf = filePath => {
+        if (testInfoByPath.has(filePath)) return testInfoByPath.get(filePath);
+        const entry = index.files.get(filePath);
+        const ranges = entry ? model.testRangesOf(filePath) : [];
+        const info = ranges.length > 0 ? { path: filePath, entry, testRanges: ranges } : null;
+        testInfoByPath.set(filePath, info);
+        if (info) testFiles.push(info);
+        return info;
+    };
+
     const searchTerm = isFilePath
         ? path.basename(nameOrFile, path.extname(nameOrFile))
         : nameOrFile;
@@ -1388,7 +1408,6 @@ function tests(index, nameOrFile, options = {}) {
     // module-level coverage remain visible.
     const fileTargetCallerSites = new Map(); // absolute test file → tiered sites
     if (isFilePath && targetRels) {
-        const testFileInfo = new Map(testFiles.map(info => [info.path, info]));
         const fileTargetDefs = [];
         for (const [, fe] of index.files) {
             if (!targetRels.has(fe.relativePath)) continue;
@@ -1410,7 +1429,7 @@ function tests(index, nameOrFile, options = {}) {
                 })) : []),
             ];
             for (const site of sites) {
-                const info = testFileInfo.get(site.file);
+                const info = testInfoOf(site.file);
                 if (!info) continue;
                 if (info.testRanges && !lineInRanges(site.line, info.testRanges)) continue;
                 let rows = fileTargetCallerSites.get(site.file);
@@ -1659,12 +1678,11 @@ function tests(index, nameOrFile, options = {}) {
                 });
             }
 
-            // Language-aware test-case detection. Under a local same-name
-            // shadow the term on a test line is the file's OWN helper —
-            // only anchor test cases to matches that survived the shadow.
+            // Under a local same-name shadow the term in a test's title is
+            // the file's OWN helper: titles link only where a match survived.
             if (!isFilePath && sourceFileLinked &&
                 (!localShadow || matches.some(m => m.matchType !== 'import'))) {
-                _addTestCaseMatches(index, testPath, entry, searchTerm, className, instanceTypeMap, matches);
+                titled.add(entry.relativePath);
             }
 
             // Deduplicate: if a line already has a 'call' or 'import', don't also add 'test-case'
@@ -1705,7 +1723,6 @@ function tests(index, nameOrFile, options = {}) {
     // command must not silently drop. Repeated names never receive that broad
     // supplement because it would leak sibling classes/files.
     if (!isFilePath && targetDefs.length > 0) {
-        const testInfo = new Map(testFiles.map(t => [t.path, t]));
         const callerSites = [];
         // A pinned definition's unverified sites were adjudicated against it
         // alone, like a globally unique name's (fix #430).
@@ -1725,7 +1742,7 @@ function tests(index, nameOrFile, options = {}) {
         }
 
         for (const site of callerSites) {
-            const info = testInfo.get(site.file);
+            const info = testInfoOf(site.file);
             if (!info) continue;
             if (info.testRanges && !lineInRanges(site.line, info.testRanges)) continue;
             // Every site here was adjudicated against the exact target
@@ -1780,16 +1797,22 @@ function tests(index, nameOrFile, options = {}) {
         const nestedTypeDefs = targetDefs.filter(def => def.enclosingType &&
             ['class', 'struct', 'interface', 'type', 'enum', 'trait', 'record', 'union'].includes(def.type));
         if (accessorDefs.length > 0 || nestedTypeDefs.length > 0) {
-            const testPaths = new Set(testFiles.map(t => t.path));
+            // Reference-only tests have no call site to add their file to
+            // testFiles above. Let the reference engines find their sites
+            // first, then ask the same model which lines a test executes.
+            // The index-only gate spares files that cannot hold test code;
+            // filenames alone never remove a candidate.
+            const referencePaths = new Set([...index.files.keys()].filter(filePath =>
+                testInfoByPath.get(filePath) || model.mayHoldTests(filePath)));
             const globallyUnique = index.find(searchTerm, { exact: true }).length === 1;
             for (const def of [...accessorDefs, ...nestedTypeDefs]) {
                 const types = nestedTypeDefs.includes(def)
-                    ? require('./analysis').findTypeReferences(index, searchTerm, def, { files: testPaths }) : null;
+                    ? require('./analysis').findTypeReferences(index, searchTerm, def, { files: referencePaths }) : null;
                 const typeSite = site => ({ ...site, absoluteFile: path.join(index.root, site.file) });
                 const refs = types ? {
                     confirmed: types.byFile.flatMap(group => group.sites).map(typeSite),
                     unverified: types.unverifiedSites.map(typeSite),
-                } : findAccessorReferences(index, searchTerm, def, { files: testPaths });
+                } : findAccessorReferences(index, searchTerm, def, { files: referencePaths });
                 if (!refs) continue;
                 const rows = [
                     ...refs.confirmed.map(r => ({ ...r, tierName: 'confirmed' })),
@@ -1797,7 +1820,7 @@ function tests(index, nameOrFile, options = {}) {
                         ? refs.unverified.map(r => ({ ...r, tierName: 'unverified' })) : []),
                 ];
                 for (const ref of rows) {
-                    const info = testInfo.get(ref.absoluteFile);
+                    const info = testInfoOf(ref.absoluteFile);
                     if (!info) continue;
                     if (info.testRanges && !lineInRanges(ref.line, info.testRanges)) continue;
                     if (excludeArr.length > 0 &&
@@ -1835,6 +1858,55 @@ function tests(index, nameOrFile, options = {}) {
         results.sort((a, b) => codeUnitCompare(a.file || '', b.file || ''));
     }
 
+    // The tests that hold the matches (core/test-units.js): one row per
+    // test, then what the file is to its runner and how to run it.
+    const absolute = new Map(testFiles.map(info => [info.entry.relativePath, info.path]));
+    const linesByFile = new Map();
+    for (const fileResult of results) {
+        const testPath = absolute.get(fileResult.file);
+        if (!testPath) continue;
+        addTestCaseRows(model, index, testPath, isFilePath ? null : searchTerm, fileResult.matches, {
+            counts: match => match.matchType !== 'import',
+            titles: titled.has(fileResult.file),
+            titleNeedsMatch: !!className,
+        });
+        linesByFile.set(testPath,
+            fileResult.matches.filter(match => match.matchType !== 'import').map(match => match.line));
+    }
+    // A test a class inherits runs where the class is: the file of a class
+    // that inherits a linked test is a result of its own, with the test.
+    const byFile = new Map(results.map(fileResult => [fileResult.file, fileResult]));
+    for (const [testPath, linked] of linkFiles(model, index, linesByFile)) {
+        const relativePath = index.files.get(testPath).relativePath;
+        let fileResult = byFile.get(relativePath);
+        if (!fileResult) {
+            fileResult = { file: relativePath, matches: [] };
+            byFile.set(relativePath, fileResult);
+            results.push(fileResult);
+        }
+        for (const unit of linked.units) {
+            if (!unit.inheritedFrom) continue;
+            fileResult.matches.push({
+                line: unit.line,
+                content: (index.getLineContent(testPath, unit.line) || '').trim(),
+                matchType: 'inherited-test',
+                name: unit.name,
+                from: unit.inheritedFrom,
+            });
+        }
+        fileResult.matches.sort((a, b) => (a.line || 0) - (b.line || 0) ||
+            codeUnitCompare(a.matchType || '', b.matchType || '') || codeUnitCompare(a.name || '', b.name || ''));
+        fileResult.role = linked.role;
+        if (linked.runner) fileResult.runner = linked.runner;
+        fileResult.tests = linked.tests;
+        if (linked.moreTests) fileResult.moreTests = true;
+        if (linked.conditionalTests) fileResult.conditionalTests = linked.conditionalTests;
+        if (linked.units.length > 0) fileResult.units = linked.units;
+        if (linked.run) fileResult.run = linked.run;
+        else if (linked.runWithheld) fileResult.runWithheld = linked.runWithheld;
+    }
+    results.sort((a, b) => codeUnitCompare(a.file || '', b.file || ''));
+
     return results;
     } finally { index._endOp(); }
 }
@@ -2181,117 +2253,6 @@ function _receiverMatchesClass(usage, dispatchNames, instanceTypeMap, lineConten
     return false;
 }
 
-/**
- * Language-aware test-case detection.
- *
- * JS/TS: describe, it, test, spec calls with searchTerm in the description.
- * Go: TestXxx, BenchmarkXxx, ExampleXxx functions containing a usage of searchTerm.
- * Python: test_ functions or TestCase methods containing a usage of searchTerm.
- * Java: @Test-annotated methods containing a usage of searchTerm.
- * Rust: #[test]-attributed functions containing a usage of searchTerm.
- */
-function _addTestCaseMatches(index, filePath, fileEntry, searchTerm, className, instanceTypeMap, matches) {
-    const matchLines = new Set(matches.map(m => m.line));
-    const lang = fileEntry.language;
-
-    if (lang === 'javascript' || lang === 'typescript' || lang === 'tsx') {
-        // JS/TS: find describe/it/test/spec calls from getCachedCalls
-        const calls = getCachedCalls(index, filePath);
-        if (!calls) return;
-        const testFrameworkCalls = new Set(['describe', 'it', 'test', 'spec']);
-        // Word-boundary match: `describe("untargeted zone")` is not a test
-        // case for `target` (fix #246 — raw substring matched mid-word).
-        const termPattern = new RegExp('(^|[^\\w$])' + escapeRegExp(searchTerm) + '([^\\w$]|$)');
-        for (const call of calls) {
-            if (!testFrameworkCalls.has(call.name)) continue;
-            const lineContent = index.getLineContent(filePath, call.line);
-            // Check if searchTerm appears in the description string on this line
-            if (termPattern.test(lineContent) && !matchLines.has(call.line)) {
-                // className scoping: only add test-case if the test body has a
-                // class-scoped match (call or class-receiver reference) — not just
-                // any mention of className.
-                if (className) {
-                    const endLine = _estimateTestBlockEnd(index, filePath, call.line);
-                    const hasClassScopedMatch = matches.some(m =>
-                        m.line >= call.line && m.line <= endLine &&
-                        m.matchType !== 'import'
-                    );
-                    if (!hasClassScopedMatch) continue;
-                }
-                matches.push({
-                    line: call.line,
-                    content: lineContent.trim(),
-                    matchType: 'test-case'
-                });
-                matchLines.add(call.line);
-            }
-        }
-    } else {
-        // Go/Python/Java/Rust: check if any AST usage falls within a test function's range
-        if (!fileEntry.symbols) return;
-        try {
-            const langModule = getLanguageAdapter(lang);
-            if (!langModule) return;
-            // Prefer kinded predicate so fn main() and fn init() aren't classified
-            // as test cases (BUG-CX). Fall back to isEntryPoint for compat.
-            const classify = langModule.getEntryPointKind
-                ? (s) => langModule.getEntryPointKind(s) === 'test'
-                : langModule.isEntryPoint;
-            if (!classify) return;
-
-            // Find test symbols
-            for (const symbol of fileEntry.symbols) {
-                if (!classify(symbol)) continue;
-                // Check if any non-import usage of searchTerm falls within this test function
-                const usageInRange = matches.some(m =>
-                    m.line >= symbol.startLine && m.line <= symbol.endLine &&
-                    m.matchType !== 'import'
-                );
-                if (usageInRange && !matchLines.has(symbol.startLine)) {
-                    // className scoping: verify the test body has class-scoped matches
-                    if (className) {
-                        const hasClassScopedMatch = matches.some(m =>
-                            m.line >= symbol.startLine && m.line <= symbol.endLine &&
-                            m.matchType !== 'import'
-                        );
-                        if (!hasClassScopedMatch) continue;
-                    }
-                    const lineContent = index.getLineContent(filePath, symbol.startLine);
-                    matches.push({
-                        line: symbol.startLine,
-                        content: lineContent.trim(),
-                        matchType: 'test-case'
-                    });
-                    matchLines.add(symbol.startLine);
-                }
-            }
-        } catch (e) {
-            // Skip if language module unavailable
-        }
-    }
-}
-
-/**
- * Estimate the end line of a test block (it/test/describe callback) by tracking
- * brace nesting from the start line.
- */
-function _estimateTestBlockEnd(index, filePath, startLine) {
-    const content = index._readFile(filePath);
-    if (!content) return startLine + 5;
-    const lines = content.split('\n');
-    let depth = 0;
-    let started = false;
-    for (let i = startLine - 1; i < lines.length; i++) {
-        const line = lines[i];
-        for (const ch of line) {
-            if (ch === '{' || ch === '(') { depth++; started = true; }
-            else if (ch === '}' || ch === ')') { depth--; }
-        }
-        if (started && depth <= 0) return i + 1; // 1-based
-    }
-    return Math.min(startLine + 10, lines.length);
-}
-
 /**
  * Deduplicate matches: prefer more specific matchTypes on the same line.
  * Priority: test-case > call > import > string-ref > reference

package/core/shared.js

@@ -260,49 +260,6 @@ function isOverrideMarked(def) {
     return false;
 }
 
-// Per-language text patterns for the "blind spots" UCN's AST can't follow:
-// eval/exec-style code execution and reflection (dynamic attribute access /
-// dynamic dispatch). ONE source of truth so doctor's trust scan and
-// detectCompleteness's about-footer warning count identically (field-report #2:
-// they used to diverge — doctor 497 reflection vs footer 194, eval 3 vs 2 —
-// because each kept its own regex set). Dynamic imports are NOT here: those are
-// structural (fileEntry.dynamicImports), the AST-accurate count both paths share.
-// `new Function(...)` is categorized as eval (code execution), not reflection.
-const BLINDSPOT_TEXT_PATTERNS = {
-    reflection: {
-        python:     /\b(getattr|hasattr|setattr|__import__|importlib\.import_module)\s*\(/g,
-        javascript: /\bReflect\.\w+\s*\(/g,
-        typescript: /\bReflect\.\w+\s*\(/g,
-        go:         /\breflect\.\w+\s*\(/g,
-        java:       /\.getDeclaredMethod\b|\.getMethod\b|\.getDeclaredField\b|Class\.forName\b/g,
-        rust:       /\bAny::downcast/g,
-    },
-    eval: {
-        python:     /\b(eval|exec)\s*\(/g,
-        javascript: /\beval\s*\(|\bnew\s+Function\s*\(/g,
-        typescript: /\beval\s*\(|\bnew\s+Function\s*\(/g,
-    },
-};
-
-/** True when a language has any text-blind-spot pattern (so callers can skip the file read otherwise). */
-function hasTextBlindspots(language) {
-    return !!(BLINDSPOT_TEXT_PATTERNS.reflection[language] || BLINDSPOT_TEXT_PATTERNS.eval[language]);
-}
-
-/**
- * Count text-detected blind spots (eval/exec, reflection) in one file's source.
- * Returns { eval, reflection } OCCURRENCE counts (global match). Shared by doctor
- * and detectCompleteness so both report the same numbers (field-report #2).
- */
-function countTextBlindspots(content, language) {
-    const reRe = BLINDSPOT_TEXT_PATTERNS.reflection[language];
-    const evRe = BLINDSPOT_TEXT_PATTERNS.eval[language];
-    return {
-        eval: evRe ? (content.match(evRe) || []).length : 0,
-        reflection: reRe ? (content.match(reRe) || []).length : 0,
-    };
-}
-
 /**
  * Line ranges of INLINE test symbols in a source file — Rust #[test] fns and
  * #[cfg(test)] module members. A production file promoted to "test file"
@@ -614,8 +571,6 @@ module.exports = { literalNameRegex,
     looksLikeHandle,
     isTestPath,
     isOverrideMarked,
-    hasTextBlindspots,
-    countTextBlindspots,
     isPathInsideRoot,
     isMacroNamespaceDefinition,
 };