ucn 5.5.1 → 5.5.3

package/core/output/analysis.js

@@ -222,6 +222,33 @@ function unverifiedCalleeLines(entries, compact) {
     return lines;
 }
 
+/**
+ * " (constructs X)" for a constructor body edge beside its class callee (fix
+ * #421); " (build alternative of F:L)" for a Go declaration of the callee in
+ * a file of another build constraint (fix #425).
+ */
+function constructsSuffix(callee) {
+    if (callee?.initializerOf) return ` (constructs ${callee.initializerOf})`;
+    return callee?.configurationAlternativeOf ? ` (build alternative of ${callee.configurationAlternativeOf})` : '';
+}
+
+/**
+ * Constructions whose class edge is confirmed while the constructor body
+ * they run is undecided (fix #421). Their sites are in the class edge's
+ * account; these lines say which body is not proven.
+ */
+function initializerReviewLines(entries, compact) {
+    if (!entries || entries.length === 0) return [];
+    const lines = [`${compact ? '' : '\n'}CONSTRUCTOR BODIES — UNDECIDED (${entries.length}) — class dependency confirmed above; which constructor runs is not proven:`];
+    for (const entry of entries) {
+        const candidates = entry.candidates > 1 ? ` (${entry.candidates} candidates)` : '';
+        const sites = entry.sites?.length ? ` L${entry.sites.join(',L')}` : '';
+        const label = entry.name === entry.initializerOf ? entry.name : `${entry.initializerOf}.${entry.name}`;
+        lines.push(`  ${label} ×${entry.callCount} — ${entry.reason}${candidates}${sites}`);
+    }
+    return lines;
+}
+
 /** "NON-CALL OCCURRENCES" summary line from the account. */
 function formatNonCallLine(account, hintName, usagesHint) {
     if (!account || !account.nonCall || account.nonCall.total === 0) return null;
@@ -388,11 +415,14 @@ function formatContextJson(context) {
                 ...(c.tier && { tier: c.tier }),
                 ...(c.sites && { sites: c.sites }),
                 ...(c.functionReference && { functionReference: true }),
+                ...(c.initializerOf && { initializerOf: c.initializerOf }),
+                ...(c.configurationAlternativeOf && { configurationAlternativeOf: c.configurationAlternativeOf }),
                 ...(c.reachable !== undefined && { reachable: c.reachable }),
             })),
             // v4 callee contract: visible unresolved-call entries (aggregated
             // name+reason), reconciled by meta.calleeAccount.
             unverifiedCallees: context.unverifiedCallees || [],
+            ...(context.initializerReviews?.length && { initializerReviews: context.initializerReviews }),
             ...(context.warnings && { warnings: context.warnings })
         }
     }, provenanceReplacer);
