ucn 4.2.3 → 5.0.2

package/core/output/reporting.js

@@ -9,6 +9,15 @@ const {
     formatClassSignature,
 } = require('./shared');
 
+const LIST_TEXT_LIMIT = 240;
+
+function elideListText(value, limit = LIST_TEXT_LIMIT) {
+    const text = String(value ?? '');
+    if (text.length <= limit) return text;
+    const kept = limit - 18;
+    return `${text.slice(0, kept)}… [${text.length} chars]`;
+}
+
 /**
  * Format toc command output
  * @param {object} toc - TOC data
@@ -63,10 +72,10 @@ function formatToc(toc, options = {}) {
             lines.push(`\n${file.file} (${parts.join(', ')})`);
             if (file.symbols) {
                 for (const fn of file.symbols.functions) {
-                    lines.push(`  ${lineRange(fn.startLine, fn.endLine)} ${formatFunctionSignature(fn)}`);
+                    lines.push(`  ${lineRange(fn.startLine, fn.endLine)} ${elideListText(formatFunctionSignature(fn))}`);
                 }
                 for (const cls of file.symbols.classes) {
-                    lines.push(`  ${lineRange(cls.startLine, cls.endLine)} ${formatClassSignature(cls)}`);
+                    lines.push(`  ${lineRange(cls.startLine, cls.endLine)} ${elideListText(formatClassSignature(cls))}`);
                 }
             }
         } else {
@@ -143,23 +152,26 @@ function formatStats(stats, options = {}) {
         lines.push(`\nFunctions by line count (top ${shown.length} of ${stats.functions.length}):`);
         for (const fn of shown) {
             const loc = `${fn.file}:${fn.startLine}`;
-            lines.push(`  ${String(fn.lines).padStart(5)} lines  ${fn.name}  (${loc})`);
+            lines.push(`  ${String(fn.lines).padStart(5)} lines  ${elideListText(fn.name, 100)}  (${loc})`);
         }
         if (stats.functions.length > top) {
-            lines.push(`  ... ${stats.functions.length - top} more (use --top=N to show more)`);
+            lines.push(`  ... ${stats.functions.length - top} more (${options.topHint || 'use --top=N to show more'})`);
         }
     }
 
     if (stats.hot) {
         const items = stats.hot.items || [];
         const total = stats.hot.total || items.length;
-        lines.push(`\nHottest functions (top ${items.length} of ${total} called):`);
+        const population = stats.hot.totalKind === 'raw-call-candidates'
+            ? `${total} raw candidates`
+            : `${total} called`;
+        lines.push(`\nHottest functions (top ${items.length} of ${population}):`);
         if (items.length === 0) {
             lines.push('  (no inbound calls detected)');
         } else {
             for (const fn of items) {
                 const loc = `${fn.file}:${fn.startLine}`;
-                lines.push(`  ${String(fn.callCount).padStart(5)} calls  ${fn.name}  (${loc})`);
+                lines.push(`  ${String(fn.callCount).padStart(5)} calls  ${elideListText(fn.name, 100)}  (${loc})`);
                 // MEDIUM-6: when the same name has multiple definitions across
                 // files (e.g. test helpers vs. test fixtures both named `tmp`),
                 // list the additional locations indented so the user knows
@@ -172,7 +184,7 @@ function formatStats(stats, options = {}) {
                 }
             }
             if (total > items.length) {
-                lines.push(`  ... ${total - items.length} more (use --top=N to show more)`);
+                lines.push(`  ... ${total - items.length} more (${options.topHint || 'use --top=N to show more'})`);
             }
         }
     }
@@ -194,7 +206,11 @@ function formatStatsJson(stats) {
  * @param {string} [options.exportedHint] - Hint about exported symbols exclusion
  */
 function formatDeadcode(results, options = {}) {
-    if (results.length === 0 && !results.excludedDecorated && !results.excludedExported && !results.excludedExternalContract) {
+    if (results.length === 0 && !results.excludedDecorated &&
+        !results.excludedExported && !results.excludedExternalContract &&
+        !results.excludedRuntimeContract && !results.pythonImplicitExportFiles &&
+        !results.excludedDynamicDispatch && !results.computedDispatch?.count &&
+        results.coverage?.complete !== false) {
         return 'No dead code found.';
     }
 
@@ -238,12 +254,16 @@ function formatDeadcode(results, options = {}) {
             : '';
         // The only references are the symbol's own recursion (fix #253c).
         const recStr = item.selfRecursive ? ' [only self-references — recursive]' : '';
-        const displayName = item.className ? `${item.className}.${item.name}` : item.name;
+        const displayName = elideListText(
+            item.className ? `${item.className}.${item.name}` : item.name,
+            120,
+        );
         lines.push(`  ${lineRange(item.startLine, item.endLine)} ${displayName} (${item.type})${exported}${hintStr}${declStr}${extStr}${recStr}`);
     }
 
     if (hidden > 0) {
-        lines.push(`\n${hidden} more result(s) not shown. Use --top=${results.length} or --all to see all.`);
+        lines.push(`\n${hidden} more result(s) not shown. ${options.topHint ||
+            `Use --top=${results.length} or --all to see all.`}`);
     }
 
     // Show counts of excluded items with expansion hints
@@ -262,6 +282,29 @@ function formatDeadcode(results, options = {}) {
         const extHint = options.externalContractHint || `${results.excludedExternalContract} symbol(s) hidden (override an out-of-tree base class — reachable via external contract, not dead). Use --include-exported to include them.`;
         lines.push(`\n${extHint}`);
     }
+    if (results.excludedRuntimeContract > 0) {
+        lines.push(`\n${results.excludedRuntimeContract} Java serialization callback(s) hidden (JVM runtime contract, not dead).`);
+    }
+    if (results.pythonImplicitExportFiles > 0) {
+        lines.push(`\nPython public-surface rule active in ${results.pythonImplicitExportFiles} file(s) without __all__: top-level non-underscore names are treated as externally reachable.`);
+    }
+    if (results.excludedDynamicDispatch > 0) {
+        lines.push(`\n${results.excludedDynamicDispatch} registry member(s) hidden because a matching computed dispatch (registry[key]()) may invoke them.`);
+    }
+    if (results.computedDispatch?.count > 0) {
+        lines.push(`\nWARNING: ${results.computedDispatch.count} computed dispatch call(s) in ${results.computedDispatch.fileCount} file(s). Dead-code results are review candidates; runtime-selected members may not have a named static edge.`);
+    }
+    if (results.coverage?.complete === false) {
+        const c = results.coverage;
+        const reasonText = Object.entries(c.reasons || {})
+            .map(([reason, count]) => `${count} ${reason}`)
+            .join(', ');
+        if (c.claimsWithdrawn) {
+            lines.push(`\nWARNING: dead-code claims withdrawn because source coverage is incomplete (${reasonText || 'unknown gap'}).`);
+        } else {
+            lines.push(`\nWARNING: source coverage is incomplete (${reasonText || 'unknown gap'}); ${c.suppressedMatched || 0} candidate name(s) found in skipped source were suppressed.`);
+        }
+    }
 
     if (lines.length === 0) {
         return 'No dead code found.';
@@ -290,6 +333,11 @@ function formatDeadcodeJson(results) {
             ...(results.excludedExported > 0 && { excludedExported: results.excludedExported }),
             ...(results.excludedDecorated > 0 && { excludedDecorated: results.excludedDecorated }),
             ...(results.excludedExternalContract > 0 && { excludedExternalContract: results.excludedExternalContract }),
+            ...(results.excludedRuntimeContract > 0 && { excludedRuntimeContract: results.excludedRuntimeContract }),
+            ...(results.pythonImplicitExportFiles > 0 && { pythonImplicitExportFiles: results.pythonImplicitExportFiles }),
+            ...(results.excludedDynamicDispatch > 0 && { excludedDynamicDispatch: results.excludedDynamicDispatch }),
+            ...(results.computedDispatch?.count > 0 && { computedDispatch: results.computedDispatch }),
+            ...(results.coverage?.complete === false && { coverage: results.coverage }),
             symbols: results.map(item => {
                 const handleSym = { ...item, relativePath: item.relativePath || item.file };
                 const handle = formatSymbolHandle(handleSym);
@@ -400,9 +448,9 @@ function formatEntrypointsJson(results) {
 /**
  * formatOrient — one-screen cold-repo orientation.
  */
-function formatOrient(result) {
+function formatOrient(result, options = {}) {
     const lines = [];
-    lines.push(`PROJECT ORIENTATION — ${result.root}`);
+    lines.push(`PROJECT ORIENTATION — ${result.root}${result.scope ? ` (scoped to ${result.scope})` : ''}`);
     lines.push('═'.repeat(60));
 
     // Size + language mix (percent by symbols, largest first)
@@ -413,7 +461,8 @@ function formatOrient(result) {
     const langStr = langs
         .map(l => `${l.lang} ${Math.round((l.symbols / totalSym) * 100)}%`)
         .join(', ');
-    lines.push(`${result.files} files · ${result.symbols} symbols · ${langStr}`);
+    lines.push(`${result.files} files · ${result.symbols} symbols · ` +
+        `language mix by symbols: ${langStr || 'none'}`);
     lines.push('');
 
     if (result.dirs?.length) {
@@ -427,7 +476,10 @@ function formatOrient(result) {
 
     if (result.hot?.items?.length) {
         const scope = result.hot.production ? 'production functions' : 'functions';
-        lines.push(`HOT (most-called ${scope}, top ${result.hot.items.length} of ${result.hot.total}):`);
+        const population = result.hot.totalKind === 'raw-call-candidates'
+            ? `${result.hot.total} raw candidates`
+            : result.hot.total;
+        lines.push(`HOT (most-called ${scope}, top ${result.hot.items.length} of ${population}):`);
         for (const h of result.hot.items) {
             const label = h.className ? `${h.className}.${h.name}` : h.name;
             lines.push(`  ${label} — ${h.callCount} call(s) · ${h.file}:${h.line}`);
@@ -438,23 +490,48 @@ function formatOrient(result) {
     if (result.entrypoints) {
         const byType = result.entrypoints.byType
             .map(t => `${t.type} ${t.count}`).join(', ');
-        lines.push(`ENTRY POINTS: ${result.entrypoints.total} — ${byType}`);
+        lines.push(`ENTRY POINTS: ${result.entrypoints.total}${byType ? ` — ${byType}` : ''}`);
     } else {
         lines.push('ENTRY POINTS: (detection unavailable)');
     }
 
     const bs = result.trust?.blindSpots || {};
     const bsParts = [];
-    if (bs.dynamicImports) bsParts.push(`${bs.dynamicImports} dynamic import(s)`);
+    if (bs.dynamicImports) {
+        const note = dynamicImportsNote(bs.dynamicImports, {
+            projectLanguage: result.projectLanguage || result.trust?.projectLanguage,
+        });
+        if (note) bsParts.push(note);
+    }
     if (bs.evalCalls) bsParts.push(`${bs.evalCalls} eval`);
     if (bs.reflection) bsParts.push(`${bs.reflection} reflection`);
+    if (bs.computedDispatch) bsParts.push(`${bs.computedDispatch} computed dispatch`);
     if (bs.parseFailures) bsParts.push(`${bs.parseFailures} parse failure(s)`);
-    lines.push(`TRUST: ${result.trust?.level || 'UNKNOWN'}${bsParts.length ? ' — ' + bsParts.join(', ') : ''}  (ucn doctor for detail)`);
+    if (bs.parseRecoveries) bsParts.push(`${bs.parseRecoveries} parser-recovery file(s)`);
+    if (bs.unsupportedSources) bsParts.push(`${bs.unsupportedSources} unsupported source file(s)`);
+    if (bs.skippedSources) bsParts.push(`${bs.skippedSources} skipped source path(s)`);
+    lines.push(`TRUST: ${result.trust?.level || 'UNKNOWN'}${bsParts.length ? ' — ' + bsParts.join(', ') : ''}  (${options.healthHint || 'ucn repo --sections=health --deep for detail'})`);
+    if (result.unsupportedSources?.count > 0) {
+        const languages = Object.entries(result.unsupportedSources.languages || {})
+            .map(([language, count]) => `${language} ${count}`)
+            .join(', ');
+        lines.push(`SKIPPED SOURCE: ${result.unsupportedSources.count} file(s)${languages ? ` (${languages})` : ''} — use grep/ripgrep plus a language-native analyzer.`);
+    }
+    if (result.skippedSources?.count > 0) {
+        const reasons = Object.entries(result.skippedSources.reasons || {})
+            .map(([reason, count]) => `${reason} ${count}`).join(', ');
+        lines.push(`SKIPPED SOURCE: ${result.skippedSources.count} path(s) were not indexed${reasons ? ` (${reasons})` : ''} — completeness claims are withdrawn.`);
+    }
     lines.push('');
 
-    const next = [];
-    if (result.suggest) next.push(`ucn about ${result.suggest}`);
-    next.push('ucn toc --detailed', 'ucn stats --hot --top=20', 'ucn doctor --deep');
+    const next = options.nextHints
+        ? options.nextHints(result)
+        : [
+            ...(result.suggest ? [`ucn show ${result.suggest}`] : []),
+            'ucn repo --sections=files --detailed',
+            'ucn repo --sections=stats --hot --top=20',
+            'ucn repo --sections=health --deep',
+        ];
     lines.push(`Next: ${next.join(' · ')}`);
 
     return lines.join('\n');

package/core/output/search.js

@@ -7,28 +7,27 @@ const { detectDoubleEscaping, advisoryLine } = require('./shared');
 /**
  * Format search command output
  */
-function formatSearch(results, term) {
+function formatSearch(results, term, options = {}) {
     const meta = results.meta;
-    const fallbackNote = meta && meta.regexFallback
-        ? `\nNote: Invalid regex (${meta.regexFallback}). Fell back to plain text search.`
-        : '';
 
-    const totalMatches = results.reduce((sum, r) => sum + r.matches.length, 0);
+    const shownMatches = results.reduce((sum, r) => sum + r.matches.length, 0);
+    const totalMatches = meta?.totalMatches ?? shownMatches;
     if (totalMatches === 0) {
         if (meta) {
             const scope = meta.filesSkipped > 0
                 ? `Searched ${meta.filesScanned} of ${meta.totalFiles} file${meta.totalFiles === 1 ? '' : 's'} (${meta.filesSkipped} excluded by filters).`
                 : `Searched ${meta.filesScanned} file${meta.filesScanned === 1 ? '' : 's'}.`;
             const escapingHint = detectDoubleEscaping(term);
-            return `No matches found for "${term}". ${scope}${fallbackNote}${escapingHint}`;
+            return `No matches found for "${term}". ${scope}${escapingHint}`;
         }
-        return `No matches found for "${term}"${fallbackNote}`;
+        return `No matches found for "${term}"`;
     }
 
     const lines = [];
-    const fileWord = results.length === 1 ? 'file' : 'files';
-    lines.push(`Found ${totalMatches} match${totalMatches === 1 ? '' : 'es'} for "${term}" in ${results.length} ${fileWord}:`);
-    if (fallbackNote) lines.push(fallbackNote.trim());
+    const totalFiles = meta?.matchedFiles ?? meta?.totalMatchedFiles ?? results.length;
+    const fileWord = totalFiles === 1 ? 'file' : 'files';
+    const showing = shownMatches < totalMatches ? ` (showing ${shownMatches})` : '';
+    lines.push(`Found ${totalMatches} match${totalMatches === 1 ? '' : 'es'} for "${term}" in ${totalFiles} ${fileWord}${showing}:`);
     lines.push('═'.repeat(60));
 
     for (const result of results) {
@@ -49,11 +48,11 @@ function formatSearch(results, term) {
     }
 
     if (meta && meta.truncatedMatches > 0) {
-        lines.push(`\n${results.reduce((s, r) => s + r.matches.length, 0)} shown of ${meta.totalMatches} total matches. Use top= to see more.`);
+        lines.push(`\n${shownMatches} shown of ${meta.totalMatches} total matches. ${options.topHint || 'Use --top=N to see more.'}`);
     }
 
     if (meta && meta.testsExcluded && meta.filesSkipped > 0) {
-        lines.push(`\nNote: ${meta.filesSkipped} test file${meta.filesSkipped === 1 ? '' : 's'} hidden by default (use include_tests=true to include).`);
+        lines.push(`\nNote: ${meta.filesSkipped} test file${meta.filesSkipped === 1 ? '' : 's'} hidden by default (${options.includeTestsHint || 'use --include-tests to include'}).`);
     }
 
     return lines.join('\n');
@@ -80,7 +79,6 @@ function formatSearchJson(results, term) {
         obj.filesScanned = meta.filesScanned;
         obj.filesSkipped = meta.filesSkipped;
         obj.totalFiles = meta.totalFiles;
-        if (meta.regexFallback) obj.regexFallback = meta.regexFallback;
         if (meta.truncatedMatches > 0) obj.truncatedMatches = meta.truncatedMatches;
     }
     return JSON.stringify(obj, null, 2);
@@ -89,7 +87,7 @@ function formatSearchJson(results, term) {
 /**
  * Format structural search results (index-based queries)
  */
-function formatStructuralSearch(result) {
+function formatStructuralSearch(result, options = {}) {
     const { results, meta } = result;
     const lines = [];
 
@@ -107,6 +105,10 @@ function formatStructuralSearch(result) {
 
     lines.push(`Structural search: ${queryStr}`);
     lines.push('═'.repeat(60));
+    if (meta.query.unused) {
+        lines.push(`NOTE: ${options.unusedFlag || '--unused'} lists callable symbols with no resolved call edge; it does not assess type/field/reference liveness and is not safe-delete proof. Confirm with deadcode and usages.`);
+        lines.push('');
+    }
 
     if (results.length === 0) {
         lines.push('No matches found.');
@@ -137,7 +139,7 @@ function formatStructuralSearch(result) {
     }
 
     if (meta.shown < meta.totalMatched) {
-        lines.push(`\n${meta.shown} of ${meta.totalMatched} shown. Use top= to see more.`);
+        lines.push(`\n${meta.shown} of ${meta.totalMatched} shown. ${options.topHint || 'Use --top=N to see more.'}`);
     }
 
     return lines.join('\n');
@@ -396,8 +398,13 @@ function formatTypedefJson(types, name) {
 function formatTests(tests, name) {
     const lines = [`Tests for "${name}":\n`];
 
+    for (const warning of tests?.warnings || []) {
+        lines.push(`Note: ${warning.message}`);
+    }
+    if (tests?.warnings?.length > 0) lines.push('');
+
     if (!tests || !Array.isArray(tests) || tests.length === 0) {
-        lines.push('  (no tests found)');
+        lines.push('  (no statically linked tests found)');
     } else {
         const totalMatches = tests.reduce((sum, t) => sum + t.matches.length, 0);
         lines.push(`Found ${totalMatches} matches in ${tests.length} test file(s):\n`);
@@ -432,6 +439,7 @@ function formatTestsJson(tests, name) {
     const safe = Array.isArray(tests) ? tests : [];
     return JSON.stringify({
         query: name,
+        ...(safe.warnings?.length > 0 && { warnings: safe.warnings }),
         testFileCount: safe.length,
         totalMatches: safe.reduce((sum, t) => sum + (t.matches?.length || 0), 0),
         testFiles: safe

package/core/output/shared.js

@@ -97,9 +97,28 @@ function formatFunctionSignature(fn) {
     // Generator marker
     if (fn.isGenerator) prefix.push('*');
 
+    // Data members are not callables.  Their declared type is stronger and
+    // more useful than the unknown-parameter sentinel (UCN5-171).
+    const dataMember = fn.type === 'field' || fn.type === 'state' ||
+        fn.memberType === 'field' || fn.memberType === 'property';
+    if (dataMember) {
+        let dataSig = fn.name;
+        const declaredType = fn.fieldType || fn.returnType;
+        if (declaredType) {
+            dataSig += `: ${String(declaredType).replace(/\s+/g, ' ').trim()}`;
+        }
+        return prefix.length > 0 ? `${prefix.join(' ')} ${dataSig}` : dataSig;
+    }
+
+    // Object-like macros expand as values, not calls. Function-like macros
+    // retain their real parameter list, including an empty `()` (UCN5-170).
+    if (fn.type === 'macro' && fn.functionLike === false) {
+        return prefix.length > 0 ? `${prefix.join(' ')} ${fn.name}` : fn.name;
+    }
+
     // Name + generics + params (concatenated without spaces)
     let sig = fn.name;
-    if (fn.generics) sig += fn.generics;
+    if (fn.generics) sig += String(fn.generics).replace(/\s+/g, ' ').trim();
     // If paramsStructured + paramTypes are available, render typed params
     const typed = renderTypedParams(fn);
     // When paramsStructured is an empty array, the function has zero params —
@@ -353,6 +372,8 @@ const ADVISORY_LABELS = {
     'scored-selection': 'examples picked by usage-quality scoring',
     'best-effort-frame-matching': 'frames matched by path similarity',
     'heuristic-route-matching': 'route↔request matches are heuristic (see per-match EXACT/PARTIAL/UNCERTAIN tiers)',
+    'incomplete-endpoint-inventory': 'AST inventory covers known framework patterns; absence is not proof that no endpoint exists',
+    'heuristic-route-matching-and-incomplete-inventory': 'AST inventory covers known framework patterns and route↔request matches are heuristic; absence is not proof that no endpoint exists',
 };
 
 /** Render the advisory line for a result's `advisory` field, or null. */

package/core/output/tracing.js

@@ -20,7 +20,7 @@ function renderFrontier(lines, frontier, options = {}, expanded = false) {
     if (!frontier || frontier.length === 0) return false;
     lines.push('');
     const suffix = expanded
-        ? 'followed (--expand-unverified); downstream nodes are possible impact'
+        ? `followed (${options.expandUnverifiedHint || '--expand-unverified'}); downstream nodes are possible impact`
         : 'not expanded; possible additional impact';
     lines.push(`UNVERIFIED EDGES (${frontier.length}) — call syntax, no binding/receiver evidence; ${suffix}:`);
     const cap = options.all ? Infinity : 20;
@@ -34,7 +34,7 @@ function renderFrontier(lines, frontier, options = {}, expanded = false) {
         shown++;
     }
     if (frontier.length > shown) {
-        lines.push(`  (+${frontier.length - shown} more unverified — use --all)`);
+        lines.push(`  (+${frontier.length - shown} more unverified — ${options.allHint || 'use --all'})`);
     }
     return true;
 }
@@ -66,8 +66,14 @@ function treeAccountLine(ta) {
         `${ta.confirmedEdges} confirmed edge${ta.confirmedEdges === 1 ? '' : 's'} · ` +
         `${ta.unverifiedEdges} unverified${reasons ? ` (${reasons})` : ''} · ` +
         `${ta.excludedTotal} excluded${excludedReasons ? ` (${excludedReasons})` : ''}`;
+    if (ta.recursiveEdges > 0) {
+        line += ` · ${ta.recursiveEdges} self-recursive edge${ta.recursiveEdges === 1 ? '' : 's'} (not external impact)`;
+    }
     if (ta.filteredEdges > 0) line += ` · ${ta.filteredEdges} hidden by --exclude`;
     if (ta.depthLimitNodes > 0) line += ` · ${ta.depthLimitNodes} node${ta.depthLimitNodes === 1 ? '' : 's'} at depth limit (callers not searched)`;
+    if (ta.truncatedChildren > 0) {
+        line += ` · ${ta.truncatedChildren} child branch${ta.truncatedChildren === 1 ? '' : 'es'} not expanded (account covers the displayed subtree only)`;
+    }
     return line;
 }
 
@@ -317,13 +323,15 @@ function formatBlast(blast, options = {}) {
             if (unverifiedEdges > 0) {
                 s += blast.expandUnverified
                     ? ` · ${unverifiedEdges} unverified edge${unverifiedEdges !== 1 ? 's' : ''} followed (${possiblyAffected || 0} possibly affected)`
-                    : ` · ${unverifiedEdges} unverified edge${unverifiedEdges !== 1 ? 's' : ''} (--expand-unverified to follow them)`;
+                    : ` · ${unverifiedEdges} unverified edge${unverifiedEdges !== 1 ? 's' : ''} (${options.expandUnverifiedHint || '--expand-unverified'} to follow them)`;
             }
             lines.push(s);
         } else if (unverifiedEdges > 0) {
             lines.push(blast.expandUnverified
                 ? `Summary: no confirmed callers · ${unverifiedEdges} unverified edge${unverifiedEdges !== 1 ? 's' : ''} followed (${possiblyAffected || 0} possibly affected)`
-                : `Summary: no confirmed callers · ${unverifiedEdges} unverified edge${unverifiedEdges !== 1 ? 's' : ''} (--expand-unverified to follow them)`);
+                : `Summary: no confirmed callers · ${unverifiedEdges} unverified edge${unverifiedEdges !== 1 ? 's' : ''} (${options.expandUnverifiedHint || '--expand-unverified'} to follow them)`);
+        } else if (blast.summary.selfRecursive) {
+            lines.push('Summary: No external callers found — this function is self-recursive; entry-point status is not established by the self-edge.');
         } else {
             lines.push('Summary: No callers found — this function is a root/entry point.');
         }
@@ -345,7 +353,7 @@ function formatBlast(blast, options = {}) {
 
     const blastFiltered = (blast.treeAccount?.filteredEdges ?? 0);
     if (blast.includeMethods === false && blastFiltered > 0) {
-        lines.push(`\nNote: ${blastFiltered} obj.method() caller edge(s) hidden (counted as filtered in the account). Use --include-methods to show them.`);
+        lines.push(`\nNote: ${blastFiltered} obj.method() caller edge(s) hidden (counted as filtered in the account). ${options.includeMethodsHint || 'Use --include-methods to show them.'}`);
     }
 
     return lines.join('\n');
@@ -406,6 +414,8 @@ function formatReverseTrace(result, options = {}) {
         }
         if (node.entryPoint) {
             label += ' ★ entry point';
+        } else if (node.selfRecursive && (!node.children || node.children.length === 0)) {
+            label += ' ↻ self-recursive (no external caller proven)';
         } else if (node.unverifiedCallerCount > 0 && (!node.children || node.children.length === 0)) {
             label += ` ⚠ no confirmed callers — ${node.unverifiedCallerCount} unverified`;
         }
@@ -432,6 +442,8 @@ function formatReverseTrace(result, options = {}) {
     let rootLabel = result.root;
     if (result.tree && result.tree.entryPoint) {
         rootLabel += ' ★ entry point (no callers)';
+    } else if (result.tree && result.tree.selfRecursive && result.tree.children.length === 0) {
+        rootLabel += ' ↻ self-recursive (no external caller proven)';
     } else if (result.tree && result.tree.unverifiedCallerCount > 0 && result.tree.children.length === 0) {
         rootLabel += ` ⚠ no confirmed callers — ${result.tree.unverifiedCallerCount} unverified`;
     }
@@ -474,6 +486,8 @@ function formatReverseTrace(result, options = {}) {
             s = `Summary: ${totalEntryPoints} entry point${totalEntryPoints !== 1 ? 's' : ''} reach${totalEntryPoints === 1 ? 'es' : ''} ${result.root}${intermediates > 0 ? ` through ${intermediates} intermediate function${intermediates !== 1 ? 's' : ''}` : ' directly'}`;
         } else if (unverifiedEdges > 0) {
             s = `Summary: no confirmed callers — ${unverifiedEdges} unverified edge${unverifiedEdges !== 1 ? 's' : ''} (not an entry-point claim)`;
+        } else if (result.summary.selfRecursive) {
+            s = 'Summary: No external callers found — this function is self-recursive; no entry point is proven.';
         } else {
             s = 'Summary: No callers found — this function is itself an entry point.';
         }
@@ -499,7 +513,7 @@ function formatReverseTrace(result, options = {}) {
 
     const rtFiltered = (result.treeAccount?.filteredEdges ?? 0);
     if (result.includeMethods === false && rtFiltered > 0) {
-        lines.push(`\nNote: ${rtFiltered} obj.method() caller edge(s) hidden (counted as filtered in the account). Use --include-methods to show them.`);
+        lines.push(`\nNote: ${rtFiltered} obj.method() caller edge(s) hidden (counted as filtered in the account). ${options.includeMethodsHint || 'Use --include-methods to show them.'}`);
     }
 
     return lines.join('\n');
@@ -531,7 +545,7 @@ function formatAffectedTests(result, options = {}) {
     lines.push('');
 
     if (result.testFiles.length === 0) {
-        lines.push('No test files found for any affected function.');
+        lines.push('No confirmed static test links found for any affected function.');
     } else {
         const MAX_TEST_FILES = options.all ? Infinity : 30;
         const displayFiles = result.testFiles.slice(0, MAX_TEST_FILES);
@@ -539,7 +553,7 @@ function formatAffectedTests(result, options = {}) {
         lines.push(`Test files to run (${summary.totalTestFiles}):`);
         lines.push('');
         for (const tf of displayFiles) {
-            lines.push(`  ${tf.file} (covers: ${tf.coveredFunctions.join(', ')})`);
+            lines.push(`  ${tf.file} (links: ${tf.linkedFunctions.join(', ')})`);
             // Show up to 5 key matches per file
             const keyMatches = tf.matches
                 .filter(m => m.matchType === 'call' || m.matchType === 'test-case')
@@ -567,25 +581,26 @@ function formatAffectedTests(result, options = {}) {
             lines.push(`  Additional test files (${pat.length}):`);
             const MAX_POSSIBLE = options.all ? Infinity : 10;
             for (const tf of pat.slice(0, MAX_POSSIBLE)) {
-                lines.push(`    ${tf.file} (covers: ${tf.coveredFunctions.join(', ')})`);
+                lines.push(`    ${tf.file} (links: ${tf.linkedFunctions.join(', ')})`);
             }
             if (pat.length > MAX_POSSIBLE) {
-                lines.push(`    ... ${pat.length - MAX_POSSIBLE} more (use --all)`);
+                lines.push(`    ... ${pat.length - MAX_POSSIBLE} more (${options.allHint || 'use --all'})`);
             }
         }
     }
 
-    if (result.uncovered.length > 0) {
+    const notStaticallyLinked = result.notStaticallyLinked || [];
+    if (notStaticallyLinked.length > 0) {
         lines.push('');
-        lines.push(`Uncovered (${result.uncovered.length}): ${result.uncovered.join(', ')}`);
-        lines.push('  ⚠ These affected functions have no test references');
+        lines.push(`Not statically linked (${notStaticallyLinked.length}): ${notStaticallyLinked.join(', ')}`);
+        lines.push('  ⚠ No indexed test call/reference path was found; this is not runtime coverage data');
     }
 
     lines.push('');
     const pct = summary.totalAffected > 0
-        ? Math.round(summary.coveredFunctions / summary.totalAffected * 100)
+        ? Math.round(summary.staticallyLinkedFunctions / summary.totalAffected * 100)
         : 0;
-    let summaryLine = `Summary: ${summary.totalAffected} affected → ${summary.totalTestFiles} test files, ${summary.coveredFunctions}/${summary.totalAffected} functions covered (${pct}%)`;
+    let summaryLine = `Summary: ${summary.totalAffected} affected → ${summary.totalTestFiles} statically linked test files, ${summary.staticallyLinkedFunctions}/${summary.totalAffected} functions linked (${pct}%)`;
     if (summary.possiblyAffected > 0) {
         summaryLine += ` · ${summary.possiblyAffected} possibly affected (unverified chains)`;
     }