ucn 5.4.2 → 5.5.0

package/core/output/analysis.js

@@ -147,6 +147,14 @@ function formatAccountLines(account) {
             `(${account.unparsed.lines} line${account.unparsed.lines === 1 ? '' : 's'}, NOT analyzed): ` +
             account.unparsed.files.join(', '));
     }
+    if (account.recovered && account.recovered.lines > 0) {
+        const rec = account.recovered;
+        const shown = rec.sites.slice(0, 5).map(site => `${site.file}:${site.line}`);
+        lines.push(`WARNING: ${rec.lines} line${rec.lines === 1 ? '' : 's'} with "${account.symbol}" in ` +
+            `${rec.fileCount} file${rec.fileCount === 1 ? '' : 's'} sit${rec.lines === 1 ? 's' : ''} in syntax-error recovery ` +
+            `regions (partially parsed; classification there may be wrong): ${shown.join(', ')}` +
+            `${rec.lines > shown.length ? `, ... and ${rec.lines - shown.length} more` : ''}`);
+    }
     if (unsupported.lines > 0) {
         const langParts = Object.entries(unsupported.languages)
             .map(([lang, count]) => `${lang}: ${count}`).join(', ');
@@ -270,6 +278,7 @@ function formatContextJson(context) {
                     ...(c.resolution && { resolution: c.resolution }),
                     ...(c.provenance && { provenance: c.provenance }),
                     ...(c.siteProvenance && { siteProvenance: c.siteProvenance }),
+                    ...(c.macroExpansion && { macroExpansion: c.macroExpansion }),
                     ...(c.tier && { tier: c.tier })
                 })),
                 unverifiedCallers: (context.unverifiedCallers || []).map(c => ({
@@ -287,6 +296,7 @@ function formatContextJson(context) {
                     ...(c.resolution && { resolution: c.resolution }),
                     ...(c.provenance && { provenance: c.provenance }),
                     ...(c.siteProvenance && { siteProvenance: c.siteProvenance }),
+                    ...(c.macroExpansion && { macroExpansion: c.macroExpansion }),
                     ...(c.reason && { reason: c.reason }),
                     ...(c.dispatchVia && { dispatchVia: c.dispatchVia }),
                     ...(c.dispatchCandidates != null && { dispatchCandidates: c.dispatchCandidates }),
@@ -329,6 +339,7 @@ function formatContextJson(context) {
                 ...(c.confidence != null && { confidence: c.confidence, resolution: c.resolution }),
                 ...(c.provenance && { provenance: c.provenance }),
                 ...(c.siteProvenance && { siteProvenance: c.siteProvenance }),
+                ...(c.macroExpansion && { macroExpansion: c.macroExpansion }),
                 ...(c.evidenceScore != null && { evidenceScore: c.evidenceScore }),
                 ...(c.scoreKind && { scoreKind: c.scoreKind }),
                 ...(c.tier && { tier: c.tier }),
@@ -345,6 +356,7 @@ function formatContextJson(context) {
                 ...(c.confidence != null && { confidence: c.confidence, resolution: c.resolution }),
                 ...(c.provenance && { provenance: c.provenance }),
                 ...(c.siteProvenance && { siteProvenance: c.siteProvenance }),
+                ...(c.macroExpansion && { macroExpansion: c.macroExpansion }),
                 ...(c.evidenceScore != null && { evidenceScore: c.evidenceScore }),
                 ...(c.scoreKind && { scoreKind: c.scoreKind }),
                 tier: 'unverified',
@@ -370,6 +382,7 @@ function formatContextJson(context) {
                 ...(c.confidence != null && { confidence: c.confidence, resolution: c.resolution }),
                 ...(c.provenance && { provenance: c.provenance }),
                 ...(c.siteProvenance && { siteProvenance: c.siteProvenance }),
+                ...(c.macroExpansion && { macroExpansion: c.macroExpansion }),
                 ...(c.evidenceScore != null && { evidenceScore: c.evidenceScore }),
                 ...(c.scoreKind && { scoreKind: c.scoreKind }),
                 ...(c.tier && { tier: c.tier }),
@@ -545,12 +558,15 @@ function formatContext(ctx, options = {}) {
     const renderCaller = (c) => {
         const callerName = c.callerName ? ` [${c.callerName}]` : '';
         const unreachableMark = (callerReach.perLine && c.reachable === false) ? ' [unreachable]' : '';
+        // The call target is produced by expanding a macro invocation on
+        // this line; the line itself does not spell the name (fix #362).
+        const viaMacro = c.macroExpansion ? ` [via macro ${c.macroExpansion.macro}]` : '';
         if (compact) {
             // One line per caller: "[N] file:line [callerName]: expression"
             const expr = c.content ? c.content.trim().replace(/\s+/g, ' ').slice(0, 100) : '';
-            lines.push(`  [${itemNum}] ${c.relativePath}:${c.line}${callerName}${unreachableMark}: ${expr}`);
+            lines.push(`  [${itemNum}] ${c.relativePath}:${c.line}${callerName}${unreachableMark}${viaMacro}: ${expr}`);
         } else {
-            lines.push(`  [${itemNum}] ${c.relativePath}:${c.line}${callerName}${unreachableMark}`);
+            lines.push(`  [${itemNum}] ${c.relativePath}:${c.line}${callerName}${unreachableMark}${viaMacro}`);
             lines.push(`    ${c.content.trim()}`);
         }
         expandable.push({

package/core/output/brief.js

@@ -87,6 +87,9 @@ function formatBrief(result) {
     if (sym.handle) lines.push(`  handle: ${sym.handle}`);
     if (sym.docstring) lines.push(`  "${sym.docstring}"`);
     if (sym.className) lines.push(`  in class ${sym.className}`);
+    if (sym.macroExpansion) {
+        lines.push(`  generated by macro ${sym.macroExpansion.macro} (${sym.macroExpansion.definition})`);
+    }
     const gitLineFn = formatGitLine(result.git);
     if (gitLineFn) lines.push(`  ${gitLineFn}`);
 

package/core/output/doctor.js

@@ -77,6 +77,8 @@ function formatDoctor(result, options = {}) {
         ['Eval/exec calls', bs.evalCalls],
         ['Reflection',      bs.reflection],
         ['Computed dispatch', bs.computedDispatch],
+        ['Token-pasting macro dispatch', bs.macroPasteDispatch],
+        ['Unexpanded macro_rules! invocations', bs.macroRulesExpansion],
         ['Parse failures',  bs.parseFailures],
         ['Parser recovery', bs.parseRecoveries],
         ['Unsupported source', bs.unsupportedSources],
@@ -86,6 +88,8 @@ function formatDoctor(result, options = {}) {
         'Dynamic imports': 'import', 'Blank/dot imports': 'import',
         'Glob imports': 'import', 'Eval/exec calls': 'use', Reflection: 'use',
         'Computed dispatch': 'call',
+        'Token-pasting macro dispatch': 'invocation',
+        'Unexpanded macro_rules! invocations': 'invocation',
         'Parse failures': 'failure',
         'Unsupported source': 'file',
         'Skipped source': 'path',

package/core/output/endpoints.js

@@ -52,10 +52,13 @@ function formatUncertainRequests(result, options) {
     const list = result?.uncertainRequests || [];
     if (list.length === 0) return [];
     const lines = [];
-    lines.push(`Possible client requests (${list.length}) — request-shaped call with a path literal, receiver not recognized as an HTTP client:`);
+    lines.push(`Possible client requests (${list.length}) — request-shaped call with a path literal, receiver or helper not proven to be an HTTP client:`);
     const cap = options.all ? Infinity : 10;
     for (const r of list.slice(0, cap)) {
-        lines.push(`  ${r.file}:${r.line} ${r.receiver}.${r.method}(${JSON.stringify(r.path)}) in ${r.callerName}${r.isTest ? ' [test]' : ''}`);
+        const callee = r.receiver ? `${r.receiver}.${r.method}` : r.method;
+        const why = String(r.reason || '').startsWith('request-helper-unproven')
+            ? ` [${r.reason.replace(/^request-helper-unproven:?/, 'helper not proven HTTP: ')}]` : '';
+        lines.push(`  ${r.file}:${r.line} ${callee}(${JSON.stringify(r.path)}) in ${r.callerName}${r.isTest ? ' [test]' : ''}${why}`);
     }
     if (list.length > cap) lines.push(`  (+${list.length - cap} more — use --all)`);
     return lines;
@@ -88,7 +91,8 @@ function formatRoutesAndRequests(routes, requests, meta, options, advisory = nul
                 for (const r of list) {
                     const handler = r.handler || '<anonymous>';
                     const fw = r.framework ? `[${r.framework}]` : '';
-                    lines.push(`  ${pad(r.method, 7)} ${pad(r.path, 40)} → ${handler} ${fw}${r.isTest ? ' [test]' : ''} :${r.line}`);
+                    const derived = r.derived ? ` [${r.derived}]` : '';
+                    lines.push(`  ${pad(r.method, 7)} ${pad(r.path, 40)} → ${handler} ${fw}${derived}${r.isTest ? ' [test]' : ''} :${r.line}`);
                 }
                 lines.push('');
             }
@@ -166,12 +170,15 @@ function formatBridges(bridges, unmatchedRoutes, unmatchedRequests, meta, option
 
         lines.push(`Matched (${sorted.length} routes):`);
         for (const { route, clients } of sorted) {
-            lines.push(`  ${pad(route.method, 7)} ${route.path}  [${route.framework}]${route.isTest ? ' [test]' : ''}  ${route.file}:${route.line}`);
+            lines.push(`  ${pad(route.method, 7)} ${route.path}  [${route.framework}]${route.derived ? ` [${route.derived}]` : ''}${route.isTest ? ' [test]' : ''}  ${route.file}:${route.line}`);
             for (const b of clients) {
                 const conf = b.confidence.toFixed(2);
                 const tier = b.matchType.toUpperCase();
                 const inf = b.methodInferred ? ' method?' : '';
-                lines.push(`    ↔ ${pad(b.request.method + inf, 9)} ${pad(b.request.path, 30)}  ${tier} (${conf})  from ${b.request.callerName}${b.request.isTest ? ' [test]' : ''}  ${b.request.file}:${b.request.line}`);
+                // An in-process client whose app did not resolve matches by path
+                // across every app (fix #392).
+                const unscoped = b.unscoped ? ' [unscoped]' : '';
+                lines.push(`    ↔ ${pad(b.request.method + inf, 9)} ${pad(b.request.path, 30)}  ${tier} (${conf})${unscoped}  from ${b.request.callerName}${b.request.isTest ? ' [test]' : ''}  ${b.request.file}:${b.request.line}`);
             }
             lines.push('');
         }
@@ -180,7 +187,7 @@ function formatBridges(bridges, unmatchedRoutes, unmatchedRequests, meta, option
     if (unmatchedRoutes.length > 0) {
         lines.push(`Unmatched server routes (${unmatchedRoutes.length}):`);
         for (const r of unmatchedRoutes) {
-            lines.push(`  ${pad(r.method, 7)} ${pad(r.path, 40)} → ${r.handler}  [${r.framework}]${r.isTest ? ' [test]' : ''}  ${r.file}:${r.line}`);
+            lines.push(`  ${pad(r.method, 7)} ${pad(r.path, 40)} → ${r.handler}  [${r.framework}]${r.derived ? ` [${r.derived}]` : ''}${r.isTest ? ' [test]' : ''}  ${r.file}:${r.line}`);
         }
         lines.push('');
     }
@@ -215,6 +222,7 @@ function formatEndpointsJson(result, options = {}) {
         framework: r.framework,
         isTest: !!r.isTest,
         ...(r.classPrefix && { classPrefix: r.classPrefix }),
+        ...(r.derived && { derived: r.derived }),
     });
     const trimReq = (r) => ({
         method: r.method,
@@ -235,6 +243,7 @@ function formatEndpointsJson(result, options = {}) {
         matchType: b.matchType,
         confidence: b.confidence,
         ...(b.methodInferred && { methodInferred: true }),
+        ...(b.unscoped && { unscoped: true }),
     });
 
     return JSON.stringify({

package/core/output/find.js

@@ -11,6 +11,9 @@ const {
 
 const { formatSymbolHandle } = require('../shared');
 
+// Detailed text rows shown by default; the rest are counted.
+const DEFAULT_DISPLAY_LIMIT = 5;
+
 /**
  * Trim a docstring to a single short sentence (max 80 chars) for inline display.
  */
@@ -112,7 +115,6 @@ function formatFindDetailed(symbols, query, options = {}) {
     // Surfaces pass validated NUMBERS; the string comparisons below made
     // --depth 0/2 dead code everywhere (fix #250). Normalize once.
     const depth = options.depth != null ? String(options.depth) : undefined;
-    const DEFAULT_LIMIT = 5;
 
     if (symbols.length === 0) {
         return `No symbols found for "${query}"`;
@@ -129,7 +131,10 @@ function formatFindDetailed(symbols, query, options = {}) {
     for (const [name, count] of Object.entries(symbols.findInfo?.nameWideDefinitionCounts || {})) {
         sameNameDefinitionCounts.set(name, count);
     }
-    const limit = all ? symbols.length : (top > 0 ? top : DEFAULT_LIMIT);
+    // Text shows the top N detailed results (default 5; --limit=N raises
+    // both the returned set and the display, --all lifts both) and counts
+    // the rest; JSON carries every returned result (up to 500 by default).
+    const limit = all ? symbols.length : (top > 0 ? top : DEFAULT_DISPLAY_LIMIT);
     const showing = Math.min(limit, symbols.length);
     const total = symbols.findInfo?.total ?? symbols.length;
     const hidden = Math.max(0, total - showing);

package/core/output/refactoring.js

@@ -27,6 +27,46 @@ function _unverifiedBandLines(sites, cap = 10) {
     return lines;
 }
 
+/**
+ * Review items grouped by finding: one finding (same reason, same
+ * consequence) often holds at many sites, e.g. every place a type is used as
+ * an interface, or every comment naming the symbol. Each finding is stated
+ * once with its sites; at most `cap` sites are listed in total and every
+ * group keeps its count.
+ */
+function groupedReviewLines(items, cap = 20) {
+    const groups = new Map();
+    for (const item of items) {
+        const key = `${item.reviewReason || ''}\0${item.suggestion}`;
+        if (!groups.has(key)) groups.set(key, { suggestion: item.suggestion, items: [] });
+        groups.get(key).items.push(item);
+    }
+    const siteLine = item => `${item.file}:${item.line}: ${item.expression.replace(/\s+/g, ' ').slice(0, 120)}`;
+    const lines = [];
+    let budget = cap;
+    for (const group of groups.values()) {
+        if (group.items.length === 1) {
+            const [item] = group.items;
+            if (budget > 0) {
+                lines.push(`  ${siteLine(item)}`);
+                lines.push(`    → ${group.suggestion}`);
+                budget--;
+            } else {
+                lines.push(`  ${item.file}:${item.line}: ${group.suggestion}`);
+            }
+            continue;
+        }
+        lines.push(`  ${group.suggestion} (${group.items.length} sites):`);
+        const shown = group.items.slice(0, Math.max(1, budget));
+        for (const item of shown) lines.push(`    ${siteLine(item)}`);
+        budget -= shown.length;
+        if (group.items.length > shown.length) {
+            lines.push(`    (+${group.items.length - shown.length} more sites)`);
+        }
+    }
+    return lines;
+}
+
 /**
  * Format plan command output - text
  * Shows before/after signatures and all changes needed
@@ -70,7 +110,7 @@ function formatPlan(plan, options = {}) {
     lines.push(`  Files affected: ${plan.filesAffected}`);
     if (plan.changeSummary) {
         const summary = plan.changeSummary;
-        lines.push(`  Definition ${summary.definitions}, calls ${summary.calls}, references ${summary.references || 0}, text dependencies ${summary.textReferences || 0}, imports ${summary.imports}, exports ${summary.exports}; manual review items ${summary.reviewRequired}`);
+        lines.push(`  Definition ${summary.definitions}, calls ${summary.calls}, references ${summary.references || 0}, ${summary.examples ? `examples ${summary.examples}, ` : ''}text dependencies ${summary.textReferences || 0}, ${summary.contracts ? `contract sites ${summary.contracts}, ` : ''}imports ${summary.imports}, exports ${summary.exports}; manual review items ${summary.reviewRequired}`);
     }
     if (plan.unchangedSites > 0) {
         lines.push(`  ${plan.unchangedSites} existing call site${plan.unchangedSites === 1 ? '' : 's'} require no edit because the new parameter has a default.`);
@@ -81,6 +121,9 @@ function formatPlan(plan, options = {}) {
     if (plan.outsideIndexedSource) {
         lines.push(`  Source boundary: ${plan.outsideIndexedSource.action}`);
     }
+    for (const rename of plan.fileRenames || []) {
+        lines.push(`  Rename file: ${rename.from} -> ${rename.to}`);
+    }
     lines.push('');
 
     // Group by file
@@ -104,15 +147,33 @@ function formatPlan(plan, options = {}) {
         }
     }
 
-    if (plan.reviewItems?.length > 0) {
-        lines.push(`\nREVIEW ITEMS (${plan.reviewItems.length}) — source text dependencies are never rewritten automatically:`);
-        for (const item of plan.reviewItems.slice(0, 20)) {
-            lines.push(`  ${item.file}:${item.line}: ${item.expression.replace(/\s+/g, ' ').slice(0, 120)}`);
-            lines.push(`    → ${item.suggestion}`);
-        }
-        if (plan.reviewItems.length > 20) {
-            lines.push(`  (+${plan.reviewItems.length - 20} more review items)`);
-        }
+    const contractItems = (plan.reviewItems || []).filter(item => item.contractDependency);
+    const templateItems = (plan.reviewItems || []).filter(item => item.templateDependency);
+    const bindingItems = (plan.reviewItems || []).filter(item => item.testBinding);
+    const textItems = (plan.reviewItems || []).filter(item =>
+        !item.contractDependency && !item.templateDependency && !item.testBinding);
+    if (plan.contract?.blocked || contractItems.length > 0) {
+        const generatedName = (plan.contract?.external || []).some(entry =>
+            entry.certainty === 'definite' && entry.reason === 'macro-generated-name');
+        const heading = plan.contract?.blocked
+            ? (generatedName
+                ? 'CONTRACT: rename blocked, a macro invocation generates the name; no edits are proposed'
+                : 'CONTRACT: rename blocked, the member fills a slot of a contract outside the project; no edits are proposed')
+            : 'CONTRACT REVIEW — the member takes part in a contract this plan cannot complete by editing project declarations';
+        lines.push(`\n${heading}:`);
+        lines.push(...groupedReviewLines(contractItems));
+    }
+    if (templateItems.length > 0) {
+        lines.push(`\nMACRO TEMPLATE SITES (${templateItems.length}) — tokens that bind at each macro expansion; review before renaming:`);
+        lines.push(...groupedReviewLines(templateItems));
+    }
+    if (bindingItems.length > 0) {
+        lines.push(`\nTEST FUNCTIONS BOUND BY NAME (${bindingItems.length}) — review before renaming:`);
+        lines.push(...groupedReviewLines(bindingItems));
+    }
+    if (textItems.length > 0) {
+        lines.push(`\nREVIEW ITEMS (${textItems.length}) — source text dependencies are never rewritten automatically:`);
+        lines.push(...groupedReviewLines(textItems));
     }
 
     // v4 tiered contract: candidates without evidence are not planned but
@@ -175,6 +236,7 @@ function formatPlanJson(plan) {
                 outsideIndexedSource: plan.outsideIndexedSource,
             }),
             ...(plan.unchangedSites > 0 && { unchangedSites: plan.unchangedSites }),
+            ...(plan.fileRenames?.length > 0 && { fileRenames: plan.fileRenames }),
             changes: plan.changes.map(c => ({
                 file: c.file,
                 line: c.line,
@@ -186,6 +248,7 @@ function formatPlanJson(plan) {
                 ...(c.isImport && { isImport: true }),
                 ...(c.isExport && { isExport: true }),
                 ...(c.needsReview && { needsReview: true }),
+                ...(c.reviewReason && { reviewReason: c.reviewReason }),
                 ...(c.textDependency && { textDependency: true }),
             })),
             reviewItems: (plan.reviewItems || []).map(item => ({
@@ -195,8 +258,13 @@ function formatPlanJson(plan) {
                 suggestion: item.suggestion,
                 editKind: item.editKind,
                 needsReview: true,
-                textDependency: true,
+                ...(item.contractDependency
+                    ? { contractDependency: true, reviewReason: item.reviewReason }
+                    : item.templateDependency
+                        ? { templateDependency: true, reviewReason: item.reviewReason }
+                        : { textDependency: true }),
             })),
+            ...(plan.contract && { contract: plan.contract }),
             // v4 tiered contract passthrough
             unverifiedCount: plan.unverifiedCount,
             unverifiedSites: plan.unverifiedSites,
@@ -239,6 +307,10 @@ function formatVerify(result, options = {}) {
     lines.push('═'.repeat(60));
     lines.push(`${result.file}:${result.startLine}`);
     lines.push(result.signature);
+    if (result.changedSince) {
+        lines.push(`Changed since ${result.changedSince.base}: was ${result.changedSince.signature}; ` +
+            `${result.changedSince.callSites} call site(s) of the old declaration checked against the new one`);
+    }
     for (const warning of result.warnings || []) {
         lines.push(`Note: ${warning.message}`);
     }
@@ -504,8 +576,18 @@ function formatStackTraceJson(result) {
 function formatAuditAsync(result) {
     if (!result) return 'No async audit data.';
     const issues = Array.isArray(result.issues) ? result.issues : [];
+    const skippedLines = [];
+    if (result.skippedUnknown > 0) {
+        skippedLines.push(`${result.skippedUnknown} unawaited call(s) to async functions whose call result is not known (unrecognized decorator or disagreeing same-name definitions) were not audited.`);
+    }
+    if (result.skippedFutures > 0) {
+        skippedLines.push(`${result.skippedFutures} unpolled Rust future(s) not known to be lazy (a type implementing Future can be a handle to started work; a non-builtin attribute can rewrite an async fn) were not audited.`);
+    }
+    const skipped = skippedLines.length > 0 ? skippedLines.join('\n') : null;
     if (issues.length === 0) {
-        return 'Async audit: no missing-await issues found.';
+        return skipped
+            ? `Async audit: no missing-await issues found.\n${skipped}`
+            : 'Async audit: no missing-await issues found.';
     }
     const lines = [];
     lines.push(`Async audit: ${result.totalIssues} likely missing-await call site(s) across ${result.filesAffected} file(s)`);
@@ -522,12 +604,32 @@ function formatAuditAsync(result) {
         lines.push(`${file} (${fileIssues.length})`);
         for (const issue of fileIssues) {
             const caller = issue.callerName ? ` [${issue.callerName}]` : '';
-            const detail = issue.reason === 'stored-promise-used-as-value'
+            const detail = issue.reason === 'future-discarded'
+                ? `${issue.calleeName}() — future created and never polled (discarded)`
+                : issue.reason === 'future-dropped'
+                    ? `${issue.calleeName}() — future dropped by \`let _ =\` without being polled`
+                : issue.reason === 'future-unused'
+                    ? `${issue.calleeName}() — future bound to ${issue.variable} and never used`
+                : issue.reason === 'stored-future-used-as-value'
+                    ? `${issue.variable} used as its Output; future from ${issue.calleeName}() at line ${issue.originLine} is not awaited`
+                : issue.reason === 'stored-promise-used-as-value'
                 ? `${issue.variable} used as a resolved value; promise from ${issue.calleeName}() at line ${issue.originLine}`
-                : `${issue.calleeName}() — async, not awaited`;
+                : issue.reason === 'stored-coroutine-used-as-value'
+                    ? `${issue.variable} used as a resolved value; coroutine from ${issue.calleeName}() at line ${issue.originLine} is not awaited`
+                : issue.reason === 'async-result-used-as-value'
+                    ? `${issue.calleeName}() — result used as a resolved value, not awaited`
+                : issue.reason === 'async-iterator-discarded'
+                    ? `${issue.calleeName}() — async iterator created and never iterated`
+                    : issue.reason === 'async-context-manager-discarded'
+                        ? `${issue.calleeName}() — async context manager created and never entered`
+                        : `${issue.calleeName}() — async, not awaited`;
             lines.push(`  :${issue.line}${caller}  ${detail}`);
         }
     }
+    if (skipped) {
+        lines.push('');
+        lines.push(skipped);
+    }
     return lines.join('\n');
 }
 
@@ -544,7 +646,12 @@ function formatAuditAsyncJson(result) {
             line: i.line,
             callerName: i.callerName,
             calleeName: i.calleeName,
+            ...(i.reason && { reason: i.reason }),
+            ...(i.reason && i.reason.startsWith('stored-') && { variable: i.variable, originLine: i.originLine }),
+            ...(i.reason === 'future-unused' && { variable: i.variable }),
         })),
+        ...(result.skippedUnknown > 0 && { skippedUnknown: result.skippedUnknown }),
+        ...(result.skippedFutures > 0 && { skippedFutures: result.skippedFutures }),
     }, null, 2);
 }
 

package/core/output/reporting.js

@@ -167,6 +167,11 @@ function formatStats(stats, options = {}) {
             ? `${total} raw candidates`
             : `${total} called`;
         lines.push(`\nHottest functions (top ${items.length} of ${population}):`);
+        if (stats.hot.budgetExhausted) {
+            lines.push(`  Refinement budget reached after ${stats.hot.refined} of ${total} candidates ` +
+                `(${stats.hot.work ?? stats.hot.refined} ${stats.hot.work !== undefined ? 'call records' : 'refinements'}): ` +
+                'ranking approximate, counts exact; narrow with --in=<dir> for an exact list.');
+        }
         if (items.length === 0) {
             lines.push('  (no inbound calls detected)');
         } else {
@@ -298,9 +303,29 @@ function formatDeadcode(results, options = {}) {
     if (results.reflection?.literalCount > 0) {
         lines.push(`\n${results.reflection.literalCount} literal reflection use(s) name ${results.reflection.names.length} member spelling(s); matching symbols were withheld from deletion candidates.`);
     }
+    if (results.reflection?.withheld > 0) {
+        const byPattern = results.reflection.withheldByPattern || [];
+        const sample = byPattern.slice(0, 5).map(w => `\`${w.pattern}\`${w.namespaceOf ? ` in the module namespace of ${w.namespaceOf}` : ''} (${w.count})`).join(', ');
+        lines.push(`\n${results.reflection.withheld} candidate(s) withheld by reflection pattern: ${sample}${byPattern.length > 5 ? ', ...' : ''}. A reflective access builds these member names at runtime.`);
+    }
     if (results.reflection?.dynamicCount > 0) {
         lines.push(`\nWARNING: ${results.reflection.dynamicCount} dynamic reflection use(s) have no static member spelling. Dead-code results remain review candidates because runtime-selected members cannot be attributed.`);
     }
+    if (results.macroPaste) {
+        const m = results.macroPaste;
+        if (m.withheld > 0) {
+            const sample = m.withheldNames.slice(0, 3)
+                .map(w => `${w.name} (${w.macro} at ${w.file}:${w.line})`).join(', ');
+            lines.push(`\n${m.withheld} candidate(s) withheld: a token-pasting macro whose expansions are not all visible could produce the name - ${sample}${m.withheld > 3 ? ', ...' : ''}.`);
+        }
+        if (m.blind?.count > 0) {
+            lines.push(`\nWARNING: ${m.blind.count} token-pasting macro dispatch invocation(s) in ${m.blind.fileCount} file(s) could not be expanded; names they produce are unattributed (${m.blind.files.slice(0, 3).join(', ')}).`);
+        }
+    }
+    if (results.macroRulesBlind?.count > 0) {
+        const b = results.macroRulesBlind;
+        lines.push(`\nWARNING: ${b.count} macro_rules! invocation(s) in ${b.fileCount} file(s) could not be expanded; calls and definitions they generate are unattributed (${b.files.slice(0, 3).join(', ')}).`);
+    }
     if (results.coverage?.complete === false) {
         const c = results.coverage;
         const reasonText = Object.entries(c.reasons || {})
@@ -345,6 +370,8 @@ function formatDeadcodeJson(results) {
             ...(results.excludedDynamicDispatch > 0 && { excludedDynamicDispatch: results.excludedDynamicDispatch }),
             ...(results.computedDispatch?.count > 0 && { computedDispatch: results.computedDispatch }),
             ...(results.reflection?.count > 0 && { reflection: results.reflection }),
+            ...(results.macroPaste && { macroPaste: results.macroPaste }),
+            ...(results.macroRulesBlind && { macroRulesBlind: results.macroRulesBlind }),
             ...(results.coverage?.complete === false && { coverage: results.coverage }),
             symbols: results.map(item => {
                 const handleSym = { ...item, relativePath: item.relativePath || item.file };
@@ -490,9 +517,10 @@ function formatOrient(result, options = {}) {
         const population = result.hot.totalKind === 'raw-call-candidates'
             ? `${result.hot.total} raw candidates`
             : result.hot.total;
-        const budgetNote = result.hot.budgetExhausted
-            ? `; refinement budget ${result.hot.maxRefine} reached — ranking approximate, exact list: ucn repo --sections=stats --hot`
-            : '';
+        const budgetNote = !result.hot.budgetExhausted ? ''
+            : result.hot.maxRefine !== undefined
+                ? `; refinement budget ${result.hot.maxRefine} reached — ranking approximate, exact list: ucn repo --sections=stats --hot`
+                : `; refinement budget reached after ${result.hot.refined} of ${result.hot.total} candidates (${result.hot.work} call records) — ranking approximate, narrow with --in=<dir> for an exact list`;
         lines.push(`HOT (most-called ${scope}, top ${result.hot.items.length} of ${population}${budgetNote}):`);
         for (const h of result.hot.items) {
             const label = h.className ? `${h.className}.${h.name}` : h.name;

package/core/output/shared.js

@@ -358,12 +358,26 @@ function unverifiedReasonLabel(entry) {
             ? `possible-dispatch via ${entry.dispatchVia} — 1 of ${n} implementations`
             : `possible-dispatch via ${entry.dispatchVia}`;
     }
+    if (entry.reason === 'macro-generated-scope' && entry.dispatchVia) {
+        // A macro-wrapped body whose argument names a class (fix #396).
+        return `macro-generated-scope via ${entry.dispatchVia}`;
+    }
     if (entry.reason === 'method-ambiguous' && entry.dispatchCandidates > 1) {
         return `method-ambiguous — ${entry.dispatchCandidates} dispatch owners`;
     }
     if (entry.reason === 'overload-ambiguous' && entry.dispatchCandidates > 1) {
         return `overload-ambiguous — 1 of ${entry.dispatchCandidates} applicable overloads`;
     }
+    if (entry.reason === 'reflection-pattern' && entry.reflectionPattern) {
+        // Member name built at runtime from literal fragments (fix #363).
+        return entry.reflectionScope === 'module-namespace'
+            ? `reflection-pattern \`${entry.reflectionPattern}\` in this module's namespace`
+            : `reflection-pattern \`${entry.reflectionPattern}\``;
+    }
+    if (entry.macroExpansion) {
+        // Call target produced by a macro invocation on this line (fix #362).
+        return `${entry.reason}, via macro ${entry.macroExpansion.macro}`;
+    }
     return entry.reason;
 }