ucn 3.8.26 → 4.0.1

package/core/output/reporting.js

@@ -194,7 +194,7 @@ function formatStatsJson(stats) {
  * @param {string} [options.exportedHint] - Hint about exported symbols exclusion
  */
 function formatDeadcode(results, options = {}) {
-    if (results.length === 0 && !results.excludedDecorated && !results.excludedExported) {
+    if (results.length === 0 && !results.excludedDecorated && !results.excludedExported && !results.excludedExternalContract) {
         return 'No dead code found.';
     }
 
@@ -227,7 +227,16 @@ function formatDeadcode(results, options = {}) {
             hints.push(...item.annotations.map(a => `@${a}`));
         }
         const hintStr = hints.length > 0 ? ` [has ${hints.join(', ')}]` : '';
-        lines.push(`  ${lineRange(item.startLine, item.endLine)} ${item.name} (${item.type})${exported}${hintStr}`);
+        // Interface/trait member declarations: unreferenced is true, but
+        // deleting one changes the contract, not dead logic — say so.
+        const declStr = item.declaredOn
+            ? ` [declared on ${item.declaredOn.kind} ${item.declaredOn.name} — contract surface, not executable code]`
+            : '';
+        // Revealed under --include-exported: mark as external-reachable, not dead.
+        const extStr = item.externalContract
+            ? ' [reachable via out-of-tree base — external contract, not dead]'
+            : '';
+        lines.push(`  ${lineRange(item.startLine, item.endLine)} ${item.name} (${item.type})${exported}${hintStr}${declStr}${extStr}`);
     }
 
     if (hidden > 0) {
@@ -246,6 +255,10 @@ function formatDeadcode(results, options = {}) {
         const exportedHint = options.exportedHint || `${results.excludedExported} exported symbol(s) excluded (all have callers). Use --include-exported to audit them.`;
         lines.push(`\n${exportedHint}`);
     }
+    if (results.excludedExternalContract > 0) {
+        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 (lines.length === 0) {
         return 'No dead code found.';
@@ -265,6 +278,7 @@ function formatDeadcodeJson(results) {
             count: results.length,
             ...(results.excludedExported > 0 && { excludedExported: results.excludedExported }),
             ...(results.excludedDecorated > 0 && { excludedDecorated: results.excludedDecorated }),
+            ...(results.excludedExternalContract > 0 && { excludedExternalContract: results.excludedExternalContract }),
             symbols: results.map(item => {
                 const handleSym = { ...item, relativePath: item.relativePath || item.file };
                 const handle = formatSymbolHandle(handleSym);
@@ -277,7 +291,9 @@ function formatDeadcodeJson(results) {
                     ...(handle && { handle }),
                     ...(item.isExported && { isExported: true }),
                     ...(item.decorators && item.decorators.length > 0 && { decorators: item.decorators }),
-                    ...(item.annotations && item.annotations.length > 0 && { annotations: item.annotations })
+                    ...(item.annotations && item.annotations.length > 0 && { annotations: item.annotations }),
+                    ...(item.declaredOn && { declaredOn: item.declaredOn }),
+                    ...(item.externalContract && { externalContract: true })
                 };
             }),
         },

package/core/output/shared.js

@@ -103,8 +103,8 @@ function formatFunctionSignature(fn) {
     else paramText = '...';
     sig += `(${paramText})`;
 
-    // Return type
-    if (fn.returnType) sig += `: ${fn.returnType}`;
+    // Return type (collapse whitespace — multi-line annotations must not break the one-line signature)
+    if (fn.returnType) sig += `: ${String(fn.returnType).replace(/\s+/g, ' ').trim()}`;
 
     // Arrow indicator
     if (fn.isArrow) sig += ' =>';
@@ -306,9 +306,40 @@ function formatGitLine(git) {
     return line;
 }
 
+/**
+ * Display label for an unverified-tier entry's reason. Dispatch-tiered
+ * entries (nominal languages) carry attribution metadata: the declared
+ * supertype the call dispatches through (dispatchVia) and how many
+ * same-name definitions the dispatch could land on (dispatchCandidates).
+ */
+function unverifiedReasonLabel(entry) {
+    if (!entry || !entry.reason) return '';
+    if (entry.reason === 'possible-dispatch' && entry.externalContract) {
+        // External contract (fix #210): the candidate set is open — any
+        // external subtype of the contract — so no implementation count.
+        return entry.dispatchVia
+            ? `possible-dispatch via ${entry.dispatchVia} — external contract`
+            : 'possible-dispatch — external contract';
+    }
+    if (entry.reason === 'possible-dispatch' && entry.dispatchVia) {
+        const n = entry.dispatchCandidates;
+        return n > 1
+            ? `possible-dispatch via ${entry.dispatchVia} — 1 of ${n} implementations`
+            : `possible-dispatch via ${entry.dispatchVia}`;
+    }
+    if (entry.reason === 'method-ambiguous' && entry.dispatchCandidates > 1) {
+        return `method-ambiguous — ${entry.dispatchCandidates} same-name definitions`;
+    }
+    if (entry.reason === 'overload-ambiguous' && entry.dispatchCandidates > 1) {
+        return `overload-ambiguous — 1 of ${entry.dispatchCandidates} applicable overloads`;
+    }
+    return entry.reason;
+}
+
 module.exports = {
     dynamicImportsNote,
     formatFileError,
+    unverifiedReasonLabel,
     normalizeParams,
     lineNum,
     lineRange,

package/core/output/tracing.js

@@ -1,7 +1,90 @@
 /**
  * core/output/tracing.js - Trace/blast/reverse tree formatters
+ *
+ * Tree contract rendering: the trunk is confirmed-tier; unverified caller
+ * edges render in an UNVERIFIED EDGES section with parent attribution and a
+ * reason; unresolved callee calls render as [unverified] leaves under their
+ * node; ACCOUNT (root text-ground) and TREE ACCOUNT (interior candidate
+ * conservation) lines close the arithmetic.
  */
 
+const { unverifiedReasonLabel } = require('./shared');
+const { formatAccountLines } = require('./analysis');
+
+/**
+ * Render the caller-direction unverified frontier. Returns true if anything
+ * was rendered.
+ */
+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'
+        : 'not expanded; possible additional impact';
+    lines.push(`UNVERIFIED EDGES (${frontier.length}) — call syntax, no binding/receiver evidence; ${suffix}:`);
+    const cap = options.all ? Infinity : 20;
+    let shown = 0;
+    for (const f of frontier) {
+        if (shown >= cap) break;
+        const callerName = f.callerName ? ` [${f.callerName}]` : '';
+        const expr = f.content ? `: ${f.content.trim().replace(/\s+/g, ' ').slice(0, 100)}` : '';
+        const reason = f.reason ? ` (${unverifiedReasonLabel(f)})` : '';
+        lines.push(`  at ${f.atNode.name} (hop ${f.hop}): ${f.relativePath}:${f.line}${callerName}${expr}${reason}`);
+        shown++;
+    }
+    if (frontier.length > shown) {
+        lines.push(`  (+${frontier.length - shown} more unverified — use --all)`);
+    }
+    return true;
+}
+
+/** Render a node's unresolved callee calls as [unverified] leaves. */
+function renderUnverifiedCallees(lines, node, prefix, isParentLast) {
+    if (!node.unverifiedCallees || node.unverifiedCallees.length === 0) return;
+    const extension = isParentLast ? '    ' : '│   ';
+    for (let i = 0; i < node.unverifiedCallees.length; i++) {
+        const u = node.unverifiedCallees[i];
+        const isLast = i === node.unverifiedCallees.length - 1;
+        const connector = isLast ? '└── ' : '├── ';
+        const owners = u.ownerCount > 1 ? ` (${u.ownerCount} owners)` : '';
+        const linesPart = u.sites && u.sites.length > 0 ? ` L${u.sites.join(',L')}` : '';
+        lines.push(`${prefix}${extension}${connector}[unverified] ${u.name} — ${u.reason}${owners}${linesPart}`);
+    }
+}
+
+/** TREE ACCOUNT line for caller-direction trees. */
+function treeAccountLine(ta) {
+    if (!ta) return null;
+    const reasons = Object.entries(ta.unverifiedByReason || {})
+        .sort((a, b) => a[0].localeCompare(b[0]))
+        .map(([r, n]) => `${n} ${r}`).join(', ');
+    const excludedReasons = Object.entries(ta.excludedByReason || {})
+        .sort((a, b) => a[0].localeCompare(b[0]))
+        .map(([r, n]) => `${n} ${r}`).join(', ');
+    let line = `TREE ACCOUNT: ${ta.nodesExpanded} node${ta.nodesExpanded === 1 ? '' : 's'} expanded · ` +
+        `${ta.confirmedEdges} confirmed edge${ta.confirmedEdges === 1 ? '' : 's'} · ` +
+        `${ta.unverifiedEdges} unverified${reasons ? ` (${reasons})` : ''} · ` +
+        `${ta.excludedTotal} excluded${excludedReasons ? ` (${excludedReasons})` : ''}`;
+    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)`;
+    return line;
+}
+
+/** CALLEE ACCOUNT rollup line for down-direction trees. */
+function calleeAccountLine(ta) {
+    if (!ta || !ta.callSites) return null;
+    const cs = ta.callSites;
+    const reasons = Object.entries(ta.unverifiedByReason || {})
+        .sort((a, b) => a[0].localeCompare(b[0]))
+        .map(([r, n]) => `${n} ${r}`).join(', ');
+    let line = `CALLEE ACCOUNT: ${ta.nodesExpanded} node${ta.nodesExpanded === 1 ? '' : 's'} expanded · ` +
+        `${cs.total} call site${cs.total === 1 ? '' : 's'} = ${cs.confirmed} confirmed + ` +
+        `${cs.unverified} unverified${reasons ? ` (${reasons})` : ''} + ` +
+        `${cs.external} external/builtin + ${cs.excluded} excluded`;
+    if (cs.filtered > 0) line += ` + ${cs.filtered} filtered`;
+    return line;
+}
+
 /**
  * Format trace command output - text
  * Shows call tree visualization
@@ -53,14 +136,16 @@ function formatTrace(trace, options = {}) {
 
         if (node.children && !node.alreadyShown) {
             const hasMore = node.truncatedChildren > 0;
+            const hasUnverified = node.unverifiedCallees && node.unverifiedCallees.length > 0;
             for (let i = 0; i < node.children.length; i++) {
-                const isChildLast = !hasMore && i === node.children.length - 1;
+                const isChildLast = !hasMore && !hasUnverified && i === node.children.length - 1;
                 renderNode(node.children[i], prefix + extension, isChildLast);
             }
             if (hasMore) {
                 hasTruncation = true;
-                lines.push(prefix + extension + `└── ... and ${node.truncatedChildren} more callees`);
+                lines.push(prefix + extension + (hasUnverified ? '├── ' : '└── ') + `... and ${node.truncatedChildren} more callees`);
             }
+            renderUnverifiedCallees(lines, node, prefix, isLast);
         }
     };
 
@@ -68,13 +153,25 @@ function formatTrace(trace, options = {}) {
     lines.push(trace.root);
     if (trace.tree && trace.tree.children) {
         const rootHasMore = trace.tree.truncatedChildren > 0;
+        const rootHasUnverified = trace.tree.unverifiedCallees && trace.tree.unverifiedCallees.length > 0;
         for (let i = 0; i < trace.tree.children.length; i++) {
-            const isLast = !rootHasMore && i === trace.tree.children.length - 1;
+            const isLast = !rootHasMore && !rootHasUnverified && i === trace.tree.children.length - 1;
             renderNode(trace.tree.children[i], '', isLast);
         }
         if (rootHasMore) {
             hasTruncation = true;
-            lines.push(`└── ... and ${trace.tree.truncatedChildren} more callees`);
+            lines.push((rootHasUnverified ? '├── ' : '└── ') + `... and ${trace.tree.truncatedChildren} more callees`);
+        }
+        if (rootHasUnverified) {
+            // Root-level unverified callees: render with no prefix
+            for (let i = 0; i < trace.tree.unverifiedCallees.length; i++) {
+                const u = trace.tree.unverifiedCallees[i];
+                const isLast = i === trace.tree.unverifiedCallees.length - 1;
+                const connector = isLast ? '└── ' : '├── ';
+                const owners = u.ownerCount > 1 ? ` (${u.ownerCount} owners)` : '';
+                const linesPart = u.sites && u.sites.length > 0 ? ` L${u.sites.join(',L')}` : '';
+                lines.push(`${connector}[unverified] ${u.name} — ${u.reason}${owners}${linesPart}`);
+            }
         }
     }
 
@@ -92,6 +189,19 @@ function formatTrace(trace, options = {}) {
         }
     }
 
+    // Caller-direction unverified frontier (up/both)
+    renderFrontier(lines, trace.unverifiedFrontier, options);
+
+    // Conservation lines: callee rollup (down/both), root account (up/both)
+    const accountParts = [];
+    const downLine = calleeAccountLine(trace.treeAccount);
+    if (downLine) accountParts.push(downLine);
+    accountParts.push(...formatAccountLines(trace.account));
+    if (accountParts.length > 0) {
+        lines.push('');
+        lines.push(...accountParts);
+    }
+
     if (hasTruncation) {
         const allHint = options.allHint || 'Use --all to show all.';
         lines.push(`\nSome results truncated. ${allHint}`);
@@ -153,6 +263,11 @@ function formatBlast(blast, options = {}) {
         if (node.callSites && node.callSites > 1) {
             label += ` ${node.callSites}x`;
         }
+        if (node.viaUnverified) {
+            label += ` [⚠ via ${node.viaUnverified}]`;
+        } else if (node.chainUnverified) {
+            label += ' [⚠ unverified chain]';
+        }
         if (node.alreadyShown) {
             label += ' (see above)';
         }
@@ -186,17 +301,39 @@ function formatBlast(blast, options = {}) {
         }
     }
 
+    // Unverified frontier
+    renderFrontier(lines, blast.unverifiedFrontier, options, !!blast.expandUnverified);
+
     // Summary
     if (blast.summary) {
         lines.push('');
-        const { totalAffected, totalFiles } = blast.summary;
+        const { totalAffected, totalFiles, unverifiedEdges, possiblyAffected } = blast.summary;
         if (totalAffected > 0) {
-            lines.push(`Summary: 1 function changed → ${totalAffected} function${totalAffected !== 1 ? 's' : ''} affected across ${totalFiles} file${totalFiles !== 1 ? 's' : ''}`);
+            let s = `Summary: 1 function changed → ${totalAffected} function${totalAffected !== 1 ? 's' : ''} affected across ${totalFiles} file${totalFiles !== 1 ? 's' : ''}`;
+            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)`;
+            }
+            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)`);
         } else {
             lines.push('Summary: No callers found — this function is a root/entry point.');
         }
     }
 
+    // Conservation lines
+    const taLine = treeAccountLine(blast.treeAccount);
+    const accountLines = formatAccountLines(blast.account);
+    if (taLine || accountLines.length > 0) {
+        lines.push('');
+        if (accountLines.length > 0) lines.push(...accountLines);
+        if (taLine) lines.push(taLine);
+    }
+
     if (hasTruncation) {
         const allHint = options.allHint || 'Use --all to show all.';
         lines.push(`\nSome results truncated. ${allHint}`);
@@ -257,8 +394,15 @@ function formatReverseTrace(result, options = {}) {
         if (node.callSites && node.callSites > 1) {
             label += ` ${node.callSites}x`;
         }
+        if (node.viaUnverified) {
+            label += ` [⚠ via ${node.viaUnverified}]`;
+        } else if (node.chainUnverified) {
+            label += ' [⚠ unverified chain]';
+        }
         if (node.entryPoint) {
             label += ' ★ entry point';
+        } else if (node.unverifiedCallerCount > 0 && (!node.children || node.children.length === 0)) {
+            label += ` ⚠ no confirmed callers — ${node.unverifiedCallerCount} unverified`;
         }
         if (node.alreadyShown) {
             label += ' (see above)';
@@ -283,6 +427,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.unverifiedCallerCount > 0 && result.tree.children.length === 0) {
+        rootLabel += ` ⚠ no confirmed callers — ${result.tree.unverifiedCallerCount} unverified`;
     }
     lines.push(rootLabel);
     if (result.tree && result.tree.children) {
@@ -297,6 +443,9 @@ function formatReverseTrace(result, options = {}) {
         }
     }
 
+    // Unverified frontier
+    renderFrontier(lines, result.unverifiedFrontier, options, !!result.expandUnverified);
+
     // Entry points summary
     if (result.entryPoints && result.entryPoints.length > 0) {
         lines.push('');
@@ -309,12 +458,28 @@ function formatReverseTrace(result, options = {}) {
     // Summary
     if (result.summary) {
         lines.push('');
-        const { totalEntryPoints, totalFunctions } = result.summary;
+        const { totalEntryPoints, totalFunctions, unverifiedEdges } = result.summary;
+        let s;
         if (totalFunctions > 0) {
-            lines.push(`Summary: ${totalEntryPoints} entry point${totalEntryPoints !== 1 ? 's' : ''} reach${totalEntryPoints === 1 ? 'es' : ''} ${result.root} through ${totalFunctions} intermediate function${totalFunctions !== 1 ? 's' : ''}`);
+            s = `Summary: ${totalEntryPoints} entry point${totalEntryPoints !== 1 ? 's' : ''} reach${totalEntryPoints === 1 ? 'es' : ''} ${result.root} through ${totalFunctions} intermediate function${totalFunctions !== 1 ? 's' : ''}`;
+        } else if (unverifiedEdges > 0) {
+            s = `Summary: no confirmed callers — ${unverifiedEdges} unverified edge${unverifiedEdges !== 1 ? 's' : ''} (not an entry-point claim)`;
         } else {
-            lines.push('Summary: No callers found — this function is itself an entry point.');
+            s = 'Summary: No callers found — this function is itself an entry point.';
+        }
+        if (totalFunctions > 0 && unverifiedEdges > 0) {
+            s += ` · ${unverifiedEdges} unverified edge${unverifiedEdges !== 1 ? 's' : ''}`;
         }
+        lines.push(s);
+    }
+
+    // Conservation lines
+    const taLine = treeAccountLine(result.treeAccount);
+    const accountLines = formatAccountLines(result.account);
+    if (taLine || accountLines.length > 0) {
+        lines.push('');
+        if (accountLines.length > 0) lines.push(...accountLines);
+        if (taLine) lines.push(taLine);
     }
 
     if (hasTruncation) {
@@ -377,6 +542,28 @@ function formatAffectedTests(result, options = {}) {
         }
     }
 
+    // Possible band: functions reachable only through unverified chains.
+    if ((result.possiblyAffected && result.possiblyAffected.length > 0) ||
+        (result.possiblyAffectedTests && result.possiblyAffectedTests.length > 0)) {
+        lines.push('');
+        const pa = result.possiblyAffected || [];
+        lines.push(`POSSIBLY AFFECTED (${pa.length}) — reachable only through unverified call edges:`);
+        if (pa.length > 0) {
+            lines.push(`  ${pa.join(', ')}`);
+        }
+        const pat = result.possiblyAffectedTests || [];
+        if (pat.length > 0) {
+            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(', ')})`);
+            }
+            if (pat.length > MAX_POSSIBLE) {
+                lines.push(`    ... ${pat.length - MAX_POSSIBLE} more (use --all)`);
+            }
+        }
+    }
+
     if (result.uncovered.length > 0) {
         lines.push('');
         lines.push(`Uncovered (${result.uncovered.length}): ${result.uncovered.join(', ')}`);
@@ -387,7 +574,18 @@ function formatAffectedTests(result, options = {}) {
     const pct = summary.totalAffected > 0
         ? Math.round(summary.coveredFunctions / summary.totalAffected * 100)
         : 0;
-    lines.push(`Summary: ${summary.totalAffected} affected → ${summary.totalTestFiles} test files, ${summary.coveredFunctions}/${summary.totalAffected} functions covered (${pct}%)`);
+    let summaryLine = `Summary: ${summary.totalAffected} affected → ${summary.totalTestFiles} test files, ${summary.coveredFunctions}/${summary.totalAffected} functions covered (${pct}%)`;
+    if (summary.possiblyAffected > 0) {
+        summaryLine += ` · ${summary.possiblyAffected} possibly affected (unverified chains)`;
+    }
+    lines.push(summaryLine);
+
+    // Conservation lines (root hop)
+    const accountLines = formatAccountLines(result.account);
+    if (accountLines.length > 0) {
+        lines.push('');
+        lines.push(...accountLines);
+    }
 
     if (result.warnings?.length > 0) {
         lines.push('');

package/core/project.js

@@ -384,11 +384,23 @@ class ProjectIndex {
             size: stat.size,
             imports: imports.map(i => i.module),
             importNames: imports.flatMap(i => i.names || []),
+            // Paired name↔module bindings (fix #209): importNames flattens the
+            // pairing away, but name-level shadow detection needs to know WHICH
+            // module bound a name (`from urllib.parse import unquote` rebinds
+            // the bare name for the whole file).
+            importBindings: imports.flatMap(i => (i.names || [])
+                .filter(n => n && n !== '*' && n !== '_' && n !== '.')
+                .map(n => ({ name: n, module: i.module }))),
             exports: exports.map(e => e.name),
             exportDetails: exports,
             symbols: [],
             bindings: [],
             ...(importAliases && { importAliases }),
+            // Module-scope assignment targets (fix #217): names a module can
+            // expose WITHOUT a def/class/import binding (`render = impl`,
+            // `global name`). The import-binding name-chase treats these as
+            // undetermined — a dead-end verdict would be unsound.
+            ...(parsed.moduleAssignedNames && { moduleAssignedNames: parsed.moduleAssignedNames }),
             ...(isBundled && { isBundled: true }),
             ...(isGenerated && { isGenerated: true })
         };
@@ -422,6 +434,7 @@ class ProjectIndex {
                 ...(item.className && { className: item.className }),
                 ...(item.memberType && { memberType: item.memberType }),
                 ...(item.fieldType && { fieldType: item.fieldType }),
+                ...(item.aliasOf && { aliasOf: item.aliasOf }),
                 ...(item.decorators && item.decorators.length > 0 && { decorators: item.decorators }),
                 // Decorator/annotation/attribute argument capture for endpoints command:
                 // these fields hold the parsed first-string-arg of each route-style annotation.
@@ -432,6 +445,10 @@ class ProjectIndex {
                 ...(item.attributesWithArgs && item.attributesWithArgs.length > 0 && { attributesWithArgs: item.attributesWithArgs }),
                 ...(item.nameLine && { nameLine: item.nameLine }),
                 ...(item.traitImpl && { traitImpl: true }),
+                // Trait the impl block implements (rust `impl Trait for X`
+                // members) — external-contract detection needs the NAME, not
+                // just the traitImpl flag (fix #210).
+                ...(item.traitName && { traitName: item.traitName }),
                 ...(item.isSignature && { isSignature: true })
             };
             fileEntry.symbols.push(symbol);
@@ -463,7 +480,7 @@ class ProjectIndex {
             if (cls.members) {
                 for (const m of cls.members) {
                     const memberType = m.memberType || 'method';
-                    addSymbol({ ...m, className: cls.name, ...(cls.traitName && { traitImpl: true }) }, memberType);
+                    addSymbol({ ...m, className: cls.name, ...(cls.traitName && { traitImpl: true, traitName: cls.traitName }) }, memberType);
                 }
             }
         }
@@ -1397,7 +1414,7 @@ class ProjectIndex {
             parts.push(`(${typed != null ? typed : def.params})`);
         }
         if (def.returnType) {
-            parts.push(`: ${def.returnType}`);
+            parts.push(`: ${String(def.returnType).replace(/\s+/g, ' ').trim()}`);
         }
         return parts.join(' ');
     }

package/core/registry.js

@@ -95,6 +95,7 @@ const PARAM_MAP = {
     server_only:       'serverOnly',
     client_only:       'clientOnly',
     hide_uncertain:    'hideUncertain',
+    expand_unverified: 'expandUnverified',
 };
 
 // ============================================================================
@@ -107,10 +108,21 @@ const PARAM_MAP = {
 const FLAG_APPLICABILITY = {
     // Understanding code
     about:        ['name', 'file', 'exclude', 'className', 'includeMethods', 'includeUncertain', 'includeTests', 'top', 'all', 'withTypes', 'minConfidence', 'showConfidence', 'unreachableOnly', 'compact', 'git'],
-    context:      ['name', 'file', 'exclude', 'className', 'includeMethods', 'includeUncertain', 'minConfidence', 'showConfidence', 'unreachableOnly', 'compact'],
+    // Note: includeMethods/includeUncertain are deprecated no-ops for
+    // about/context/impact since the tiered-output contract (unverified
+    // callers are always shown in their own section); kept in the matrix so
+    // legacy invocations don't warn as "inapplicable". `all` lifts the
+    // unverified display cap.
+    context:      ['name', 'file', 'exclude', 'className', 'includeMethods', 'includeUncertain', 'minConfidence', 'showConfidence', 'unreachableOnly', 'compact', 'all'],
     impact:       ['name', 'file', 'exclude', 'className', 'includeMethods', 'includeUncertain', 'top', 'unreachableOnly', 'compact'],
-    blast:        ['name', 'file', 'exclude', 'className', 'includeMethods', 'includeUncertain', 'depth', 'all', 'minConfidence'],
-    reverseTrace: ['name', 'file', 'exclude', 'className', 'includeMethods', 'includeUncertain', 'depth', 'all', 'minConfidence'],
+    // trace/blast/reverseTrace/affectedTests run the tiered tree contract:
+    // includeUncertain is an implied no-op (unverified edges are always
+    // visible — frontier/possible band); expandUnverified follows unverified
+    // CALLER edges, marking downstream nodes chainUnverified (blast/
+    // reverseTrace only — surface trace is down-direction, where unresolved
+    // callees have no definition to expand into).
+    blast:        ['name', 'file', 'exclude', 'className', 'includeMethods', 'includeUncertain', 'depth', 'all', 'minConfidence', 'expandUnverified'],
+    reverseTrace: ['name', 'file', 'exclude', 'className', 'includeMethods', 'includeUncertain', 'depth', 'all', 'minConfidence', 'expandUnverified'],
     smart:        ['name', 'file', 'exclude', 'className', 'includeMethods', 'includeUncertain', 'withTypes', 'minConfidence'],
     trace:        ['name', 'file', 'exclude', 'className', 'includeMethods', 'includeUncertain', 'depth', 'all', 'minConfidence'],
     example:      ['name', 'file', 'className', 'diverse', 'top', 'includeTests'],

package/core/shared.js

@@ -139,6 +139,26 @@ function looksLikeHandle(input) {
     return /^.+:\d+(?::.+)?$/.test(input);
 }
 
+/**
+ * Explicit override marker on a method definition (fix #210). Marker fields are
+ * language-disjoint and compiler-checked syntax (never inferred): traitImpl is
+ * Rust's `impl Trait`, an 'override' modifier is Java's lowercased @Override, an
+ * override-bearing memberType is TS's `override` keyword, and an override
+ * decorator is Python's typing.@override. Shared by the external-contract
+ * reasoning in both the caller dispatch gate and deadcode (out-of-tree override
+ * suppression) — one source of truth so a new marker is added once, not in two
+ * drifting copies.
+ */
+function isOverrideMarked(def) {
+    if (def.traitImpl) return true;
+    const mods = def.modifiers || [];
+    if (mods.includes('override')) return true;
+    if (def.memberType && /\boverride\b/.test(def.memberType)) return true;
+    if (def.decorators && def.decorators.some(d =>
+        String(d).replace(/\(.*$/, '').split('.').pop() === 'override')) return true;
+    return false;
+}
+
 module.exports = {
     pickBestDefinition,
     addTestExclusions,
@@ -148,4 +168,5 @@ module.exports = {
     parseSymbolHandle,
     looksLikeHandle,
     isTestPath,
+    isOverrideMarked,
 };