@@ -747,9 +777,9 @@ function formatContext(ctx, options = {}) {
         if (compact) {
             const snip = c.docstring ? calleeDocstringSnippet(c.docstring) : '';
             const docPart = snip ? `: ${snip}` : '';
-            lines.push(`  [${itemNum}] ${c.name}${returnSuffix}${sideEffects} - ${c.relativePath}:${c.startLine}${docPart}${unreachableMark}`);
+            lines.push(`  [${itemNum}] ${c.name}${returnSuffix}${sideEffects} - ${c.relativePath}:${c.startLine}${constructsSuffix(c)}${docPart}${unreachableMark}`);
         } else {
-            lines.push(`  [${itemNum}] ${c.name}${weight}${returnSuffix}${sideEffects} - ${c.relativePath}:${c.startLine}${unreachableMark}`);
+            lines.push(`  [${itemNum}] ${c.name}${weight}${returnSuffix}${sideEffects} - ${c.relativePath}:${c.startLine}${constructsSuffix(c)}${unreachableMark}`);
             if (c.docstring) {
                 const snip = calleeDocstringSnippet(c.docstring);
                 if (snip) lines.push(`    "${snip}"`);
@@ -770,6 +800,7 @@ function formatContext(ctx, options = {}) {
     // Unverified callee band (v4): aggregated name+reason entries — visible,
     // never silently dropped. Not expandable (no definition resolved).
     lines.push(...unverifiedCalleeLines(ctx.unverifiedCallees, compact));
+    lines.push(...initializerReviewLines(ctx.initializerReviews, compact));
 
     // Conservation contract lines: non-call summary + ACCOUNT/WARNING/FILTERED
     const account = ctx.meta && ctx.meta.account;
@@ -793,6 +824,38 @@ function formatContext(ctx, options = {}) {
 }
 
 /** Format impact command output - text. Shows what would need updating if a function signature changes. */
+/**
+ * The value band's token account (fix #420): every name token of the
+ * scanned lines is an access (confirmed, unverified, excluded by reason) or
+ * a declaration token.
+ */
+function formatValueAccount(name, band) {
+    const account = band.account;
+    const reasons = Object.entries(band.excluded?.byReason || {})
+        .sort((a, b) => b[1] - a[1] || (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0))
+        .slice(0, 4).map(([reason, count]) => `${reason} ${count}`).join(', ');
+    return `VALUE ACCOUNT: "${name}" is ${account.tokens} name token(s) on ${account.lines} line(s) in ` +
+        `${account.files} file(s): ${account.confirmed} confirmed, ${account.unverified} unverified, ` +
+        `${account.excluded} excluded${reasons ? ` (${reasons})` : ''}, ${account.declarations} declaration` +
+        `${account.textLines ? `; ${account.textLines} text-only line(s)` : ''}` +
+        `${account.conserved ? '' : ' [NOT CONSERVED]'}`;
+}
+
+function formatTypeAccount(name, band) {
+    const account = band.account;
+    const reasons = Object.entries(band.excluded?.byReason || {})
+        .sort((a, b) => b[1] - a[1] || (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0))
+        .slice(0, 4).map(([reason, count]) => `${reason} ${count}`).join(', ');
+    return `TYPE ACCOUNT: "${name}" is ${account.tokens} name token(s) on ${account.lines} line(s) in ` +
+        `${account.files} file(s): ${account.confirmed} confirmed, ${account.unverified} unverified, ` +
+        `${account.excluded} excluded${reasons ? ` (${reasons})` : ''}, ${account.constructions} at call sites, ` +
+        `${account.declarations} declaration` +
+        `${account.attributeTokens ? ` (${account.attributeTokens} attribute short name(s))` : ''}` +
+        `${account.unparsedLines ? `; ${account.unparsedLines} unparsed line(s)` : ''}` +
+        `${account.textLines ? `; ${account.textLines} text-only line(s)` : ''}` +
+        `${account.conserved ? '' : ' [NOT CONSERVED]'}`;
+}
+
 function formatImpact(impact, options = {}) {
     if (!impact) {
         return 'Function not found.';
@@ -814,8 +877,8 @@ function formatImpact(impact, options = {}) {
     // Summary (confirmed + unverified tiers reported separately)
     const impactUnverified = impact.unverifiedSites || [];
     const unverifiedSuffix = impactUnverified.length > 0 ? ` confirmed + ${impactUnverified.length} unverified` : '';
-    if (impact.propertyAccesses || impact.typeReferences) {
-        const pa = impact.propertyAccesses || impact.typeReferences;
+    if (impact.propertyAccesses || impact.valueAccesses || impact.typeReferences) {
+        const pa = impact.propertyAccesses || impact.valueAccesses || impact.typeReferences;
         const uv = pa.unverifiedCount ? ` + ${pa.unverifiedCount} unverified` : '';
         lines.push(`DEPENDENCY SITES: ${impact.totalDependencySites} confirmed${uv}`);
     }
@@ -891,9 +954,10 @@ function formatImpact(impact, options = {}) {
     }
     if (impactReach.note && !compact) lines.push(impactReach.note);
 
-    if (impact.propertyAccesses) {
-        const access = impact.propertyAccesses;
-        lines.push(`${compact ? '' : '\n'}PROPERTY ACCESS SITES: ${access.confirmedCount} confirmed` +
+    if (impact.propertyAccesses || impact.valueAccesses) {
+        const access = impact.propertyAccesses || impact.valueAccesses;
+        const label = impact.propertyAccesses ? 'PROPERTY' : 'VALUE';
+        lines.push(`${compact ? '' : '\n'}${label} ACCESS SITES: ${access.confirmedCount} confirmed` +
             (access.unverifiedCount ? ` + ${access.unverifiedCount} unverified` : ''));
         for (const group of access.byFile) {
             for (const site of group.sites) {
@@ -903,44 +967,47 @@ function formatImpact(impact, options = {}) {
             }
         }
         if (access.unverifiedSites.length > 0) {
-            lines.push(`${compact ? '' : '\n'}UNVERIFIED PROPERTY ACCESS CANDIDATES (${access.unverifiedSites.length}) — matching attribute syntax, receiver identity unresolved:`);
+            const reason = impact.propertyAccesses ? 'matching attribute syntax, receiver identity unresolved'
+                : 'matching value syntax, binding identity unresolved';
+            lines.push(`${compact ? '' : '\n'}UNVERIFIED ${label} ACCESS CANDIDATES (${access.unverifiedSites.length}) — ${reason}:`);
             for (const site of access.unverifiedSites.slice(0, 10)) {
                 const caller = site.callerName ? ` [${site.callerName}]` : '';
                 const expr = site.expression ? `: ${site.expression.replace(/\s+/g, ' ').slice(0, 100)}` : '';
-                lines.push(`  ${site.file}:${site.line}${caller} [${site.accessKind || 'access'}${Number.isInteger(site.column) ? `, column ${site.column + 1}` : ''}]${expr}`);
+                const why = impact.valueAccesses && site.reason ? ` (${site.reason})` : '';
+                lines.push(`  ${site.file}:${site.line}${caller} [${site.accessKind || 'access'}${Number.isInteger(site.column) ? `, column ${site.column + 1}` : ''}]${expr}${why}`);
             }
             if (access.unverifiedSites.length > 10) {
                 lines.push(`  (+${access.unverifiedSites.length - 10} more unverified)`);
             }
         }
+        const valueAccount = impact.valueAccesses?.account;
+        if (valueAccount) lines.push(formatValueAccount(impact.function, impact.valueAccesses));
     }
 
-    // fix #345: annotation sites of a type-kind definition, tiered like the
-    // accessor band. The headline no longer says 0 for a type with dependents.
+    // fixes #345, #428: the tokens naming a type outside its call sites,
+    // tiered by the type lookup, with their own account.
     if (impact.typeReferences) {
         const refs = impact.typeReferences;
         lines.push(`${compact ? '' : '\n'}TYPE REFERENCE SITES: ${refs.confirmedCount} confirmed` +
-            (refs.unverifiedCount ? ` + ${refs.unverifiedCount} unverified` : '') +
-            (refs.excluded?.total ? ` (${refs.excluded.total} other-target)` : ''));
+            (refs.unverifiedCount ? ` + ${refs.unverifiedCount} unverified` : ''));
+        const position = site => `${site.kind || 'type'}${Number.isInteger(site.column) ? `, column ${site.column + 1}` : ''}`;
         for (const group of refs.byFile) {
             for (const site of group.sites) {
                 const expr = site.expression ? `: ${site.expression.replace(/\s+/g, ' ').slice(0, 100)}` : '';
-                lines.push(`  ${group.file}:${site.line}${expr}`);
+                lines.push(`  ${group.file}:${site.line} [${position(site)}]${expr}`);
             }
         }
         if (refs.unverifiedSites.length > 0) {
-            lines.push(`${compact ? '' : '\n'}UNVERIFIED TYPE REFERENCE CANDIDATES (${refs.unverifiedSites.length}) — name matches, no import link to this definition:`);
+            lines.push(`${compact ? '' : '\n'}UNVERIFIED TYPE REFERENCE CANDIDATES (${refs.unverifiedSites.length}) — the name, the type lookup cannot decide what it names:`);
             for (const site of refs.unverifiedSites.slice(0, 10)) {
                 const expr = site.expression ? `: ${site.expression.replace(/\s+/g, ' ').slice(0, 100)}` : '';
-                lines.push(`  ${site.file}:${site.line}${expr} (${site.reason})`);
+                lines.push(`  ${site.file}:${site.line} [${position(site)}]${expr} (${site.reason})`);
             }
             if (refs.unverifiedSites.length > 10) {
                 lines.push(`  (+${refs.unverifiedSites.length - 10} more unverified)`);
             }
         }
-        if (refs.confirmedCount === 0 && refs.unverifiedCount === 0) {
-            lines.push('  (no annotation sites outside the definition)');
-        }
+        if (refs.account) lines.push(formatTypeAccount(impact.function, refs));
     }
 
     // Unverified tier: visible, capped at 10 one-liners
@@ -1132,7 +1199,7 @@ function formatAbout(about, options = {}) {
             const returnSuffix = c.returnType ? ` → ${c.returnType}` : '';
             const sideEffects = (c.sideEffects && c.sideEffects.length) ? ` {${c.sideEffects.join(',')}}` : '';
             const unreachableMark = (aboutCalleeReach.perLine && c.reachable === false) ? ' [unreachable]' : '';
-            lines.push(`  ${c.name}${weight}${returnSuffix}${sideEffects} - ${c.file}:${c.line} (${c.callCount}x)${unreachableMark}`);
+            lines.push(`  ${c.name}${weight}${returnSuffix}${sideEffects} - ${c.file}:${c.line} (${c.callCount}x)${constructsSuffix(c)}${unreachableMark}`);
             if (!compact && c.docstring) {
                 const snip = calleeDocstringSnippet(c.docstring);
                 if (snip) lines.push(`    "${snip}"`);
@@ -1261,4 +1328,6 @@ module.exports = {
     // Shared with output/analysis-ext.js (smart): single-node callee contract.
     formatCalleeAccountLine,
     unverifiedCalleeLines,
+    initializerReviewLines,
+    constructsSuffix,
 };

package/core/output/graph.js

@@ -443,8 +443,9 @@ function formatCircularDeps(result) {
         return lines.join('\n');
     }
 
-    const eager = result.cycles.filter(cycle => cycle.classification !== 'deferred');
+    const eager = result.cycles.filter(cycle => cycle.classification !== 'deferred' && cycle.classification !== 'static');
     const deferred = result.cycles.filter(cycle => cycle.classification === 'deferred');
+    const staticCycles = result.cycles.filter(cycle => cycle.classification === 'static');
 
     // Groups first: a strongly connected file set is the unit a refactor has
     // to break, and a 14-file tangle can hold hundreds of elementary cycles.
@@ -454,8 +455,12 @@ function formatCircularDeps(result) {
         lines.push(`CYCLE GROUPS (${groups.length}) — every member reaches every other member:`);
         for (const group of groups) {
             const counts = [];
-            if (group.eagerCycles != null) counts.push(`${group.eagerCycles} import-time`);
-            if (group.deferredCycles != null) counts.push(`${group.deferredCycles} deferred`);
+            // A group of files that run no module code on import has only
+            // static cycles; the import-time/deferred split does not apply.
+            const onlyStatic = group.staticCycles > 0 && !group.eagerCycles && !group.deferredCycles;
+            if (group.eagerCycles != null && !onlyStatic) counts.push(`${group.eagerCycles} import-time`);
+            if (group.deferredCycles != null && !onlyStatic) counts.push(`${group.deferredCycles} deferred`);
+            if (group.staticCycles > 0) counts.push(`${group.staticCycles} static`);
             const suffix = counts.length > 0 ? `  [${counts.join(', ')}${result.summary.truncated ? '; enumerated counts only' : ''}]` : '';
             lines.push(`  ${group.size} files: ${group.files.join(', ')}${suffix}`);
         }
@@ -489,6 +494,7 @@ function formatCircularDeps(result) {
     };
     renderGroup('IMPORT-TIME CYCLES', eager, false, EAGER_CYCLE_DISPLAY_LIMIT);
     renderGroup('DEFERRED CYCLES', deferred, true, DEFERRED_CYCLE_DISPLAY_LIMIT);
+    renderGroup('STATIC CYCLES', staticCycles, false, EAGER_CYCLE_DISPLAY_LIMIT);
 
     lines.push('');
     const { totalCycles, filesInCycles } = result.summary;
@@ -502,6 +508,9 @@ function formatCircularDeps(result) {
         }
         lines.push('The CYCLE GROUPS list and files-in-cycles count are complete; enumerated cycle counts are lower bounds.');
     }
+    if (staticCycles.length > 0) {
+        lines.push(`${staticCycles.length} chain${staticCycles.length === 1 ? ' links' : 's link'} only files whose imports and includes run no module code (Go, Rust, Java, C#, C, C++): static dependency cycles, not import-time cycles.`);
+    }
     if (deferred.length > 0) {
         lines.push(`${deferred.length} chain${deferred.length === 1 ? '' : 's'} close only through deferred edges (function-local, TYPE_CHECKING-only, or type-only imports); they are not unconditional import-time cycles, but a function-local edge may still matter if invoked during initialization.`);
     }

package/core/output/lines.js

@@ -244,15 +244,16 @@ function impactRecords(result) {
     }
     if (result.typeReferences) {
         const refs = result.typeReferences;
+        const where = site => `type-reference: ${site.kind || 'type'}${Number.isInteger(site.column) ? `, column ${site.column + 1}` : ''}`;
         for (const group of refs.byFile || []) {
             for (const site of group.sites || []) {
-                out.push(record(group.file, site.line, site.expression, 'type-reference'));
+                out.push(record(group.file, site.line, site.expression, where(site)));
             }
         }
         for (const site of refs.unverifiedSites || []) {
-            out.push(record(pathOf(site), site.line, site.expression, `unverified: ${site.reason}; type-reference`));
+            out.push(record(pathOf(site), site.line, site.expression, `unverified: ${site.reason}; ${where(site)}`));
         }
-        notes.push(`# TYPE REFERENCE SITES: ${refs.confirmedCount} confirmed, ${refs.unverifiedCount} unverified, ${refs.excluded?.total || 0} other-target (separate from caller ACCOUNT).`);
+        notes.push(`# TYPE REFERENCE SITES: ${refs.confirmedCount} confirmed, ${refs.unverifiedCount} unverified, ${refs.excluded?.total || 0} excluded (separate from caller ACCOUNT).`);
     }
     notes.push(...accountComments(result.account));
     for (const warning of result.warnings || []) notes.push(...commentLines(warning.message));

package/core/output/public.js

@@ -410,6 +410,7 @@ function formatPublicJson(command, result, params = {}, execution = {}) {
         commandMeta.excludedDecorated = result.excludedDecorated || 0;
         commandMeta.excludedExternalContract = result.excludedExternalContract || 0;
         commandMeta.excludedRuntimeContract = result.excludedRuntimeContract || 0;
+        commandMeta.excludedConstructors = result.excludedConstructors || 0;
         commandMeta.pythonImplicitExportFiles = result.pythonImplicitExportFiles || 0;
         commandMeta.excludedDynamicDispatch = result.excludedDynamicDispatch || 0;
         commandMeta.computedDispatch = result.computedDispatch || { count: 0, names: [] };
@@ -475,6 +476,7 @@ function formatPublicJson(command, result, params = {}, execution = {}) {
     const envelope = {
         meta: {
             command: surfaceCommand,
+            ...(execution.surface === 'cli' && { maxChars: 'not-applied' }),
             ...(surfaceCommand !== command && { canonicalCommand: command }),
             // A result that self-reports it could not run (check with a bad
             // base ref / outside git) must be machine-distinguishable from a

package/core/output/reporting.js

@@ -214,8 +214,9 @@ function formatStatsJson(stats) {
 function formatDeadcode(results, options = {}) {
     if (results.length === 0 && !results.excludedDecorated &&
         !results.excludedExported && !results.excludedExternalContract &&
-        !results.excludedRuntimeContract && !results.pythonImplicitExportFiles &&
+        !results.excludedRuntimeContract && !results.excludedConstructors && !results.pythonImplicitExportFiles &&
         !results.excludedDynamicDispatch && !results.computedDispatch?.count &&
+        !results.reflection?.withheld && !results.reflection?.dynamicCount && !results.reflection?.literalCount &&
         results.coverage?.complete !== false) {
         return 'No dead code found.';
     }
@@ -291,6 +292,9 @@ function formatDeadcode(results, options = {}) {
     if (results.excludedRuntimeContract > 0) {
         lines.push(`\n${results.excludedRuntimeContract} runtime callback(s) hidden (language/runtime registrations, not dead).`);
     }
+    if (results.excludedConstructors > 0) {
+        lines.push(`\n${results.excludedConstructors} constructor(s) not listed: a constructor belongs to its type's allocation protocol, so the type is audited instead.`);
+    }
     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.`);
     }
@@ -311,6 +315,12 @@ function formatDeadcode(results, options = {}) {
     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.reflection?.withheldByTable?.length > 0) {
+        lines.push('\nConservatively withheld: exact string literals in a file with dynamic reflection (flow to the reflection call is unproven):');
+        for (const site of results.reflection.withheldByTable) {
+            lines.push(`  ${site.name}: named in possible reflection table ${site.file}:${site.line}`);
+        }
+    }
     if (results.macroPaste) {
         const m = results.macroPaste;
         if (m.withheld > 0) {
@@ -366,6 +376,7 @@ function formatDeadcodeJson(results) {
             ...(results.excludedDecorated > 0 && { excludedDecorated: results.excludedDecorated }),
             ...(results.excludedExternalContract > 0 && { excludedExternalContract: results.excludedExternalContract }),
             ...(results.excludedRuntimeContract > 0 && { excludedRuntimeContract: results.excludedRuntimeContract }),
+            ...(results.excludedConstructors > 0 && { excludedConstructors: results.excludedConstructors }),
             ...(results.pythonImplicitExportFiles > 0 && { pythonImplicitExportFiles: results.pythonImplicitExportFiles }),
             ...(results.excludedDynamicDispatch > 0 && { excludedDynamicDispatch: results.excludedDynamicDispatch }),
             ...(results.computedDispatch?.count > 0 && { computedDispatch: results.computedDispatch }),

package/core/output/shared.js

@@ -177,6 +177,8 @@ function formatClassSignature(cls) {
     if (cls.implements && cls.implements.length > 0) {
         parts.push(`implements ${cls.implements.join(', ')}`);
     }
+    // `class State;` declares a class defined elsewhere (fix #427).
+    if (cls.forwardDeclaration) parts.push('(forward declaration)');
 
     return parts.join(' ');
 }

package/core/output/tracing.js

@@ -39,18 +39,31 @@ function renderFrontier(lines, frontier, options = {}, expanded = false) {
     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 ? '└── ' : '├── ';
+/**
+ * A node's unresolved callee calls as [unverified] leaves, then the
+ * constructions whose constructor body is undecided (fix #421; their class
+ * edge is a child of the node).
+ */
+function undecidedLeafLines(node) {
+    const out = [];
+    for (const u of node.unverifiedCallees || []) {
         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}`);
+        out.push(`[unverified] ${u.name} — ${u.reason}${owners}${linesPart}`);
+    }
+    for (const r of node.initializerReviews || []) {
+        const candidates = r.candidates > 1 ? ` (${r.candidates} candidates)` : '';
+        const linesPart = r.sites && r.sites.length > 0 ? ` L${r.sites.join(',L')}` : '';
+        const label = r.name === r.initializerOf ? r.name : `${r.initializerOf}.${r.name}`;
+        out.push(`[constructor undecided] ${label} — ${r.reason}${candidates}${linesPart}`);
     }
+    return out;
+}
+
+function renderUnverifiedCallees(lines, node, prefix, isParentLast) {
+    const leaves = undecidedLeafLines(node);
+    const extension = isParentLast ? '    ' : '│   ';
+    leaves.forEach((text, i) => lines.push(`${prefix}${extension}${i === leaves.length - 1 ? '└── ' : '├── '}${text}`));
 }
 
 /** TREE ACCOUNT line for caller-direction trees. */
@@ -129,6 +142,7 @@ function formatTrace(trace, options = {}) {
         } else if (node.file) {
             label += ` (${node.file}:${node.line})`;
         }
+        if (node.constructs) label += ` (constructs ${node.constructs})`;
         if (node.weight && node.weight !== 'normal') {
             label += ` [${node.weight}]`;
         }
@@ -143,7 +157,7 @@ function formatTrace(trace, options = {}) {
 
         if (node.children && !node.alreadyShown) {
             const hasMore = node.truncatedChildren > 0;
-            const hasUnverified = node.unverifiedCallees && node.unverifiedCallees.length > 0;
+            const hasUnverified = node.unverifiedCallees?.length > 0 || node.initializerReviews?.length > 0;
             for (let i = 0; i < node.children.length; i++) {
                 const isChildLast = !hasMore && !hasUnverified && i === node.children.length - 1;
                 renderNode(node.children[i], prefix + extension, isChildLast);
@@ -160,7 +174,8 @@ 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;
+        const rootLeaves = undecidedLeafLines(trace.tree);
+        const rootHasUnverified = rootLeaves.length > 0;
         for (let i = 0; i < trace.tree.children.length; i++) {
             const isLast = !rootHasMore && !rootHasUnverified && i === trace.tree.children.length - 1;
             renderNode(trace.tree.children[i], '', isLast);
@@ -169,17 +184,8 @@ function formatTrace(trace, options = {}) {
             hasTruncation = true;
             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}`);
-            }
-        }
+        // Root-level unverified callees: render with no prefix
+        rootLeaves.forEach((text, i) => lines.push(`${i === rootLeaves.length - 1 ? '└── ' : '├── '}${text}`));
     }
 
     // Callers section

package/core/output-budget.js

@@ -15,10 +15,10 @@ const BROAD_COMMANDS = new Set([
     ...[...BROAD_CANONICAL].map(toMcpName),
 ]);
 
-const CONTRACT_LINE_RE = /^\s*(?:(?:Summary|ACCOUNT|CONTRACT|WARNING|FILTERED|CALLEE ACCOUNT|TREE ACCOUNT|Note):|\d+ test-file usage\(s\) hidden\b|Found \d+ (?:definitions|fuzzy matches)\b)/;
+const CONTRACT_LINE_RE = /^\s*(?:(?:Summary|ACCOUNT|CONTRACT|WARNING|FILTERED|CALLEE ACCOUNT|TREE ACCOUNT|VALUE ACCOUNT|TYPE ACCOUNT|Note):|\d+ test-file usage\(s\) hidden\b|Found \d+ (?:definitions|fuzzy matches)\b)/;
 // Trust lines: the accounting and contract lines that qualify a caller
 // answer. A truncated answer carries every one of them or none of its body.
-const TRUST_LINE_RE = /^(?:ACCOUNT|CONTRACT|WARNING|FILTERED|CALLEE ACCOUNT|TREE ACCOUNT):/;
+const TRUST_LINE_RE = /^(?:ACCOUNT|CONTRACT|WARNING|FILTERED|CALLEE ACCOUNT|TREE ACCOUNT|VALUE ACCOUNT|TYPE ACCOUNT):/;
 const MAX_PRESERVED_CONTRACT_LINES = 24;
 const MAX_PRESERVED_CONTRACT_CHARS = 8000;
 

package/core/parallel-build.js

@@ -275,4 +275,55 @@ function parallelBuild(index, files, options = {}) {
     return changed;
 }
 
-module.exports = { parallelBuild, scheduleFiles };
+/**
+ * Worker threads for a sequential build's Rust macro expansion (fix #422): a
+ * pool shaped like the one a parallel build keeps (`options.onParsed`), whose
+ * workers have no file to parse and wait for their expansion job. A crate
+ * whose API macros generate most of its code has little source to parse and
+ * much expansion work.
+ */
+function spawnExpansionPool(index, count) {
+    if (!(count >= 1)) return null;
+    const sab = new SharedArrayBuffer(4 * (count + 1));
+    const control = new SharedArrayBuffer(4 * count);
+    const controlArray = new Int32Array(control);
+    const ports = [];
+    const workers = [];
+    for (let i = 0; i < count; i++) {
+        const { port1, port2 } = new MessageChannel();
+        ports.push(port1);
+        const worker = new Worker(path.join(__dirname, 'build-worker.js'), {
+            workerData: {
+                files: [], rootDir: index.root, existingHashes: {}, signal: sab, workerIndex: i,
+                queueIndex: count, port: port2, control, macroDictionary: null, dictionarySignal: null,
+            },
+            transferList: [port2],
+            resourceLimits: { maxYoungGenerationSizeMb: WORKER_YOUNG_GENERATION_MB },
+        });
+        worker.unref();
+        workers.push(worker);
+    }
+    const live = new Set(workers.map((_, i) => i));
+    const retire = i => {
+        if (!live.delete(i)) return;
+        Atomics.store(controlArray, i, 1);
+        Atomics.notify(controlArray, i);
+        ports[i].close();
+        workers[i].terminate();
+    };
+    return {
+        available: [...live],
+        ports,
+        post(i, job) {
+            ports[i].postMessage(job);
+            Atomics.store(controlArray, i, 2);
+            Atomics.notify(controlArray, i);
+        },
+        retire,
+        dispose() {
+            for (const i of [...live]) retire(i);
+        },
+    };
+}
+
+module.exports = { parallelBuild, scheduleFiles, spawnExpansionPool };